QSessionManager man page on Peanut

Man page or keyword search:  
man Server   7435 pages
apropos Keyword Search (all sections)
Output format
Peanut logo
[printable version]

QSessionManager(3qt)					  QSessionManager(3qt)

NAME
       QSessionManager - Access to the session manager

SYNOPSIS
       #include <qsessionmanager.h>

       Inherits QObject.

   Public Members
       QString sessionId () const
       QString sessionKey () const
       void * handle () const
       bool allowsInteraction ()
       bool allowsErrorInteraction ()
       void release ()
       void cancel ()
       enum RestartHint { RestartIfRunning, RestartAnyway, RestartImmediately,
	   RestartNever }
       void setRestartHint ( RestartHint hint )
       RestartHint restartHint () const
       void setRestartCommand ( const QStringList & command )
       QStringList restartCommand () const
       void setDiscardCommand ( const QStringList & )
       QStringList discardCommand () const
       void setManagerProperty ( const QString & name, const QString & value )
       void setManagerProperty ( const QString & name, const QStringList &
	   value )
       bool isPhase2 () const
       void requestPhase2 ()

DESCRIPTION
       The QSessionManager class provides access to the session manager.

       The session manager is responsible for session management, most
       importantly for interruption and resumption. A "session" is a kind of
       record of the state of the system, e.g. which applications were run at
       start up and which applications are currently running. The session
       manager is used to save the session, e.g. when the machine is shut
       down; and to restore a session, e.g. when the machine is started up.
       Use QSettings to save and restore an individual application's settings,
       e.g. window positions, recently used files, etc.

       QSessionManager provides an interface between the application and the
       session manager so that the program can work well with the session
       manager. In Qt, session management requests for action are handled by
       the two virtual functions QApplication::commitData() and
       QApplication::saveState(). Both provide a reference to a session
       manager object as argument, to allow the application to communicate
       with the session manager.

       During a session management action (i.e. within commitData() and
       saveState()), no user interaction is possible unless the application
       got explicit permission from the session manager. You ask for
       permission by calling allowsInteraction() or, if it's really urgent,
       allowsErrorInteraction(). Qt does not enforce this, but the session
       manager may.

       You can try to abort the shutdown process by calling cancel(). The
       default commitData() function does this if some top-level window
       rejected its closeEvent().

       For sophisticated session managers provided on Unix/X11,
       QSessionManager offers further possibilites to fine-tune an
       application's session management behavior: setRestartCommand(),
       setDiscardCommand(), setRestartHint(), setProperty(), requestPhase2().
       See the respective function descriptions for further details.

       See also Main Window and Related Classes and Environment Classes.

   Member Type Documentation
QSessionManager::RestartHint
       This enum type defines the circumstances under which this application
       wants to be restarted by the session manager. The current values are

       QSessionManager::RestartIfRunning - if the application is still running
       when the session is shut down, it wants to be restarted at the start of
       the next session.

       QSessionManager::RestartAnyway - the application wants to be started at
       the start of the next session, no matter what. (This is useful for
       utilities that run just after startup and then quit.)

       QSessionManager::RestartImmediately - the application wants to be
       started immediately whenever it is not running.

       QSessionManager::RestartNever - the application does not want to be
       restarted automatically.

       The default hint is RestartIfRunning.

MEMBER FUNCTION DOCUMENTATION
bool QSessionManager::allowsErrorInteraction ()
       This is similar to allowsInteraction(), but also tells the session
       manager that an error occurred. Session managers may give error
       interaction request higher priority, which means that it is more likely
       that an error interaction is permitted. However, you are still not
       guaranteed that the session manager will allow interaction.

       See also allowsInteraction(), release(), and cancel().

bool QSessionManager::allowsInteraction ()
       Asks the session manager for permission to interact with the user.
       Returns TRUE if interaction is permitted; otherwise returns FALSE.

       The rationale behind this mechanism is to make it possible to
       synchronize user interaction during a shutdown. Advanced session
       managers may ask all applications simultaneously to commit their data,
       resulting in a much faster shutdown.

       When the interaction is completed we strongly recommend releasing the
       user interaction semaphore with a call to release(). This way, other
       applications may get the chance to interact with the user while your
       application is still busy saving data. (The semaphore is implicitly
       released when the application exits.)

       If the user decides to cancel the shutdown process during the
       interaction phase, you must tell the session manager that this has
       happened by calling cancel().

       Here's an example of how an application's QApplication::commitData()
       might be implemented:

       void MyApplication::commitData( QSessionManager& sm ) {
	   if ( sm.allowsInteraction() ) {
	       switch ( QMessageBox::warning(
			   yourMainWindow,
			   tr("Application Name"),
			   tr("Save changes to document Foo?"),
			   tr("&Yes"),
			   tr("&No"),
			   tr("Cancel"),
			   0, 2) ) {
	       case 0: // yes
		   sm.release();
		   // save document here; if saving fails, call sm.cancel()
		   break;
	       case 1: // continue without saving
		   break;
	       default: // cancel
		   sm.cancel();
		   break;
	       }
	   } else {
	       // we did not get permission to interact, then
	       // do something reasonable instead.
	   }
       }

       If an error occurred within the application while saving its data, you
       may want to try allowsErrorInteraction() instead.

       See also QApplication::commitData(), release(), and cancel().

void QSessionManager::cancel ()
       Tells the session manager to cancel the shutdown process. Applications
       should not call this function without first asking the user.

       See also allowsInteraction() and allowsErrorInteraction().

QStringList QSessionManager::discardCommand () const
       Returns the currently set discard command.

       Note that if you want to iterate over the list, you should iterate over
       a copy, e.g.

	   QStringList list = mySession.discardCommand();
	   QStringList::Iterator it = list.begin();
	   while( it != list.end() ) {
	       myProcessing( *it );
	       ++it;
	   }

       See also setDiscardCommand(), restartCommand(), and
       setRestartCommand().

void * QSessionManager::handle () const
       X11 only: returns a handle to the current SmcConnection.

bool QSessionManager::isPhase2 () const
       Returns TRUE if the session manager is currently performing a second
       session management phase; otherwise returns FALSE.

       See also requestPhase2().

void QSessionManager::release ()
       Releases the session manager's interaction semaphore after an
       interaction phase.

       See also allowsInteraction() and allowsErrorInteraction().

void QSessionManager::requestPhase2 ()
       Requests a second session management phase for the application. The
       application may then return immediately from the
       QApplication::commitData() or QApplication::saveState() function, and
       they will be called again once most or all other applications have
       finished their session management.

       The two phases are useful for applications such as the X11 window
       manager that need to store information about another application's
       windows and therefore have to wait until these applications have
       completed their respective session management tasks.

       Note that if another application has requested a second phase it may
       get called before, simultaneously with, or after your application's
       second phase.

       See also isPhase2().

QStringList QSessionManager::restartCommand () const
       Returns the currently set restart command.

       Note that if you want to iterate over the list, you should iterate over
       a copy, e.g.

	   QStringList list = mySession.restartCommand();
	   QStringList::Iterator it = list.begin();
	   while( it != list.end() ) {
	       myProcessing( *it );
	       ++it;
	   }

       See also setRestartCommand() and restartHint().

RestartHint QSessionManager::restartHint () const
       Returns the application's current restart hint. The default is
       RestartIfRunning.

       See also setRestartHint().

QString QSessionManager::sessionId () const
       Returns the identifier of the current session.

       If the application has been restored from an earlier session, this
       identifier is the same as it was in that earlier session.

       See also sessionKey() and QApplication::sessionId().

QString QSessionManager::sessionKey () const
       Returns the session key in the current session.

       If the application has been restored from an earlier session, this key
       is the same as it was when the previous session ended.

       The session key changes with every call of commitData() or saveState().

       See also sessionId() and QApplication::sessionKey().

void QSessionManager::setDiscardCommand ( const QStringList & )
       See also discardCommand() and setRestartCommand().

void QSessionManager::setManagerProperty ( const QString & name, const
       QStringList & value )
       Low-level write access to the application's identification and state
       record are kept in the session manager.

       The property called name has its value set to the string list value.

void QSessionManager::setManagerProperty ( const QString & name, const QString
       & value )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Low-level write access to the application's identification and state
       records are kept in the session manager.

       The property called name has its value set to the string value.

void QSessionManager::setRestartCommand ( const QStringList & command )
       If the session manager is capable of restoring sessions it will execute
       command in order to restore the application. The command defaults to

	       appname -session id

       The -session option is mandatory; otherwise QApplication cannot tell
       whether it has been restored or what the current session identifier is.
       See QApplication::isSessionRestored() and QApplication::sessionId() for
       details.

       If your application is very simple, it may be possible to store the
       entire application state in additional command line options. This is
       usually a very bad idea because command lines are often limited to a
       few hundred bytes. Instead, use QSettings, or temporary files or a
       database for this purpose. By marking the data with the unique
       sessionId(), you will be able to restore the application in a future
       session.

       See also restartCommand(), setDiscardCommand(), and setRestartHint().

void QSessionManager::setRestartHint ( RestartHint hint )
       Sets the application's restart hint to hint. On application startup the
       hint is set to RestartIfRunning.

       Note that these flags are only hints, a session manager may or may not
       respect them.

       We recommend setting the restart hint in QApplication::saveState()
       because most session managers perform a checkpoint shortly after an
       application's startup.

       See also restartHint().

SEE ALSO
       http://doc.trolltech.com/qsessionmanager.html
       http://www.trolltech.com/faq/tech.html

COPYRIGHT
       Copyright 1992-2007 Trolltech ASA, http://www.trolltech.com.  See the
       license file included in the distribution for a complete license
       statement.

AUTHOR
       Generated automatically from the source code.

BUGS
       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.	Good bug reports help us to
       help you. Thank you.

       The definitive Qt documentation is provided in HTML format; it is
       located at $QTDIR/doc/html and can be read using Qt Assistant or with a
       web browser. This man page is provided as a convenience for those users
       who prefer man pages, although this format is not officially supported
       by Trolltech.

       If you find errors in this manual page, please report them to qt-
       bugs@trolltech.com.  Please include the name of the manual page
       (qsessionmanager.3qt) and the Qt version (3.3.8).

Trolltech AS			2 February 2007		  QSessionManager(3qt)
[top]

List of man pages available for Peanut

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net