Unix/Linux Go Back    


CentOS 7.0 - man page for qsessionmanager (centos section 3qt)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


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)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 10:28 PM.