QWSServer Class Reference

The QWSServer class encapsulates a server process in Qt for Embedded Linux. More...

#include <qwindowsystem_qws.h>

Inheritance diagram for QWSServer:

Classes
class	KeyboardFilter
	The KeyboardFilter class is a base class for global keyboard event filters in Qt for Embedded Linux. More...

Public Types
enum	IMMouse { MousePress, MouseRelease, MouseMove, MouseOutside }
	This enum describes the various types of mouse events recognized by the QWSInputMethod::mouseHandler() function. More...
enum	ServerFlags { DisableKeyboard = 0x01, DisableMouse = 0x02 }
	This enum is used to pass various options to the window system server. More...
enum	WindowEvent {   Create =0x0001, Destroy =0x0002, Hide =0x0004, Show =0x0008,   Raise =0x0010, Lower =0x0020, Geometry =0x0040, Active = 0x0080,   Name =0x0100 }
	This enum specifies the various events that can occur in a top-level window. More...

Signals
void	markedText (const QString &)
	This signal is emitted whenever some text is selected in any of the running applications, passing the selected text in the selection parameter. More...
void	newChannel (const QString &channel)
	This signal is emitted whenever a new QCopChannel object is created, passing the channel's name in the channel parameter. More...
void	removedChannel (const QString &channel)
	This signal is emitted immediately after the given the QCopChannel object specified by channel, is destroyed. More...
void	windowEvent (QWSWindow *w, QWSServer::WindowEvent e)
	This signal is emitted whenever something happens to a top-level window (e.g., it's created or destroyed), passing a pointer to the window and the event's type in the window and eventType parameters, respectively. More...
Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...

Public Functions
const QBrush &	backgroundBrush () const
	Returns the brush used as background in the absence of obscuring windows. More...
const QList< QWSWindow * > &	clientWindows ()
	Returns the list of current top-level windows. More...
void	closeKeyboard ()
	Closes all the keyboard devices (specified by the QWS_KEYBOARD environment variable) by deleting the associated keyboard drivers. More...
void	closeMouse ()
	Closes all pointer devices (specified by the QWS_MOUSE_PROTO environment variable) by deleting the associated mouse drivers. More...
void	enablePainting (bool)
	Enables painting onto the screen if enable is true; otherwise painting is disabled. More...
void	openKeyboard ()
	Opens the keyboard devices specified by the QWS_KEYBOARD environment variable. More...
void	openMouse ()
	Opens the mouse devices specified by the QWS_MOUSE_PROTO environment variable. More...
	QWSServer (int flags=0, QObject *parent=0)
void	refresh ()
	Refreshes the display by making the screen driver update the entire display. More...
void	refresh (QRegion &)
	Refreshes the given region of the display. More...
void	resumeMouse ()
	Resumes pointer handling by reactivating all the mouse drivers registered by the QWS_MOUSE_PROTO environment variable. More...
void	sendIMEvent (const QInputMethodEvent *)
	Sends the given input method event. More...
void	sendIMQuery (int property)
	Sends an input method query for the given property. More...
void	sendPropertyNotifyEvent (int property, int state)
void	suspendMouse ()
	Suspends pointer handling by deactivating all the mouse drivers registered by the QWS_MOUSE_PROTO environment variable. More...
QWSWindow *	windowAt (const QPoint &pos)
	Returns the window containing the given position. More...
	~QWSServer ()
	Destructs this server. More...
Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
const QObjectList &	children () const
	Returns a list of child objects. More...
bool	connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
bool	disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
bool	disconnect (const QObject *receiver, const char *member=0)
void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...
void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...
QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...
virtual bool	event (QEvent *)
	This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
virtual bool	eventFilter (QObject *, QEvent *)
	Filters events if this object has been installed as an event filter for the watched object. More...
template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
template<typename T >
QList< T >	findChildren (const QRegExp &re) const
bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...
bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...
void	killTimer (int id)
	Kills the timer with timer identifier, id. More...
virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...
void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...
QString	objectName () const
QObject *	parent () const
	Returns a pointer to the parent object. More...
QVariant	property (const char *name) const
	Returns the value of the object's name property. More...
Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...
void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...
void	setObjectName (const QString &name)
void	setParent (QObject *)
	Makes the object a child of parent. More...
bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...
void	setUserData (uint id, QObjectUserData *data)
bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...
int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
QThread *	thread () const
	Returns the thread in which the object lives. More...
QObjectUserData *	userData (uint id) const
virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...

Static Public Functions
static void	addKeyboardFilter (KeyboardFilter *f)
	Activates the given keyboard filter all key events generated by physical keyboard drivers (i.e., events sent using the processKeyEvent() function). More...
static void	beginDisplayReconfigure ()
static void	closedown ()
static void	endDisplayReconfigure ()
static QWSServer *	instance ()
static bool	isCursorVisible ()
	Returns true if the cursor is visible; otherwise returns false. More...
static QWSKeyboardHandler *	keyboardHandler ()
	Returns the primary keyboard driver. More...
static QWSMouseHandler *	mouseHandler ()
	Returns the primary mouse driver. More...
static const QList< QWSMouseHandler * > &	mouseHandlers ()
	Returns list of all mouse handlers. More...
static void	processEventQueue ()
static void	processKeyEvent (int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat)
	Processes the given key event. More...
static void	removeKeyboardFilter ()
	Removes and deletes the most recently added filter. More...
static void	resetInputMethod ()
static void	screenSaverActivate (bool)
	Activates the screen saver if activate is true; otherwise it is deactivated. More...
static bool	screenSaverActive ()
	Returns true if the screen saver is active; otherwise returns false. More...
static void	sendKeyEvent (int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat)
	Sends the given key event. More...
static void	sendMouseEvent (const QPoint &pos, int state, int wheel=0)
	Send a mouse event. More...
static void	setBackground (const QBrush &)
	Sets the brush used as background in the absence of obscuring windows, to be the given brush. More...
static void	setCurrentInputMethod (QWSInputMethod *im)
	Sets the current input method to be the given method. More...
static void	setCursorVisible (bool)
	Shows the cursor if visible is true: otherwise the cursor is hidden. More...
static void	setDefaultKeyboard (const char *)
	Sets the keyboard driver that will be used if the QWS_KEYBOARD environment variable is not defined, to be the given keyboardDriver. More...
static void	setDefaultMouse (const char *)
	Sets the mouse driver that will be used if the QWS_MOUSE_PROTO environment variable is not defined, to be the given mouseDriver. More...
static void	setKeyboardHandler (QWSKeyboardHandler *kh)
	Sets the primary keyboard driver to be the given driver. More...
static void	setMaxWindowRect (const QRect &)
	Sets the maximum area of the screen that Qt for Embedded Linux applications can use, to be the given rectangle. More...
static void	setMouseHandler (QWSMouseHandler *)
	Sets the primary mouse driver to be the given driver. More...
static void	setScreenSaver (QWSScreenSaver *)
	Installs the given screenSaver, deleting the current screen saver. More...
static void	setScreenSaverBlockLevel (int)
	Block the key or mouse event that wakes the system from level eventBlockLevel or higher. More...
static void	setScreenSaverInterval (int)
	Sets the timeout interval for the screensaver to the specified milliseconds. More...
static void	setScreenSaverIntervals (int *ms)
	Specifies the time intervals (in milliseconds) between the different levels of screen responsiveness. More...
static void	startup (int flags)
static QList< QWSInternalWindowInfo * > *	windowList ()
Static Public Functions inherited from QObject
static bool	connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
static bool	connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
static bool	disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
	Disconnects signal in object sender from method in object receiver. More...
static bool	disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
static uint	registerUserData ()
static QString	tr (const char *sourceText, const char *comment=0, int n=-1)
static QString	trUtf8 (const char *sourceText, const char *comment=0, int n=-1)

Static Public Variables
static QPoint	mousePosition
Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...

Protected Functions
void	timerEvent (QTimerEvent *e)
Protected Functions inherited from QObject
virtual void	childEvent (QChildEvent *)
	This event handler can be reimplemented in a subclass to receive child events. More...
virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...
virtual void	customEvent (QEvent *)
	This event handler can be reimplemented in a subclass to receive custom events. More...
virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...
	QObject (QObjectPrivate &dd, QObject *parent=0)
int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...
QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
int	senderSignalIndex () const

Private Functions
void	updateWindowRegions () const

Friends
class	QApplicationPrivate
class	QCopChannel
class	QWSDisplay
class	QWSInputMethod
class	QWSMouseHandler
class	QWSWindow

Additional Inherited Members
Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...
Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr
Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject
Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()
T *	qobject_cast (QObject *object)
	QObjectList
void *	qt_find_obj_child (QObject *parent, const char *type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Detailed Description

The QWSServer class encapsulates a server process in Qt for Embedded Linux.

When you run a Qt for Embedded Linux application, it either runs as a server or connects to an existing server. The server and client processes have different responsibilities: The client process performs all application specific operations. The server process is responsible for managing the clients as well as taking care of the pointer handling, character input, and screen output. In addition, the server provides functionality to handle input methods.

In Qt for Embedded Linux, all system generated events are passed to the server application which then propagates the event to the appropriate client. See the Qt for Embedded Linux Architecture documentation for details.

Note that this class is instantiated by QApplication for Qt for Embedded Linux server processes; you should never construct this class yourself. Use the instance() function to retrieve a pointer to the server object.

Note that the static functions of the QWSServer class can only be used in the server process.

Client Administration

As applications add and remove windows, the server process maintains information about each window. In Qt for Embedded Linux, top-level windows are encapsulated as QWSWindow objects. Each window can tell which client that owns it through its QWSWindow::client() function. Use the clientWindows() function to retrieve a list of the current top-level windows. Given a particular position on the display, the window containing it can be retrieved using the windowAt() function.

QWSServer also provides the windowEvent() signal which is emitted whenever something happens to a top level window; the WindowEvent enum describes the various types of events that the signal recognizes. In addition, the server class provides the markedText() signal which is emitted whenever some text has been selected in any of the windows, passing the selection as parameter.

The QCopChannel class and the QCOP communication protocol enable transfer of messages between clients. QWSServer provides the newChannel() and removedChannel() signals that is emitted whenever a new QCopChannel object is created or destroyed, respectively.

See also: QWSWindow, QWSClient and QCopChannel.

Mouse Handling

The mouse driver (represented by an instance of the QWSMouseHandler class) is loaded by the server application when it starts running, using Qt's How to Create Qt Plugins. A mouse driver receives mouse events from the device and encapsulates each event with an instance of the QWSEvent class which it then passes to the server.

The openMouse() function opens the mouse devices specified by the QWS_MOUSE_PROTO environment variable, and the setMouseHandler() functions sets the primary mouse driver. Alternatively, the static setDefaultMouse() function provides means of specifying the mouse driver to use if the QWS_MOUSE_PROTO variable is not defined (note that the default is otherwise platform dependent). The primary mouse driver can be retrieved using the static mouseHandler() function. Use the closeMouse() function to delete the mouse drivers.

In addition, the QWSServer class can control the flow of mouse input using the suspendMouse() and resumeMouse() functions.

See also: QWSMouseHandler and Qt for Embedded Linux Pointer Handling.

Keyboard Handling

The keyboard driver (represented by an instance of the QWSKeyboardHandler class) is loaded by the server application when it starts running, using Qt's How to Create Qt Plugins. A keyboard driver receives keyboard events from the device and encapsulates each event with an instance of the QWSEvent class which it then passes to the server.

The openKeyboard() function opens the keyboard devices specified by the QWS_KEYBOARD environment variable, and the setKeyboardHandler() functions sets the primary keyboard driver. Alternatively, the static setDefaultKeyboard() function provides means of specifying the keyboard driver to use if the QWS_KEYBOARD variable is not defined (note again that the default is otherwise platform dependent). The primary keyboard driver can be retrieved using the static keyboardHandler() function. Use the closeKeyboard() function to delete the keyboard drivers.

In addition, the QWSServer class can handle key events from both physical and virtual keyboards using the processKeyEvent() and sendKeyEvent() functions, respectively. Use the addKeyboardFilter() function to filter the key events from physical keyboard drivers, the most recently added filter can be removed and deleted using the removeKeyboardFilter() function.

See also: QWSKeyboardHandler and Qt for Embedded Linux Character Input.

Display Handling

When a screen update is required, the server runs through all the top-level windows that intersect with the region that is about to be updated, and ensures that the associated clients have updated their memory buffer. Then the server uses the screen driver (represented by an instance of the QScreen class) to copy the content of the memory to the screen.

In addition, the QWSServer class provides some means of managing the screen output: Use the refresh() function to refresh the entire display, or alternatively a specified region of it. The enablePainting() function can be used to disable (and enable) painting onto the screen. QWSServer also provide the setMaxWindowRect() function restricting the area of the screen which Qt for Embedded Linux applications will consider to be the maximum area to use for windows. To set the brush used as the background in the absence of obscuring windows, QWSServer provides the static setBackground() function. The corresponding backgroundBrush() function returns the currently set brush.

QWSServer also controls the screen saver: Use the setScreenSaver() to install a custom screen saver derived from the QWSScreenSaver class. Once installed, the screensaver can be activated using the screenSaverActivate() function, and the screenSaverActive() function returns its current status. Use the setScreenSaverInterval() function to specify the timeout interval. Qt for Embedded Linux also supports multilevel screen saving, use the setScreenSaverIntervals() function to specify the various levels and their timeout intervals.

Finally, the QWSServer class controls the cursor's appearance, i.e., use the setCursorVisible() function to hide or show the cursor, and the isCursorVisible() function to determine whether the cursor is visible on the display or not.

See also: QScreen and Qt for Embedded Linux Display Management.

Input Method Handling

Whenever the server receives an event, it queries its stack of top-level windows to find the window containing the event's position (each window can identify the client application that created it). Then the server forwards the event to the appropriate client. If an input method is installed, it is used as a filter between the server and the client application.

Derive from the QWSInputMethod class to create custom input methods, and use the server's setCurrentInputMethod() function to install it. Use the sendIMEvent() and sendIMQuery() functions to send input method events and queries.

QWSServer provides the IMMouse enum describing the various mouse events recognized by the QWSInputMethod::mouseHandler() function. The latter function allows subclasses of QWSInputMethod to handle mouse events within the preedit text.

See also

QWSInputMethod

Definition at line 209 of file qwindowsystem_qws.h.

Enumerations

IMMouse

enum QWSServer::IMMouse

This enum describes the various types of mouse events recognized by the QWSInputMethod::mouseHandler() function.

• MousePress An event generated by pressing a mouse button.
• MouseRelease An event generated by relasing a mouse button.
• MouseMove An event generated by moving the mouse cursor.
• MouseOutside This value is only reserved, i.e., it is not used in current implementations.

See also

QWSInputMethod, setCurrentInputMethod()

Enumerator
MousePress
MouseRelease
MouseMove
MouseOutside

Definition at line 240 of file qwindowsystem_qws.h.

{ MousePress, MouseRelease, MouseMove, MouseOutside }; //MouseMove reserved but not used

ServerFlags

enum QWSServer::ServerFlags

This enum is used to pass various options to the window system server.

Warning

This function is not part of the public interface.

• DisableKeyboard Ignore all keyboard input.
• DisableMouse Ignore all mouse input.

Enumerator
DisableKeyboard
DisableMouse

Definition at line 224 of file qwindowsystem_qws.h.

                     { DisableKeyboard = 0x01,
                       DisableMouse = 0x02 };

WindowEvent

enum QWSServer::WindowEvent

This enum specifies the various events that can occur in a top-level window.

• Create A new window has been created (by the QWidget constructor).
• Destroy The window has been closed and deleted (by the QWidget destructor).
• Hide The window has been hidden using the QWidget::hide() function.
• Show The window has been shown using the QWidget::show() function or similar.
• Raise The window has been raised to the top of the desktop.
• Lower The window has been lowered.
• Geometry The window has changed size or position.
• Active The window has become the active window (i.e., it has keyboard focus).
• Name The window has been named.

See also

windowEvent()

Enumerator
Create
Destroy
Hide
Show
Raise
Lower
Geometry
Active
Name

Definition at line 324 of file qwindowsystem_qws.h.

                     { Create=0x0001, Destroy=0x0002, Hide=0x0004, Show=0x0008,
                       Raise=0x0010, Lower=0x0020, Geometry=0x0040, Active = 0x0080,
                       Name=0x0100 };

Constructors and Destructors

QWSServer()

QWSServer::QWSServer ( int  flags = 0, QObject *  parent = 0  )

explicit

Warning

This function is not part of the public interface.

Construct a QWSServer object with the given parent. The flags are used for keyboard and mouse settings.

Warning

This class is instantiated by QApplication for Qt for Embedded Linux server processes. You should never construct this class yourself.

See also

{Running Applications}

Definition at line 1399 of file qwindowsystem_qws.cpp.

                                               :
    QObject(*new QWSServerPrivate, parent)
{
    Q_D(QWSServer);
    QT_TRY {
        d->initServer(flags);
    } QT_CATCH(...) {
        qwsServer = 0;
        qwsServerPrivate = 0;
        QT_RETHROW;
    }
}

~QWSServer()

QWSServer::~QWSServer

(

)

Destructs this server.

Warning

This function is not part of the public interface.

Definition at line 1563 of file qwindowsystem_qws.cpp.

{
    closeMouse();
#ifndef QT_NO_QWS_KEYBOARD
    closeKeyboard();
#endif
    d_func()->cleanupFonts(/*force =*/true);
}

Functions

addKeyboardFilter()

void QWSServer::addKeyboardFilter ( KeyboardFilter *  filter )

static

Activates the given keyboard filter all key events generated by physical keyboard drivers (i.e., events sent using the processKeyEvent() function).

Note that the filter is not invoked for keys generated by virtual keyboard drivers (i.e., events sent using the sendKeyEvent() function).

Note that this function can only be used in the server process.

See also

removeKeyboardFilter()

Definition at line 4294 of file qwindowsystem_qws.cpp.

{
     if (!keyFilters)
        keyFilters = new QList<QWSServer::KeyboardFilter*>;
     if (f) {
        keyFilters->prepend(f);
     }
}

backgroundBrush()

const QBrush & QWSServer::backgroundBrush

(

)

const

Returns the brush used as background in the absence of obscuring windows.

See also

setBackground()

Definition at line 4113 of file qwindowsystem_qws.cpp.

Referenced by QScreen::compose(), and QScreen::paintBackground().

{
    return *QWSServerPrivate::bgBrush;
}

beginDisplayReconfigure()

void QWSServer::beginDisplayReconfigure ( )

static

Warning

This function is not part of the public interface.

Definition at line 2700 of file qwindowsystem_qws.cpp.

{
    qwsServer->enablePainting(false);
#ifndef QT_NO_QWS_CURSOR
    if (qt_screencursor)
        qt_screencursor->hide();
#endif
    QWSDisplay::grab(true);
    qt_screen->disconnect();
}

clientWindows()

const QList< QWSWindow * > & QWSServer::clientWindows

(

)

Returns the list of current top-level windows.

Note that the collection of top-level windows changes as applications add and remove widgets so it should not be stored for future use. The windows are sorted in stacking order from top-most to bottom-most.

Use the QWSWindow::client() function to retrieve the client application that owns a given window.

See also

windowAt(), instance()

Definition at line 1586 of file qwindowsystem_qws.cpp.

Referenced by QScreen::compose(), QDirectFBScreen::exposeRegion(), QScreen::exposeRegion(), and QWSTtyKbPrivate::handleConsoleSwitch().

{
    Q_D(QWSServer);
    return d->windows;
}

closedown()

void QWSServer::closedown ( )

static

Warning

This function is not part of the public interface.

Definition at line 4207 of file qwindowsystem_qws.cpp.

Referenced by qt_cleanup(), and QWSServerCleaner::~QWSServerCleaner().

{
    QScopedPointer<QWSServer> server(qwsServer);
    qwsServer = 0;
    QT_TRY {
        unlink(qws_qtePipeFilename().toLatin1().constData());
    } QT_CATCH(const std::bad_alloc &) {
        // ### TODO - what to do when we run out of memory
        // when calling toLatin1?
    }
}

closeKeyboard()

void QWSServer::closeKeyboard

(

)

Closes all the keyboard devices (specified by the QWS_KEYBOARD environment variable) by deleting the associated keyboard drivers.

See also

openKeyboard(), keyboardHandler()

Definition at line 3841 of file qwindowsystem_qws.cpp.

Referenced by QWSServerPrivate::emergency_cleanup(), openKeyboard(), and ~QWSServer().

{
    Q_D(QWSServer);
    qDeleteAll(d->keyboardhandlers);
    d->keyboardhandlers.clear();
}

closeMouse()

void QWSServer::closeMouse

(

)

Closes all pointer devices (specified by the QWS_MOUSE_PROTO environment variable) by deleting the associated mouse drivers.

See also

openMouse(), mouseHandler()

Definition at line 3725 of file qwindowsystem_qws.cpp.

Referenced by openMouse(), and ~QWSServer().

{
    Q_D(QWSServer);
    qDeleteAll(d->mousehandlers);
    d->mousehandlers.clear();
}

enablePainting()

void QWSServer::enablePainting

(

bool

enable

)

Enables painting onto the screen if enable is true; otherwise painting is disabled.

See also

{Qt for Embedded Linux Architecture::Drawing on Screen}{Qt for Embedded Linux Architecture}

Definition at line 2169 of file qwindowsystem_qws.cpp.

Referenced by beginDisplayReconfigure(), QVNCServer::discardClient(), endDisplayReconfigure(), QWSTtyKbPrivate::handleConsoleSwitch(), QVNCScreen::initDevice(), and QVNCServer::newConnection().

{
    Q_D(QWSServer);

    if (d->disablePainting == !enable)
        return;

    d->disablePainting = !enable;

    if (enable) {
        // Reset the server side allocated regions to ensure update_regions()
        // will send out region events.
        for (int i = 0; i < d->windows.size(); ++i) {
            QWSWindow *w = d->windows.at(i);
            w->setAllocatedRegion(QRegion());
#ifdef QT_QWS_CLIENTBLIT
            w->setDirectPaintRegion(QRegion());
#endif
        }
        d->update_regions();
        d->showCursor();
    } else {
        // Disable painting by clients by taking away their allocated region.
        // To ensure mouse events are still delivered to the correct windows,
        // the allocated regions are not modified on the server.
        for (int i = 0; i < d->windows.size(); ++i) {
            QWSWindow *w = d->windows.at(i);
            w->client()->sendRegionEvent(w->winId(), QRegion(),
                                         QWSRegionEvent::Allocation);
#ifdef QT_QWS_CLIENTBLIT
            w->client()->sendRegionEvent(w->winId(), QRegion(),
                                         QWSRegionEvent::DirectPaint);
#endif
        }
        d->hideCursor();
    }
}

endDisplayReconfigure()

void QWSServer::endDisplayReconfigure ( )

static

Warning

This function is not part of the public interface.

Definition at line 2714 of file qwindowsystem_qws.cpp.

{
    qt_screen->connect(QString());
    qwsServerPrivate->swidth = qt_screen->deviceWidth();
    qwsServerPrivate->sheight = qt_screen->deviceHeight();

    QWSDisplay::ungrab();
#ifndef QT_NO_QWS_CURSOR
    if (qt_screencursor)
        qt_screencursor->show();
#endif
    QApplicationPrivate *ap = QApplicationPrivate::instance();
    ap->setMaxWindowRect(qt_screen, 0,
                         QRect(0, 0, qt_screen->width(), qt_screen->height()));
    QSize olds = qApp->desktop()->size();
    qApp->desktop()->resize(qt_screen->width(), qt_screen->height());
    qApp->postEvent(qApp->desktop(), new QResizeEvent(qApp->desktop()->size(), olds));
    qwsServer->enablePainting(true);
    qwsServer->refresh();
    qDebug("Desktop size: %dx%d", qApp->desktop()->width(), qApp->desktop()->height());
}

instance()

static QWSServer * QWSServer::instance ( )

inlinestatic

Since

4.2

Returns a pointer to the server instance.

Note that the pointer will be 0 if the application is not the server, i.e., if the QApplication::type() function doesn't return QApplication::GuiServer.

See also

clientWindows(), windowAt()

Definition at line 234 of file qwindowsystem_qws.h.

Referenced by QVNCServer::discardClient(), QDirectFBScreen::exposeRegion(), QWSTtyKbPrivate::handleConsoleSwitch(), QVNCScreen::initDevice(), QDirectFBScreen::initDevice(), QFontDatabasePrivate::loadFromCache(), QVNCServer::newConnection(), QDirectFBScreenPrivate::QDirectFBScreenPrivate(), and QApplicationPrivate::setScreenTransformation().

{ return qwsServer; }

isCursorVisible()

bool QWSServer::isCursorVisible ( )

static

Returns true if the cursor is visible; otherwise returns false.

Note that this function can only be used in the server process.

See also

setCursorVisible()

Definition at line 2778 of file qwindowsystem_qws.cpp.

{
    return qwsServerPrivate ? qwsServerPrivate->haveviscurs : true;
}

keyboardHandler()

QWSKeyboardHandler * QWSServer::keyboardHandler ( )

static

Returns the primary keyboard driver.

Note that this function can only be used in the server process.

See also

setKeyboardHandler(), openKeyboard(), closeKeyboard()

Definition at line 3855 of file qwindowsystem_qws.cpp.

{
    return qwsServerPrivate->keyboardhandlers.first();
}

markedText

void QWSServer::markedText ( const QString &  selection )

signal

This signal is emitted whenever some text is selected in any of the running applications, passing the selected text in the selection parameter.

See also

windowEvent()

mouseHandler()

QWSMouseHandler * QWSServer::mouseHandler ( )

static

Returns the primary mouse driver.

Note that this function can only be used in the server process.

See also

setMouseHandler(), openMouse(), closeMouse()

Definition at line 2494 of file qwindowsystem_qws.cpp.

{
    if (qwsServerPrivate->mousehandlers.empty())
        return 0;
    return qwsServerPrivate->mousehandlers.first();
}

mouseHandlers()

const QList< QWSMouseHandler * > & QWSServer::mouseHandlers ( )

static

Returns list of all mouse handlers.

Note that this function can only be used in the server process.

Since

4.5

See also

mouseHandler(), setMouseHandler(), openMouse(), closeMouse()

Definition at line 2513 of file qwindowsystem_qws.cpp.

{
    return qwsServerPrivate->mousehandlers;
}

newChannel

void QWSServer::newChannel ( const QString &  channel )

signal

This signal is emitted whenever a new QCopChannel object is created, passing the channel's name in the channel parameter.

See also

removedChannel()

openKeyboard()

void QWSServer::openKeyboard

(

)

Opens the keyboard devices specified by the QWS_KEYBOARD environment variable.

See also

closeKeyboard(), keyboardHandler()

Definition at line 3888 of file qwindowsystem_qws.cpp.

{
    QString keyboards = QString::fromLatin1(qgetenv("QWS_KEYBOARD"));
#if defined(QT_QWS_CASSIOPEIA)
    if (keyboards.isEmpty())
        keyboards = QLatin1String("Buttons");
#endif
    if (keyboards.isEmpty())
        keyboards = *defaultKeyboard();

    closeKeyboard();
    if (keyboards == QLatin1String("None"))
        return;

    QString device;
    QString type;
    QStringList keyboard = keyboards.split(QLatin1Char(' '));
    for (int i = keyboard.size() - 1; i >= 0; --i) {
        const QString spec = keyboard.at(i);
        int colon=spec.indexOf(QLatin1Char(':'));
        if (colon>=0) {
            type = spec.left(colon);
            device = spec.mid(colon+1);
        } else {
            type = spec;
            device = QString();
        }
        QWSKeyboardHandler *handler = QKbdDriverFactory::create(type, device);
        setKeyboardHandler(handler);
    }
}

openMouse()

void QWSServer::openMouse

(

)

Opens the mouse devices specified by the QWS_MOUSE_PROTO environment variable.

Be advised that closeMouse() is called first to delete all the existing mouse handlers. This behaviour could be the cause of problems if you were not expecting it.

See also

closeMouse(), mouseHandler()

Definition at line 3740 of file qwindowsystem_qws.cpp.

{
    Q_D(QWSServer);
    QString mice = QString::fromLatin1(qgetenv("QWS_MOUSE_PROTO"));
#if defined(QT_QWS_CASSIOPEIA)
    if (mice.isEmpty())
        mice = QLatin1String("TPanel:/dev/tpanel");
#endif
    if (mice.isEmpty())
        mice = *defaultMouse();
    closeMouse();
    bool needviscurs = true;
    if (mice != QLatin1String("None")) {
        const QStringList mouse = mice.split(QLatin1Char(' '));
        for (int i = mouse.size() - 1; i >= 0; --i) {
            QWSMouseHandler *handler = d->newMouseHandler(mouse.at(i));
            setMouseHandler(handler);
            /* XXX handle mouse cursor visibility sensibly
               if (!h->inherits("QCalibratedMouseHandler"))
               needviscurs = true;
            */
        }
    }
#ifndef QT_NO_QWS_CURSOR
    setCursorVisible(needviscurs);
#else
    Q_UNUSED(needviscurs)
#endif
}

processEventQueue()

void QWSServer::processEventQueue ( )

static

Warning

This function is not part of the public interface.

Definition at line 1963 of file qwindowsystem_qws.cpp.

Referenced by QWSDisplay::Data::fillQueue(), and QEventDispatcherQWS::processEvents().

{
    if (qwsServerPrivate)
        qwsServerPrivate->doClient(qwsServerPrivate->clientMap.value(-1));
}

processKeyEvent()

void QWSServer::processKeyEvent ( int  unicode, int  keycode, Qt::KeyboardModifiers  modifiers, bool  isPress, bool  autoRepeat  )

static

Processes the given key event.

The key is identified by its unicode value and the given keycode, modifiers, isPress and autoRepeat parameters.

The keycode parameter is the Qt keycode value as defined by the Qt::Key enum. The modifiers is an OR combination of Qt::KeyboardModifier values, indicating whether Shift/Alt/Ctrl keys are pressed. The isPress parameter is true if the event is a key press event and autoRepeat is true if the event is caused by an auto-repeat mechanism and not an actual key press.

This function is typically called internally by keyboard drivers. Note that this function can only be used in the server process.

See also

sendKeyEvent(), {Qt for Embedded Linux Character Input}

Definition at line 4248 of file qwindowsystem_qws.cpp.

Referenced by QWSKeyboardHandler::processKeyEvent(), QVFbKeyboardHandler::readKeyboardData(), and QWSUmKeyboardHandlerPrivate::readKeyboardData().

{
    bool block;
    // Don't block the POWER or LIGHT keys
    if ( keycode == Qt::Key_F34 || keycode == Qt::Key_F35 )
        block = false;
    else
        block = qwsServerPrivate->screensaverblockevent(KEY, qwsServerPrivate->screensaverinterval, isPress);

#ifdef EVENT_BLOCK_DEBUG
    qDebug() << "processKeyEvent" << unicode << keycode << modifiers << isPress << autoRepeat << (block ? "block" : "pass");
#endif

    // If we press a key and it's going to be blocked, wake up the screen
    if (block) {
        if (isPress)
            qwsServerPrivate->_q_screenSaverWake();
        return;
    }

    if (keyFilters) {
        for (int i = 0; i < keyFilters->size(); ++i) {
            QWSServer::KeyboardFilter *keyFilter = keyFilters->at(i);
            if (keyFilter->filter(unicode, keycode, modifiers, isPress, autoRepeat))
                return;
        }
    }
    sendKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat);
}

refresh() [1/2]

void QWSServer::refresh

(

)

Refreshes the display by making the screen driver update the entire display.

See also

QScreen::exposeRegion()

Definition at line 2213 of file qwindowsystem_qws.cpp.

Referenced by endDisplayReconfigure(), QWSTtyKbPrivate::handleConsoleSwitch(), and QApplicationPrivate::setScreenTransformation().

{
    Q_D(QWSServer);
    d->exposeRegion(QScreen::instance()->region());
//### send repaint to non-buffered windows
}

refresh() [2/2]

void QWSServer::refresh

(

QRegion &

region

)

Refreshes the given region of the display.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2229 of file qwindowsystem_qws.cpp.

{
    Q_D(QWSServer);
    d->exposeRegion(r);
//### send repaint to non-buffered windows
}

removedChannel

void QWSServer::removedChannel ( const QString &  channel )

signal

This signal is emitted immediately after the given the QCopChannel object specified by channel, is destroyed.

Note that a channel is not destroyed until all its listeners have been unregistered.

See also

newChannel()

removeKeyboardFilter()

void QWSServer::removeKeyboardFilter ( )

static

Removes and deletes the most recently added filter.

Note that the programmer is responsible for removing each added keyboard filter.

Note that this function can only be used in the server process.

See also

addKeyboardFilter()

Definition at line 4323 of file qwindowsystem_qws.cpp.

{
     if (!keyFilters || keyFilters->isEmpty())
         return;
     delete keyFilters->takeAt(0);
}

resetInputMethod()

void QWSServer::resetInputMethod ( )

static

Warning

This function is not part of the public interface.

Definition at line 3350 of file qwindowsystem_qws.cpp.

{
    if (current_IM && qwsServer) {
      current_IM->reset();
    }
}

resumeMouse()

void QWSServer::resumeMouse

(

)

Resumes pointer handling by reactivating all the mouse drivers registered by the QWS_MOUSE_PROTO environment variable.

See also

suspendMouse(), QWSMouseHandler::resume()

Definition at line 3790 of file qwindowsystem_qws.cpp.

Referenced by QWSTtyKbPrivate::handleConsoleSwitch().

{
    Q_D(QWSServer);
    for (int i=0; i < d->mousehandlers.size(); ++i)
        d->mousehandlers.at(i)->resume();
}

screenSaverActivate()

void QWSServer::screenSaverActivate ( bool  activate )

static

Activates the screen saver if activate is true; otherwise it is deactivated.

Note that this function can only be used in the server process.

See also

screenSaverActive(), setScreenSaver()

Definition at line 4565 of file qwindowsystem_qws.cpp.

{
    if (activate)
        qwsServerPrivate->_q_screenSaverSleep();
    else
        qwsServerPrivate->_q_screenSaverWake();
}

screenSaverActive()

bool QWSServer::screenSaverActive ( )

static

Returns true if the screen saver is active; otherwise returns false.

Note that this function can only be used in the server process.

See also

screenSaverActivate()

Definition at line 4543 of file qwindowsystem_qws.cpp.

{
    return qwsServerPrivate->screensaverinterval
        && !qwsServerPrivate->screensavertimer->isActive();
}

sendIMEvent()

void QWSServer::sendIMEvent

(

const QInputMethodEvent *

event

)

Sends the given input method event.

The QInputMethodEvent class is derived from QWSEvent, i.e., it is a QWSEvent object of the QWSEvent::IMEvent type.

If there is a window actively composing the preedit string, the event is sent to that window. Otherwise, the event is sent to the window currently in focus.

See also

sendIMQuery(), QWSInputMethod::sendEvent()

Definition at line 2801 of file qwindowsystem_qws.cpp.

Referenced by QWSInputMethod::sendCommitString(), QWSInputMethod::sendEvent(), and QWSInputMethod::sendPreeditString().

{
    QWSIMEvent event;

    QWSWindow *win = keyboardGrabber ? keyboardGrabber :
                     qwsServerPrivate->focusw;

    //if currently composing then event must go to the composing window

    if (current_IM_composing_win)
        win = current_IM_composing_win;

    event.simpleData.window = win ? win->winId() : 0;
    event.simpleData.replaceFrom = ime->replacementStart();;
    event.simpleData.replaceLength = ime->replacementLength();

    QBuffer buffer;
    buffer.open(QIODevice::WriteOnly);
    QDataStream out(&buffer);

    out << ime->preeditString();
    out << ime->commitString();

    const QList<QInputMethodEvent::Attribute> &attributes = ime->attributes();
    for (int i = 0; i < attributes.count(); ++i) {
        const QInputMethodEvent::Attribute &a = attributes.at(i);
        out << a.type << a.start << a.length << a.value;
    }
    event.setData(buffer.data(), buffer.size());
    QWSClient *serverClient = qwsServerPrivate->clientMap.value(-1);
    if (serverClient)
        serverClient->sendEvent(&event);
    if (win && win->client() && win->client() != serverClient)
        win->client()->sendEvent(&event);

    current_IM_composing_win = ime->preeditString().isEmpty() ? 0 : win;
    current_IM_winId = win ? win->winId() : 0;
}

sendIMQuery()

void QWSServer::sendIMQuery

(

int

property

)

Sends an input method query for the given property.

To receive responses to input method queries, the virtual QWSInputMethod::queryResponse() function must be reimplemented in a QWSInputMethod subclass that is activated using the setCurrentInputMethod() function.

See also

sendIMEvent(), setCurrentInputMethod()

Definition at line 2851 of file qwindowsystem_qws.cpp.

Referenced by QWSInputMethod::sendQuery().

{
    QWSIMQueryEvent event;

    QWSWindow *win = keyboardGrabber ? keyboardGrabber :
                     qwsServerPrivate->focusw;
    if (current_IM_composing_win)
        win = current_IM_composing_win;

    event.simpleData.window = win ? win->winId() : 0;
    event.simpleData.property = property;
    if (win && win->client())
        win->client()->sendEvent(&event);
}

sendKeyEvent()

void QWSServer::sendKeyEvent ( int  unicode, int  keycode, Qt::KeyboardModifiers  modifiers, bool  isPress, bool  autoRepeat  )

static

Sends the given key event.

The key is identified by its unicode value and the given keycode, modifiers, isPress and autoRepeat parameters.

Use this function to send key events generated by "virtual keyboards" (note that the processKeyEvent() function is impelemented using this function).

The keycode parameter is the Qt keycode value as defined by the Qt::Key enum. The modifiers is an OR combination of Qt::KeyboardModifier values, indicating whether Shift/Alt/Ctrl keys are pressed. The isPress parameter is true if the event is a key press event and autoRepeat is true if the event is caused by an auto-repeat mechanism and not an actual key press.

Note that this function can only be used in the server process.

See also

processKeyEvent(), {Qt for Embedded Linux Character Input}

Definition at line 2652 of file qwindowsystem_qws.cpp.

Referenced by QVNCServer::keyEvent(), and processKeyEvent().

{
    qws_keyModifiers = modifiers;

    if (isPress) {
        if (keycode != Qt::Key_F34 && keycode != Qt::Key_F35)
            qwsServerPrivate->_q_screenSaverWake();
    }

#ifndef QT_NO_QWS_INPUTMETHODS

    if (!current_IM || !current_IM->filter(unicode, keycode, modifiers, isPress, autoRepeat))
        QWSServerPrivate::sendKeyEventUnfiltered(unicode, keycode, modifiers, isPress, autoRepeat);
#else
    QWSServerPrivate::sendKeyEventUnfiltered(unicode, keycode, modifiers, isPress, autoRepeat);
#endif
}

sendMouseEvent()

void QWSServer::sendMouseEvent ( const QPoint &  pos, int  state, int  wheel = 0  )

static

Send a mouse event.

Warning

This function is not part of the public interface.

pos is the screen position where the mouse event occurred and state is a mask indicating which buttons are pressed.

pos is in device coordinates

Definition at line 2334 of file qwindowsystem_qws.cpp.

Referenced by QWSMouseHandler::mouseChanged(), and QVNCServer::pointerEvent().

{
    bool block = qwsServerPrivate->screensaverblockevent(MOUSE, qwsServerPrivate->screensaverinterval, state);
#ifdef EVENT_BLOCK_DEBUG
    qDebug() << "sendMouseEvent" << pos.x() << pos.y() << state << (block ? "block" : "pass");
#endif

    if (state || wheel)
        qwsServerPrivate->_q_screenSaverWake();

    if ( block )
        return;

    QPoint tpos;
    // transformations
    if (qt_screen->isTransformed()) {
    QSize s = QSize(qt_screen->deviceWidth(), qt_screen->deviceHeight());
    tpos = qt_screen->mapFromDevice(pos, s);
    } else {
    tpos = pos;
    }

    if (qt_last_x) {
         *qt_last_x = tpos.x();
         *qt_last_y = tpos.y();
    }
    QWSServer::mousePosition = tpos;
    qwsServerPrivate->mouseState = state;

#ifndef QT_NO_QWS_INPUTMETHODS
    const int btnMask = Qt::LeftButton | Qt::RightButton | Qt::MidButton;
    int stroke_count; // number of strokes to keep shown.
    if (force_reject_strokeIM || !current_IM)
    {
    stroke_count = 0;
    } else {
    stroke_count = current_IM->filter(tpos, state, wheel);
    }

    if (stroke_count == 0) {
    if (state&btnMask)
        force_reject_strokeIM = true;
        QWSServerPrivate::sendMouseEventUnfiltered(tpos, state, wheel);
    }
    // stop force reject after stroke ends.
    if (state&btnMask && force_reject_strokeIM)
    force_reject_strokeIM = false;
    // on end of stroke, force_rejct
    // and once a stroke is rejected, do not try again till pen is lifted
#else
    QWSServerPrivate::sendMouseEventUnfiltered(tpos, state, wheel);
#endif // end QT_NO_QWS_FSIM
}

sendPropertyNotifyEvent()

void QWSServer::sendPropertyNotifyEvent	(	int	property,
		int	state
	)

Warning

This function is not part of the public interface.

Definition at line 2896 of file qwindowsystem_qws.cpp.

{
    Q_D(QWSServer);
    QWSServerPrivate::ClientIterator it = d->clientMap.begin();
    while (it != d->clientMap.end()) {
        QWSClient *cl = *it;
        ++it;
        cl->sendPropertyNotifyEvent(property, state);
    }
}

setBackground()

void QWSServer::setBackground ( const QBrush &  brush )

static

Sets the brush used as background in the absence of obscuring windows, to be the given brush.

Note that this function can only be used in the server process.

See also

backgroundBrush()

Definition at line 4126 of file qwindowsystem_qws.cpp.

{
    if (!QWSServerPrivate::bgBrush)
        QWSServerPrivate::bgBrush = new QBrush(brush);
    else
        *QWSServerPrivate::bgBrush = brush;
    if (!qwsServer)
        return;
    qt_screen->exposeRegion(QRect(0,0,qt_screen->width(), qt_screen->height()), 0);
}

setCurrentInputMethod()

void QWSServer::setCurrentInputMethod ( QWSInputMethod *  method )

static

Sets the current input method to be the given method.

Note that this function can only be used in the server process.

See also

sendIMQuery(), sendIMEvent()

Definition at line 2877 of file qwindowsystem_qws.cpp.

{
    if (current_IM)
        current_IM->reset(); //??? send an update event instead ?
    current_IM = im;
}

setCursorVisible()

void QWSServer::setCursorVisible ( bool  visible )

static

Shows the cursor if visible is true: otherwise the cursor is hidden.

Note that this function can only be used in the server process.

See also

isCursorVisible()

Definition at line 2761 of file qwindowsystem_qws.cpp.

Referenced by openMouse().

{
    if (qwsServerPrivate && qwsServerPrivate->haveviscurs != vis) {
        QWSCursor* c = qwsServerPrivate->cursor;
        qwsServerPrivate->setCursor(QWSCursor::systemCursor(Qt::BlankCursor));
        qwsServerPrivate->haveviscurs = vis;
        qwsServerPrivate->setCursor(c);
    }
}

setDefaultKeyboard()

void QWSServer::setDefaultKeyboard ( const char *  keyboardDriver )

static

Sets the keyboard driver that will be used if the QWS_KEYBOARD environment variable is not defined, to be the given keyboardDriver.

Note that the default is platform-dependent. This function can only be used in the server process.

See also

setKeyboardHandler(), {Qt for Embedded Linux Character Input}

Definition at line 2309 of file qwindowsystem_qws.cpp.

Referenced by QIntfbScreen::connect(), QVNCScreen::connect(), QVFbScreen::initDevice(), and QDirectFBScreen::initDevice().

{
    *defaultKeyboard() = QString::fromAscii(k);
}

setDefaultMouse()

void QWSServer::setDefaultMouse ( const char *  mouseDriver )

static

Sets the mouse driver that will be used if the QWS_MOUSE_PROTO environment variable is not defined, to be the given mouseDriver.

Note that the default is platform-dependent. This function can only be used in the server process.

See also

setMouseHandler(), {Qt for Embedded Linux Pointer Handling}

Definition at line 2292 of file qwindowsystem_qws.cpp.

Referenced by QIntfbScreen::connect(), QVNCScreen::connect(), QVFbScreen::initDevice(), and QDirectFBScreen::initDevice().

{
    *defaultMouse() = QString::fromAscii(m);
}

setKeyboardHandler()

void QWSServer::setKeyboardHandler ( QWSKeyboardHandler *  driver )

static

Sets the primary keyboard driver to be the given driver.

Qt for Embedded Linux provides several ready-made keyboard drivers, and custom drivers are typically added using Qt's plugin mechanism. See the Qt for Embedded Linux Character Input documentation for details.

Note that this function can only be used in the server process.

See also

keyboardHandler(), setDefaultKeyboard()

Definition at line 3874 of file qwindowsystem_qws.cpp.

Referenced by openKeyboard().

{
    if (!kh)
        return;
    qwsServerPrivate->keyboardhandlers.removeAll(kh);
    qwsServerPrivate->keyboardhandlers.prepend(kh);
}

setMaxWindowRect()

void QWSServer::setMaxWindowRect ( const QRect &  rectangle )

static

Sets the maximum area of the screen that Qt for Embedded Linux applications can use, to be the given rectangle.

Note that this function can only be used in the server process.

See also

QWidget::showMaximized()

Definition at line 2249 of file qwindowsystem_qws.cpp.

{
    QList<QScreen*> subScreens = qt_screen->subScreens();
    if (subScreens.isEmpty() && qt_screen != 0)
        subScreens.append(qt_screen);

    for (int i = 0; i < subScreens.size(); ++i) {
        const QScreen *screen = subScreens.at(i);
        const QRect r = (screen->region() & rect).boundingRect();
        if (r.isEmpty())
            continue;

        QApplicationPrivate *ap = QApplicationPrivate::instance();
        if (ap->maxWindowRect(screen) != r) {
            ap->setMaxWindowRect(screen, i, r);
            qwsServerPrivate->sendMaxWindowRectEvents(r);
        }
    }
}

setMouseHandler()

void QWSServer::setMouseHandler ( QWSMouseHandler *  driver )

static

Sets the primary mouse driver to be the given driver.

Qt for Embedded Linux provides several ready-made mouse drivers, and custom drivers are typically added using Qt's plugin mechanism. See the Qt for Embedded Linux Pointer Handling documentation for details.

Note that this function can only be used in the server process.

See also

mouseHandler(), setDefaultMouse()

Definition at line 2534 of file qwindowsystem_qws.cpp.

Referenced by openMouse().

{
    if (!mh)
        return;
    qwsServerPrivate->mousehandlers.removeAll(mh);
    qwsServerPrivate->mousehandlers.prepend(mh);
}

setScreenSaver()

void QWSServer::setScreenSaver ( QWSScreenSaver *  screenSaver )

static

Installs the given screenSaver, deleting the current screen saver.

Note that this function can only be used in the server process.

See also

screenSaverActivate(), setScreenSaverInterval(), setScreenSaverIntervals(), setScreenSaverBlockLevel()

Definition at line 4474 of file qwindowsystem_qws.cpp.

{
    QWSServerPrivate *qd = qwsServer->d_func();
    delete qd->saver;
    qd->saver = ss;
}

setScreenSaverBlockLevel()

void QWSServer::setScreenSaverBlockLevel ( int  eventBlockLevel )

static

Block the key or mouse event that wakes the system from level eventBlockLevel or higher.

To completely disable event blocking (the default behavior), set eventBlockLevel to -1.

The algorithm blocks the "down", "up" as well as any "repeat" events for the same key but will not block other key events after the initial "down" event. For mouse events, the algorithm blocks all mouse events until an event with no buttons pressed is received.

There are 2 keys that are never blocked, Qt::Key_F34 (POWER) and Qt::Key_F35 (LIGHT).

Example usage:

bool MyScreenSaver::save( int level )
{
    switch ( level ) {
        case 0:
            if ( dim_enabled ) {
                // dim the screen
            }
            return true;
        case 1:
            if ( screenoff_enabled ) {
                // turn off the screen
            }
            return true;
        case 2:
            if ( suspend_enabled ) {
                // suspend
            }
            return true;
        default:
            return false;
    }
}

...

int timings[4];

Note that this function can only be used in the server process.

See also

setScreenSaverIntervals(), setScreenSaverInterval()

Definition at line 4417 of file qwindowsystem_qws.cpp.

{
    if (!qwsServerPrivate)
        return;
    qwsServerPrivate->screensavereventblocklevel = eventBlockLevel;
#ifdef EVENT_BLOCK_DEBUG
    qDebug() << "QWSServer::setScreenSaverBlockLevel() " << eventBlockLevel;
#endif
}

setScreenSaverInterval()

void QWSServer::setScreenSaverInterval ( int  milliseconds )

static

Sets the timeout interval for the screensaver to the specified milliseconds.

To turn off the screensaver, set the timout interval to 0.

Note that this function can only be used in the server process.

See also

setScreenSaverIntervals(), setScreenSaverBlockLevel()

Definition at line 4391 of file qwindowsystem_qws.cpp.

{
    int v[2];
    v[0] = ms;
    v[1] = 0;
    setScreenSaverIntervals(v);
}

setScreenSaverIntervals()

void QWSServer::setScreenSaverIntervals ( int *  intervals )

static

Specifies the time intervals (in milliseconds) between the different levels of screen responsiveness.

Qt for Embedded Linux supports multilevel screen saving, i.e., it is possible to specify several different levels of screen responsiveness by implementing the QWSScreenSaver::save() function. For example, you can choose to first turn off the light before you fully activate the screensaver. See the QWSScreenSaver documentation for details.

Note that an interval of 0 milliseconds will turn off the screensaver, and that the intervals array must be 0-terminated. This function can only be used in the server process.

See also

setScreenSaverInterval(), setScreenSaverBlockLevel()

Definition at line 4350 of file qwindowsystem_qws.cpp.

Referenced by setScreenSaverInterval().

{
    if (!qwsServerPrivate)
        return;

    delete [] qwsServerPrivate->screensaverintervals;
    if (ms) {
        int* t=ms;
        int n=0;
        while (*t++) n++;
        if (n) {
            n++; // the 0
            qwsServerPrivate->screensaverintervals = new int[n];
            memcpy(qwsServerPrivate->screensaverintervals, ms, n*sizeof(int));
        } else {
            qwsServerPrivate->screensaverintervals = 0;
        }
    } else {
        qwsServerPrivate->screensaverintervals = 0;
    }
    qwsServerPrivate->screensaverinterval = 0;

    qwsServerPrivate->screensavertimer->stop();
    qt_screen->blank(false);
    qwsServerPrivate->_q_screenSaverWake();
}

startup()

void QWSServer::startup ( int  flags )

static

Warning

This function is not part of the public interface.

Definition at line 4195 of file qwindowsystem_qws.cpp.

Referenced by qt_init().

{
    if (qwsServer)
        return;
    unlink(qws_qtePipeFilename().toLatin1().constData());
    (void)new QWSServer(flags);
}

suspendMouse()

void QWSServer::suspendMouse

(

)

Suspends pointer handling by deactivating all the mouse drivers registered by the QWS_MOUSE_PROTO environment variable.

See also

resumeMouse(), QWSMouseHandler::suspend()

Definition at line 3777 of file qwindowsystem_qws.cpp.

Referenced by QWSTtyKbPrivate::handleConsoleSwitch().

{
    Q_D(QWSServer);
    for (int i=0; i < d->mousehandlers.size(); ++i)
        d->mousehandlers.at(i)->suspend();
}

timerEvent()

void QWSServer::timerEvent ( QTimerEvent *  e )

protectedvirtual

Warning

This function is not part of the public interface.

Reimplemented from QObject.

Definition at line 1575 of file qwindowsystem_qws.cpp.

{
    Q_D(QWSServer);
    if (e->timerId() == d->fontCleanupTimer.timerId()) {
        d->cleanupFonts();
        d->fontCleanupTimer.stop();
    } else {
        QObject::timerEvent(e);
    }
}

updateWindowRegions()

void QWSServer::updateWindowRegions ( ) const

private

Warning

This function is not part of the public interface.

Definition at line 4552 of file qwindowsystem_qws.cpp.

Referenced by QApplicationPrivate::setScreenTransformation().

{
    qwsServerPrivate->update_regions();
}

windowAt()

QWSWindow * QWSServer::windowAt

(

const QPoint &

position

)

Returns the window containing the given position.

Note that if there is no window under the specified point this function returns 0.

See also

clientWindows(), instance()

Definition at line 2606 of file qwindowsystem_qws.cpp.

Referenced by QWSServerPrivate::sendMouseEventUnfiltered(), QWSServerPrivate::updateClientCursorPos(), and QWSDisplay::windowAt().

{
    Q_D(QWSServer);
    for (int i=0; i<d->windows.size(); ++i) {
        QWSWindow* w = d->windows.at(i);
        if (w->allocatedRegion().contains(pos))
            return w;
    }
    return 0;
}

windowEvent

QWSServer::windowEvent ( QWSWindow *  window, QWSServer::WindowEvent  eventType  )

signal

This signal is emitted whenever something happens to a top-level window (e.g., it's created or destroyed), passing a pointer to the window and the event's type in the window and eventType parameters, respectively.

See also

markedText()

windowList()

QList< QWSInternalWindowInfo * > * QWSServer::windowList ( )

static

Warning

This function is not part of the public interface.

Definition at line 2547 of file qwindowsystem_qws.cpp.

Referenced by QWSDisplay::windowList().

{
    QList<QWSInternalWindowInfo*> * ret=new QList<QWSInternalWindowInfo*>;
    for (int i=0; i < qwsServerPrivate->windows.size(); ++i) {
        QWSWindow *window = qwsServerPrivate->windows.at(i);
        QWSInternalWindowInfo * qwi=new QWSInternalWindowInfo();
        qwi->winid=window->winId();
        qwi->clientid=window->client()->clientId();
        ret->append(qwi);
    }
    return ret;
}

Friends and Related Functions

QApplicationPrivate

friend class QApplicationPrivate

friend

Definition at line 344 of file qwindowsystem_qws.h.

QCopChannel

friend class QCopChannel

friend

Definition at line 211 of file qwindowsystem_qws.h.

QWSDisplay

friend class QWSDisplay

friend

Definition at line 214 of file qwindowsystem_qws.h.

QWSInputMethod

friend class QWSInputMethod

friend

Definition at line 215 of file qwindowsystem_qws.h.

QWSMouseHandler

friend class QWSMouseHandler

friend

Definition at line 212 of file qwindowsystem_qws.h.

QWSWindow

friend class QWSWindow

friend

Definition at line 213 of file qwindowsystem_qws.h.

Referenced by QWSServerPrivate::newWindow().

Properties

mousePosition

QPoint QWSServer::mousePosition

static

Definition at line 309 of file qwindowsystem_qws.h.

Referenced by QWSServerPrivate::invokePositionCursor(), QWSServerPrivate::invokeSelectCursor(), openKeyboard(), and sendMouseEvent().

---

The documentation for this class was generated from the following files:

• /src/gui/embedded/qwindowsystem_qws.h
• /src/gui/embedded/qwindowsystem_qws.cpp