QWSServerPrivate Class Reference

#include <qwindowsystem_p.h>

Inheritance diagram for QWSServerPrivate:

Classes
struct	SelectionOwner

Public Functions
	QWSServerPrivate ()
bool	screensaverblockevent (int index, int *screensaverinterval, bool isDown)
void	update_regions ()
	~QWSServerPrivate ()
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
QList< int >	crashedClientIds
QWSClient *	cursorClient
QList< QWSWindow * >	deletedWindows
int	mouseState
QWSScreenSaver *	saver
bool	screensaverblockevents
int	screensavereventblocklevel
int *	screensaverintervals
QTime	screensavertime
QTimer *	screensavertimer
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Private Types
typedef QMap< int, QWSClient * >::Iterator	ClientIterator
typedef QMap< int, QWSClient * >	ClientMap

Private Functions
void	_q_clientClosed ()
void	_q_deleteWindowsLater ()
void	_q_doClient ()
void	_q_newConnection ()
void	_q_screenSaverSleep ()
void	_q_screenSaverTimeout ()
void	_q_screenSaverWake ()
void	cleanupFonts (bool force=false)
void	closeDisplay ()
void	dereferenceFont (QWSClientPrivate *client, const QByteArray &font)
void	destroy_region (const QWSRegionDestroyCommand *)
void	disconnectClient (QWSClient *)
void	doClient (QWSClient *)
void	exposeRegion (const QRegion &, int index=0)
QWSWindow *	findWindow (int windowid, QWSClient *client=0)
bool	get_property (int winId, int property, const char *&data, int &len)
void	handleWindowClose (QWSWindow *w)
void	hideCursor ()
void	im_response (const QWSIMResponseCommand *)
void	im_update (const QWSIMUpdateCommand *)
void	initializeCursor ()
void	initIO ()
void	initServer (int flags)
void	invokeAddProperty (QWSAddPropertyCommand *cmd)
void	invokeConvertSelection (QWSConvertSelectionCommand *cmd)
void	invokeCreate (QWSCreateCommand *cmd, QWSClient *client)
void	invokeDefineCursor (QWSDefineCursorCommand *cmd, QWSClient *client)
void	invokeEmbed (QWSEmbedCommand *cmd, QWSClient *client)
void	invokeFont (const QWSFontCommand *cmd, QWSClient *client)
void	invokeGetProperty (QWSGetPropertyCommand *cmd, QWSClient *client)
void	invokeGrabKeyboard (QWSGrabKeyboardCommand *cmd, QWSClient *client)
void	invokeGrabMouse (QWSGrabMouseCommand *cmd, QWSClient *client)
void	invokeIdentify (const QWSIdentifyCommand *cmd, QWSClient *client)
void	invokeIMResponse (const QWSIMResponseCommand *cmd, QWSClient *client)
void	invokeIMUpdate (const QWSIMUpdateCommand *cmd, QWSClient *client)
void	invokePlaySound (QWSPlaySoundCommand *cmd, QWSClient *client)
void	invokePositionCursor (QWSPositionCursorCommand *cmd, QWSClient *client)
void	invokeQCopSend (QWSQCopSendCommand *cmd, QWSClient *client)
void	invokeRegion (QWSRegionCommand *cmd, QWSClient *client)
void	invokeRegionDestroy (const QWSRegionDestroyCommand *cmd, QWSClient *client)
void	invokeRegionMove (const QWSRegionMoveCommand *cmd, QWSClient *client)
void	invokeRegionName (const QWSRegionNameCommand *cmd, QWSClient *client)
void	invokeRegisterChannel (QWSQCopRegisterChannelCommand *cmd, QWSClient *client)
void	invokeRemoveProperty (QWSRemovePropertyCommand *cmd)
void	invokeRepaintRegion (QWSRepaintRegionCommand *cmd, QWSClient *client)
void	invokeScreenTransform (const QWSScreenTransformCommand *cmd, QWSClient *client)
void	invokeSelectCursor (QWSSelectCursorCommand *cmd, QWSClient *client)
void	invokeSetAltitude (const QWSChangeAltitudeCommand *cmd, QWSClient *client)
void	invokeSetFocus (const QWSRequestFocusCommand *cmd, QWSClient *client)
void	invokeSetOpacity (const QWSSetOpacityCommand *cmd, QWSClient *client)
void	invokeSetProperty (QWSSetPropertyCommand *cmd)
void	invokeSetSelectionOwner (QWSSetSelectionOwnerCommand *cmd)
void	lowerWindow (QWSWindow *, int=-1)
void	move_region (const QWSRegionMoveCommand *)
void	moveWindowRegion (QWSWindow *, int dx, int dy)
void	name_region (const QWSRegionNameCommand *)
QWSMouseHandler *	newMouseHandler (const QString &spec)
QWSWindow *	newWindow (int id, QWSClient *client)
void	openDisplay ()
void	raiseWindow (QWSWindow *, int=0)
void	referenceFont (QWSClientPrivate *client, const QByteArray &font)
void	releaseKeyboard (QWSWindow *w)
void	releaseMouse (QWSWindow *w)
void	repaint_region (int winId, int windowFlags, bool opaque, const QRegion &)
void	request_focus (const QWSRequestFocusCommand *)
void	request_region (int winId, const QString &surfaceKey, const QByteArray &surfaceData, const QRegion &region)
QRegion	reserve_region (QWSWindow *window, const QRegion &region)
void	resetEngine ()
void	screenSave (int level)
void	send_im_mouse (const QWSIMMouseCommand *)
void	sendFontRemovedEvent (const QByteArray &font)
void	sendMaxWindowRectEvents (const QRect &rect)
void	set_altitude (const QWSChangeAltitudeCommand *)
void	set_identity (const QWSIdentifyCommand *)
void	set_opacity (const QWSSetOpacityCommand *)
void	setCursor (QWSCursor *curs)
void	setFocus (QWSWindow *, bool gain)
void	setWindowRegion (QWSWindow *, const QRegion &r)
	Changes the requested region of window changingw to r If changingw is 0, the server's reserved region is changed. More...
void	showCursor ()
void	updateClientCursorPos ()

Static Private Functions
static void	emergency_cleanup ()
static void	sendKeyEventUnfiltered (int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat)
static void	sendMouseEventUnfiltered (const QPoint &pos, int state, int wheel=0)
static void	sendQCopEvent (QWSClient *c, const QString &ch, const QString &msg, const QByteArray &data, bool response=false)

Properties
QMap< QString, QList< QWSClient * > >	channels
ClientMap	clientMap
QList< QWSCommandStruct * >	commandQueue
QWSCursor *	cursor
bool	disablePainting
bool	doClientIsActive
QWSWindow *	focusw
QBasicTimer	fontCleanupTimer
QMap< QByteArray, int >	fontReferenceCount
bool	haveviscurs
bool	inputMethodMouseGrabbed
QList< QWSKeyboardHandler * >	keyboardhandlers
QWSWindow *	mouseGrabber
bool	mouseGrabbing
QList< QWSMouseHandler * >	mousehandlers
QWSCursor *	nextCursor
int	nReserved
QList< QWSClient * >	pendingDoClients
QWSPropertyManager	propertyManager
int	ramlen
int *	screensaverinterval
int	sdepth
struct QWSServerPrivate::SelectionOwner	selectionOwner
uchar *	sharedram
int	sheight
QWSSoundServer *	soundserver
QWSServerSocket *	ssocket
int	swidth
QTime	timer
QList< QWSWindow * >	windows

Static Private Attributes
static QBrush *	bgBrush = 0

Friends
class	QCopChannel
class	QWSDisplay
class	QWSInputMethod
class	QWSMouseHandler
class	QWSWindow

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 66 of file qwindowsystem_p.h.

Typedefs

ClientIterator

typedef QMap<int,QWSClient*>::Iterator QWSServerPrivate::ClientIterator

private

Definition at line 231 of file qwindowsystem_p.h.

ClientMap

typedef QMap<int,QWSClient*> QWSServerPrivate::ClientMap

private

Definition at line 232 of file qwindowsystem_p.h.

Constructors and Destructors

QWSServerPrivate()

QWSServerPrivate::QWSServerPrivate ( )

inline

Definition at line 75 of file qwindowsystem_p.h.

        : screensaverintervals(0)
        , screensavereventblocklevel(-1), screensaverblockevents(false)
        , saver(0), cursorClient(0), mouseState(0), nReserved(0)
        , doClientIsActive(false)
    {
    }

~QWSServerPrivate()

QWSServerPrivate::~QWSServerPrivate ( )

inline

Definition at line 82 of file qwindowsystem_p.h.

    {
        closeDisplay();

        qDeleteAll(deletedWindows);
        delete [] screensaverintervals;
        delete saver;

        qDeleteAll(windows);
        windows.clear();

        delete bgBrush;
        bgBrush = 0;
    }

Functions

_q_clientClosed()

void QWSServerPrivate::_q_clientClosed ( )

private

Warning

This function is not part of the public interface.

Definition at line 1703 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    QWSClient* cl = (QWSClient*)q->sender();

    // Remove any queued commands for this client
    int i = 0;
    while (i < commandQueue.size()) {
        QWSCommandStruct *cs = commandQueue.at(i);
        if (cs->client == cl) {
            commandQueue.removeAt(i);
            delete cs;
        } else {
            ++i;
        }
    }

#ifndef QT_NO_COP
    // Enfore unsubscription from all channels.
    QCopChannel::detach(cl);
#endif

    // Shut down all windows for this client
    for (int i = 0; i < windows.size(); ++i) {
        QWSWindow* w = windows.at(i);
        if (w->forClient(cl))
            w->shuttingDown();
    }

    // Delete all windows for this client
    QRegion exposed;
    i = 0;
    while (i < windows.size()) {
        QWSWindow* w = windows.at(i);
        if (w->forClient(cl)) {
            windows.takeAt(i);
            w->c = 0; //so we don't send events to it anymore
            releaseMouse(w);
            releaseKeyboard(w);
            exposed += w->allocatedRegion();
//                rgnMan->remove(w->allocationIndex());
            if (focusw == w)
                setFocus(focusw,0);
            if (mouseGrabber == w)
                releaseMouse(w);
            if (i < nReserved)
                --nReserved;
#ifndef QT_NO_QWS_PROPERTIES
            propertyManager.removeProperties(w->winId());
#endif
            emit q->windowEvent(w, QWSServer::Destroy);
            w->d->state = QWSWindow::Destroyed; //???
            deletedWindows.append(w);
        } else {
            ++i;
        }
    }
    if (deletedWindows.count())
        QTimer::singleShot(0, q, SLOT(_q_deleteWindowsLater()));

    QWSClientPrivate *clientPrivate = cl->d_func();
    if (!clientPrivate->shutdown) {
#if defined(QWS_DEBUG_FONTCLEANUP)
        qDebug() << "client" << cl->clientId() << "crashed";
#endif
        // this would be the place to emit a signal to notify about the
        // crash of a client
        crashedClientIds.append(cl->clientId());
        fontCleanupTimer.start(10, q_func());
    }
    clientPrivate->shutdown = true;

    while (!clientPrivate->usedFonts.isEmpty()) {
        const QByteArray font = *clientPrivate->usedFonts.begin();
#if defined(QWS_DEBUG_FONTCLEANUP)
        qDebug() << "dereferencing font" << font << "from disconnected client";
#endif
        dereferenceFont(clientPrivate, font);
    }
    clientPrivate->usedFonts.clear();

    //qDebug("removing client %d with socket %d", cl->clientId(), cl->socket());
    clientMap.remove(cl->socket());
    if (cl == cursorClient)
        cursorClient = 0;
    if (qt_screen->clearCacheFunc)
        (qt_screen->clearCacheFunc)(qt_screen, cl->clientId());  // remove any remaining cache entries.
    cl->deleteLater();

    update_regions();
    exposeRegion(exposed);
}

_q_deleteWindowsLater()

void QWSServerPrivate::_q_deleteWindowsLater ( )

private

Definition at line 1796 of file qwindowsystem_qws.cpp.

{
    qDeleteAll(deletedWindows);
    deletedWindows.clear();
}

_q_doClient()

void QWSServerPrivate::_q_doClient ( )

private

Definition at line 1971 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);

    QWSClient* client;
#ifndef QT_NO_SXE
    QAuthDevice *ad = qobject_cast<QAuthDevice*>(q->sender());
    if (ad)
        client = (QWSClient*)ad->client();
    else
#endif
        client = (QWSClient*)q->sender();

    if (doClientIsActive) {
        pendingDoClients.append(client);
        return;
    }
    doClientIsActive = true;

    doClient(client);

    while (!pendingDoClients.isEmpty()) {
        doClient(pendingDoClients.takeFirst());
    }

    doClientIsActive = false;
}

_q_newConnection()

void QWSServerPrivate::_q_newConnection ( )

private

Warning

This function is not part of the public interface.

Definition at line 1637 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    while (QWS_SOCK_BASE *sock = ssocket->nextPendingConnection()) {
        int socket = sock->socketDescriptor();
        sock->setParent(0);

        QWSClient *client = new QWSClient(q,sock, get_object_id());
        clientMap[socket] = client;

#ifndef QT_NO_SXE
#ifdef QTRANSPORTAUTH_DEBUG
        qDebug( "Transport auth connected: unix stream socket %d", socket );
#endif
        // get a handle to the per-process authentication service
        QTransportAuth *a = QTransportAuth::getInstance();

        // assert that this transport is trusted
        QTransportAuth::Data *d = a->connectTransport(
                QTransportAuth::UnixStreamSock |
                QTransportAuth::Trusted, socket );

        QAuthDevice *ad = a->recvBuf( d, sock );
        ad->setClient(client);

        QObject::connect(ad, SIGNAL(readyRead()),
                q, SLOT(_q_doClient()));

        QObject::connect(client, SIGNAL(connectionClosed()),
                q, SLOT(_q_clientClosed()));
#else
        QObject::connect(client, SIGNAL(readyRead()),
                         q, SLOT(_q_doClient()));
        QObject::connect(client, SIGNAL(connectionClosed()),
                         q, SLOT(_q_clientClosed()));
#endif // QT_NO_SXE

        client->sendConnectedEvent(qws_display_spec.constData());

        if (clientMap.contains(socket)) {
            QList<QScreen*> screens = qt_screen->subScreens();
            if (screens.isEmpty())
                screens.append(qt_screen);
            for (int i = 0; i < screens.size(); ++i) {
                const QApplicationPrivate *ap = QApplicationPrivate::instance();
                QScreen *screen = screens.at(i);
                const QRect rect = ap->maxWindowRect(screen);
                if (!rect.isEmpty())
                    client->sendMaxWindowRectEvent(rect);
                if (screen->isTransformed()) {
                    QWSScreenTransformationEvent event;
                    event.simpleData.screen = i;
                    event.simpleData.transformation = screen->transformOrientation();
                    client->sendEvent(&event);
                }
            }
        }

        // pre-provide some object id's
        QWSCreateCommand cmd(30);
        invokeCreate(&cmd, client);
    }
}

_q_screenSaverSleep()

void QWSServerPrivate::_q_screenSaverSleep ( )

private

Definition at line 4448 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::screenSaverActivate().

{
    qt_screen->blank(true);
#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_EBX)
    screensavertimer->stop();
#else
    if (screensaverinterval) {
        screensavertimer->start(*screensaverinterval);
        screensavertime.start();
    } else {
        screensavertimer->stop();
    }
#endif
    qt_disable_lowpriority_timers=true;
}

_q_screenSaverTimeout()

void QWSServerPrivate::_q_screenSaverTimeout ( )

private

Definition at line 4523 of file qwindowsystem_qws.cpp.

{
    if (screensaverinterval) {
        if (screensavertime.elapsed() > *screensaverinterval*2) {
            // bogus (eg. unsuspend, system time changed)
            _q_screenSaverWake(); // try again
            return;
        }
        screenSave(screensaverinterval - screensaverintervals);
    }
}

_q_screenSaverWake()

void QWSServerPrivate::_q_screenSaverWake ( )

private

Definition at line 4429 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::processKeyEvent(), QWSServer::screenSaverActivate(), QWSServer::sendKeyEvent(), QWSServer::sendMouseEvent(), and QWSServer::setScreenSaverIntervals().

{
    if (screensaverintervals) {
        if (screensaverinterval != screensaverintervals) {
            if (saver) saver->restore();
            screensaverinterval = screensaverintervals;
            screensaverblockevents = false;
        } else {
            if (!screensavertimer->isActive()) {
                qt_screen->blank(false);
                if (saver) saver->restore();
            }
        }
        screensavertimer->start(*screensaverinterval);
        screensavertime.start();
    }
    qt_disable_lowpriority_timers=false;
}

cleanupFonts()

void QWSServerPrivate::cleanupFonts ( bool  force = false )

private

Definition at line 1849 of file qwindowsystem_qws.cpp.

{
    static bool dontDelete = !qgetenv("QWS_KEEP_FONTS").isEmpty();
    if (dontDelete)
        return;

#if defined(QWS_DEBUG_FONTCLEANUP)
    qDebug() << "cleanupFonts()";
#endif
    if (!fontReferenceCount.isEmpty()) {
        QMap<QByteArray, int>::Iterator it = fontReferenceCount.begin();
        while (it != fontReferenceCount.end()) {
            if (it.value() && !force) {
                ++it;
                continue;
            }

            const QByteArray &fontName = it.key();
#if defined(QWS_DEBUG_FONTCLEANUP)
            qDebug() << "removing unused font file" << fontName;
#endif
            QT_TRY {
                QFile::remove(QFile::decodeName(fontName));
                sendFontRemovedEvent(fontName);

                it = fontReferenceCount.erase(it);
            } QT_CATCH(...) {
                // so we were not able to remove the font.
                // don't be angry and just continue with the next ones.
                ++it;
            }
        }
    }

    if (crashedClientIds.isEmpty())
        return;

    QList<QByteArray> removedFonts;
#if !defined(QT_NO_QWS_QPF2) && !defined(QT_FONTS_ARE_RESOURCES)
    removedFonts = QFontEngineQPF::cleanUpAfterClientCrash(crashedClientIds);
#endif
    crashedClientIds.clear();

    for (int i = 0; i < removedFonts.count(); ++i)
        sendFontRemovedEvent(removedFonts.at(i));
}

closeDisplay()

void QWSServerPrivate::closeDisplay ( )

private

Definition at line 4101 of file qwindowsystem_qws.cpp.

Referenced by ~QWSServerPrivate().

{
    if (qt_screen)
        qt_screen->shutdownDevice();
}

dereferenceFont()

void QWSServerPrivate::dereferenceFont ( QWSClientPrivate *  client, const QByteArray &  font  )

private

Definition at line 1817 of file qwindowsystem_qws.cpp.

{
    if (client->usedFonts.contains(font)) {
        client->usedFonts.remove(font);

        Q_ASSERT(fontReferenceCount[font]);
        if (!--fontReferenceCount[font] && !fontCleanupTimer.isActive())
            fontCleanupTimer.start(FontCleanupInterval, q_func());

#if defined(QWS_DEBUG_FONTCLEANUP)
        qDebug() << "Client" << client->q_func()->clientId() << "removed font" << font;
        qDebug() << "Refcount is" << fontReferenceCount[font];
#endif
    }
}

destroy_region()

void QWSServerPrivate::destroy_region ( const QWSRegionDestroyCommand *  cmd )

private

Definition at line 4064 of file qwindowsystem_qws.cpp.

{
    invokeRegionDestroy(cmd, clientMap.value(-1));
}

disconnectClient()

void QWSServerPrivate::disconnectClient ( QWSClient *  c )

private

Definition at line 4573 of file qwindowsystem_qws.cpp.

{
    QTimer::singleShot(0, c, SLOT(closeHandler()));
}

doClient()

void QWSServerPrivate::doClient ( QWSClient *  client )

private

Definition at line 2000 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::processEventQueue().

{
    QWSCommand* command=client->readMoreCommand();

    while (command) {
        QWSCommandStruct *cs = new QWSCommandStruct(command, client);
        commandQueue.append(cs);
        // Try for some more...
        command=client->readMoreCommand();
    }

    while (!commandQueue.isEmpty()) {
        QWSCommandStruct *cs = commandQueue.takeAt(0);
        switch (cs->command->type) {
        case QWSCommand::Identify:
            invokeIdentify((QWSIdentifyCommand*)cs->command, cs->client);
            break;
        case QWSCommand::Create:
            invokeCreate((QWSCreateCommand*)cs->command, cs->client);
            break;
#ifndef QT_NO_QWS_MULTIPROCESS
        case QWSCommand::Shutdown:
            cs->client->d_func()->shutdown = true;
            break;
#endif
        case QWSCommand::RegionName:
            invokeRegionName((QWSRegionNameCommand*)cs->command, cs->client);
            break;
        case QWSCommand::Region:
            invokeRegion((QWSRegionCommand*)cs->command, cs->client);
            cs->client->d_func()->unlockCommunication();
            break;
        case QWSCommand::RegionMove:
            invokeRegionMove((QWSRegionMoveCommand*)cs->command, cs->client);
            cs->client->d_func()->unlockCommunication();
            break;
        case QWSCommand::RegionDestroy:
            invokeRegionDestroy((QWSRegionDestroyCommand*)cs->command, cs->client);
            break;
#ifndef QT_NO_QWS_PROPERTIES
        case QWSCommand::AddProperty:
            invokeAddProperty((QWSAddPropertyCommand*)cs->command);
            break;
        case QWSCommand::SetProperty:
            invokeSetProperty((QWSSetPropertyCommand*)cs->command);
            break;
        case QWSCommand::RemoveProperty:
            invokeRemoveProperty((QWSRemovePropertyCommand*)cs->command);
            break;
        case QWSCommand::GetProperty:
            invokeGetProperty((QWSGetPropertyCommand*)cs->command, cs->client);
            break;
#endif
        case QWSCommand::SetSelectionOwner:
            invokeSetSelectionOwner((QWSSetSelectionOwnerCommand*)cs->command);
            break;
        case QWSCommand::RequestFocus:
            invokeSetFocus((QWSRequestFocusCommand*)cs->command, cs->client);
            break;
        case QWSCommand::ChangeAltitude:
            invokeSetAltitude((QWSChangeAltitudeCommand*)cs->command,
                               cs->client);
            cs->client->d_func()->unlockCommunication();
            break;
        case QWSCommand::SetOpacity:
            invokeSetOpacity((QWSSetOpacityCommand*)cs->command,
                               cs->client);
            break;

#ifndef QT_NO_QWS_CURSOR
        case QWSCommand::DefineCursor:
            invokeDefineCursor((QWSDefineCursorCommand*)cs->command, cs->client);
            break;
        case QWSCommand::SelectCursor:
            invokeSelectCursor((QWSSelectCursorCommand*)cs->command, cs->client);
            break;
        case QWSCommand::PositionCursor:
            invokePositionCursor((QWSPositionCursorCommand*)cs->command, cs->client);
            break;
#endif
        case QWSCommand::GrabMouse:
            invokeGrabMouse((QWSGrabMouseCommand*)cs->command, cs->client);
            break;
        case QWSCommand::GrabKeyboard:
            invokeGrabKeyboard((QWSGrabKeyboardCommand*)cs->command, cs->client);
            break;
#if !defined(QT_NO_SOUND) && !defined(Q_OS_DARWIN)
        case QWSCommand::PlaySound:
            invokePlaySound((QWSPlaySoundCommand*)cs->command, cs->client);
            break;
#endif
#ifndef QT_NO_COP
        case QWSCommand::QCopRegisterChannel:
            invokeRegisterChannel((QWSQCopRegisterChannelCommand*)cs->command,
                                   cs->client);
            break;
        case QWSCommand::QCopSend:
            invokeQCopSend((QWSQCopSendCommand*)cs->command, cs->client);
            break;
#endif
#ifndef QT_NO_QWS_INPUTMETHODS
        case QWSCommand::IMUpdate:
            invokeIMUpdate((QWSIMUpdateCommand*)cs->command, cs->client);
            break;
        case QWSCommand::IMResponse:
            invokeIMResponse((QWSIMResponseCommand*)cs->command, cs->client);
            break;
        case QWSCommand::IMMouse:
            {
                if (current_IM) {
                    QWSIMMouseCommand *cmd = (QWSIMMouseCommand *) cs->command;
                    current_IM->mouseHandler(cmd->simpleData.index,
                                              cmd->simpleData.state);
                }
            }
            break;
#endif
        case QWSCommand::Font:
            invokeFont((QWSFontCommand *)cs->command, cs->client);
            break;
        case QWSCommand::RepaintRegion:
            invokeRepaintRegion((QWSRepaintRegionCommand*)cs->command,
                                cs->client);
            cs->client->d_func()->unlockCommunication();
            break;
#ifndef QT_NO_QWSEMBEDWIDGET
        case QWSCommand::Embed:
            invokeEmbed(static_cast<QWSEmbedCommand*>(cs->command),
                        cs->client);
            break;
#endif
        case QWSCommand::ScreenTransform:
            invokeScreenTransform(static_cast<QWSScreenTransformCommand*>(cs->command),
                                  cs->client);
            break;
        }
        delete cs;
    }
}

emergency_cleanup()

void QWSServerPrivate::emergency_cleanup ( )

staticprivate

Definition at line 4219 of file qwindowsystem_qws.cpp.

{
#ifndef QT_NO_QWS_KEYBOARD
    if (qwsServer)
        qwsServer->closeKeyboard();
#endif
}

exposeRegion()

void QWSServerPrivate::exposeRegion ( const QRegion &  r, int  index = 0  )

private

Definition at line 3701 of file qwindowsystem_qws.cpp.

{
    if (disablePainting)
        return;

    if (r.isEmpty())
        return;

    static bool initial = true;
    if (initial) {
        changing = 0;
        initial = false;
        qt_screen->exposeRegion(qt_screen->region(), changing);
    } else {
        qt_screen->exposeRegion(r, changing);
    }
}

findWindow()

QWSWindow * QWSServerPrivate::findWindow ( int  windowid, QWSClient *  client = 0  )

private

Definition at line 3471 of file qwindowsystem_qws.cpp.

{
    for (int i=0; i<windows.size(); ++i) {
        QWSWindow* w = windows.at(i);
        if (w->winId() == windowid)
            return w;
    }
    if (client)
        return newWindow(windowid,client);
    else
        return 0;
}

get_property()

bool QWSServerPrivate::get_property ( int  winId, int  property, const char *&  data, int &  len  )

private

Definition at line 3173 of file qwindowsystem_qws.cpp.

{
    return propertyManager.getProperty(winId, property, data, len);
}

handleWindowClose()

void QWSServerPrivate::handleWindowClose ( QWSWindow *  w )

private

Definition at line 1621 of file qwindowsystem_qws.cpp.

{
    w->shuttingDown();
    if (focusw == w)
        setFocus(w,false);
    if (mouseGrabber == w)
        releaseMouse(w);
    if (keyboardGrabber == w)
        releaseKeyboard(w);
}

hideCursor()

void QWSServerPrivate::hideCursor ( )

private

Definition at line 2149 of file qwindowsystem_qws.cpp.

{
#ifndef QT_NO_QWS_CURSOR
    if (qt_screencursor)
        qt_screencursor->hide();
#endif
}

im_response()

void QWSServerPrivate::im_response ( const QWSIMResponseCommand *  cmd )

private

Definition at line 4075 of file qwindowsystem_qws.cpp.

 {
     invokeIMResponse(cmd, clientMap.value(-1));
}

im_update()

void QWSServerPrivate::im_update ( const QWSIMUpdateCommand *  cmd )

private

Definition at line 4080 of file qwindowsystem_qws.cpp.

{
    invokeIMUpdate(cmd, clientMap.value(-1));
}

initializeCursor()

void QWSServerPrivate::initializeCursor ( )

private

Definition at line 338 of file qwscursor_qws.cpp.

{
    Q_Q(QWSServer);
    // setup system cursors
#ifndef QT_NO_QWS_CURSOR
//    qt_screen->initCursor(sharedram + ramlen,true);

    // default cursor
    cursor = 0;
    setCursor(QWSCursor::systemCursor(Qt::ArrowCursor));
#endif
    q->sendMouseEvent(QPoint(swidth/2, sheight/2), 0);
}

initIO()

void QWSServerPrivate::initIO ( )

private

initServer()

void QWSServerPrivate::initServer ( int  flags )

private

Definition at line 1466 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    Q_ASSERT(!qwsServer);
    qwsServer = q;
    qwsServerPrivate = this;
    disablePainting = false;
#ifndef QT_NO_QWS_MULTIPROCESS
    ssocket = new QWSServerSocket(qws_qtePipeFilename(), q);
    QObject::connect(ssocket, SIGNAL(newConnection()), q, SLOT(_q_newConnection()));

    if ( !ssocket->isListening()) {
        perror("QWSServerPrivate::initServer: server socket not listening");
        qFatal("Failed to bind to %s", qws_qtePipeFilename().toLatin1().constData());
    }

    struct linger tmp;
    tmp.l_onoff=1;
    tmp.l_linger=0;
    setsockopt(ssocket->socketDescriptor(),SOL_SOCKET,SO_LINGER,(char *)&tmp,sizeof(tmp));


    signal(SIGPIPE, ignoreSignal); //we get it when we read
#endif
    focusw = 0;
    mouseGrabber = 0;
    mouseGrabbing = false;
    inputMethodMouseGrabbed = false;
    keyboardGrabber = 0;
    keyboardGrabbing = false;
#ifndef QT_NO_QWS_CURSOR
    haveviscurs = false;
    cursor = 0;
    nextCursor = 0;
#endif

#ifndef QT_NO_QWS_MULTIPROCESS

    if (!geteuid()) {
#if defined(Q_OS_LINUX) && !defined(QT_LINUXBASE)
        if(mount(0,"/var/shm", "shm", 0, 0)) {
            /* This just confuses people with 2.2 kernels
            if (errno != EBUSY)
                qDebug("Failed mounting shm fs on /var/shm: %s",strerror(errno));
            */
        }
#endif
    }
#endif

    // no selection yet
    selectionOwner.windowid = -1;
    selectionOwner.time.set(-1, -1, -1, -1);

    cleanupFontsDir();

    // initialize the font database
    // from qfontdatabase_qws.cpp
    extern void qt_qws_init_fontdb();
    qt_qws_init_fontdb();

    openDisplay();

    screensavertimer = new QTimer(q);
    screensavertimer->setSingleShot(true);
    QObject::connect(screensavertimer, SIGNAL(timeout()), q, SLOT(_q_screenSaverTimeout()));
    _q_screenSaverWake();

    clientMap[-1] = new QWSClient(q, 0, 0);

    if (!bgBrush)
        bgBrush = new QBrush(QColor(0x20, 0xb0, 0x50));

    initializeCursor();

    // input devices
    if (!(flags&QWSServer::DisableMouse)) {
        q->openMouse();
    }
#ifndef QT_NO_QWS_KEYBOARD
    if (!(flags&QWSServer::DisableKeyboard)) {
        q->openKeyboard();
    }
#endif

#if !defined(QT_NO_SOUND) && !defined(QT_EXTERNAL_SOUND_SERVER) && !defined(Q_OS_DARWIN)
    soundserver = new QWSSoundServer(q);
#endif
}

invokeAddProperty()

void QWSServerPrivate::invokeAddProperty ( QWSAddPropertyCommand *  cmd )

private

Definition at line 3138 of file qwindowsystem_qws.cpp.

{
    propertyManager.addProperty(cmd->simpleData.windowid, cmd->simpleData.property);
}

invokeConvertSelection()

void QWSServerPrivate::invokeConvertSelection ( QWSConvertSelectionCommand *  cmd )

private

Definition at line 3214 of file qwindowsystem_qws.cpp.

{
    qDebug("QWSServer::invokeConvertSelection");

    if (selectionOwner.windowid != -1) {
        QWSWindow *win = findWindow(selectionOwner.windowid, 0);
        if (win)
            win->client()->sendSelectionRequestEvent(cmd, selectionOwner.windowid);
        else
            qDebug("couldn't find window %d", selectionOwner.windowid);
    }
}

invokeCreate()

void QWSServerPrivate::invokeCreate ( QWSCreateCommand *  cmd, QWSClient *  client  )

private

Definition at line 2917 of file qwindowsystem_qws.cpp.

{
    QWSCreationEvent event;
    event.simpleData.objectid = get_object_id(cmd->count);
    event.simpleData.count = cmd->count;
    client->sendEvent(&event);
}

invokeDefineCursor()

void QWSServerPrivate::invokeDefineCursor ( QWSDefineCursorCommand *  cmd, QWSClient *  client  )

private

Definition at line 3228 of file qwindowsystem_qws.cpp.

{
    if (cmd->simpleData.height > 64 || cmd->simpleData.width > 64) {
        qDebug("Cannot define cursor size > 64x64");
        return;
    }

    delete client->cursors.take(cmd->simpleData.id);

    int dataLen = cmd->simpleData.height * ((cmd->simpleData.width+7) / 8);

    if (dataLen > 0 && cmd->data) {
        QWSCursor *curs = new QWSCursor(cmd->data, cmd->data + dataLen,
                                        cmd->simpleData.width, cmd->simpleData.height,
                                        cmd->simpleData.hotX, cmd->simpleData.hotY);
        client->cursors.insert(cmd->simpleData.id, curs);
    }
}

invokeEmbed()

void QWSServerPrivate::invokeEmbed ( QWSEmbedCommand *  cmd, QWSClient *  client  )

private

Definition at line 3395 of file qwindowsystem_qws.cpp.

{
    // Should find these two windows in a single loop
    QWSWindow *embedder = findWindow(cmd->simpleData.embedder, client);
    QWSWindow *embedded = findWindow(cmd->simpleData.embedded);

    if (!embedder) {
        qWarning("QWSServer: Embed command from window %i failed: No such id.",
                 static_cast<int>(cmd->simpleData.embedder));
        return;
    }

    if (!embedded) {
        qWarning("QWSServer: Embed command on window %i failed: No such id.",
                 static_cast<int>(cmd->simpleData.embedded));
        return;
    }

    switch (cmd->simpleData.type) {
    case QWSEmbedEvent::StartEmbed:
        embedder->startEmbed(embedded);
        windows.removeAll(embedded);
        windows.insert(windows.indexOf(embedder), embedded);
        break;
    case QWSEmbedEvent::StopEmbed:
        embedder->stopEmbed(embedded);
        break;
    case QWSEmbedEvent::Region:
        break;
    }

    embedded->client()->sendEmbedEvent(embedded->winId(),
                                       cmd->simpleData.type, cmd->region);
    const QRegion oldAllocated = embedded->allocatedRegion();
    update_regions();
    exposeRegion(oldAllocated - embedded->allocatedRegion(),
                 windows.indexOf(embedded));
}

invokeFont()

void QWSServerPrivate::invokeFont ( const QWSFontCommand *  cmd, QWSClient *  client  )

private

Definition at line 3376 of file qwindowsystem_qws.cpp.

{
    QWSClientPrivate *priv = client->d_func();
    if (cmd->simpleData.type == QWSFontCommand::StartedUsingFont) {
        referenceFont(priv, cmd->fontName);
    } else if (cmd->simpleData.type == QWSFontCommand::StoppedUsingFont) {
        dereferenceFont(priv, cmd->fontName);
    }
}

invokeGetProperty()

void QWSServerPrivate::invokeGetProperty ( QWSGetPropertyCommand *  cmd, QWSClient *  client  )

private

Definition at line 3179 of file qwindowsystem_qws.cpp.

{
    const char *data;
    int len;

    if (propertyManager.getProperty(cmd->simpleData.windowid,
                                    cmd->simpleData.property,
                                    data, len)) {
        client->sendPropertyReplyEvent(cmd->simpleData.property, len, data);
    } else {
        client->sendPropertyReplyEvent(cmd->simpleData.property, -1, 0);
    }
}

invokeGrabKeyboard()

void QWSServerPrivate::invokeGrabKeyboard ( QWSGrabKeyboardCommand *  cmd, QWSClient *  client  )

private

Definition at line 3306 of file qwindowsystem_qws.cpp.

{
    QWSWindow* win = findWindow(cmd->simpleData.windowid, 0);
    if (!win)
        return;

    if (cmd->simpleData.grab) {
        if (!keyboardGrabber || (keyboardGrabber->client() == client)) {
            keyboardGrabbing = true;
            keyboardGrabber = win;
        }
    } else {
        releaseKeyboard(keyboardGrabber);
    }
}

invokeGrabMouse()

void QWSServerPrivate::invokeGrabMouse ( QWSGrabMouseCommand *  cmd, QWSClient *  client  )

private

Definition at line 3290 of file qwindowsystem_qws.cpp.

{
    QWSWindow* win = findWindow(cmd->simpleData.windowid, 0);
    if (!win)
        return;

    if (cmd->simpleData.grab) {
        if (!mouseGrabber || mouseGrabber->client() == client) {
            mouseGrabbing = true;
            mouseGrabber = win;
        }
    } else {
        releaseMouse(mouseGrabber);
    }
}

invokeIdentify()

void QWSServerPrivate::invokeIdentify ( const QWSIdentifyCommand *  cmd, QWSClient *  client  )

private

Definition at line 2908 of file qwindowsystem_qws.cpp.

{
    client->setIdentity(cmd->id);
#ifndef QT_NO_QWS_MULTIPROCESS
    if (client->clientId() > 0)
        client->d_func()->setLockId(cmd->simpleData.idLock);
#endif
}

invokeIMResponse()

void QWSServerPrivate::invokeIMResponse ( const QWSIMResponseCommand *  cmd, QWSClient *  client  )

private

Definition at line 3357 of file qwindowsystem_qws.cpp.

{
    if (current_IM)
        current_IM->queryResponse(cmd->simpleData.property, cmd->result);
}

invokeIMUpdate()

void QWSServerPrivate::invokeIMUpdate ( const QWSIMUpdateCommand *  cmd, QWSClient *  client  )

private

Definition at line 3364 of file qwindowsystem_qws.cpp.

{
    if (cmd->simpleData.type == QWSInputMethod::FocusIn)
        current_IM_winId = cmd->simpleData.windowid;

    if (current_IM && (current_IM_winId == cmd->simpleData.windowid || cmd->simpleData.windowid == -1))
        current_IM->updateHandler(cmd->simpleData.type);
}

invokePlaySound()

void QWSServerPrivate::invokePlaySound ( QWSPlaySoundCommand *  cmd, QWSClient *  client  )

private

Definition at line 3323 of file qwindowsystem_qws.cpp.

{
#if !defined(QT_EXTERNAL_SOUND_SERVER) && !defined(Q_OS_DARWIN)
    soundserver->playFile( 1, cmd->filename );
#else
    Q_UNUSED(cmd);
#endif
}

invokePositionCursor()

void QWSServerPrivate::invokePositionCursor ( QWSPositionCursorCommand *  cmd, QWSClient *  client  )

private

Definition at line 3281 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    QPoint newPos(cmd->simpleData.newX, cmd->simpleData.newY);
    if (newPos != QWSServer::mousePosition)
        q->sendMouseEvent(newPos, qwsServer->d_func()->mouseState);
}

invokeQCopSend()

void QWSServerPrivate::invokeQCopSend ( QWSQCopSendCommand *  cmd, QWSClient *  client  )

private

Definition at line 3342 of file qwindowsystem_qws.cpp.

{
    QCopChannel::answer(client, cmd->channel, cmd->message, cmd->data);
}

invokeRegion()

void QWSServerPrivate::invokeRegion ( QWSRegionCommand *  cmd, QWSClient *  client  )

private

Definition at line 2936 of file qwindowsystem_qws.cpp.

{
#ifdef QWS_REGION_DEBUG
    qDebug("QWSServer::invokeRegion %d rects (%d)",
            cmd->simpleData.nrectangles, cmd->simpleData.windowid);
#endif

    QWSWindow* changingw = findWindow(cmd->simpleData.windowid, 0);
    if (!changingw) {
        qWarning("Invalid window handle %08x",cmd->simpleData.windowid);
        return;
    }
    if (!changingw->forClient(client)) {
        qWarning("Disabled: clients changing other client's window region");
        return;
    }

    request_region(cmd->simpleData.windowid, cmd->surfaceKey, cmd->surfaceData,
                   cmd->region);
}

invokeRegionDestroy()

void QWSServerPrivate::invokeRegionDestroy ( const QWSRegionDestroyCommand *  cmd, QWSClient *  client  )

private

Definition at line 2975 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    QWSWindow* changingw = findWindow(cmd->simpleData.windowid, 0);
    if (!changingw) {
        qWarning("invokeRegionDestroy: Invalid window handle %d",cmd->simpleData.windowid);
        return;
    }
    if (!changingw->forClient(client)) {
        qWarning("Disabled: clients changing other client's window region");
        return;
    }

    setWindowRegion(changingw, QRegion());
//    rgnMan->remove(changingw->allocationIndex());
    for (int i = 0; i < windows.size(); ++i) {
        if (windows.at(i) == changingw) {
            windows.takeAt(i);
            if (i < nReserved)
                --nReserved;
            break;
        }
    }

    handleWindowClose(changingw);
#ifndef QT_NO_QWS_PROPERTIES
    propertyManager.removeProperties(changingw->winId());
#endif
    emit q->windowEvent(changingw, QWSServer::Destroy);
    delete changingw;
}

invokeRegionMove()

void QWSServerPrivate::invokeRegionMove ( const QWSRegionMoveCommand *  cmd, QWSClient *  client  )

private

Definition at line 2957 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    QWSWindow* changingw = findWindow(cmd->simpleData.windowid, 0);
    if (!changingw) {
        qWarning("invokeRegionMove: Invalid window handle %d",cmd->simpleData.windowid);
        return;
    }
    if (!changingw->forClient(client)) {
        qWarning("Disabled: clients changing other client's window region");
        return;
    }

//    changingw->setNeedAck(true);
    moveWindowRegion(changingw, cmd->simpleData.dx, cmd->simpleData.dy);
    emit q->windowEvent(changingw, QWSServer::Geometry);
}

invokeRegionName()

void QWSServerPrivate::invokeRegionName ( const QWSRegionNameCommand *  cmd, QWSClient *  client  )

private

Definition at line 2925 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    QWSWindow* changingw = findWindow(cmd->simpleData.windowid, client);
    if (changingw && (changingw->name() != cmd->name || changingw->caption() !=cmd->caption)) {
        changingw->setName(cmd->name);
        changingw->setCaption(cmd->caption);
        emit q->windowEvent(changingw, QWSServer::Name);
    }
}

invokeRegisterChannel()

void QWSServerPrivate::invokeRegisterChannel ( QWSQCopRegisterChannelCommand *  cmd, QWSClient *  client  )

private

Definition at line 3334 of file qwindowsystem_qws.cpp.

{
  // QCopChannel will force us to emit the newChannel signal if this channel
  // didn't already exist.
  QCopChannel::registerChannel(cmd->channel, client);
}

invokeRemoveProperty()

void QWSServerPrivate::invokeRemoveProperty ( QWSRemovePropertyCommand *  cmd )

private

Definition at line 3162 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    if (propertyManager.removeProperty(cmd->simpleData.windowid,
                                       cmd->simpleData.property)) {
        q->sendPropertyNotifyEvent(cmd->simpleData.property,
                                 QWSPropertyNotifyEvent::PropertyDeleted);
    }
}

invokeRepaintRegion()

void QWSServerPrivate::invokeRepaintRegion ( QWSRepaintRegionCommand *  cmd, QWSClient *  client  )

private

Definition at line 3386 of file qwindowsystem_qws.cpp.

{
    QRegion r;
    r.setRects(cmd->rectangles,cmd->simpleData.nrectangles);
    repaint_region(cmd->simpleData.windowid, cmd->simpleData.windowFlags, cmd->simpleData.opaque, r);
}

invokeScreenTransform()

void QWSServerPrivate::invokeScreenTransform ( const QWSScreenTransformCommand *  cmd, QWSClient *  client  )

private

Definition at line 3435 of file qwindowsystem_qws.cpp.

{
    Q_UNUSED(client);

    QWSScreenTransformationEvent event;
    event.simpleData.screen = cmd->simpleData.screen;
    event.simpleData.transformation = cmd->simpleData.transformation;

    QMap<int, QWSClient*>::const_iterator it = clientMap.constBegin();
    for (; it != clientMap.constEnd(); ++it)
        (*it)->sendEvent(&event);
}

invokeSelectCursor()

void QWSServerPrivate::invokeSelectCursor ( QWSSelectCursorCommand *  cmd, QWSClient *  client  )

private

Definition at line 3247 of file qwindowsystem_qws.cpp.

{
    int id = cmd->simpleData.id;
    QWSCursor *curs = 0;
    if (id <= Qt::LastCursor) {
        curs = QWSCursor::systemCursor(id);
    }
    else {
        QWSCursorMap cursMap = client->cursors;
        QWSCursorMap::Iterator it = cursMap.find(id);
        if (it != cursMap.end()) {
            curs = it.value();
        }
    }
    if (curs == 0) {
        curs = QWSCursor::systemCursor(Qt::ArrowCursor);
    }

    QWSWindow* win = findWindow(cmd->simpleData.windowid, 0);
    if (mouseGrabber) {
        // If the mouse is being grabbed, we don't want just anyone to
        // be able to change the cursor.  We do want the cursor to be set
        // correctly once mouse grabbing is stopped though.
        if (win != mouseGrabber)
            nextCursor = curs;
        else
            setCursor(curs);
    } else if (win && win->allocatedRegion().contains(QWSServer::mousePosition)) { //##################### cursor
        // A non-grabbing window can only set the cursor shape if the
        // cursor is within its allocated region.
        setCursor(curs);
    }
}

invokeSetAltitude()

void QWSServerPrivate::invokeSetAltitude ( const QWSChangeAltitudeCommand *  cmd, QWSClient *  client  )

private

Definition at line 3101 of file qwindowsystem_qws.cpp.

{
    Q_UNUSED(client);

    int winId = cmd->simpleData.windowid;
    int alt = cmd->simpleData.altitude;
    bool fixed = cmd->simpleData.fixed;
#if 0
    qDebug("QWSServer::invokeSetAltitude winId %d alt %d)", winId, alt);
#endif

    if (alt < -1 || alt > 1) {
        qWarning("QWSServer::invokeSetAltitude Only lower, raise and stays-on-top supported");
        return;
    }

    QWSWindow* changingw = findWindow(winId, 0);
    if (!changingw) {
        qWarning("invokeSetAltitude: Invalid window handle %d", winId);
        return;
    }

    if (fixed && alt >= 1) {
        changingw->onTop = true;
    }
    if (alt == QWSChangeAltitudeCommand::Lower)
        changingw->lower();
    else
        changingw->raise();

//      if (!changingw->forClient(client)) {
//         refresh();
//     }
}

invokeSetFocus()

void QWSServerPrivate::invokeSetFocus ( const QWSRequestFocusCommand *  cmd, QWSClient *  client  )

private

Definition at line 3007 of file qwindowsystem_qws.cpp.

{
    int winId = cmd->simpleData.windowid;
    int gain = cmd->simpleData.flag;

    if (gain != 0 && gain != 1) {
        qWarning("Only 0(lose) and 1(gain) supported");
        return;
    }

    QWSWindow* changingw = findWindow(winId, 0);
    if (!changingw)
        return;

    if (!changingw->forClient(client)) {
       qWarning("Disabled: clients changing other client's focus");
        return;
    }

    setFocus(changingw, gain);
}

invokeSetOpacity()

void QWSServerPrivate::invokeSetOpacity ( const QWSSetOpacityCommand *  cmd, QWSClient *  client  )

private

Definition at line 3080 of file qwindowsystem_qws.cpp.

{
    Q_UNUSED( client );
    int winId = cmd->simpleData.windowid;
    int opacity = cmd->simpleData.opacity;

    QWSWindow* changingw = findWindow(winId, 0);

    if (!changingw) {
        qWarning("invokeSetOpacity: Invalid window handle %d", winId);
        return;
    }

    int altitude = windows.indexOf(changingw);
    const bool wasOpaque = changingw->isOpaque();
    changingw->_opacity = opacity;
    if (wasOpaque != changingw->isOpaque())
        update_regions();
    exposeRegion(changingw->allocatedRegion(), altitude);
}

invokeSetProperty()

void QWSServerPrivate::invokeSetProperty ( QWSSetPropertyCommand *  cmd )

private

Definition at line 3143 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    if (propertyManager.setProperty(cmd->simpleData.windowid,
                                    cmd->simpleData.property,
                                    cmd->simpleData.mode,
                                    cmd->data,
                                    cmd->rawLen)) {
        q->sendPropertyNotifyEvent(cmd->simpleData.property,
                                 QWSPropertyNotifyEvent::PropertyNewValue);
#ifndef QT_NO_QWS_INPUTMETHODS
        if (cmd->simpleData.property == QT_QWS_PROPERTY_MARKEDTEXT) {
            QString s((const QChar*)cmd->data, cmd->rawLen/2);
            emit q->markedText(s);
        }
#endif
    }
}

invokeSetSelectionOwner()

void QWSServerPrivate::invokeSetSelectionOwner ( QWSSetSelectionOwnerCommand *  cmd )

private

Definition at line 3194 of file qwindowsystem_qws.cpp.

{
    qDebug("QWSServer::invokeSetSelectionOwner");

    SelectionOwner so;
    so.windowid = cmd->simpleData.windowid;
    so.time.set(cmd->simpleData.hour, cmd->simpleData.minute,
                 cmd->simpleData.sec, cmd->simpleData.ms);

    if (selectionOwner.windowid != -1) {
        QWSWindow *win = findWindow(selectionOwner.windowid, 0);
        if (win)
            win->client()->sendSelectionClearEvent(selectionOwner.windowid);
        else
            qDebug("couldn't find window %d", selectionOwner.windowid);
    }

    selectionOwner = so;
}

lowerWindow()

void QWSServerPrivate::lowerWindow ( QWSWindow *  changingw, int  = -1  )

private

Definition at line 3550 of file qwindowsystem_qws.cpp.

Referenced by QWSWindow::lower().

{
    Q_Q(QWSServer);
    if (changingw == windows.last())
        return;
    QWSWindow::State oldstate = changingw->d->state;
    changingw->d->state = QWSWindow::Lowering;

    int i = windows.indexOf(changingw);
    int newIdx = windows.size()-1;
    windows.move(i, newIdx);

    const QRegion bound = changingw->allocatedRegion();

    update_regions();

    // Expose regions previously overlapped by transparent window
    if (!changingw->isOpaque()) {
        QRegion expose;
        for (int j = i; j < windows.size() - 1; ++j)
            expose += (windows.at(j)->allocatedRegion() & bound);
        if (!expose.isEmpty())
            exposeRegion(expose, newIdx);
    }

    changingw->d->state = oldstate;
    emit q->windowEvent(changingw, QWSServer::Lower);
}

move_region()

void QWSServerPrivate::move_region ( const QWSRegionMoveCommand *  cmd )

private

Definition at line 3925 of file qwindowsystem_qws.cpp.

{
    QWSClient *serverClient = clientMap.value(-1);
    invokeRegionMove(cmd, serverClient);
}

moveWindowRegion()

void QWSServerPrivate::moveWindowRegion ( QWSWindow *  changingw, int  dx, int  dy  )

private

Definition at line 3645 of file qwindowsystem_qws.cpp.

{
    if (!changingw)
        return;

    QWSWindow::State oldState = changingw->d->state;
    changingw->d->state = QWSWindow::Moving;
    const QRegion oldRegion(changingw->allocatedRegion());
    changingw->requested_region.translate(dx, dy);

    // hw: Even if the allocated region doesn't change, the requested region
    // region has changed and we need to send region events.
    // Resetting the allocated region to force update_regions to send events.
    changingw->setAllocatedRegion(QRegion());
    update_regions();
    const QRegion newRegion(changingw->allocatedRegion());

    QWSWindowSurface *surface = changingw->windowSurface();
    QRegion expose;
    if (surface)
        expose = surface->move(QPoint(dx, dy), changingw->allocatedRegion());
    else
        expose = oldRegion + newRegion;

    if (!changingw->d->painted && !expose.isEmpty())
        expose = oldRegion - newRegion;

    int idx = windows.indexOf(changingw);
    exposeRegion(expose, idx);
    changingw->d->state = oldState;
}

name_region()

void QWSServerPrivate::name_region ( const QWSRegionNameCommand *  cmd )

private

Definition at line 4069 of file qwindowsystem_qws.cpp.

{
    invokeRegionName(cmd, clientMap.value(-1));
}

newMouseHandler()

QWSMouseHandler * QWSServerPrivate::newMouseHandler ( const QString &  spec )

private

Definition at line 3799 of file qwindowsystem_qws.cpp.

{
    int c = spec.indexOf(QLatin1Char(':'));
    QString mouseProto;
    QString mouseDev;
    if (c >= 0) {
        mouseProto = spec.left(c);
        mouseDev = spec.mid(c+1);
    } else {
        mouseProto = spec;
    }

    int screen = -1;
    const QList<QRegExp> regexps = QList<QRegExp>()
                                   << QRegExp(QLatin1String(":screen=(\\d+)\\b"))
                                   << QRegExp(QLatin1String("\\bscreen=(\\d+):"));
    for (int i = 0; i < regexps.size(); ++i) {
        QRegExp regexp = regexps.at(i);
        if (regexp.indexIn(mouseDev) == -1)
            continue;
        screen = regexp.cap(1).toInt();
        mouseDev.remove(regexp.pos(0), regexp.matchedLength());
        break;
    }

    QWSMouseHandler *handler = 0;
    handler = QMouseDriverFactory::create(mouseProto, mouseDev);
    if (screen != -1)
        handler->setScreen(qt_screen->subScreens().at(screen));

    return handler;
}

newWindow()

QWSWindow * QWSServerPrivate::newWindow ( int  id, QWSClient *  client  )

private

Definition at line 3449 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    // Make a new window, put it on top.
    QWSWindow* w = new QWSWindow(id,client);

    // insert after "stays on top" windows
    bool added = false;
    for (int i = nReserved; i < windows.size(); ++i) {
        QWSWindow *win = windows.at(i);
        if (!win->onTop) {
            windows.insert(i, w);
            added = true;
            break;
        }
    }
    if (!added)
        windows.append(w);
    emit q->windowEvent(w, QWSServer::Create);
    return w;
}

openDisplay()

void QWSServerPrivate::openDisplay ( )

private

Definition at line 4092 of file qwindowsystem_qws.cpp.

{
    qt_init_display();

//    rgnMan = qt_fbdpy->regionManager();
    swidth = qt_screen->deviceWidth();
    sheight = qt_screen->deviceHeight();
}

raiseWindow()

void QWSServerPrivate::raiseWindow ( QWSWindow *  changingw, int  = 0  )

private

Definition at line 3484 of file qwindowsystem_qws.cpp.

Referenced by QWSWindow::raise().

{
    Q_Q(QWSServer);
    if (changingw == windows.first())
        return;
    QWSWindow::State oldstate = changingw->d->state;
    changingw->d->state = QWSWindow::Raising;
    // Expose regions previously overlapped by transparent windows
    const QRegion bound = changingw->allocatedRegion();
    QRegion expose;
    int windowPos = 0;

    //change position in list:
    for (int i = 0; i < windows.size(); ++i) {
        QWSWindow *w = windows.at(i);
        if (w == changingw) {
            windowPos = i;
            windows.takeAt(i);
            break;
        }
        if (!w->isOpaque())
            expose += (w->allocatedRegion() & bound);
    }

    bool onTop = changingw->onTop;

#ifndef QT_NO_QWSEMBEDWIDGET
    // an embedded window is on top if the embedder is on top
    QWSWindow *embedder = changingw->d->embedder;
    while (!onTop && embedder) {
        onTop = embedder->onTop;
        embedder = embedder->d->embedder;
    }
#endif

    int newPos = -1;
    if (onTop) {
        windows.insert(nReserved, changingw);
        newPos = nReserved;
    } else {
        // insert after "stays on top" windows
        bool in = false;
        for (int i = nReserved; i < windows.size(); ++i) {
            QWSWindow *w = windows.at(i);
            if (!w->onTop) {
                windows.insert(i, changingw);
                in = true;
                newPos = i;
                break;
            }
        }
        if (!in) {
            windows.append(changingw);
            newPos = windows.size()-1;
        }
    }

    if (windowPos != newPos) {
        update_regions();
        if (!expose.isEmpty())
            exposeRegion(expose, newPos);
    }
    changingw->d->state = oldstate;
    emit q->windowEvent(changingw, QWSServer::Raise);
}

referenceFont()

void QWSServerPrivate::referenceFont ( QWSClientPrivate *  client, const QByteArray &  font  )

private

Definition at line 1804 of file qwindowsystem_qws.cpp.

{
    if (!client->usedFonts.contains(font)) {
        client->usedFonts.insert(font);

        ++fontReferenceCount[font];
#if defined(QWS_DEBUG_FONTCLEANUP)
        qDebug() << "Client" << client->q_func()->clientId() << "added font" << font;
        qDebug() << "Refcount is" << fontReferenceCount[font];
#endif
    }
}

releaseKeyboard()

void QWSServerPrivate::releaseKeyboard ( QWSWindow *  w )

private

Warning

This function is not part of the public interface.

Definition at line 1613 of file qwindowsystem_qws.cpp.

{
    if (keyboardGrabber == w) {
        keyboardGrabber = 0;
        keyboardGrabbing = false;
    }
}

releaseMouse()

void QWSServerPrivate::releaseMouse ( QWSWindow *  w )

private

Warning

This function is not part of the public interface.

Definition at line 1595 of file qwindowsystem_qws.cpp.

Referenced by sendMouseEventUnfiltered().

{
    if (w && mouseGrabber == w) {
        mouseGrabber = 0;
        mouseGrabbing = false;
#ifndef QT_NO_QWS_CURSOR
        if (nextCursor) {
            // Not grabbing -> set the correct cursor
            setCursor(nextCursor);
            nextCursor = 0;
        }
#endif
    }
}

repaint_region()

void QWSServerPrivate::repaint_region ( int  winId, int  windowFlags, bool  opaque, const QRegion &  region  )

private

Definition at line 3954 of file qwindowsystem_qws.cpp.

{
    QWSWindow* changingw = findWindow(wid, 0);
    if (!changingw) {
        return;
    }

    const bool isOpaque = changingw->opaque;
    const bool wasPainted = changingw->d->painted;
    changingw->opaque = opaque;
    changingw->d->windowFlags = QFlag(windowFlags);
    changingw->d->dirtyOnScreen |= region;
    changingw->d->painted = true;
    if (isOpaque != opaque || !wasPainted)
        update_regions();

    int level = windows.indexOf(changingw);
    exposeRegion(region, level);
    changingw->d->dirtyOnScreen = QRegion();
}

request_focus()

void QWSServerPrivate::request_focus ( const QWSRequestFocusCommand *  cmd )

private

Definition at line 3944 of file qwindowsystem_qws.cpp.

{
    invokeSetFocus(cmd, clientMap.value(-1));
}

request_region()

void QWSServerPrivate::request_region ( int  winId, const QString &  surfaceKey, const QByteArray &  surfaceData, const QRegion &  region  )

private

Definition at line 3994 of file qwindowsystem_qws.cpp.

{
    QWSWindow *changingw = findWindow(wid, 0);
    if (!changingw)
        return;

    Q_Q(QWSServer);
    QWSWindow::State windowState = QWSWindow::NoState;

    if (region.isEmpty()) {
        windowState = QWSWindow::Hiding;
        emit q->windowEvent(changingw, QWSServer::Hide);
    }

    const bool wasOpaque = changingw->opaque;

    QWSWindowSurface *surface = changingw->windowSurface();
    if (!surface) {
        changingw->createSurface(surfaceKey, surfaceData);
        surface = changingw->windowSurface();
    } else {
        surface->setPermanentState(surfaceData);
    }

    changingw->opaque = surface->isOpaque();

    QRegion r;
    if (surface->isRegionReserved())
        r = reserve_region(changingw, region);
    else
        r = region;

    if (!region.isEmpty())  {
        if (changingw->isVisible())
            windowState = QWSWindow::ChangingGeometry;
        else
            windowState = QWSWindow::Showing;
    }
    changingw->d->state = windowState;

    if (!r.isEmpty() && wasOpaque != changingw->opaque && surface->isBuffered())
        changingw->requested_region = QRegion(); // XXX: force update_regions

    const QRegion oldAllocated = changingw->allocatedRegion();
    setWindowRegion(changingw, r);
    if (oldAllocated == changingw->allocatedRegion()) {
        // Always send region event to the requesting window even if the
        // region didn't change. This is necessary as the client will reset
        // the clip region until an event is received.
        changingw->client()->sendRegionEvent(wid, changingw->allocatedRegion(),
                                             QWSRegionEvent::Allocation);
    }

    surface->QWindowSurface::setGeometry(r.boundingRect());

    if (windowState == QWSWindow::Showing)
        emit q->windowEvent(changingw, QWSServer::Show);
    else if (windowState == QWSWindow::ChangingGeometry)
        emit q->windowEvent(changingw, QWSServer::Geometry);
    if (windowState == QWSWindow::Hiding) {
        handleWindowClose(changingw);
        changingw->d->state = QWSWindow::Hidden;
        changingw->d->painted = false;
    } else {
        changingw->d->state = QWSWindow::Visible;
    }
}

reserve_region()

QRegion QWSServerPrivate::reserve_region ( QWSWindow *  window, const QRegion &  region  )

private

Definition at line 3976 of file qwindowsystem_qws.cpp.

{
    QRegion r = region;

    int oldPos = windows.indexOf(win);
    int newPos = oldPos < nReserved ? nReserved - 1 : nReserved;
    for (int i = 0; i < nReserved; ++i) {
        if (i != oldPos) {
            QWSWindow *w = windows.at(i);
            r -= w->requested_region;
        }
    }
    windows.move(oldPos, newPos);
    nReserved = newPos + 1;

    return r;
}

resetEngine()

void QWSServerPrivate::resetEngine ( )

private

Definition at line 2736 of file qwindowsystem_qws.cpp.

{
#ifndef QT_NO_QWS_CURSOR
    if (!qt_screencursor)
        return;
    qt_screencursor->hide();
    qt_screencursor->show();
#endif
}

screenSave()

void QWSServerPrivate::screenSave ( int  level )

private

Definition at line 4481 of file qwindowsystem_qws.cpp.

{
    if (saver) {
        // saver->save() may call QCoreApplication::processEvents,
        // block event before calling saver->save().
        bool oldScreensaverblockevents = screensaverblockevents;
        if (*screensaverinterval >= 1000) {
            screensaverblockevents = (screensavereventblocklevel >= 0 && screensavereventblocklevel <= level);
#ifdef EVENT_BLOCK_DEBUG
            if (screensaverblockevents)
                qDebug("ready to block events");
#endif
        }
        int *oldScreensaverinterval = screensaverinterval;
        if (saver->save(level)) {
            // only update screensaverinterval if it hasn't already changed
            if (oldScreensaverinterval == screensaverinterval) {
                if (screensaverinterval && screensaverinterval[1]) {
                    screensavertimer->start(*++screensaverinterval);
                    screensavertime.start();
                } else {
                    screensaverinterval = 0;
                }
            }
        } else {
            // restore previous state
            screensaverblockevents = oldScreensaverblockevents;

            // for some reason, the saver don't want us to change to the
            // next level, so we'll stay at this level for another interval
            if (screensaverinterval && *screensaverinterval) {
                screensavertimer->start(*screensaverinterval);
                screensavertime.start();
            }
        }
    } else {
        screensaverinterval = 0;//screensaverintervals;
        screensaverblockevents = false;
        _q_screenSaverSleep();
    }
}

screensaverblockevent()

bool QWSServerPrivate::screensaverblockevent	(	int	index,
		int *	screensaverinterval,
		bool	isDown
	)

Definition at line 1431 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::processKeyEvent(), and QWSServer::sendMouseEvent().

{
    static bool ignoreEvents[2] = { false, false };
    if ( isDown ) {
        if ( !ignoreEvents[index] ) {
            bool wake = false;
            if ( screensaverintervals ) {
                if ( screensaverinterval != screensaverintervals ) {
                    wake = true;
                }
            }
            if ( screensaverblockevents && wake ) {
#ifdef EVENT_BLOCK_DEBUG
                qDebug( "waking the screen" );
#endif
                ignoreEvents[index] = true;
            } else if ( !screensaverblockevents ) {
#ifdef EVENT_BLOCK_DEBUG
                qDebug( "the screen was already awake" );
#endif
                ignoreEvents[index] = false;
            }
        }
    } else {
        if ( ignoreEvents[index] ) {
#ifdef EVENT_BLOCK_DEBUG
            qDebug( "mouseup?" );
#endif
            ignoreEvents[index] = false;
            return true;
        }
    }
    return ignoreEvents[index];
}

send_im_mouse()

void QWSServerPrivate::send_im_mouse ( const QWSIMMouseCommand *  cmd )

private

Definition at line 4085 of file qwindowsystem_qws.cpp.

{
    if (current_IM)
        current_IM->mouseHandler(cmd->simpleData.index, cmd->simpleData.state);
}

sendFontRemovedEvent()

void QWSServerPrivate::sendFontRemovedEvent ( const QByteArray &  font )

private

Definition at line 1896 of file qwindowsystem_qws.cpp.

{
    QWSFontEvent event;
    event.simpleData.type = QWSFontEvent::FontRemoved;
    event.setData(font.constData(), font.length(), false);

    QMap<int,QWSClient*>::const_iterator it = clientMap.constBegin();
    for (; it != clientMap.constEnd(); ++it)
        (*it)->sendEvent(&event);
}

sendKeyEventUnfiltered()

void QWSServerPrivate::sendKeyEventUnfiltered ( int  unicode, int  keycode, Qt::KeyboardModifiers  modifiers, bool  isPress, bool  autoRepeat  )

staticprivate

Definition at line 2671 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::sendKeyEvent().

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

#ifndef QT_NO_QWS_KEYBOARD
    if (unicode < 0)
        unicode = keyUnicode(keycode);
#endif

    QWSKeyEvent event;
    event.simpleData.window = win ? win->winId() : 0;
    event.simpleData.unicode = unicode;
    event.simpleData.keycode = keycode;
    event.simpleData.modifiers = modifiers;
    event.simpleData.is_press = isPress;
    event.simpleData.is_auto_repeat = autoRepeat;

    QWSClient *serverClient = qwsServerPrivate->clientMap.value(-1);
    QWSClient *winClient = win ? win->client() : 0;
    if (serverClient)
        serverClient->sendEvent(&event);
    if (winClient && winClient != serverClient)
        winClient->sendEvent(&event);
}

sendMaxWindowRectEvents()

void QWSServerPrivate::sendMaxWindowRectEvents ( const QRect &  rect )

private

Warning

This function is not part of the public interface.

Definition at line 2272 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::setMaxWindowRect().

{
    QMap<int,QWSClient*>::const_iterator it = clientMap.constBegin();
    for (; it != clientMap.constEnd(); ++it)
        (*it)->sendMaxWindowRectEvent(rect);
}

sendMouseEventUnfiltered()

void QWSServerPrivate::sendMouseEventUnfiltered ( const QPoint &  pos, int  state, int  wheel = 0  )

staticprivate

Definition at line 2388 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::sendMouseEvent(), and QWSInputMethod::sendMouseEvent().

{
    const int btnMask = Qt::LeftButton | Qt::RightButton | Qt::MidButton;
    QWSMouseEvent event;

    QWSWindow *win = qwsServer->windowAt(pos);

    QWSClient *serverClient = qwsServerPrivate->clientMap.value(-1);
    QWSClient *winClient = win ? win->client() : 0;


    bool imMouse = false;
#ifndef QT_NO_QWS_INPUTMETHODS
    // check for input method window
    if (current_IM && current_IM_winId != -1) {
        QWSWindow *kbw = keyboardGrabber ? keyboardGrabber :
                         qwsServerPrivate->focusw;

        imMouse = kbw == win;
        if ( !imMouse ) {
            QWidget *target = winClient == serverClient ?
                              QApplication::widgetAt(pos) : 0;
            imMouse = target && (target->testAttribute(Qt::WA_InputMethodTransparent));
        }
    }
#endif

    //If grabbing window disappears, grab is still active until
    //after mouse release.
    if ( qwsServerPrivate->mouseGrabber && (!imMouse || qwsServerPrivate->inputMethodMouseGrabbed)) {
        win = qwsServerPrivate->mouseGrabber;
        winClient = win ? win->client() : 0;
    }
    event.simpleData.window = win ? win->id : 0;

#ifndef QT_NO_QWS_CURSOR
    if (qt_screencursor)
        qt_screencursor->move(pos.x(),pos.y());

    // Arrow cursor over desktop
    // prevWin remembers if the last event was over a window
    if (!win && prevWin) {
        if (!qwsServerPrivate->mouseGrabber)
            qwsServerPrivate->setCursor(QWSCursor::systemCursor(Qt::ArrowCursor));
        else
            qwsServerPrivate->nextCursor = QWSCursor::systemCursor(Qt::ArrowCursor);
        prevWin = false;
    }
    // reset prevWin
    if (win && !prevWin)
        prevWin = true;
#endif

    if ((state&btnMask) && !qwsServerPrivate->mouseGrabbing) {
        qwsServerPrivate->mouseGrabber = win;
        if (imMouse)
            qwsServerPrivate->inputMethodMouseGrabbed = true;
    }
    if (!(state&btnMask))
        qwsServerPrivate->inputMethodMouseGrabbed = false;

    event.simpleData.x_root=pos.x();
    event.simpleData.y_root=pos.y();
    event.simpleData.state=state | qws_keyModifiers;
    event.simpleData.delta = wheel;
    event.simpleData.time=qwsServerPrivate->timer.elapsed();

    static int oldstate = 0;

#ifndef QT_NO_QWS_INPUTMETHODS
    //tell the input method if we click on a different window that is not IM transparent
    bool isPress = state > oldstate;
    if (isPress && !imMouse && current_IM && current_IM_winId != -1)
        current_IM->mouseHandler(-1, QWSServer::MouseOutside);
#endif

    if (serverClient)
       serverClient->sendEvent(&event);
    if (winClient && winClient != serverClient)
       winClient->sendEvent(&event);

    if ( !imMouse ) {
        // Make sure that if we leave a window, that window gets one last mouse
        // event so that it knows the mouse has left.
        QWSClient *oldClient = qwsServer->d_func()->cursorClient;
        if (oldClient && oldClient != winClient && oldClient != serverClient) {
            event.simpleData.state = oldstate | qws_keyModifiers;
            oldClient->sendEvent(&event);
        }
    }

    oldstate = state;
    if ( !imMouse )
        qwsServer->d_func()->cursorClient = winClient;

    if (!(state&btnMask) && !qwsServerPrivate->mouseGrabbing)
        qwsServerPrivate->releaseMouse(qwsServerPrivate->mouseGrabber);
}

sendQCopEvent()

void QWSServerPrivate::sendQCopEvent ( QWSClient *  c, const QString &  ch, const QString &  msg, const QByteArray &  data, bool  response = false  )

staticprivate

Warning

This function is not part of the public interface.

Definition at line 2564 of file qwindowsystem_qws.cpp.

Referenced by QCopChannel::answer().

{
    Q_ASSERT(c);

    QWSQCopMessageEvent event;
    event.channel = ch.toLatin1();
    event.message = msg.toLatin1();
    event.data = data;
    event.simpleData.is_response = response;
    event.simpleData.lchannel = ch.length();
    event.simpleData.lmessage = msg.length();
    event.simpleData.ldata = data.size();
    int l = event.simpleData.lchannel + event.simpleData.lmessage +
            event.simpleData.ldata;

    // combine channel, message and data into one block of raw bytes
    char *tmp = new char [l];
    char *d = tmp;
    memcpy(d, event.channel.constData(), event.simpleData.lchannel);
    d += event.simpleData.lchannel;
    memcpy(d, event.message.constData(), event.simpleData.lmessage);
    d += event.simpleData.lmessage;
    memcpy(d, data.constData(), event.simpleData.ldata);

    event.setDataDirect(tmp, l);

    c->sendEvent(&event);
}

set_altitude()

void QWSServerPrivate::set_altitude ( const QWSChangeAltitudeCommand *  cmd )

private

Definition at line 3931 of file qwindowsystem_qws.cpp.

{
    QWSClient *serverClient = clientMap.value(-1);
    invokeSetAltitude(cmd, serverClient);
}

set_identity()

void QWSServerPrivate::set_identity ( const QWSIdentifyCommand *  cmd )

private

Definition at line 3949 of file qwindowsystem_qws.cpp.

{
    invokeIdentify(cmd, clientMap.value(-1));
}

set_opacity()

void QWSServerPrivate::set_opacity ( const QWSSetOpacityCommand *  cmd )

private

Definition at line 3937 of file qwindowsystem_qws.cpp.

{
    QWSClient *serverClient = clientMap.value(-1);
    invokeSetOpacity(cmd, serverClient);
}

setCursor()

void QWSServerPrivate::setCursor ( QWSCursor *  curs )

private

Definition at line 352 of file qwscursor_qws.cpp.

Referenced by initializeCursor(), sendMouseEventUnfiltered(), and QWSServer::setCursorVisible().

{
#ifdef QT_NO_QWS_CURSOR
    Q_UNUSED(curs);
#else
    if (cursor == curs)
        return;

    cursor = curs;

    if (!haveviscurs || !curs)
        curs = QWSCursor::systemCursor(Qt::BlankCursor);

    if (qt_screencursor) {
        qt_screencursor->set(curs->image(),
                             curs->hotSpot().x(),
                             curs->hotSpot().y());
    }
#endif
}

setFocus()

void QWSServerPrivate::setFocus ( QWSWindow *  changingw, bool  gain  )

private

Definition at line 3029 of file qwindowsystem_qws.cpp.

Referenced by QWSWindow::setActiveWindow().

{
    Q_Q(QWSServer);
#ifndef QT_NO_QWS_INPUTMETHODS
    /*
      This is the logic:
      QWSWindow *loser = 0;
      if (gain && focusw != changingw)
         loser = focusw;
      else if (!gain && focusw == changingw)
         loser = focusw;
      But these five lines can be reduced to one:
    */
    if (current_IM) {
        QWSWindow *loser =  (!gain == (focusw==changingw)) ? focusw : 0;
        if (loser && loser->winId() == current_IM_winId)
            current_IM->updateHandler(QWSInputMethod::FocusOut);
    }
#endif
    if (gain) {
        if (focusw != changingw) {
            if (focusw) focusw->focus(0);
            focusw = changingw;
            focusw->focus(1);
            emit q->windowEvent(focusw, QWSServer::Active);
        }
    } else if (focusw == changingw) {
        if (changingw->client())
            changingw->focus(0);
        focusw = 0;
        // pass focus to window which most recently got it...
        QWSWindow* bestw=0;
        for (int i=0; i<windows.size(); ++i) {
            QWSWindow* w = windows.at(i);
            if (w != changingw && !w->hidden() &&
                    (!bestw || bestw->focusPriority() < w->focusPriority()))
                bestw = w;
        }
        if (!bestw && changingw->focusPriority()) { // accept focus back?
            bestw = changingw; // must be the only one
        }
        focusw = bestw;
        if (focusw) {
            focusw->focus(1);
            emit q->windowEvent(focusw, QWSServer::Active);
        }
    }
}

setWindowRegion()

void QWSServerPrivate::setWindowRegion ( QWSWindow *  changingw, const QRegion &  r  )

private

Changes the requested region of window changingw to r If changingw is 0, the server's reserved region is changed.

Definition at line 3681 of file qwindowsystem_qws.cpp.

{
    if (!changingw) {
        qWarning("Not implemented in this release");
        return;
    }

    if (changingw->requested_region == r)
        return;

    const QRegion oldRegion(changingw->allocatedRegion());
    changingw->requested_region = r;
    update_regions();
    const QRegion newRegion(changingw->allocatedRegion());

    int idx = windows.indexOf(changingw);
    exposeRegion(oldRegion - newRegion, idx);
}

showCursor()

void QWSServerPrivate::showCursor ( )

private

Definition at line 2141 of file qwindowsystem_qws.cpp.

{
#ifndef QT_NO_QWS_CURSOR
    if (qt_screencursor)
        qt_screencursor->show();
#endif
}

update_regions()

void QWSServerPrivate::update_regions

(

)

Definition at line 3579 of file qwindowsystem_qws.cpp.

Referenced by QWSServer::updateWindowRegions().

{
    if (disablePainting)
        return;

    QRegion available = QRect(0, 0, qt_screen->width(), qt_screen->height());
    QRegion transparentRegion;

    // only really needed if there are unbuffered surfaces...
    const bool doLock = (clientMap.size() > 1);
    if (doLock)
        QWSDisplay::grab(true);

    for (int i = 0; i < windows.count(); ++i) {
        QWSWindow *w = windows.at(i);
        QRegion r = (w->requested_region & available);

#ifndef QT_NO_QWSEMBEDWIDGET
        // Subtract regions needed for embedded windows
        const int n = w->d->embedded.size();
        for (int i = 0; i < n; ++i)
            r -= w->d->embedded.at(i)->allocatedRegion();

        // Limited to the embedder region
        if (w->d->embedder)
            r &= w->d->embedder->requested_region;
#endif // QT_NO_QWSEMBEDWIDGET

        QWSWindowSurface *surface = w->windowSurface();
        const bool opaque = w->isOpaque()
                            && (w->d->painted || !surface || !surface->isBuffered());

        if (!opaque) {
            transparentRegion += r;
        } else {
            if (surface && (surface->isRegionReserved() || !surface->isBuffered()))
                r -= transparentRegion;
            available -= r;
        }

        if (r != w->allocatedRegion()) {
            w->setAllocatedRegion(r);
            w->client()->sendRegionEvent(w->winId(), r,
                                         QWSRegionEvent::Allocation);
        }

#ifdef QT_QWS_CLIENTBLIT
#ifdef QT_NO_QWS_CURSOR
        // This optimization only really works when there isn't a crazy cursor
        // wizzing around.
        QRegion directPaint = (r - transparentRegion); // in gloal coords
        if(directPaint != w->directPaintRegion()) {
            w->setDirectPaintRegion(directPaint);
            static int id = 0;
            surface->setDirectRegion(directPaint, ++id);
            w->client()->sendRegionEvent(w->winId(), directPaint,
                                         QWSRegionEvent::DirectPaint, id);
        }
#endif
#endif
    }

    if (doLock)
        QWSDisplay::ungrab();
}

updateClientCursorPos()

void QWSServerPrivate::updateClientCursorPos ( )

private

Definition at line 4578 of file qwindowsystem_qws.cpp.

{
    Q_Q(QWSServer);
    QWSWindow *win = qwsServerPrivate->mouseGrabber ? qwsServerPrivate->mouseGrabber : qwsServer->windowAt(QWSServer::mousePosition);
    QWSClient *winClient = win ? win->client() : 0;
    if (winClient && winClient != cursorClient)
        q->sendMouseEvent(QWSServer::mousePosition, mouseState);
}

Friends and Related Functions

QCopChannel

friend class QCopChannel

friend

Definition at line 67 of file qwindowsystem_p.h.

QWSDisplay

friend class QWSDisplay

friend

Definition at line 70 of file qwindowsystem_p.h.

QWSInputMethod

friend class QWSInputMethod

friend

Definition at line 71 of file qwindowsystem_p.h.

QWSMouseHandler

friend class QWSMouseHandler

friend

Definition at line 68 of file qwindowsystem_p.h.

QWSWindow

friend class QWSWindow

friend

Definition at line 69 of file qwindowsystem_p.h.

Properties

bgBrush

QBrush * QWSServerPrivate::bgBrush = 0

staticprivate

Definition at line 147 of file qwindowsystem_p.h.

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

channels

QMap<QString, QList<QWSClient*> > QWSServerPrivate::channels

private

Definition at line 294 of file qwindowsystem_p.h.

clientMap

ClientMap QWSServerPrivate::clientMap

private

Definition at line 241 of file qwindowsystem_p.h.

Referenced by QWSServer::processEventQueue(), QWSServer::sendIMEvent(), sendKeyEventUnfiltered(), and sendMouseEventUnfiltered().

commandQueue

QList<QWSCommandStruct*> QWSServerPrivate::commandQueue

private

Definition at line 274 of file qwindowsystem_p.h.

crashedClientIds

QList<int> QWSServerPrivate::crashedClientIds

Definition at line 107 of file qwindowsystem_p.h.

cursor

QWSCursor* QWSServerPrivate::cursor

private

Definition at line 264 of file qwindowsystem_p.h.

Referenced by QWSCursor::createDropShadow(), initializeCursor(), QWSCursor::set(), setCursor(), QWSServer::setCursorVisible(), and QWSCursor::systemCursor().

cursorClient

QWSClient* QWSServerPrivate::cursorClient

Definition at line 103 of file qwindowsystem_p.h.

deletedWindows

QList<QWSWindow*> QWSServerPrivate::deletedWindows

Definition at line 106 of file qwindowsystem_p.h.

Referenced by ~QWSServerPrivate().

disablePainting

bool QWSServerPrivate::disablePainting

private

Definition at line 268 of file qwindowsystem_p.h.

doClientIsActive

bool QWSServerPrivate::doClientIsActive

private

Definition at line 309 of file qwindowsystem_p.h.

focusw

QWSWindow* QWSServerPrivate::focusw

private

Definition at line 257 of file qwindowsystem_p.h.

Referenced by QWSServer::sendIMEvent(), QWSServer::sendIMQuery(), sendKeyEventUnfiltered(), and sendMouseEventUnfiltered().

fontCleanupTimer

QBasicTimer QWSServerPrivate::fontCleanupTimer

private

Definition at line 303 of file qwindowsystem_p.h.

fontReferenceCount

QMap<QByteArray, int> QWSServerPrivate::fontReferenceCount

private

Definition at line 302 of file qwindowsystem_p.h.

haveviscurs

bool QWSServerPrivate::haveviscurs

private

Definition at line 263 of file qwindowsystem_p.h.

Referenced by QWSServer::isCursorVisible(), setCursor(), and QWSServer::setCursorVisible().

inputMethodMouseGrabbed

bool QWSServerPrivate::inputMethodMouseGrabbed

private

Definition at line 260 of file qwindowsystem_p.h.

Referenced by sendMouseEventUnfiltered().

keyboardhandlers

QList<QWSKeyboardHandler*> QWSServerPrivate::keyboardhandlers

private

Definition at line 271 of file qwindowsystem_p.h.

Referenced by QWSServer::keyboardHandler(), and QWSServer::setKeyboardHandler().

mouseGrabber

QWSWindow* QWSServerPrivate::mouseGrabber

private

Definition at line 258 of file qwindowsystem_p.h.

Referenced by sendMouseEventUnfiltered(), and updateClientCursorPos().

mouseGrabbing

bool QWSServerPrivate::mouseGrabbing

private

Definition at line 259 of file qwindowsystem_p.h.

Referenced by sendMouseEventUnfiltered().

mousehandlers

QList<QWSMouseHandler*> QWSServerPrivate::mousehandlers

private

Definition at line 269 of file qwindowsystem_p.h.

Referenced by QWSServer::mouseHandler(), QWSServer::mouseHandlers(), and QWSServer::setMouseHandler().

mouseState

int QWSServerPrivate::mouseState

Definition at line 104 of file qwindowsystem_p.h.

Referenced by QWSServer::sendMouseEvent(), and QWSInputMethod::sendMouseEvent().

nextCursor

QWSCursor* QWSServerPrivate::nextCursor

private

Definition at line 265 of file qwindowsystem_p.h.

Referenced by sendMouseEventUnfiltered().

nReserved

int QWSServerPrivate::nReserved

private

Definition at line 278 of file qwindowsystem_p.h.

pendingDoClients

QList<QWSClient*> QWSServerPrivate::pendingDoClients

private

Definition at line 310 of file qwindowsystem_p.h.

propertyManager

QWSPropertyManager QWSServerPrivate::propertyManager

private

Definition at line 243 of file qwindowsystem_p.h.

ramlen

int QWSServerPrivate::ramlen

private

Definition at line 239 of file qwindowsystem_p.h.

saver

QWSScreenSaver* QWSServerPrivate::saver

Definition at line 102 of file qwindowsystem_p.h.

Referenced by QWSServer::setScreenSaver(), and ~QWSServerPrivate().

screensaverblockevents

bool QWSServerPrivate::screensaverblockevents

Definition at line 100 of file qwindowsystem_p.h.

screensavereventblocklevel

int QWSServerPrivate::screensavereventblocklevel

Definition at line 99 of file qwindowsystem_p.h.

Referenced by QWSServer::setScreenSaverBlockLevel().

screensaverinterval

int* QWSServerPrivate::screensaverinterval

private

Definition at line 255 of file qwindowsystem_p.h.

Referenced by QWSServer::processKeyEvent(), QWSServer::screenSaverActive(), QWSServer::sendMouseEvent(), and QWSServer::setScreenSaverIntervals().

screensaverintervals

int* QWSServerPrivate::screensaverintervals

Definition at line 98 of file qwindowsystem_p.h.

Referenced by QWSServer::setScreenSaverIntervals(), and ~QWSServerPrivate().

screensavertime

QTime QWSServerPrivate::screensavertime

Definition at line 96 of file qwindowsystem_p.h.

screensavertimer

QTimer* QWSServerPrivate::screensavertimer

Definition at line 97 of file qwindowsystem_p.h.

Referenced by QWSServer::screenSaverActive(), and QWSServer::setScreenSaverIntervals().

sdepth

int QWSServerPrivate::sdepth

private

Definition at line 261 of file qwindowsystem_p.h.

selectionOwner

struct QWSServerPrivate::SelectionOwner QWSServerPrivate::selectionOwner

private

sharedram

uchar* QWSServerPrivate::sharedram

private

Definition at line 238 of file qwindowsystem_p.h.

sheight

int QWSServerPrivate::sheight

private

Definition at line 261 of file qwindowsystem_p.h.

Referenced by QWSServer::endDisplayReconfigure(), and initializeCursor().

soundserver

QWSSoundServer* QWSServerPrivate::soundserver

private

Definition at line 291 of file qwindowsystem_p.h.

ssocket

QWSServerSocket* QWSServerPrivate::ssocket

private

Definition at line 298 of file qwindowsystem_p.h.

swidth

int QWSServerPrivate::swidth

private

Definition at line 261 of file qwindowsystem_p.h.

Referenced by QWSServer::endDisplayReconfigure(), and initializeCursor().

timer

QTime QWSServerPrivate::timer

private

Definition at line 254 of file qwindowsystem_p.h.

Referenced by sendMouseEventUnfiltered().

windows

QList<QWSWindow*> QWSServerPrivate::windows

private

Definition at line 277 of file qwindowsystem_p.h.

Referenced by QWSServer::windowList(), and ~QWSServerPrivate().

---

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

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