QWSDisplay::Data Class Reference

#include <qwsdisplay_qws_p.h>

Public Functions
void	connectToPipe ()
void	create (int n=1)
	Data (QObject *parent, bool singleProcess=false)
QWSEvent *	dequeue ()
bool	directServerConnection ()
void	fillQueue ()
void	flush ()
void	flushCommands ()
bool	hasPendingRegionEvents () const
void	init ()
QWSEvent *	peek ()
bool	queueNotEmpty ()
QWSEvent *	readMore ()
void	reinit (const QString &newAppName)
void	sendCommand (QWSCommand &cmd)
void	sendSynchronousCommand (QWSCommand &cmd)
void	setMouseFilter (void(*filter)(QWSMouseEvent *))
int	takeId ()
void	waitForConnection ()
void	waitForCreation ()
void	waitForPropertyReply ()
void	waitForQCopResponse ()
void	waitForRegionAck (int winId)
void	waitForRegionEvents (int winId, bool ungrabDisplay)
	~Data ()

Static Public Functions
static QWSLock *	getClientLock ()
static bool	lockClient (QWSLock::LockType, int timeout=-1)
static void	unlockClient (QWSLock::LockType)
static bool	waitClient (QWSLock::LockType, int timeout=-1)

Public Variables
uchar *	sharedRam
int	sharedRamSize
QWSSharedMemory	shm

Static Public Variables
static QWSLock *	clientLock = 0

Private Types
enum	{ VariableEvent =-1 }

Properties
QWSConnectedEvent *	connected_event
QWSSocket *	csocket
QWSEvent *	current_event
QWSMouseEvent *	mouse_event
int	mouse_state
int	mouse_winid
void(*	mouseFilter )(QWSMouseEvent *)
QWSQCopMessageEvent *	qcop_response
QList< QWSEvent * >	queue
int	region_events_count
QPoint	region_offset
int	region_offset_window
QList< int >	unused_identifiers

Detailed Description

Definition at line 65 of file qwsdisplay_qws_p.h.

Enumerations

anonymous enum

anonymous enum

private

Enumerator
VariableEvent

Definition at line 155 of file qwsdisplay_qws_p.h.

{ VariableEvent=-1 };

Constructors and Destructors

Data()

QWSDisplay::Data::Data	(	QObject *	parent,
		bool	singleProcess = false
	)

Definition at line 498 of file qapplication_qws.cpp.

{
#ifdef QT_NO_QWS_MULTIPROCESS
    Q_UNUSED(parent);
    Q_UNUSED(singleProcess);
#else
    if (singleProcess)
        csocket = 0;
    else {
        csocket = new QWSSocket(parent);
        QObject::connect(csocket, SIGNAL(disconnected()),
                         qApp, SLOT(quit()));
    }
    clientLock = 0;
#endif
    init();
}

~Data()

QWSDisplay::Data::~Data

(

)

Definition at line 516 of file qapplication_qws.cpp.

{
//        delete rgnMan; rgnMan = 0;
//        delete memorymanager; memorymanager = 0;
    qt_screen->disconnect();
    delete qt_screen; qt_screen = 0;
#ifndef QT_NO_QWS_CURSOR
    delete qt_screencursor; qt_screencursor = 0;
#endif
#ifndef QT_NO_QWS_MULTIPROCESS
    shm.detach();
    if (csocket) {
        QWSCommand shutdownCmd(QWSCommand::Shutdown, 0, 0);
        shutdownCmd.write(csocket);
        csocket->flush(); // may be pending QCop message, eg.
        delete csocket;
    }
    delete clientLock;
    clientLock = 0;
#endif
    delete connected_event;
    delete mouse_event;
    delete current_event;
    qDeleteAll(queue);
#ifndef QT_NO_COP
    delete qcop_response;
#endif
}

Functions

connectToPipe()

void QWSDisplay::Data::connectToPipe

(

)

Definition at line 1090 of file qapplication_qws.cpp.

{
    Q_ASSERT(csocket);

    int timeout = qgetenv("QWS_CONNECTION_TIMEOUT").toInt();
    if (timeout)
        qws_connection_timeout = timeout;

    const QString pipe = qws_qtePipeFilename();
    int i = 0;
    while (!csocket->connectToLocalFile(pipe)) {
        if (++i > qws_connection_timeout) {
            qWarning("No Qt for Embedded Linux server appears to be running.");
            qWarning("If you want to run this program as a server,");
            qWarning("add the \"-qws\" command-line option.");
            exit(1);
        }
        sleep(1);
    }
}

create()

void QWSDisplay::Data::create

(

int

n = 1

)

Definition at line 622 of file qapplication_qws.cpp.

{
    QWSCreateCommand cmd(n);
    sendCommand(cmd);
}

dequeue()

QWSEvent * QWSDisplay::Data::dequeue

(

)

Definition at line 590 of file qapplication_qws.cpp.

Referenced by QWSDisplay::waitForQCopResponse().

{
    QWSEvent *r=0;
    if (queue.count()) {
        r = queue.first();
        queue.removeFirst();
        if (r->type == QWSEvent::Region)
            region_events_count--;
    } else if (mouse_event) {
        r = mouse_event;
        mouse_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
        mouse_event_count = 0;
#endif
    }
    return r;
}

directServerConnection()

bool QWSDisplay::Data::directServerConnection

(

)

Definition at line 613 of file qapplication_qws.cpp.

{
#ifndef QT_NO_QWS_MULTIPROCESS
    return csocket == 0;
#else
    return true;
#endif
}

fillQueue()

void QWSDisplay::Data::fillQueue

(

)

Definition at line 973 of file qapplication_qws.cpp.

{
    QWSServer::processEventQueue();
    QWSEvent *e = readMore();
#ifndef QT_NO_QWS_MULTIPROCESS
    int bytesAvailable = csocket ? csocket->bytesAvailable() : 0;
    int bytesRead = 0;
#endif
    while (e) {
#ifndef QT_NO_QWS_MULTIPROCESS
        bytesRead += QWS_PROTOCOL_ITEM_SIZE((*e));
#endif
        if (e->type == QWSEvent::Connected) {
            connected_event = static_cast<QWSConnectedEvent *>(e);
            return;
        } else if (e->type == QWSEvent::Creation) {
            QWSCreationEvent *ce = static_cast<QWSCreationEvent*>(e);
            int id = ce->simpleData.objectid;
            int count = ce->simpleData.count;
            for (int i = 0; i < count; ++i)
                unused_identifiers.append(id++);
            delete e;
        } else if (e->type == QWSEvent::Mouse) {
            if (!qt_screen) {
                delete e;
            } else {
                QWSMouseEvent *me = static_cast<QWSMouseEvent*>(e);
                if (mouseFilter)
                    mouseFilter(me);
#ifdef QAPPLICATION_EXTRA_DEBUG
                static const char *defaultAction= "INITIAL";
                const char * action = defaultAction;
#endif
                delete mouse_event;
                if (mouse_winid != me->window ()
                    || mouse_state != me->simpleData.state) {
                        queue.append(me);
                        mouse_winid = me->window();
                        mouse_state = me->simpleData.state;
                        mouse_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
                        mouse_event_count = 0;
                        action = "ENQUEUE";
#endif
                } else {
#ifdef QAPPLICATION_EXTRA_DEBUG
                    if (mouse_event)
                        action = "COMPRESS";
                    mouse_event_count++;
#endif
                    mouse_event = me;
                }
#ifdef QAPPLICATION_EXTRA_DEBUG
                if (me->simpleData.state !=0 || action != defaultAction || mouse_event_count != 0)
                    qDebug("fillQueue %s (%d,%d), state %x win %d count %d", action,
                           me->simpleData.x_root, me->simpleData.y_root, me->simpleData.state,
                           me->window(), mouse_event_count);
#endif
            }
#ifndef QT_NO_QWS_MULTIPROCESS
        } else if (e->type == QWSEvent::Region && clientLock) {
            // not really an unlock, decrements the semaphore
            region_events_count++;
            clientLock->unlock(QWSLock::RegionEvent);
            queue.append(e);
#endif
#ifndef QT_NO_QWS_PROPERTIES
        } else if (e->type == QWSEvent::PropertyReply) {
            QWSPropertyReplyEvent *pe = static_cast<QWSPropertyReplyEvent*>(e);
            int len = pe->simpleData.len;
            char *data;
            if (len <= 0) {
                data = 0;
            } else {
                data = new char[len];
                memcpy(data, pe->data, len) ;
            }
            QPaintDevice::qwsDisplay()->getPropertyLen = len;
            QPaintDevice::qwsDisplay()->getPropertyData = data;
            delete e;
#endif // QT_NO_QWS_PROPERTIES
        } else if (e->type==QWSEvent::MaxWindowRect && qt_screen) {
            // Process this ASAP, in case new widgets are created (startup)
            setMaxWindowRect((static_cast<QWSMaxWindowRectEvent*>(e))->simpleData.rect);
            delete e;
#ifndef QT_NO_QWS_DYNAMICSCREENTRANSFORMATION
        } else if (e->type == QWSEvent::ScreenTransformation) {
            QWSScreenTransformationEvent *pe = static_cast<QWSScreenTransformationEvent*>(e);
            setScreenTransformation(pe->simpleData.screen,
                                    pe->simpleData.transformation);
            delete e;
#endif
#ifndef QT_NO_COP
        } else if (e->type == QWSEvent::QCopMessage) {
            QWSQCopMessageEvent *pe = static_cast<QWSQCopMessageEvent*>(e);
            if (pe->simpleData.is_response) {
                qcop_response = pe;
            } else {
                queue.append(e);
            }
#endif
        } else {
            queue.append(e);
        }
        //debugQueue();
#ifndef QT_NO_QWS_MULTIPROCESS
        if (csocket && bytesRead >= bytesAvailable)
            break;
#endif
        e = readMore();
    }
}

flush()

void QWSDisplay::Data::flush

(

)

Definition at line 567 of file qapplication_qws.cpp.

{
#ifndef QT_NO_QWS_MULTIPROCESS
    if (csocket) {
        csocket->waitForReadyRead(0);
        csocket->flush();
   }
#endif
}

flushCommands()

void QWSDisplay::Data::flushCommands

(

)

Definition at line 628 of file qapplication_qws.cpp.

Referenced by QWSDisplay::flushCommands().

{
#ifndef QT_NO_QWS_MULTIPROCESS
    if  (csocket)
        csocket->flush();
#endif
}

getClientLock()

QWSLock * QWSDisplay::Data::getClientLock ( )

static

Definition at line 561 of file qapplication_qws.cpp.

Referenced by QWSMemorySurface::QWSMemorySurface(), QWSMemorySurface::setLock(), and QWSMemorySurface::~QWSMemorySurface().

{
    return clientLock;
}

hasPendingRegionEvents()

bool QWSDisplay::Data::hasPendingRegionEvents

(

)

const

Definition at line 1225 of file qapplication_qws.cpp.

Referenced by QWSDirectPainterSurface::hasPendingRegionEvents().

{
    if (clientLock && !clientLock->hasLock(QWSLock::RegionEvent))
        return true;

    return region_events_count > 0;
}

init()

void QWSDisplay::Data::init

(

)

Definition at line 799 of file qapplication_qws.cpp.

{
    connected_event = 0;
    region_events_count = 0;
//    region_ack = 0;
    mouse_event = 0;
    mouse_state = -1;
    mouse_winid = 0;
//    region_event = 0;
    region_offset_window = 0;
#ifndef QT_NO_COP
    qcop_response = 0;
#endif
    current_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
    mouse_event_count = 0;
#endif
    mouseFilter = 0;

    QString pipe = qws_qtePipeFilename();

    sharedRamSize = qwsSharedRamSize;

#ifndef QT_NO_QWS_MULTIPROCESS
    if (csocket)    {
        // QWS client

        connectToPipe();

        QWSDisplay::Data::clientLock = new QWSLock();

        QWSIdentifyCommand cmd;
        cmd.setId(appName, QWSDisplay::Data::clientLock->id());
#ifndef QT_NO_SXE
        QTransportAuth *a = QTransportAuth::getInstance();
        QTransportAuth::Data *d = a->connectTransport(
                QTransportAuth::UnixStreamSock |
                QTransportAuth::Trusted,
                csocket->socketDescriptor());
        QAuthDevice *ad = a->authBuf( d, csocket );
        ad->setClient( csocket );
        cmd.write(ad);
#else
        cmd.write(csocket);
#endif

        // create(30); // not necessary, server will send ids anyway
        waitForConnection();

        qws_client_id = connected_event->simpleData.clientId;

        // now we want to get the exact display spec to use if we haven't
        // specified anything.
        if (qws_display_spec.at(0) == ':')
            qws_display_spec = connected_event->display;

        if (!QWSDisplay::initLock(pipe, false))
            qFatal("Cannot get display lock");

        if (shm.attach(connected_event->simpleData.servershmid)) {
            sharedRam = static_cast<uchar *>(shm.address());
            QScreen *s = qt_get_screen(qws_display_id, qws_display_spec.constData());
            if (s)
                sharedRamSize += s->memoryNeeded(QLatin1String(qws_display_spec.constData()));
        } else {
            perror("QWSDisplay::Data::init");
            qFatal("Client can't attach to main ram memory.");
        }

        // We wait for creation mainly so that we can process important
        // initialization events such as MaxWindowRect that are sent
        // before object id creation.  Waiting here avoids later window
        // resizing since we have the MWR before windows are displayed.
        waitForCreation();
    } else
#endif
    {
        create(30);

        // QWS server
        if (!QWSDisplay::initLock(pipe, true))
            qFatal("Cannot get display lock");

        QScreen *s = qt_get_screen(qws_display_id, qws_display_spec.constData());
        if (s)
            sharedRamSize += s->memoryNeeded(QLatin1String(qws_display_spec.constData()));

#ifndef QT_NO_QWS_MULTIPROCESS

        if (!shm.create(sharedRamSize)) {
            perror("Cannot create main ram shared memory\n");
            qFatal("Unable to allocate %d bytes of shared memory", sharedRamSize);
        }
        qt_servershmid = shm.id();
        sharedRam = static_cast<uchar *>(shm.address());
#else
        sharedRam=static_cast<uchar *>(malloc(sharedRamSize));
#endif
        // Need to zero index count at end of block, might as well zero
        // the rest too
        memset(sharedRam,0,sharedRamSize);

        QWSIdentifyCommand cmd;
        cmd.setId(appName, -1);
        qt_server_enqueue(&cmd);
    }

    // Allow some memory for the graphics driver too
    //### Note that sharedRamSize() has side effects; it must be called
    //### once, and only once, and before initDevice()
    sharedRamSize -= qt_screen->sharedRamSize(sharedRam+sharedRamSize);

#ifndef QT_NO_QWS_MULTIPROCESS
    if(!csocket)
#endif
    {
        //QWS server process
        if (!qt_screen->initDevice())
            qFatal("Unable to initialize screen driver!");
    }

    sharedRamSize -= sizeof(int);
    qt_last_x = reinterpret_cast<int *>(sharedRam + sharedRamSize);
    sharedRamSize -= sizeof(int);
    qt_last_y = reinterpret_cast<int *>(sharedRam + sharedRamSize);

    /* Initialise framebuffer memory manager */
    /* Add 4k for luck and to avoid clobbering hardware cursor */
//    int screensize=qt_screen->screenSize();
//     memorymanager=new QMemoryManager(qt_screen->base()+screensize+4096,
//         qt_screen->totalSize()-(screensize+4096),0);

// #ifndef QT_NO_QWS_MULTIPROCESS
//     rgnMan = new QWSRegionManager(pipe, csocket);
// #else
//     rgnMan = new QWSRegionManager(pipe, 0); //####### not necessary
// #endif
#ifndef QT_NO_QWS_MULTIPROCESS
    if (csocket)
        csocket->flush();
#endif
}

lockClient()

bool QWSDisplay::Data::lockClient ( QWSLock::LockType  type, int  timeout = -1  )

static

Definition at line 546 of file qapplication_qws.cpp.

{
    return !clientLock || clientLock->lock(type, timeout);
}

peek()

QWSEvent * QWSDisplay::Data::peek

(

)

Definition at line 608 of file qapplication_qws.cpp.

{
    return queue.first();
}

queueNotEmpty()

bool QWSDisplay::Data::queueNotEmpty

(

)

Definition at line 586 of file qapplication_qws.cpp.

{
    return mouse_event/*||region_event*/||queue.count() > 0;
}

readMore()

QWSEvent * QWSDisplay::Data::readMore

(

)

Definition at line 943 of file qapplication_qws.cpp.

{
#ifdef QT_NO_QWS_MULTIPROCESS
    return incoming.isEmpty() ? 0 : incoming.takeFirst();
#else
    if (!csocket)
        return incoming.isEmpty() ? 0 : incoming.takeFirst();
    // read next event
    if (!current_event) {
        int event_type = qws_read_uint(csocket);

        if (event_type >= 0) {
            current_event = QWSEvent::factory(event_type);
        }
    }

    if (current_event) {
        if (current_event->read(csocket)) {
            // Finished reading a whole event.
            QWSEvent* result = current_event;
            current_event = 0;
            return result;
        }
    }

    // Not finished reading a whole event.
    return 0;
#endif
}

reinit()

void QWSDisplay::Data::reinit

(

const QString &

newAppName

)

Definition at line 700 of file qapplication_qws.cpp.

Referenced by qt_app_reinit().

{
    Q_ASSERT(csocket);

    delete connected_event;
    connected_event = 0;
    region_events_count = 0;
//    region_ack = 0;
    delete mouse_event;
    mouse_event = 0;
//    region_event = 0;
    region_offset_window = 0;
#ifndef QT_NO_COP
    delete qcop_response;
    qcop_response = 0;
#endif
    delete current_event;
    current_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
    mouse_event_count = 0;
#endif
    mouseFilter = 0;

    qt_desktopWidget = 0;
    delete QWSDisplay::Data::clientLock;
    QWSDisplay::Data::clientLock = 0;

    QString pipe = qws_qtePipeFilename();

    // QWS client
    // Cleanup all cached ids
    unused_identifiers.clear();
    delete csocket;

    appName = newAppName;
    qApp->setObjectName( appName );

    csocket = new QWSSocket();
    QObject::connect(csocket, SIGNAL(disconnected()),
                     qApp, SLOT(quit()));
    csocket->connectToLocalFile(pipe);

    QWSDisplay::Data::clientLock = new QWSLock();

    QWSIdentifyCommand cmd;
    cmd.setId(appName, QWSDisplay::Data::clientLock->id());

#ifndef QT_NO_SXE
    QTransportAuth *a = QTransportAuth::getInstance();
    QTransportAuth::Data *d = a->connectTransport(
            QTransportAuth::UnixStreamSock |
            QTransportAuth::Trusted,
            csocket->socketDescriptor());
    QAuthDevice *ad = a->authBuf( d, csocket );
    ad->setClient( csocket );

    cmd.write(ad);
#else
    cmd.write(csocket);
#endif

    // wait for connect confirmation
    waitForConnection();

    qws_client_id = connected_event->simpleData.clientId;

    if (!QWSDisplay::initLock(pipe, false))
        qFatal("Cannot get display lock");

    if (shm.attach(connected_event->simpleData.servershmid)) {
        sharedRam = static_cast<uchar *>(shm.address());
        QScreen *s = qt_get_screen(qws_display_id, qws_display_spec.constData());
        if (s)
            sharedRamSize += s->memoryNeeded(QLatin1String(qws_display_spec.constData()));
    } else {
        perror("QWSDisplay::Data::init");
        qFatal("Client can't attach to main ram memory.");
    }

    qApp->desktop();

    // We wait for creation mainly so that we can process important
    // initialization events such as MaxWindowRect that are sent
    // before object id creation.  Waiting here avoids later window
    // resizing since we have the MWR before windows are displayed.
    waitForCreation();

    sharedRamSize -= sizeof(int);
    qt_last_x = reinterpret_cast<int *>(sharedRam + sharedRamSize);
    sharedRamSize -= sizeof(int);
    qt_last_y = reinterpret_cast<int *>(sharedRam + sharedRamSize);

#ifndef QT_NO_COP
    QCopChannel::reregisterAll();
#endif
    csocket->flush();
}

sendCommand()

void QWSDisplay::Data::sendCommand

(

QWSCommand &

cmd

)

Definition at line 636 of file qapplication_qws.cpp.

Referenced by QWSDisplay::registerChannel(), QWSEmbedWidgetPrivate::resize(), QWSDisplay::sendMessage(), QScreen::setTransformation(), QWSEmbedWidgetPrivate::updateWindow(), and QWSEmbedWidget::~QWSEmbedWidget().

{
#ifndef QT_NO_QWS_MULTIPROCESS
    if  (csocket)
        cmd.write(csocket);
    else
#endif
        qt_server_enqueue(&cmd);
}

sendSynchronousCommand()

void QWSDisplay::Data::sendSynchronousCommand

(

QWSCommand &

cmd

)

Definition at line 646 of file qapplication_qws.cpp.

{
#ifndef QT_NO_QWS_MULTIPROCESS
    if  (csocket) {
        lockClient(QWSLock::Communication);
        cmd.write(csocket);
        bool ok = true;
        while (csocket->bytesToWrite() > 0) {
            if (!csocket->waitForBytesWritten(-1)) {
                qCritical("QWSDisplay::Data::sendSynchronousCommand: %s",
                          qPrintable(csocket->errorString()));
                ok = false;
                break;
            }
        }
        if (ok)
            waitClient(QWSLock::Communication);
    } else
#endif
        qt_server_enqueue(&cmd);
}

setMouseFilter()

void QWSDisplay::Data::setMouseFilter

(

void(*)(QWSMouseEvent *)

filter

)

Definition at line 681 of file qapplication_qws.cpp.

Referenced by QWSDisplay::setRawMouseEventFilter().

{
    mouseFilter = filter;
}

takeId()

int QWSDisplay::Data::takeId

(

)

Definition at line 668 of file qapplication_qws.cpp.

{
    int unusedIdCount = unused_identifiers.count();
    if (unusedIdCount <= 10)
        create(15);
    if (unusedIdCount == 0) {
        create(1); // Make sure we have an incoming id to wait for, just in case we're recursive
        waitForCreation();
    }

    return unused_identifiers.takeFirst();
}

unlockClient()

void QWSDisplay::Data::unlockClient ( QWSLock::LockType  type )

static

Definition at line 551 of file qapplication_qws.cpp.

{
    if (clientLock) clientLock->unlock(type);
}

waitClient()

bool QWSDisplay::Data::waitClient ( QWSLock::LockType  type, int  timeout = -1  )

static

Definition at line 556 of file qapplication_qws.cpp.

{
    return !clientLock || clientLock->wait(type, timeout);
}

waitForConnection()

void QWSDisplay::Data::waitForConnection

(

)

Definition at line 1111 of file qapplication_qws.cpp.

{
    connected_event = 0;

    for (int i = 0; i < qws_connection_timeout; i++) {
        fillQueue();
        if (connected_event)
            return;
        csocket->flush();
        csocket->waitForReadyRead(1000);
    }

    csocket->flush();
    if (!connected_event)
        qFatal("Did not receive a connection event from the qws server");
}

waitForCreation()

void QWSDisplay::Data::waitForCreation

(

)

Definition at line 1235 of file qapplication_qws.cpp.

{
    fillQueue();
#ifndef QT_NO_QWS_MULTIPROCESS
    while (unused_identifiers.count() == 0) {
        if (csocket) {
            csocket->flush();
            csocket->waitForReadyRead(1000);
        }
        fillQueue();
    }
#endif
}

waitForPropertyReply()

void QWSDisplay::Data::waitForPropertyReply

(

)

Definition at line 1251 of file qapplication_qws.cpp.

{
    if (!csocket)
        return;
    fillQueue();
    while (qt_fbdpy->getPropertyLen == -2) {
        csocket->flush();
        csocket->waitForReadyRead(1000);
        fillQueue();
    }
}

waitForQCopResponse()

void QWSDisplay::Data::waitForQCopResponse

(

)

Definition at line 1265 of file qapplication_qws.cpp.

Referenced by QWSDisplay::waitForQCopResponse().

{
    for (;;) {
        fillQueue();
        if (qcop_response)
            break;
#ifndef QT_NO_QWS_MULTIPROCESS
        if (csocket) {
            csocket->flush();
            csocket->waitForReadyRead(1000);
        }
#endif
    }
    queue.prepend(qcop_response);
    qcop_response = 0;
}

waitForRegionAck()

void QWSDisplay::Data::waitForRegionAck

(

int

winId

)

Definition at line 1128 of file qapplication_qws.cpp.

Referenced by QWSDirectPainterSurface::setRegion().

{
    QWSEvent *ack = 0;

    if (csocket) { // GuiClient
        int i = 0;
        while (!ack) {
            fillQueue();

            while (i < queue.size()) {
                QWSEvent *e = queue.at(i);
                if (e->type == QWSEvent::Region && e->window() == winId) {
                    ack = e;
                    queue.removeAt(i);
                    break;
                }
                ++i;
            }

            if (!ack) {
                csocket->flush();
                csocket->waitForReadyRead(1000);
            }
        }
    } else { // GuiServer
        fillQueue();
        for (int i = 0; i < queue.size(); /* nothing */) {
            QWSEvent *e = queue.at(i);
            if (e->type == QWSEvent::Region && e->window() == winId) {
                ack = e;
                queue.removeAt(i);
                break;
            }
            ++i;
        }
        if (!ack) // already processed
            return;
    }

    Q_ASSERT(ack);

    qApp->qwsProcessEvent(ack);
    delete ack;
    region_events_count--;
}

waitForRegionEvents()

void QWSDisplay::Data::waitForRegionEvents	(	int	winId,
		bool	ungrabDisplay
	)

Definition at line 1174 of file qapplication_qws.cpp.

Referenced by QWSDirectPainterSurface::beginPaint().

{
    if (!clientLock)
        return;

    int removedEventsCount = 0;

    // fill queue with unreceived region events
    if (!clientLock->hasLock(QWSLock::RegionEvent)) {
        bool ungrabbed = false;
        if (ungrabDisplay && QWSDisplay::grabbed()) {
            QWSDisplay::ungrab();
            ungrabbed = true;
        }

        for (;;) {
            fillQueue();
            if (clientLock->hasLock(QWSLock::RegionEvent))
                break;
            csocket->flush();
            csocket->waitForReadyRead(1000);
        }

        if (ungrabbed)
            QWSDisplay::grab(true);
    }

    // check the queue for pending region events
    QWSEvent *regionEvent = 0;
    for (int i = 0; i < queue.size(); /* nothing */) {
        QWSEvent *e = queue.at(i);
        if (e->type == QWSEvent::Region && e->window() == winId) {
            QWSRegionEvent *re = static_cast<QWSRegionEvent*>(e);
            if (re->simpleData.type == QWSRegionEvent::Allocation) {
                delete regionEvent;
                regionEvent = re;
            }
            queue.removeAt(i);
            removedEventsCount++;
        } else {
            ++i;
        }
    }

    if (regionEvent) {
        qApp->qwsProcessEvent(regionEvent);
        delete regionEvent;
    }
    region_events_count -= removedEventsCount;
}

Properties

clientLock

QWSLock * QWSDisplay::Data::clientLock = 0

static

Definition at line 115 of file qwsdisplay_qws_p.h.

Referenced by reinit(), and setMouseFilter().

connected_event

QWSConnectedEvent* QWSDisplay::Data::connected_event

private

Definition at line 138 of file qwsdisplay_qws_p.h.

csocket

QWSSocket* QWSDisplay::Data::csocket

private

Definition at line 125 of file qwsdisplay_qws_p.h.

current_event

QWSEvent* QWSDisplay::Data::current_event

private

Definition at line 148 of file qwsdisplay_qws_p.h.

mouse_event

QWSMouseEvent* QWSDisplay::Data::mouse_event

private

Definition at line 139 of file qwsdisplay_qws_p.h.

mouse_state

int QWSDisplay::Data::mouse_state

private

Definition at line 141 of file qwsdisplay_qws_p.h.

mouse_winid

int QWSDisplay::Data::mouse_winid

private

Definition at line 142 of file qwsdisplay_qws_p.h.

mouseFilter

void(* QWSDisplay::Data::mouseFilter) (QWSMouseEvent *)

private

Definition at line 153 of file qwsdisplay_qws_p.h.

qcop_response

QWSQCopMessageEvent* QWSDisplay::Data::qcop_response

private

Definition at line 146 of file qwsdisplay_qws_p.h.

queue

QList<QWSEvent*> QWSDisplay::Data::queue

private

Definition at line 127 of file qwsdisplay_qws_p.h.

region_events_count

int QWSDisplay::Data::region_events_count

private

Definition at line 140 of file qwsdisplay_qws_p.h.

region_offset

QPoint QWSDisplay::Data::region_offset

private

Definition at line 143 of file qwsdisplay_qws_p.h.

region_offset_window

int QWSDisplay::Data::region_offset_window

private

Definition at line 144 of file qwsdisplay_qws_p.h.

sharedRam

uchar* QWSDisplay::Data::sharedRam

Definition at line 108 of file qwsdisplay_qws_p.h.

sharedRamSize

int QWSDisplay::Data::sharedRamSize

Definition at line 112 of file qwsdisplay_qws_p.h.

shm

QWSSharedMemory QWSDisplay::Data::shm

Definition at line 110 of file qwsdisplay_qws_p.h.

unused_identifiers

QList<int> QWSDisplay::Data::unused_identifiers

private

Definition at line 149 of file qwsdisplay_qws_p.h.

---

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

• /src/gui/embedded/qwsdisplay_qws_p.h
• /src/gui/kernel/qapplication_qws.cpp