Google Git
Sign in
android / platform / external / qt / 7bfefd596b628604816a01c904428ab99099b10d / . / Windows-4.7.4 / src / gui / embedded / qwindowsystem_qws.cpp
blob: 66f444c4272ca25f70a732d85d4fcdad11977f26 [file] [log] [blame]
/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qplatformdefs.h"
#include "qwindowsystem_qws.h"
#include "qwsevent_qws.h"
#include "qwscommand_qws_p.h"
#include "qtransportauth_qws_p.h"
#include "qwsutils_qws.h"
#include "qwscursor_qws.h"
#include "qwsdisplay_qws.h"
#include "qmouse_qws.h"
#include "qcopchannel_qws.h"
#include "qwssocket_qws.h"
#include "qapplication.h"
#include "private/qapplication_p.h"
#include "qsocketnotifier.h"
#include "qpolygon.h"
#include "qimage.h"
#include "qcursor.h"
#include <private/qpaintengine_raster_p.h>
#include "qscreen_qws.h"
#include "qwindowdefs.h"
#include "private/qlock_p.h"
#include "qwslock_p.h"
#include "qfile.h"
#include "qtimer.h"
#include "qpen.h"
#include "qdesktopwidget.h"
#include "qevent.h"
#include "qinputcontext.h"
#include "qpainter.h"
#include <qdebug.h>
#include "qkbddriverfactory_qws.h"
#include "qmousedriverfactory_qws.h"
#include <qbuffer.h>
#include <qdir.h>
#include <private/qwindowsurface_qws_p.h>
#include <private/qfontengine_qpf_p.h>
#include "qwindowsystem_p.h"
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#ifndef QT_NO_QWS_MULTIPROCESS
#include <sys/param.h>
#include <sys/mount.h>
#endif
#if !defined(QT_NO_SOUND) && !defined(Q_OS_DARWIN)
#ifdef QT_USE_OLD_QWS_SOUND
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>
#else
#include "qsoundqss_qws.h"
#endif
#endif
//#define QWS_DEBUG_FONTCLEANUP
QT_BEGIN_NAMESPACE
QWSServer Q_GUI_EXPORT *qwsServer=0;
static QWSServerPrivate *qwsServerPrivate=0;
#define MOUSE 0
#define KEY 1
//#define EVENT_BLOCK_DEBUG
QWSScreenSaver::~QWSScreenSaver()
{
}
extern QByteArray qws_display_spec;
extern void qt_init_display(); //qapplication_qws.cpp
extern QString qws_qtePipeFilename();
extern void qt_client_enqueue(const QWSEvent *); //qapplication_qws.cpp
extern QList<QWSCommand*> *qt_get_server_queue();
Q_GLOBAL_STATIC_WITH_ARGS(QString, defaultMouse, (QLatin1String("Auto")))
Q_GLOBAL_STATIC_WITH_ARGS(QString, defaultKeyboard, (QLatin1String("TTY")))
static const int FontCleanupInterval = 60 * 1000;
static int qws_keyModifiers = 0;
static QWSWindow *keyboardGrabber;
static bool keyboardGrabbing;
static int get_object_id(int count = 1)
{
static int next=1000;
int n = next;
next += count;
return n;
}
#ifndef QT_NO_QWS_INPUTMETHODS
static QWSInputMethod *current_IM = 0;
static QWSWindow *current_IM_composing_win = 0;
static int current_IM_winId = -1;
static bool force_reject_strokeIM = false;
#endif
static void cleanupFontsDir();
//#define QWS_REGION_DEBUG
/*!
\class QWSScreenSaver
\ingroup qws
\brief The QWSScreenSaver class is a base class for screensavers
in Qt for Embedded Linux.
When running \l{Qt for Embedded Linux} applications, it is the server
application that installs and controls the screensaver.
\l{Qt for Embedded Linux} supports multilevel screen saving; i.e., it is possible to
specify several different levels of screen responsiveness. For
example, you can choose to first turn off the light before you
fully activate the screensaver.
Note that there exists no default screensaver implementation.
To create a custom screensaver, derive from this class and
reimplement the restore() and save() functions. These functions
are called whenever the screensaver is activated or deactivated,
respectively. Once an instance of your custom screensaver is
created, you can use the QWSServer::setScreenSaver() function to
install it.
\sa QWSServer, QScreen, {Qt for Embedded Linux}
*/
/*!
\fn QWSScreenSaver::~QWSScreenSaver()
Reimplement this function to destroy the screensaver.
*/
/*!
\fn QWSScreenSaver::restore()
Implement this function to deactivate the screensaver, restoring
the previously saved screen.
\sa save(), QWSServer::screenSaverActivate()
*/
/*!
\fn QWSScreenSaver::save(int level)
Implement this function to activate the screensaver, saving the
current screen.
\l{Qt for Embedded Linux} supports multilevel screen saving; i.e., it is
possible to specify several different levels of screen
responsiveness. For example, you can choose to first turn off the
light before you fully activate the screensaver. Use the
QWSServer::setScreenSaverIntervals() to specify the time intervals
between the different levels.
This function should return true if the screensaver successfully
enters the given \a level; otherwise it should return false.
\sa restore(), QWSServer::screenSaverActivate()
*/
class QWSWindowPrivate
{
public:
QWSWindowPrivate();
#ifdef QT_QWS_CLIENTBLIT
QRegion directPaintRegion;
#endif
QRegion allocatedRegion;
#ifndef QT_NO_QWSEMBEDWIDGET
QList<QWSWindow*> embedded;
QWSWindow *embedder;
#endif
QWSWindow::State state;
Qt::WindowFlags windowFlags;
QRegion dirtyOnScreen;
bool painted;
};
QWSWindowPrivate::QWSWindowPrivate()
:
#ifndef QT_NO_QWSEMBEDWIDGET
embedder(0), state(QWSWindow::NoState),
#endif
painted(false)
{
}
/*!
\class QWSWindow
\ingroup qws
\brief The QWSWindow class encapsulates a top-level window in
Qt for Embedded Linux.
When you run a \l{Qt for Embedded Linux} application, it either runs as a
server or connects to an existing server. As applications add and
remove windows, the server process maintains information about
each window. In \l{Qt for Embedded Linux}, top-level windows are
encapsulated as QWSWindow objects. Note that you should never
construct the QWSWindow class yourself; the current top-level
windows can be retrieved using the QWSServer::clientWindows()
function.
With a window at hand, you can retrieve its caption, name, opacity
and ID using the caption(), name(), opacity() and winId()
functions, respectively. Use the client() function to retrieve a
pointer to the client that owns the window.
Use the isVisible() function to find out if the window is
visible. You can find out if the window is completely obscured by
another window or by the bounds of the screen, using the
isFullyObscured() function. The isOpaque() function returns true
if the window has an alpha channel equal to 255. Finally, the
requestedRegion() function returns the region of the display the
window wants to draw on.
\sa QWSServer, QWSClient, {Qt for Embedded Linux Architecture}
*/
/*!
\fn int QWSWindow::winId() const
Returns the window's ID.
\sa name(), caption()
*/
/*!
\fn const QString &QWSWindow::name() const
Returns the window's name, which is taken from the \l {QWidget::}{objectName()}
at the time of \l {QWidget::}{show()}.
\sa caption(), winId()
*/
/*!
\fn const QString &QWSWindow::caption() const
Returns the window's caption.
\sa name(), winId()
*/
/*!
\fn QWSClient* QWSWindow::client() const
Returns a reference to the QWSClient object that owns this window.
\sa requestedRegion()
*/
/*!
\fn QRegion QWSWindow::requestedRegion() const
Returns the region that the window has requested to draw onto,
including any window decorations.
\sa client()
*/
/*!
\fn bool QWSWindow::isVisible() const
Returns true if the window is visible; otherwise returns false.
\sa isFullyObscured()
*/
/*!
\fn bool QWSWindow::isOpaque() const
Returns true if the window is opaque, i.e., if its alpha channel
equals 255; otherwise returns false.
\sa opacity()
*/
/*!
\fn uint QWSWindow::opacity () const
Returns the window's alpha channel value.
\sa isOpaque()
*/
/*!
\fn bool QWSWindow::isPartiallyObscured() const
\internal
Returns true if the window is partially obsured by another window
or by the bounds of the screen; otherwise returns false.
*/
/*!
\fn bool QWSWindow::isFullyObscured() const
Returns true if the window is completely obsured by another window
or by the bounds of the screen; otherwise returns false.
\sa isVisible()
*/
/*!
\fn QWSWindowSurface* QWSWindow::windowSurface() const
\internal
*/
QWSWindow::QWSWindow(int i, QWSClient* client)
: id(i), modified(false),
onTop(false), c(client), last_focus_time(0), _opacity(255),
opaque(true), d(new QWSWindowPrivate)
{
surface = 0;
}
/*!
\enum QWSWindow::State
This enum describes the state of a window. Most of the
transitional states are set just before a call to
QScreen::exposeRegion() and reset immediately afterwards.
\value NoState Initial state before the window is properly initialized.
\value Hidden The window is not visible.
\value Showing The window is being shown.
\value Visible The window is visible, and not in a transition.
\value Hiding The window is being hidden.
\value Raising The windoe is being raised.
\value Lowering The window is being raised.
\value Moving The window is being moved.
\value ChangingGeometry The window's geometry is being changed.
\value Destroyed The window is destroyed.
\sa state(), QScreen::exposeRegion()
*/
/*!
Returns the current state of the window.
\since 4.3
*/
QWSWindow::State QWSWindow::state() const
{
return d->state;
}
/*!
Returns the window flags of the window. This value is only available
after the first paint event.
\since 4.3
*/
Qt::WindowFlags QWSWindow::windowFlags() const
{
return d->windowFlags;
}
/*!
Returns the region that has been repainted since the previous
QScreen::exposeRegion(), and needs to be copied to the screen.
\since 4.3
*/
QRegion QWSWindow::dirtyOnScreen() const
{
return d->dirtyOnScreen;
}
void QWSWindow::createSurface(const QString &key, const QByteArray &data)
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (surface && !surface->isBuffered())
c->removeUnbufferedSurface();
#endif
delete surface;
surface = qt_screen->createSurface(key);
surface->setPermanentState(data);
#ifndef QT_NO_QWS_MULTIPROCESS
if (!surface->isBuffered())
c->addUnbufferedSurface();
#endif
}
/*!
\internal
Raises the window above all other windows except "Stay on top" windows.
*/
void QWSWindow::raise()
{
qwsServerPrivate->raiseWindow(this);
#ifndef QT_NO_QWSEMBEDWIDGET
const int n = d->embedded.size();
for (int i = 0; i < n; ++i)
d->embedded.at(i)->raise();
#endif
}
/*!
\internal
Lowers the window below other windows.
*/
void QWSWindow::lower()
{
qwsServerPrivate->lowerWindow(this);
#ifndef QT_NO_QWSEMBEDWIDGET
const int n = d->embedded.size();
for (int i = 0; i < n; ++i)
d->embedded.at(i)->lower();
#endif
}
/*!
\internal
Shows the window.
*/
void QWSWindow::show()
{
operation(QWSWindowOperationEvent::Show);
#ifndef QT_NO_QWSEMBEDWIDGET
const int n = d->embedded.size();
for (int i = 0; i < n; ++i)
d->embedded.at(i)->show();
#endif
}
/*!
\internal
Hides the window.
*/
void QWSWindow::hide()
{
operation(QWSWindowOperationEvent::Hide);
#ifndef QT_NO_QWSEMBEDWIDGET
const int n = d->embedded.size();
for (int i = 0; i < n; ++i)
d->embedded.at(i)->hide();
#endif
}
/*!
\internal
Make this the active window (i.e., sets the keyboard focus to this
window).
*/
void QWSWindow::setActiveWindow()
{
qwsServerPrivate->setFocus(this, true);
#ifndef QT_NO_QWSEMBEDWIDGET
const int n = d->embedded.size();
for (int i = 0; i < n; ++i)
d->embedded.at(i)->setActiveWindow();
#endif
}
void QWSWindow::setName(const QString &n)
{
rgnName = n;
}
/*!
\internal
Sets the window's caption to \a c.
*/
void QWSWindow::setCaption(const QString &c)
{
rgnCaption = c;
}
static int global_focus_time_counter=100;
void QWSWindow::focus(bool get)
{
if (get)
last_focus_time = global_focus_time_counter++;
if (c) {
QWSFocusEvent event;
event.simpleData.window = id;
event.simpleData.get_focus = get;
c->sendEvent(&event);
}
}
void QWSWindow::operation(QWSWindowOperationEvent::Operation o)
{
if (!c)
return;
QWSWindowOperationEvent event;
event.simpleData.window = id;
event.simpleData.op = o;
c->sendEvent(&event);
}
/*!
\internal
Destructor.
*/
QWSWindow::~QWSWindow()
{
#ifndef QT_NO_QWS_INPUTMETHODS
if (current_IM_composing_win == this)
current_IM_composing_win = 0;
#endif
#ifndef QT_NO_QWSEMBEDWIDGET
QWSWindow *embedder = d->embedder;
if (embedder) {
embedder->d->embedded.removeAll(this);
d->embedder = 0;
}
while (!d->embedded.isEmpty())
stopEmbed(d->embedded.first());
#endif
#ifndef QT_NO_QWS_MULTIPROCESS
if (surface && !surface->isBuffered()) {
if (c && c->d_func()) // d_func() will be 0 if client is deleted
c->removeUnbufferedSurface();
}
#endif
delete surface;
delete d;
}
/*!
\internal
Returns the region that the window is allowed to draw onto,
including any window decorations but excluding regions covered by
other windows.
\sa paintedRegion(), requestedRegion()
*/
QRegion QWSWindow::allocatedRegion() const
{
return d->allocatedRegion;
}
#ifdef QT_QWS_CLIENTBLIT
QRegion QWSWindow::directPaintRegion() const
{
return d->directPaintRegion;
}
inline void QWSWindow::setDirectPaintRegion(const QRegion &r)
{
d->directPaintRegion = r;
}
#endif
/*!
\internal
Returns the region that the window is known to have drawn into.
\sa allocatedRegion(), requestedRegion()
*/
QRegion QWSWindow::paintedRegion() const
{
return (d->painted ? d->allocatedRegion : QRegion());
}
inline void QWSWindow::setAllocatedRegion(const QRegion &region)
{
d->allocatedRegion = region;
}
#ifndef QT_NO_QWSEMBEDWIDGET
inline void QWSWindow::startEmbed(QWSWindow *w)
{
d->embedded.append(w);
w->d->embedder = this;
}
inline void QWSWindow::stopEmbed(QWSWindow *w)
{
w->d->embedder = 0;
w->client()->sendEmbedEvent(w->winId(), QWSEmbedEvent::Region, QRegion());
d->embedded.removeAll(w);
}
#endif // QT_NO_QWSEMBEDWIDGET
/*********************************************************************
*
* Class: QWSClient
*
*********************************************************************/
class QWSClientPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QWSClient)
public:
QWSClientPrivate();
~QWSClientPrivate();
void setLockId(int id);
void unlockCommunication();
private:
#ifndef QT_NO_QWS_MULTIPROCESS
QWSLock *clientLock;
bool shutdown;
int numUnbufferedSurfaces;
#endif
QSet<QByteArray> usedFonts;
friend class QWSServerPrivate;
};
QWSClientPrivate::QWSClientPrivate()
{
#ifndef QT_NO_QWS_MULTIPROCESS
clientLock = 0;
shutdown = false;
numUnbufferedSurfaces = 0;
#endif
}
QWSClientPrivate::~QWSClientPrivate()
{
#ifndef QT_NO_QWS_MULTIPROCESS
delete clientLock;
#endif
}
void QWSClientPrivate::setLockId(int id)
{
#ifdef QT_NO_QWS_MULTIPROCESS
Q_UNUSED(id);
#else
clientLock = new QWSLock(id);
#endif
}
void QWSClientPrivate::unlockCommunication()
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (clientLock)
clientLock->unlock(QWSLock::Communication);
#endif
}
/*!
\class QWSClient
\ingroup qws
\brief The QWSClient class encapsulates a client process in Qt for Embedded Linux.
When you run a \l{Qt for Embedded Linux} application, it either runs as a
server or connects to an existing server. The server and client
processes have different responsibilities: The client process
performs all application specific operations. The server process
is responsible for managing the clients as well as taking care of
the pointer handling, character input, and screen output. In
addition, the server provides functionality to handle input
methods.
As applications add and remove windows, the server process
maintains information about each window. In \l{Qt for Embedded Linux},
top-level windows are encapsulated as QWSWindow objects. A list of
the current windows can be retrieved using the
QWSServer::clientWindows() function, and each window can tell
which client that owns it through its QWSWindow::client()
function.
A QWSClient object has an unique ID that can be retrieved using
its clientId() function. QWSClient also provides the identity()
function which typically returns the name of this client's running
application.
\sa QWSServer, QWSWindow, {Qt for Embedded Linux Architecture}
*/
/*!
\internal
*/
//always use frame buffer
QWSClient::QWSClient(QObject* parent, QWS_SOCK_BASE* sock, int id)
: QObject(*new QWSClientPrivate, parent), command(0), cid(id)
{
#ifdef QT_NO_QWS_MULTIPROCESS
Q_UNUSED(sock);
isClosed = false;
#else
csocket = 0;
if (!sock) {
socketDescriptor = -1;
isClosed = false;
} else {
csocket = static_cast<QWSSocket*>(sock); //###
isClosed = false;
csocket->flush();
socketDescriptor = csocket->socketDescriptor();
connect(csocket, SIGNAL(readyRead()), this, SIGNAL(readyRead()));
connect(csocket, SIGNAL(disconnected()), this, SLOT(closeHandler()));
connect(csocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(errorHandler()));
}
#endif //QT_NO_QWS_MULTIPROCESS
}
/*!
\internal
*/
QWSClient::~QWSClient()
{
qDeleteAll(cursors);
delete command;
#ifndef QT_NO_QWS_MULTIPROCESS
delete csocket;
#endif
}
#ifndef QT_NO_QWS_MULTIPROCESS
void QWSClient::removeUnbufferedSurface()
{
Q_D(QWSClient);
--d->numUnbufferedSurfaces;
}
void QWSClient::addUnbufferedSurface()
{
Q_D(QWSClient);
++d->numUnbufferedSurfaces;
}
#endif // QT_NO_QWS_MULTIPROCESS
/*!
\internal
*/
void QWSClient::setIdentity(const QString& i)
{
id = i;
}
void QWSClient::closeHandler()
{
isClosed = true;
emit connectionClosed();
}
void QWSClient::errorHandler()
{
#if defined(QWS_SOCKET_DEBUG)
qDebug("Client %p error %s", this, csocket ? csocket->errorString().toLatin1().constData() : "(no socket)");
#endif
isClosed = true;
//####Do we need to clean out the pipes?
emit connectionClosed();
}
/*!
\internal
*/
int QWSClient::socket() const
{
return socketDescriptor;
}
/*!
\internal
*/
void QWSClient::sendEvent(QWSEvent* event)
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket) {
// qDebug() << "QWSClient::sendEvent type " << event->type << " socket state " << csocket->state();
if ((QAbstractSocket::SocketState)(csocket->state()) == QAbstractSocket::ConnectedState) {
event->write(csocket);
}
}
else
#endif
{
qt_client_enqueue(event);
}
}
/*!
\internal
*/
void QWSClient::sendRegionEvent(int winid, QRegion rgn, int type
#ifdef QT_QWS_CLIENTBLIT
, int id
#endif
)
{
#ifndef QT_NO_QWS_MULTIPROCESS
Q_D(QWSClient);
if (d->clientLock)
d->clientLock->lock(QWSLock::RegionEvent);
#endif
QWSRegionEvent event;
event.setData(winid, rgn, type);
#ifdef QT_QWS_CLIENTBLIT
event.simpleData.id = id;
#endif
// qDebug() << "Sending Region event to" << winid << "rgn" << rgn << "type" << type;
sendEvent(&event);
}
extern int qt_servershmid;
/*!
\internal
*/
void QWSClient::sendConnectedEvent(const char *display_spec)
{
QWSConnectedEvent event;
event.simpleData.window = 0;
event.simpleData.len = strlen(display_spec) + 1;
event.simpleData.clientId = cid;
event.simpleData.servershmid = qt_servershmid;
char * tmp=(char *)display_spec;
event.setData(tmp, event.simpleData.len);
sendEvent(&event);
}
/*!
\internal
*/
void QWSClient::sendMaxWindowRectEvent(const QRect &rect)
{
QWSMaxWindowRectEvent event;
event.simpleData.window = 0;
event.simpleData.rect = rect;
sendEvent(&event);
}
/*!
\internal
*/
#ifndef QT_NO_QWS_PROPERTIES
void QWSClient::sendPropertyNotifyEvent(int property, int state)
{
QWSPropertyNotifyEvent event;
event.simpleData.window = 0; // not used yet
event.simpleData.property = property;
event.simpleData.state = state;
sendEvent(&event);
}
/*!
\internal
*/
void QWSClient::sendPropertyReplyEvent(int property, int len, const char *data)
{
QWSPropertyReplyEvent event;
event.simpleData.window = 0; // not used yet
event.simpleData.property = property;
event.simpleData.len = len;
event.setData(data, len);
sendEvent(&event);
}
#endif //QT_NO_QWS_PROPERTIES
/*!
\internal
*/
void QWSClient::sendSelectionClearEvent(int windowid)
{
QWSSelectionClearEvent event;
event.simpleData.window = windowid;
sendEvent(&event);
}
/*!
\internal
*/
void QWSClient::sendSelectionRequestEvent(QWSConvertSelectionCommand *cmd, int windowid)
{
QWSSelectionRequestEvent event;
event.simpleData.window = windowid;
event.simpleData.requestor = cmd->simpleData.requestor;
event.simpleData.property = cmd->simpleData.selection;
event.simpleData.mimeTypes = cmd->simpleData.mimeTypes;
sendEvent(&event);
}
#ifndef QT_NO_QWSEMBEDWIDGET
/*!
\internal
*/
void QWSClient::sendEmbedEvent(int windowid, QWSEmbedEvent::Type type,
const QRegion &region)
{
QWSEmbedEvent event;
event.setData(windowid, type, region);
sendEvent(&event);
}
#endif // QT_NO_QWSEMBEDWIDGET
/*!
\fn void QWSClient::connectionClosed()
\internal
*/
/*!
\fn void QWSClient::readyRead();
\internal
*/
/*!
\fn int QWSClient::clientId () const
Returns an integer uniquely identfying this client.
*/
/*!
\fn QString QWSClient::identity () const
Returns the name of this client's running application.
*/
/*********************************************************************
*
* Class: QWSServer
*
*********************************************************************/
/*!
\class QWSServer
\brief The QWSServer class encapsulates a server process in Qt for Embedded Linux.
\ingroup qws
When you run a \l{Qt for Embedded Linux} application, it either runs as a
server or connects to an existing server. The server and client
processes have different responsibilities: The client process
performs all application specific operations. The server process
is responsible for managing the clients as well as taking care of
the pointer handling, character input, and screen output. In
addition, the server provides functionality to handle input
methods.
In \l{Qt for Embedded Linux}, all system generated events are passed to the
server application which then propagates the event to the
appropriate client. See the \l{Qt for Embedded Linux Architecture}
documentation for details.
Note that this class is instantiated by QApplication for
\l{Qt for Embedded Linux} server processes; you should never construct this
class yourself. Use the instance() function to retrieve a pointer
to the server object.
Note that the static functions of the QWSServer class can only be
used in the server process.
\tableofcontents
\section1 Client Administration
As applications add and remove windows, the server process
maintains information about each window. In \l{Qt for Embedded Linux},
top-level windows are encapsulated as QWSWindow objects. Each
window can tell which client that owns it through its
QWSWindow::client() function. Use the clientWindows() function to
retrieve a list of the current top-level windows. Given a
particular position on the display, the window containing it can
be retrieved using the windowAt() function.
QWSServer also provides the windowEvent() signal which is emitted
whenever something happens to a top level window; the WindowEvent
enum describes the various types of events that the signal
recognizes. In addition, the server class provides the
markedText() signal which is emitted whenever some text has been
selected in any of the windows, passing the selection as
parameter.
The QCopChannel class and the QCOP communication protocol enable
transfer of messages between clients. QWSServer provides the
newChannel() and removedChannel() signals that is emitted whenever
a new QCopChannel object is created or destroyed, respectively.
See also: QWSWindow, QWSClient and QCopChannel.
\section1 Mouse Handling
The mouse driver (represented by an instance of the
QWSMouseHandler class) is loaded by the server application when it
starts running, using Qt's \l {How to Create Qt Plugins}{plugin
system}. A mouse driver receives mouse events from the device and
encapsulates each event with an instance of the QWSEvent class
which it then passes to the server.
The openMouse() function opens the mouse devices specified by the
QWS_MOUSE_PROTO environment variable, and the setMouseHandler()
functions sets the primary mouse driver. Alternatively, the static
setDefaultMouse() function provides means of specifying the mouse
driver to use if the QWS_MOUSE_PROTO variable is not defined (note
that the default is otherwise platform dependent). The primary
mouse driver can be retrieved using the static mouseHandler()
function. Use the closeMouse() function to delete the mouse
drivers.
In addition, the QWSServer class can control the flow of mouse
input using the suspendMouse() and resumeMouse() functions.
See also: QWSMouseHandler and \l{Qt for Embedded Linux Pointer Handling}.
\section1 Keyboard Handling
The keyboard driver (represented by an instance of the
QWSKeyboardHandler class) is loaded by the server application when
it starts running, using Qt's \l {How to Create Qt Plugins}{plugin
system}. A keyboard driver receives keyboard events from the
device and encapsulates each event with an instance of the
QWSEvent class which it then passes to the server.
The openKeyboard() function opens the keyboard devices specified
by the QWS_KEYBOARD environment variable, and the
setKeyboardHandler() functions sets the primary keyboard
driver. Alternatively, the static setDefaultKeyboard() function
provides means of specifying the keyboard driver to use if the
QWS_KEYBOARD variable is not defined (note again that the default
is otherwise platform dependent). The primary keyboard driver can
be retrieved using the static keyboardHandler() function. Use the
closeKeyboard() function to delete the keyboard drivers.
In addition, the QWSServer class can handle key events from both
physical and virtual keyboards using the processKeyEvent() and
sendKeyEvent() functions, respectively. Use the
addKeyboardFilter() function to filter the key events from
physical keyboard drivers, the most recently added filter can be
removed and deleted using the removeKeyboardFilter() function.
See also: QWSKeyboardHandler and \l{Qt for Embedded Linux Character Input}.
\section1 Display Handling
When a screen update is required, the server runs through all the
top-level windows that intersect with the region that is about to
be updated, and ensures that the associated clients have updated
their memory buffer. Then the server uses the screen driver
(represented by an instance of the QScreen class) to copy the
content of the memory to the screen.
In addition, the QWSServer class provides some means of managing
the screen output: Use the refresh() function to refresh the
entire display, or alternatively a specified region of it. The
enablePainting() function can be used to disable (and enable)
painting onto the screen. QWSServer also provide the
setMaxWindowRect() function restricting the area of the screen
which \l{Qt for Embedded Linux} applications will consider to be the
maximum area to use for windows. To set the brush used as the
background in the absence of obscuring windows, QWSServer provides
the static setBackground() function. The corresponding
backgroundBrush() function returns the currently set brush.
QWSServer also controls the screen saver: Use the setScreenSaver()
to install a custom screen saver derived from the QWSScreenSaver
class. Once installed, the screensaver can be activated using the
screenSaverActivate() function, and the screenSaverActive()
function returns its current status. Use the
setScreenSaverInterval() function to specify the timeout interval.
\l{Qt for Embedded Linux} also supports multilevel screen saving, use the
setScreenSaverIntervals() function to specify the various levels
and their timeout intervals.
Finally, the QWSServer class controls the cursor's appearance,
i.e., use the setCursorVisible() function to hide or show the
cursor, and the isCursorVisible() function to determine whether
the cursor is visible on the display or not.
See also: QScreen and \l{Qt for Embedded Linux Display Management}.
\section1 Input Method Handling
Whenever the server receives an event, it queries its stack of
top-level windows to find the window containing the event's
position (each window can identify the client application that
created it). Then the server forwards the event to the appropriate
client. If an input method is installed, it is used as a filter
between the server and the client application.
Derive from the QWSInputMethod class to create custom input
methods, and use the server's setCurrentInputMethod() function to
install it. Use the sendIMEvent() and sendIMQuery() functions to
send input method events and queries.
QWSServer provides the IMMouse enum describing the various mouse
events recognized by the QWSInputMethod::mouseHandler()
function. The latter function allows subclasses of QWSInputMethod
to handle mouse events within the preedit text.
\sa QWSInputMethod
*/
/*!
\enum QWSServer::IMState
\obsolete
This enum describes the various states of an input method.
\value IMCompose Composing.
\value IMStart Equivalent to IMCompose.
\value IMEnd Finished composing.
\sa QWSInputMethod::sendIMEvent()
*/
/*!
\enum QWSServer::IMMouse
This enum describes the various types of mouse events recognized
by the QWSInputMethod::mouseHandler() function.
\value MousePress An event generated by pressing a mouse button.
\value MouseRelease An event generated by relasing a mouse button.
\value MouseMove An event generated by moving the mouse cursor.
\value MouseOutside This value is only reserved, i.e., it is not used in
current implementations.
\sa QWSInputMethod, setCurrentInputMethod()
*/
/*!
\enum QWSServer::ServerFlags
\internal
This enum is used to pass various options to the window system
server.
\value DisableKeyboard Ignore all keyboard input.
\value DisableMouse Ignore all mouse input.
*/
/*!
\enum QWSServer::WindowEvent
This enum specifies the various events that can occur in a
top-level window.
\value Create A new window has been created (by the QWidget constructor).
\value Destroy The window has been closed and deleted (by the QWidget destructor).
\value Hide The window has been hidden using the QWidget::hide() function.
\value Show The window has been shown using the QWidget::show() function or similar.
\value Raise The window has been raised to the top of the desktop.
\value Lower The window has been lowered.
\value Geometry The window has changed size or position.
\value Active The window has become the active window (i.e., it has keyboard focus).
\value Name The window has been named.
\sa windowEvent()
*/
/*!
\fn void QWSServer::markedText(const QString &selection)
This signal is emitted whenever some text is selected in any of
the running applications, passing the selected text in the \a
selection parameter.
\sa windowEvent()
*/
/*!
\fn const QList<QWSWindow*> &QWSServer::clientWindows()
Returns the list of current top-level windows.
Note that the collection of top-level windows changes as
applications add and remove widgets so it should not be stored for
future use. The windows are sorted in stacking order from top-most
to bottom-most.
Use the QWSWindow::client() function to retrieve the client
application that owns a given window.
\sa windowAt(), instance()
*/
/*!
\fn void QWSServer::newChannel(const QString& channel)
This signal is emitted whenever a new QCopChannel object is
created, passing the channel's name in the \a channel parameter.
\sa removedChannel()
*/
/*!
\fn void QWSServer::removedChannel(const QString& channel)
This signal is emitted immediately after the given the QCopChannel
object specified by \a channel, is destroyed.
Note that a channel is not destroyed until all its listeners have
been unregistered.
\sa newChannel()
*/
/*!
\fn QWSServer::QWSServer(int flags, QObject *parent)
\internal
Construct a QWSServer object with the given \a parent. The \a
flags are used for keyboard and mouse settings.
\warning This class is instantiated by QApplication for
\l{Qt for Embedded Linux} server processes. You should never construct
this class yourself.
\sa {Running Applications}
*/
/*!
\fn static QWSServer* QWSServer::instance()
\since 4.2
Returns a pointer to the server instance.
Note that the pointer will be 0 if the application is not the
server, i.e., if the QApplication::type() function doesn't return
QApplication::GuiServer.
\sa clientWindows(), windowAt()
*/
struct QWSCommandStruct
{
QWSCommandStruct(QWSCommand *c, QWSClient *cl) :command(c),client(cl){}
~QWSCommandStruct() { delete command; }
QWSCommand *command;
QWSClient *client;
};
QWSServer::QWSServer(int flags, QObject *parent) :
QObject(*new QWSServerPrivate, parent)
{
Q_D(QWSServer);
QT_TRY {
d->initServer(flags);
} QT_CATCH(...) {
qwsServer = 0;
qwsServerPrivate = 0;
QT_RETHROW;
}
}
#ifdef QT3_SUPPORT
/*!
Use the two-argument overload and call the
QObject::setObjectName() function instead.
*/
QWSServer::QWSServer(int flags, QObject *parent, const char *name) :
QObject(*new QWSServerPrivate, parent)
{
Q_D(QWSServer);
setObjectName(QString::fromAscii(name));
d->initServer(flags);
}
#endif
#ifndef QT_NO_QWS_MULTIPROCESS
static void ignoreSignal(int) {} // Used to eat SIGPIPE signals below
#endif
bool QWSServerPrivate::screensaverblockevent( int index, int *screensaverinterval, bool isDown )
{
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];
}
void QWSServerPrivate::initServer(int flags)
{
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
}
/*!
\internal
Destructs this server.
*/
QWSServer::~QWSServer()
{
closeMouse();
#ifndef QT_NO_QWS_KEYBOARD
closeKeyboard();
#endif
d_func()->cleanupFonts(/*force =*/true);
}
/*!
\internal
*/
void QWSServer::timerEvent(QTimerEvent *e)
{
Q_D(QWSServer);
if (e->timerId() == d->fontCleanupTimer.timerId()) {
d->cleanupFonts();
d->fontCleanupTimer.stop();
} else {
QObject::timerEvent(e);
}
}
const QList<QWSWindow*> &QWSServer::clientWindows()
{
Q_D(QWSServer);
return d->windows;
}
/*!
\internal
*/
void QWSServerPrivate::releaseMouse(QWSWindow* w)
{
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
}
}
/*!
\internal
*/
void QWSServerPrivate::releaseKeyboard(QWSWindow* w)
{
if (keyboardGrabber == w) {
keyboardGrabber = 0;
keyboardGrabbing = false;
}
}
void QWSServerPrivate::handleWindowClose(QWSWindow *w)
{
w->shuttingDown();
if (focusw == w)
setFocus(w,false);
if (mouseGrabber == w)
releaseMouse(w);
if (keyboardGrabber == w)
releaseKeyboard(w);
}
#ifndef QT_NO_QWS_MULTIPROCESS
/*!
\internal
*/
void QWSServerPrivate::_q_newConnection()
{
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);
}
}
/*!
\internal
*/
void QWSServerPrivate::_q_clientClosed()
{
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);
}
void QWSServerPrivate::_q_deleteWindowsLater()
{
qDeleteAll(deletedWindows);
deletedWindows.clear();
}
#endif //QT_NO_QWS_MULTIPROCESS
void QWSServerPrivate::referenceFont(QWSClientPrivate *client, const QByteArray &font)
{
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
}
}
void QWSServerPrivate::dereferenceFont(QWSClientPrivate *client, const QByteArray &font)
{
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
}
}
static void cleanupFontsDir()
{
static bool dontDelete = !qgetenv("QWS_KEEP_FONTS").isEmpty();
if (dontDelete)
return;
extern QString qws_fontCacheDir();
QDir dir(qws_fontCacheDir(), QLatin1String("*.qsf"));
for (uint i = 0; i < dir.count(); ++i) {
#if defined(QWS_DEBUG_FONTCLEANUP)
qDebug() << "removing stale font file" << dir[i];
#endif
dir.remove(dir[i]);
}
}
void QWSServerPrivate::cleanupFonts(bool force)
{
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));
}
void QWSServerPrivate::sendFontRemovedEvent(const QByteArray &font)
{
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);
}
/*!
\internal
*/
QWSCommand* QWSClient::readMoreCommand()
{
#ifndef QT_NO_QWS_MULTIPROCESS
QIODevice *socket = 0;
#endif
#ifndef QT_NO_SXE
if (socketDescriptor != -1) // not server socket
socket = QTransportAuth::getInstance()->passThroughByClient( this );
#if QTRANSPORTAUTH_DEBUG
if (socket) {
char displaybuf[1024];
qint64 bytes = socket->bytesAvailable();
if ( bytes > 511 ) bytes = 511;
hexstring( displaybuf, ((unsigned char *)(reinterpret_cast<QAuthDevice*>(socket)->buffer().constData())), bytes );
qDebug( "readMoreCommand: %lli bytes - %s", socket->bytesAvailable(), displaybuf );
}
#endif
#endif // QT_NO_SXE
#ifndef QT_NO_QWS_MULTIPROCESS
if (!socket)
socket = csocket; // server socket
if (socket) {
// read next command
if (!command) {
int command_type = qws_read_uint(socket);
if (command_type >= 0)
command = QWSCommand::factory(command_type);
}
if (command) {
if (command->read(socket)) {
// Finished reading a whole command.
QWSCommand* result = command;
command = 0;
return result;
}
}
// Not finished reading a whole command.
return 0;
} else
#endif // QT_NO_QWS_MULTIPROCESS
{
QList<QWSCommand*> *serverQueue = qt_get_server_queue();
return serverQueue->isEmpty() ? 0 : serverQueue->takeFirst();
}
}
/*!
\internal
*/
void QWSServer::processEventQueue()
{
if (qwsServerPrivate)
qwsServerPrivate->doClient(qwsServerPrivate->clientMap.value(-1));
}
#ifndef QT_NO_QWS_MULTIPROCESS
void QWSServerPrivate::_q_doClient()
{
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;
}
#endif // QT_NO_QWS_MULTIPROCESS
void QWSServerPrivate::doClient(QWSClient *client)
{
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;
}
}
void QWSServerPrivate::showCursor()
{
#ifndef QT_NO_QWS_CURSOR
if (qt_screencursor)
qt_screencursor->show();
#endif
}
void QWSServerPrivate::hideCursor()
{
#ifndef QT_NO_QWS_CURSOR
if (qt_screencursor)
qt_screencursor->hide();
#endif
}
/*!
\fn void QWSServer::enablePainting(bool enable)
Enables painting onto the screen if \a enable is true; otherwise
painting is disabled.
\sa {Qt for Embedded Linux Architecture#Drawing on Screen}{Qt for Embedded Linux
Architecture}
*/
void QWSServer::enablePainting(bool enable)
{
Q_D(QWSServer);
if (d->disablePainting == !enable)
return;
d->disablePainting = !enable;
if (enable) {
// Reset the server side allocated regions to ensure update_regions()
// will send out region events.
for (int i = 0; i < d->windows.size(); ++i) {
QWSWindow *w = d->windows.at(i);
w->setAllocatedRegion(QRegion());
#ifdef QT_QWS_CLIENTBLIT
w->setDirectPaintRegion(QRegion());
#endif
}
d->update_regions();
d->showCursor();
} else {
// Disable painting by clients by taking away their allocated region.
// To ensure mouse events are still delivered to the correct windows,
// the allocated regions are not modified on the server.
for (int i = 0; i < d->windows.size(); ++i) {
QWSWindow *w = d->windows.at(i);
w->client()->sendRegionEvent(w->winId(), QRegion(),
QWSRegionEvent::Allocation);
#ifdef QT_QWS_CLIENTBLIT
w->client()->sendRegionEvent(w->winId(), QRegion(),
QWSRegionEvent::DirectPaint);
#endif
}
d->hideCursor();
}
}
/*!
Refreshes the display by making the screen driver update the
entire display.
\sa QScreen::exposeRegion()
*/
void QWSServer::refresh()
{
Q_D(QWSServer);
d->exposeRegion(QScreen::instance()->region());
//### send repaint to non-buffered windows
}
/*!
\fn void QWSServer::refresh(QRegion & region)
\overload
Refreshes the given \a region of the display.
*/
void QWSServer::refresh(QRegion & r)
{
Q_D(QWSServer);
d->exposeRegion(r);
//### send repaint to non-buffered windows
}
/*!
\fn void QWSServer::setMaxWindowRect(const QRect& rectangle)
Sets the maximum area of the screen that \l{Qt for Embedded Linux}
applications can use, to be the given \a rectangle.
Note that this function can only be used in the server process.
\sa QWidget::showMaximized()
*/
void QWSServer::setMaxWindowRect(const QRect &rect)
{
QList<QScreen*> subScreens = qt_screen->subScreens();
if (subScreens.isEmpty() && qt_screen != 0)
subScreens.append(qt_screen);
for (int i = 0; i < subScreens.size(); ++i) {
const QScreen *screen = subScreens.at(i);
const QRect r = (screen->region() & rect).boundingRect();
if (r.isEmpty())
continue;
QApplicationPrivate *ap = QApplicationPrivate::instance();
if (ap->maxWindowRect(screen) != r) {
ap->setMaxWindowRect(screen, i, r);
qwsServerPrivate->sendMaxWindowRectEvents(r);
}
}
}
/*!
\internal
*/
void QWSServerPrivate::sendMaxWindowRectEvents(const QRect &rect)
{
QMap<int,QWSClient*>::const_iterator it = clientMap.constBegin();
for (; it != clientMap.constEnd(); ++it)
(*it)->sendMaxWindowRectEvent(rect);
}
/*!
\fn void QWSServer::setDefaultMouse(const char *mouseDriver)
Sets the mouse driver that will be used if the QWS_MOUSE_PROTO
environment variable is not defined, to be the given \a
mouseDriver.
Note that the default is platform-dependent. This function can
only be used in the server process.
\sa setMouseHandler(), {Qt for Embedded Linux Pointer Handling}
*/
void QWSServer::setDefaultMouse(const char *m)
{
*defaultMouse() = QString::fromAscii(m);
}
/*!
\fn void QWSServer::setDefaultKeyboard(const char *keyboardDriver)
Sets the keyboard driver that will be used if the QWS_KEYBOARD
environment variable is not defined, to be the given \a
keyboardDriver.
Note that the default is platform-dependent. This function can
only be used in the server process.
\sa setKeyboardHandler(), {Qt for Embedded Linux Character Input}
*/
void QWSServer::setDefaultKeyboard(const char *k)
{
*defaultKeyboard() = QString::fromAscii(k);
}
#ifndef QT_NO_QWS_CURSOR
static bool prevWin;
#endif
extern int *qt_last_x,*qt_last_y;
/*!
\internal
Send a mouse event. \a pos is the screen position where the mouse
event occurred and \a state is a mask indicating which buttons are
pressed.
\a pos is in device coordinates
*/
void QWSServer::sendMouseEvent(const QPoint& pos, int state, int wheel)
{
bool block = qwsServerPrivate->screensaverblockevent(MOUSE, qwsServerPrivate->screensaverinterval, state);
#ifdef EVENT_BLOCK_DEBUG
qDebug() << "sendMouseEvent" << pos.x() << pos.y() << state << (block ? "block" : "pass");
#endif
if (state || wheel)
qwsServerPrivate->_q_screenSaverWake();
if ( block )
return;
QPoint tpos;
// transformations
if (qt_screen->isTransformed()) {
QSize s = QSize(qt_screen->deviceWidth(), qt_screen->deviceHeight());
tpos = qt_screen->mapFromDevice(pos, s);
} else {
tpos = pos;
}
if (qt_last_x) {
*qt_last_x = tpos.x();
*qt_last_y = tpos.y();
}
QWSServer::mousePosition = tpos;
qwsServerPrivate->mouseState = state;
#ifndef QT_NO_QWS_INPUTMETHODS
const int btnMask = Qt::LeftButton | Qt::RightButton | Qt::MidButton;
int stroke_count; // number of strokes to keep shown.
if (force_reject_strokeIM || !current_IM)
{
stroke_count = 0;
} else {
stroke_count = current_IM->filter(tpos, state, wheel);
}
if (stroke_count == 0) {
if (state&btnMask)
force_reject_strokeIM = true;
QWSServerPrivate::sendMouseEventUnfiltered(tpos, state, wheel);
}
// stop force reject after stroke ends.
if (state&btnMask && force_reject_strokeIM)
force_reject_strokeIM = false;
// on end of stroke, force_rejct
// and once a stroke is rejected, do not try again till pen is lifted
#else
QWSServerPrivate::sendMouseEventUnfiltered(tpos, state, wheel);
#endif // end QT_NO_QWS_FSIM
}
void QWSServerPrivate::sendMouseEventUnfiltered(const QPoint &pos, int state, int wheel)
{
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);
}
/*!
Returns the primary mouse driver.
Note that this function can only be used in the server process.
\sa setMouseHandler(), openMouse(), closeMouse()
*/
QWSMouseHandler *QWSServer::mouseHandler()
{
if (qwsServerPrivate->mousehandlers.empty())
return 0;
return qwsServerPrivate->mousehandlers.first();
}
/*!
\since 4.5
Returns list of all mouse handlers
Note that this function can only be used in the server process.
\sa mouseHandler(), setMouseHandler(), openMouse(), closeMouse()
*/
const QList<QWSMouseHandler*>& QWSServer::mouseHandlers()
{
return qwsServerPrivate->mousehandlers;
}
// called by QWSMouseHandler constructor, not user code.
/*!
\fn void QWSServer::setMouseHandler(QWSMouseHandler* driver)
Sets the primary mouse driver to be the given \a driver.
\l{Qt for Embedded Linux} provides several ready-made mouse drivers, and
custom drivers are typically added using Qt's plugin
mechanism. See the \l{Qt for Embedded Linux Pointer Handling} documentation
for details.
Note that this function can only be used in the server process.
\sa mouseHandler(), setDefaultMouse()
*/
void QWSServer::setMouseHandler(QWSMouseHandler* mh)
{
if (!mh)
return;
qwsServerPrivate->mousehandlers.removeAll(mh);
qwsServerPrivate->mousehandlers.prepend(mh);
}
/*!
\internal
\obsolete
Caller owns data in list, and must delete contents
*/
QList<QWSInternalWindowInfo*> * QWSServer::windowList()
{
QList<QWSInternalWindowInfo*> * ret=new QList<QWSInternalWindowInfo*>;
for (int i=0; i < qwsServerPrivate->windows.size(); ++i) {
QWSWindow *window = qwsServerPrivate->windows.at(i);
QWSInternalWindowInfo * qwi=new QWSInternalWindowInfo();
qwi->winid=window->winId();
qwi->clientid=window->client()->clientId();
ret->append(qwi);
}
return ret;
}
#ifndef QT_NO_COP
/*!
\internal
*/
void QWSServerPrivate::sendQCopEvent(QWSClient *c, const QString &ch,
const QString &msg, const QByteArray &data,
bool response)
{
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);
}
#endif
/*!
\fn QWSWindow *QWSServer::windowAt(const QPoint& position)
Returns the window containing the given \a position.
Note that if there is no window under the specified point this
function returns 0.
\sa clientWindows(), instance()
*/
QWSWindow *QWSServer::windowAt(const QPoint& pos)
{
Q_D(QWSServer);
for (int i=0; i<d->windows.size(); ++i) {
QWSWindow* w = d->windows.at(i);
if (w->allocatedRegion().contains(pos))
return w;
}
return 0;
}
#ifndef QT_NO_QWS_KEYBOARD
static int keyUnicode(int keycode)
{
int code = 0xffff;
if (keycode >= Qt::Key_A && keycode <= Qt::Key_Z)
code = keycode - Qt::Key_A + 'a';
else if (keycode >= Qt::Key_0 && keycode <= Qt::Key_9)
code = keycode - Qt::Key_0 + '0';
return code;
}
#endif
/*!
Sends the given key event. The key is identified by its \a unicode
value and the given \a keycode, \a modifiers, \a isPress and \a
autoRepeat parameters.
Use this function to send key events generated by "virtual
keyboards" (note that the processKeyEvent() function is
impelemented using this function).
The \a keycode parameter is the Qt keycode value as defined by the
Qt::Key enum. The \a modifiers is an OR combination of
Qt::KeyboardModifier values, indicating whether \gui
Shift/Alt/Ctrl keys are pressed. The \a isPress parameter is true
if the event is a key press event and \a autoRepeat is true if the
event is caused by an auto-repeat mechanism and not an actual key
press.
Note that this function can only be used in the server process.
\sa processKeyEvent(), {Qt for Embedded Linux Character Input}
*/
void QWSServer::sendKeyEvent(int unicode, int keycode, Qt::KeyboardModifiers modifiers,
bool isPress, bool autoRepeat)
{
qws_keyModifiers = modifiers;
if (isPress) {
if (keycode != Qt::Key_F34 && keycode != Qt::Key_F35)
qwsServerPrivate->_q_screenSaverWake();
}
#ifndef QT_NO_QWS_INPUTMETHODS
if (!current_IM || !current_IM->filter(unicode, keycode, modifiers, isPress, autoRepeat))
QWSServerPrivate::sendKeyEventUnfiltered(unicode, keycode, modifiers, isPress, autoRepeat);
#else
QWSServerPrivate::sendKeyEventUnfiltered(unicode, keycode, modifiers, isPress, autoRepeat);
#endif
}
void QWSServerPrivate::sendKeyEventUnfiltered(int unicode, int keycode, Qt::KeyboardModifiers modifiers,
bool isPress, bool autoRepeat)
{
QWSKeyEvent event;
QWSWindow *win = keyboardGrabber ? keyboardGrabber :
qwsServerPrivate->focusw;
event.simpleData.window = win ? win->winId() : 0;
event.simpleData.unicode =
#ifndef QT_NO_QWS_KEYBOARD
unicode < 0 ? keyUnicode(keycode) :
#endif
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);
}
/*!
\internal
*/
void QWSServer::beginDisplayReconfigure()
{
qwsServer->enablePainting(false);
#ifndef QT_NO_QWS_CURSOR
if (qt_screencursor)
qt_screencursor->hide();
#endif
QWSDisplay::grab(true);
qt_screen->disconnect();
}
/*!
\internal
*/
void QWSServer::endDisplayReconfigure()
{
qt_screen->connect(QString());
qwsServerPrivate->swidth = qt_screen->deviceWidth();
qwsServerPrivate->sheight = qt_screen->deviceHeight();
QWSDisplay::ungrab();
#ifndef QT_NO_QWS_CURSOR
if (qt_screencursor)
qt_screencursor->show();
#endif
QApplicationPrivate *ap = QApplicationPrivate::instance();
ap->setMaxWindowRect(qt_screen, 0,
QRect(0, 0, qt_screen->width(), qt_screen->height()));
QSize olds = qApp->desktop()->size();
qApp->desktop()->resize(qt_screen->width(), qt_screen->height());
qApp->postEvent(qApp->desktop(), new QResizeEvent(qApp->desktop()->size(), olds));
qwsServer->enablePainting(true);
qwsServer->refresh();
qDebug("Desktop size: %dx%d", qApp->desktop()->width(), qApp->desktop()->height());
}
void QWSServerPrivate::resetEngine()
{
#ifndef QT_NO_QWS_CURSOR
if (!qt_screencursor)
return;
qt_screencursor->hide();
qt_screencursor->show();
#endif
}
#ifndef QT_NO_QWS_CURSOR
/*!
\fn void QWSServer::setCursorVisible(bool visible)
Shows the cursor if \a visible is true: otherwise the cursor is
hidden.
Note that this function can only be used in the server process.
\sa isCursorVisible()
*/
void QWSServer::setCursorVisible(bool vis)
{
if (qwsServerPrivate && qwsServerPrivate->haveviscurs != vis) {
QWSCursor* c = qwsServerPrivate->cursor;
qwsServerPrivate->setCursor(QWSCursor::systemCursor(Qt::BlankCursor));
qwsServerPrivate->haveviscurs = vis;
qwsServerPrivate->setCursor(c);
}
}
/*!
Returns true if the cursor is visible; otherwise returns false.
Note that this function can only be used in the server process.
\sa setCursorVisible()
*/
bool QWSServer::isCursorVisible()
{
return qwsServerPrivate ? qwsServerPrivate->haveviscurs : true;
}
#endif
#ifndef QT_NO_QWS_INPUTMETHODS
/*!
\fn void QWSServer::sendIMEvent(const QInputMethodEvent *event)
Sends the given input method \a event.
The \c QInputMethodEvent class is derived from QWSEvent, i.e., it
is a QWSEvent object of the QWSEvent::IMEvent type.
If there is a window actively composing the preedit string, the
event is sent to that window. Otherwise, the event is sent to the
window currently in focus.
\sa sendIMQuery(), QWSInputMethod::sendEvent()
*/
void QWSServer::sendIMEvent(const QInputMethodEvent *ime)
{
QWSIMEvent event;
QWSWindow *win = keyboardGrabber ? keyboardGrabber :
qwsServerPrivate->focusw;
//if currently composing then event must go to the composing window
if (current_IM_composing_win)
win = current_IM_composing_win;
event.simpleData.window = win ? win->winId() : 0;
event.simpleData.replaceFrom = ime->replacementStart();;
event.simpleData.replaceLength = ime->replacementLength();
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
QDataStream out(&buffer);
out << ime->preeditString();
out << ime->commitString();
const QList<QInputMethodEvent::Attribute> &attributes = ime->attributes();
for (int i = 0; i < attributes.count(); ++i) {
const QInputMethodEvent::Attribute &a = attributes.at(i);
out << a.type << a.start << a.length << a.value;
}
event.setData(buffer.data(), buffer.size());
QWSClient *serverClient = qwsServerPrivate->clientMap.value(-1);
if (serverClient)
serverClient->sendEvent(&event);
if (win && win->client() && win->client() != serverClient)
win->client()->sendEvent(&event);
current_IM_composing_win = ime->preeditString().isEmpty() ? 0 : win;
current_IM_winId = win ? win->winId() : 0;
}
/*!
Sends an input method query for the given \a property.
To receive responses to input method queries, the virtual
QWSInputMethod::queryResponse() function must be reimplemented in
a QWSInputMethod subclass that is activated using the
setCurrentInputMethod() function.
\sa sendIMEvent(), setCurrentInputMethod()
*/
void QWSServer::sendIMQuery(int property)
{
QWSIMQueryEvent event;
QWSWindow *win = keyboardGrabber ? keyboardGrabber :
qwsServerPrivate->focusw;
if (current_IM_composing_win)
win = current_IM_composing_win;
event.simpleData.window = win ? win->winId() : 0;
event.simpleData.property = property;
if (win && win->client())
win->client()->sendEvent(&event);
}
/*!
\fn void QWSServer::setCurrentInputMethod(QWSInputMethod *method)
Sets the current input method to be the given \a method.
Note that this function can only be used in the server process.
\sa sendIMQuery(), sendIMEvent()
*/
void QWSServer::setCurrentInputMethod(QWSInputMethod *im)
{
if (current_IM)
current_IM->reset(); //??? send an update event instead ?
current_IM = im;
}
/*!
\fn static void QWSServer::resetInputMethod()
\internal
*/
#endif //QT_NO_QWS_INPUTMETHODS
#ifndef QT_NO_QWS_PROPERTIES
/*!
\internal
*/
void QWSServer::sendPropertyNotifyEvent(int property, int state)
{
Q_D(QWSServer);
QWSServerPrivate::ClientIterator it = d->clientMap.begin();
while (it != d->clientMap.end()) {
QWSClient *cl = *it;
++it;
cl->sendPropertyNotifyEvent(property, state);
}
}
#endif
void QWSServerPrivate::invokeIdentify(const QWSIdentifyCommand *cmd, QWSClient *client)
{
client->setIdentity(cmd->id);
#ifndef QT_NO_QWS_MULTIPROCESS
if (client->clientId() > 0)
client->d_func()->setLockId(cmd->simpleData.idLock);
#endif
}
void QWSServerPrivate::invokeCreate(QWSCreateCommand *cmd, QWSClient *client)
{
QWSCreationEvent event;
event.simpleData.objectid = get_object_id(cmd->count);
event.simpleData.count = cmd->count;
client->sendEvent(&event);
}
void QWSServerPrivate::invokeRegionName(const QWSRegionNameCommand *cmd, QWSClient *client)
{
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);
}
}
void QWSServerPrivate::invokeRegion(QWSRegionCommand *cmd, QWSClient *client)
{
#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);
}
void QWSServerPrivate::invokeRegionMove(const QWSRegionMoveCommand *cmd, QWSClient *client)
{
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);
}
void QWSServerPrivate::invokeRegionDestroy(const QWSRegionDestroyCommand *cmd, QWSClient *client)
{
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;
}
void QWSServerPrivate::invokeSetFocus(const QWSRequestFocusCommand *cmd, QWSClient *client)
{
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);
}
void QWSServerPrivate::setFocus(QWSWindow* changingw, bool gain)
{
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);
}
}
}
void QWSServerPrivate::invokeSetOpacity(const QWSSetOpacityCommand *cmd, QWSClient *client)
{
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);
}
void QWSServerPrivate::invokeSetAltitude(const QWSChangeAltitudeCommand *cmd,
QWSClient *client)
{
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();
// }
}
#ifndef QT_NO_QWS_PROPERTIES
void QWSServerPrivate::invokeAddProperty(QWSAddPropertyCommand *cmd)
{
propertyManager.addProperty(cmd->simpleData.windowid, cmd->simpleData.property);
}
void QWSServerPrivate::invokeSetProperty(QWSSetPropertyCommand *cmd)
{
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
}
}
void QWSServerPrivate::invokeRemoveProperty(QWSRemovePropertyCommand *cmd)
{
Q_Q(QWSServer);
if (propertyManager.removeProperty(cmd->simpleData.windowid,
cmd->simpleData.property)) {
q->sendPropertyNotifyEvent(cmd->simpleData.property,
QWSPropertyNotifyEvent::PropertyDeleted);
}
}
bool QWSServerPrivate:: get_property(int winId, int property, const char *&data, int &len)
{
return propertyManager.getProperty(winId, property, data, len);
}
void QWSServerPrivate::invokeGetProperty(QWSGetPropertyCommand *cmd, QWSClient *client)
{
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);
}
}
#endif //QT_NO_QWS_PROPERTIES
void QWSServerPrivate::invokeSetSelectionOwner(QWSSetSelectionOwnerCommand *cmd)
{
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;
}
void QWSServerPrivate::invokeConvertSelection(QWSConvertSelectionCommand *cmd)
{
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);
}
}
#ifndef QT_NO_QWS_CURSOR
void QWSServerPrivate::invokeDefineCursor(QWSDefineCursorCommand *cmd, QWSClient *client)
{
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);
}
}
void QWSServerPrivate::invokeSelectCursor(QWSSelectCursorCommand *cmd, QWSClient *client)
{
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);
}
}
void QWSServerPrivate::invokePositionCursor(QWSPositionCursorCommand *cmd, QWSClient *)
{
Q_Q(QWSServer);
QPoint newPos(cmd->simpleData.newX, cmd->simpleData.newY);
if (newPos != QWSServer::mousePosition)
q->sendMouseEvent(newPos, qwsServer->d_func()->mouseState);
}
#endif
void QWSServerPrivate::invokeGrabMouse(QWSGrabMouseCommand *cmd, QWSClient *client)
{
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);
}
}
void QWSServerPrivate::invokeGrabKeyboard(QWSGrabKeyboardCommand *cmd, QWSClient *client)
{
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);
}
}
#if !defined(QT_NO_SOUND)
void QWSServerPrivate::invokePlaySound(QWSPlaySoundCommand *cmd, QWSClient *)
{
#if !defined(QT_EXTERNAL_SOUND_SERVER) && !defined(Q_OS_DARWIN)
soundserver->playFile( 1, cmd->filename );
#else
Q_UNUSED(cmd);
#endif
}
#endif
#ifndef QT_NO_COP
void QWSServerPrivate::invokeRegisterChannel(QWSQCopRegisterChannelCommand *cmd,
QWSClient *client)
{
// QCopChannel will force us to emit the newChannel signal if this channel
// didn't already exist.
QCopChannel::registerChannel(cmd->channel, client);
}
void QWSServerPrivate::invokeQCopSend(QWSQCopSendCommand *cmd, QWSClient *client)
{
QCopChannel::answer(client, cmd->channel, cmd->message, cmd->data);
}
#endif
#ifndef QT_NO_QWS_INPUTMETHODS
void QWSServer::resetInputMethod()
{
if (current_IM && qwsServer) {
current_IM->reset();
}
}
void QWSServerPrivate::invokeIMResponse(const QWSIMResponseCommand *cmd,
QWSClient *)
{
if (current_IM)
current_IM->queryResponse(cmd->simpleData.property, cmd->result);
}
void QWSServerPrivate::invokeIMUpdate(const QWSIMUpdateCommand *cmd,
QWSClient *)
{
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);
}
#endif
void QWSServerPrivate::invokeFont(const QWSFontCommand *cmd, QWSClient *client)
{
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);
}
}
void QWSServerPrivate::invokeRepaintRegion(QWSRepaintRegionCommand * cmd,
QWSClient *)
{
QRegion r;
r.setRects(cmd->rectangles,cmd->simpleData.nrectangles);
repaint_region(cmd->simpleData.windowid, cmd->simpleData.windowFlags, cmd->simpleData.opaque, r);
}
#ifndef QT_NO_QWSEMBEDWIDGET
void QWSServerPrivate::invokeEmbed(QWSEmbedCommand *cmd, QWSClient *client)
{
// 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));
}
#endif // QT_NO_QWSEMBEDWIDGET
void QWSServerPrivate::invokeScreenTransform(const QWSScreenTransformCommand *cmd,
QWSClient *client)
{
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);
}
QWSWindow* QWSServerPrivate::newWindow(int id, QWSClient* client)
{
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;
}
QWSWindow* QWSServerPrivate::findWindow(int windowid, QWSClient* client)
{
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;
}
void QWSServerPrivate::raiseWindow(QWSWindow *changingw, int /*alt*/)
{
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);
}
void QWSServerPrivate::lowerWindow(QWSWindow *changingw, int /*alt*/)
{
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);
}
void QWSServerPrivate::update_regions()
{
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();
}
void QWSServerPrivate::moveWindowRegion(QWSWindow *changingw, int dx, int dy)
{
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;
}
/*!
Changes the requested region of window \a changingw to \a r
If \a changingw is 0, the server's reserved region is changed.
*/
void QWSServerPrivate::setWindowRegion(QWSWindow* changingw, const QRegion &r)
{
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);
}
void QWSServerPrivate::exposeRegion(const QRegion &r, int changing)
{
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);
}
}
/*!
Closes all pointer devices (specified by the QWS_MOUSE_PROTO
environment variable) by deleting the associated mouse drivers.
\sa openMouse(), mouseHandler()
*/
void QWSServer::closeMouse()
{
Q_D(QWSServer);
qDeleteAll(d->mousehandlers);
d->mousehandlers.clear();
}
/*!
Opens the mouse devices specified by the QWS_MOUSE_PROTO
environment variable. Be advised that closeMouse() is called first
to delete all the existing mouse handlers. This behaviour could be
the cause of problems if you were not expecting it.
\sa closeMouse(), mouseHandler()
*/
void QWSServer::openMouse()
{
Q_D(QWSServer);
QString mice = QString::fromLatin1(qgetenv("QWS_MOUSE_PROTO"));
#if defined(QT_QWS_CASSIOPEIA)
if (mice.isEmpty())
mice = QLatin1String("TPanel:/dev/tpanel");
#endif
if (mice.isEmpty())
mice = *defaultMouse();
closeMouse();
bool needviscurs = true;
if (mice != QLatin1String("None")) {
const QStringList mouse = mice.split(QLatin1Char(' '));
for (int i = mouse.size() - 1; i >= 0; --i) {
QWSMouseHandler *handler = d->newMouseHandler(mouse.at(i));
setMouseHandler(handler);
/* XXX handle mouse cursor visibility sensibly
if (!h->inherits("QCalibratedMouseHandler"))
needviscurs = true;
*/
}
}
#ifndef QT_NO_QWS_CURSOR
setCursorVisible(needviscurs);
#else
Q_UNUSED(needviscurs)
#endif
}
/*!
Suspends pointer handling by deactivating all the mouse drivers
registered by the QWS_MOUSE_PROTO environment variable.
\sa resumeMouse(), QWSMouseHandler::suspend()
*/
void QWSServer::suspendMouse()
{
Q_D(QWSServer);
for (int i=0; i < d->mousehandlers.size(); ++i)
d->mousehandlers.at(i)->suspend();
}
/*!
Resumes pointer handling by reactivating all the mouse drivers
registered by the QWS_MOUSE_PROTO environment variable.
\sa suspendMouse(), QWSMouseHandler::resume()
*/
void QWSServer::resumeMouse()
{
Q_D(QWSServer);
for (int i=0; i < d->mousehandlers.size(); ++i)
d->mousehandlers.at(i)->resume();
}
QWSMouseHandler* QWSServerPrivate::newMouseHandler(const QString& spec)
{
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;
}
#ifndef QT_NO_QWS_KEYBOARD
/*!
Closes all the keyboard devices (specified by the QWS_KEYBOARD
environment variable) by deleting the associated keyboard
drivers.
\sa openKeyboard(), keyboardHandler()
*/
void QWSServer::closeKeyboard()
{
Q_D(QWSServer);
qDeleteAll(d->keyboardhandlers);
d->keyboardhandlers.clear();
}
/*!
Returns the primary keyboard driver.
Note that this function can only be used in the server process.
\sa setKeyboardHandler(), openKeyboard(), closeKeyboard()
*/
QWSKeyboardHandler* QWSServer::keyboardHandler()
{
return qwsServerPrivate->keyboardhandlers.first();
}
/*!
\fn void QWSServer::setKeyboardHandler(QWSKeyboardHandler* driver)
Sets the primary keyboard driver to be the given \a driver.
\l{Qt for Embedded Linux} provides several ready-made keyboard drivers, and
custom drivers are typically added using Qt's plugin
mechanism. See the \l{Qt for Embedded Linux Character Input} documentation
for details.
Note that this function can only be used in the server process.
\sa keyboardHandler(), setDefaultKeyboard()
*/
void QWSServer::setKeyboardHandler(QWSKeyboardHandler* kh)
{
if (!kh)
return;
qwsServerPrivate->keyboardhandlers.removeAll(kh);
qwsServerPrivate->keyboardhandlers.prepend(kh);
}
/*!
Opens the keyboard devices specified by the QWS_KEYBOARD
environment variable.
\sa closeKeyboard(), keyboardHandler()
*/
void QWSServer::openKeyboard()
{
QString keyboards = QString::fromLatin1(qgetenv("QWS_KEYBOARD"));
#if defined(QT_QWS_CASSIOPEIA)
if (keyboards.isEmpty())
keyboards = QLatin1String("Buttons");
#endif
if (keyboards.isEmpty())
keyboards = *defaultKeyboard();
closeKeyboard();
if (keyboards == QLatin1String("None"))
return;
QString device;
QString type;
QStringList keyboard = keyboards.split(QLatin1Char(' '));
for (int i = keyboard.size() - 1; i >= 0; --i) {
const QString spec = keyboard.at(i);
int colon=spec.indexOf(QLatin1Char(':'));
if (colon>=0) {
type = spec.left(colon);
device = spec.mid(colon+1);
} else {
type = spec;
device = QString();
}
QWSKeyboardHandler *handler = QKbdDriverFactory::create(type, device);
setKeyboardHandler(handler);
}
}
#endif //QT_NO_QWS_KEYBOARD
QPoint QWSServer::mousePosition;
QBrush *QWSServerPrivate::bgBrush = 0;
void QWSServerPrivate::move_region(const QWSRegionMoveCommand *cmd)
{
QWSClient *serverClient = clientMap.value(-1);
invokeRegionMove(cmd, serverClient);
}
void QWSServerPrivate::set_altitude(const QWSChangeAltitudeCommand *cmd)
{
QWSClient *serverClient = clientMap.value(-1);
invokeSetAltitude(cmd, serverClient);
}
void QWSServerPrivate::set_opacity(const QWSSetOpacityCommand *cmd)
{
QWSClient *serverClient = clientMap.value(-1);
invokeSetOpacity(cmd, serverClient);
}
void QWSServerPrivate::request_focus(const QWSRequestFocusCommand *cmd)
{
invokeSetFocus(cmd, clientMap.value(-1));
}
void QWSServerPrivate::set_identity(const QWSIdentifyCommand *cmd)
{
invokeIdentify(cmd, clientMap.value(-1));
}
void QWSServerPrivate::repaint_region(int wid, int windowFlags, bool opaque,
const QRegion &region)
{
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();
}
QRegion QWSServerPrivate::reserve_region(QWSWindow *win, const QRegion &region)
{
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;
}
void QWSServerPrivate::request_region(int wid, const QString &surfaceKey,
const QByteArray &surfaceData,
const QRegion &region)
{
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;
changingw->createSurface(surfaceKey, surfaceData);
QWSWindowSurface *surface = changingw->windowSurface();
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;
}
}
void QWSServerPrivate::destroy_region(const QWSRegionDestroyCommand *cmd)
{
invokeRegionDestroy(cmd, clientMap.value(-1));
}
void QWSServerPrivate::name_region(const QWSRegionNameCommand *cmd)
{
invokeRegionName(cmd, clientMap.value(-1));
}
#ifndef QT_NO_QWS_INPUTMETHODS
void QWSServerPrivate::im_response(const QWSIMResponseCommand *cmd)
{
invokeIMResponse(cmd, clientMap.value(-1));
}
void QWSServerPrivate::im_update(const QWSIMUpdateCommand *cmd)
{
invokeIMUpdate(cmd, clientMap.value(-1));
}
void QWSServerPrivate::send_im_mouse(const QWSIMMouseCommand *cmd)
{
if (current_IM)
current_IM->mouseHandler(cmd->simpleData.index, cmd->simpleData.state);
}
#endif
void QWSServerPrivate::openDisplay()
{
qt_init_display();
// rgnMan = qt_fbdpy->regionManager();
swidth = qt_screen->deviceWidth();
sheight = qt_screen->deviceHeight();
}
void QWSServerPrivate::closeDisplay()
{
if (qt_screen)
qt_screen->shutdownDevice();
}
/*!
Returns the brush used as background in the absence of obscuring
windows.
\sa setBackground()
*/
const QBrush &QWSServer::backgroundBrush() const
{
return *QWSServerPrivate::bgBrush;
}
/*!
Sets the brush used as background in the absence of obscuring
windows, to be the given \a brush.
Note that this function can only be used in the server process.
\sa backgroundBrush()
*/
void QWSServer::setBackground(const QBrush &brush)
{
if (!QWSServerPrivate::bgBrush)
QWSServerPrivate::bgBrush = new QBrush(brush);
else
*QWSServerPrivate::bgBrush = brush;
if (!qwsServer)
return;
qt_screen->exposeRegion(QRect(0,0,qt_screen->width(), qt_screen->height()), 0);
}
#ifdef QT3_SUPPORT
/*!
\fn void QWSServer::setDesktopBackground(const QImage &image)
Sets the image used as background in the absence of obscuring
windows, to be the given \a image.
Use the setBackground() function instead.
\oldcode
QImage image;
setDesktopBackground(image);
\newcode
QImage image;
setBackground(QBrush(image));
\endcode
*/
void QWSServer::setDesktopBackground(const QImage &img)
{
if (img.isNull())
setBackground(Qt::NoBrush);
else
setBackground(QBrush(QPixmap::fromImage(img)));
}
/*!
\fn void QWSServer::setDesktopBackground(const QColor &color)
\overload
Sets the color used as background in the absence of obscuring
windows, to be the given \a color.
Use the setBackground() function instead.
\oldcode
QColor color;
setDesktopBackground(color);
\newcode
QColor color;
setBackground(QBrush(color));
\endcode
*/
void QWSServer::setDesktopBackground(const QColor &c)
{
setBackground(QBrush(c));
}
#endif //QT3_SUPPORT
/*!
\internal
*/
void QWSServer::startup(int flags)
{
if (qwsServer)
return;
unlink(qws_qtePipeFilename().toLatin1().constData());
(void)new QWSServer(flags);
}
/*!
\internal
*/
void QWSServer::closedown()
{
QScopedPointer<QWSServer> server(qwsServer);
qwsServer = 0;
QT_TRY {
unlink(qws_qtePipeFilename().toLatin1().constData());
} QT_CATCH(const std::bad_alloc &) {
// ### TODO - what to do when we run out of memory
// when calling toLatin1?
}
}
void QWSServerPrivate::emergency_cleanup()
{
#ifndef QT_NO_QWS_KEYBOARD
if (qwsServer)
qwsServer->closeKeyboard();
#endif
}
#ifndef QT_NO_QWS_KEYBOARD
static QList<QWSServer::KeyboardFilter*> *keyFilters = 0;
/*!
Processes the given key event. The key is identified by its \a
unicode value and the given \a keycode, \a modifiers, \a isPress
and \a autoRepeat parameters.
The \a keycode parameter is the Qt keycode value as defined by the
Qt::Key enum. The \a modifiers is an OR combination of
Qt::KeyboardModifier values, indicating whether \gui
Shift/Alt/Ctrl keys are pressed. The \a isPress parameter is true
if the event is a key press event and \a autoRepeat is true if the
event is caused by an auto-repeat mechanism and not an actual key
press.
This function is typically called internally by keyboard drivers.
Note that this function can only be used in the server process.
\sa sendKeyEvent(), {Qt for Embedded Linux Character Input}
*/
void QWSServer::processKeyEvent(int unicode, int keycode, Qt::KeyboardModifiers modifiers,
bool isPress, bool autoRepeat)
{
bool block;
// Don't block the POWER or LIGHT keys
if ( keycode == Qt::Key_F34 || keycode == Qt::Key_F35 )
block = false;
else
block = qwsServerPrivate->screensaverblockevent(KEY, qwsServerPrivate->screensaverinterval, isPress);
#ifdef EVENT_BLOCK_DEBUG
qDebug() << "processKeyEvent" << unicode << keycode << modifiers << isPress << autoRepeat << (block ? "block" : "pass");
#endif
// If we press a key and it's going to be blocked, wake up the screen
if ( block && isPress )
qwsServerPrivate->_q_screenSaverWake();
if ( block )
return;
if (keyFilters) {
for (int i = 0; i < keyFilters->size(); ++i) {
QWSServer::KeyboardFilter *keyFilter = keyFilters->at(i);
if (keyFilter->filter(unicode, keycode, modifiers, isPress, autoRepeat))
return;
}
}
sendKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat);
}
/*!
\fn void QWSServer::addKeyboardFilter(KeyboardFilter *filter)
Activates the given keyboard \a filter all key events generated by
physical keyboard drivers (i.e., events sent using the
processKeyEvent() function).
Note that the filter is not invoked for keys generated by \e
virtual keyboard drivers (i.e., events sent using the
sendKeyEvent() function).
Note that this function can only be used in the server process.
\sa removeKeyboardFilter()
*/
void QWSServer::addKeyboardFilter(KeyboardFilter *f)
{
if (!keyFilters)
keyFilters = new QList<QWSServer::KeyboardFilter*>;
if (f) {
keyFilters->prepend(f);
}
}
/*
//#######
We should probably obsolete the whole keyboard filter thing since
it's not useful for input methods anyway
We could do removeKeyboardFilter(KeyboardFilter *f), but
the "remove and delete the filter" concept does not match "user
remembers the pointer".
*/
/*!
Removes and deletes the most recently added filter.
Note that the programmer is responsible for removing each added
keyboard filter.
Note that this function can only be used in the server process.
\sa addKeyboardFilter()
*/
void QWSServer::removeKeyboardFilter()
{
if (!keyFilters || keyFilters->isEmpty())
return;
delete keyFilters->takeAt(0);
}
#endif // QT_NO_QWS_KEYBOARD
/*!
\fn void QWSServer::setScreenSaverIntervals(int* intervals)
Specifies the time \a intervals (in milliseconds) between the
different levels of screen responsiveness.
\l{Qt for Embedded Linux} supports multilevel screen saving, i.e., it is
possible to specify several different levels of screen
responsiveness by implementing the QWSScreenSaver::save()
function. For example, you can choose to first turn off the light
before you fully activate the screensaver. See the QWSScreenSaver
documentation for details.
Note that an interval of 0 milliseconds will turn off the
screensaver, and that the \a intervals array must be 0-terminated.
This function can only be used in the server process.
\sa setScreenSaverInterval(), setScreenSaverBlockLevel()
*/
void QWSServer::setScreenSaverIntervals(int* ms)
{
if (!qwsServerPrivate)
return;
delete [] qwsServerPrivate->screensaverintervals;
if (ms) {
int* t=ms;
int n=0;
while (*t++) n++;
if (n) {
n++; // the 0
qwsServerPrivate->screensaverintervals = new int[n];
memcpy(qwsServerPrivate->screensaverintervals, ms, n*sizeof(int));
} else {
qwsServerPrivate->screensaverintervals = 0;
}
} else {
qwsServerPrivate->screensaverintervals = 0;
}
qwsServerPrivate->screensaverinterval = 0;
qwsServerPrivate->screensavertimer->stop();
qt_screen->blank(false);
qwsServerPrivate->_q_screenSaverWake();
}
/*!
\fn void QWSServer::setScreenSaverInterval(int milliseconds)
Sets the timeout interval for the screensaver to the specified \a
milliseconds. To turn off the screensaver, set the timout interval
to 0.
Note that this function can only be used in the server process.
\sa setScreenSaverIntervals(), setScreenSaverBlockLevel()
*/
void QWSServer::setScreenSaverInterval(int ms)
{
int v[2];
v[0] = ms;
v[1] = 0;
setScreenSaverIntervals(v);
}
/*!
Block the key or mouse event that wakes the system from level \a eventBlockLevel or higher.
To completely disable event blocking (the default behavior), set \a eventBlockLevel to -1.
The algorithm blocks the "down", "up" as well as any "repeat" events for the same key
but will not block other key events after the initial "down" event. For mouse events, the
algorithm blocks all mouse events until an event with no buttons pressed is received.
There are 2 keys that are never blocked, Qt::Key_F34 (POWER) and Qt::Key_F35 (LIGHT).
Example usage:
\snippet doc/src/snippets/code/src_gui_embedded_qwindowsystem_qws.cpp 0
Note that this function can only be used in the server process.
\sa setScreenSaverIntervals(), setScreenSaverInterval()
*/
void QWSServer::setScreenSaverBlockLevel(int eventBlockLevel)
{
if (!qwsServerPrivate)
return;
qwsServerPrivate->screensavereventblocklevel = eventBlockLevel;
#ifdef EVENT_BLOCK_DEBUG
qDebug() << "QWSServer::setScreenSaverBlockLevel() " << eventBlockLevel;
#endif
}
extern bool qt_disable_lowpriority_timers; //in qeventloop_unix.cpp
void QWSServerPrivate::_q_screenSaverWake()
{
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;
}
void QWSServerPrivate::_q_screenSaverSleep()
{
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;
}
/*!
\fn void QWSServer::setScreenSaver(QWSScreenSaver* screenSaver)
Installs the given \a screenSaver, deleting the current screen
saver.
Note that this function can only be used in the server process.
\sa screenSaverActivate(), setScreenSaverInterval(), setScreenSaverIntervals(), setScreenSaverBlockLevel()
*/
void QWSServer::setScreenSaver(QWSScreenSaver* ss)
{
QWSServerPrivate *qd = qwsServer->d_func();
delete qd->saver;
qd->saver = ss;
}
void QWSServerPrivate::screenSave(int level)
{
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();
}
}
void QWSServerPrivate::_q_screenSaverTimeout()
{
if (screensaverinterval) {
if (screensavertime.elapsed() > *screensaverinterval*2) {
// bogus (eg. unsuspend, system time changed)
_q_screenSaverWake(); // try again
return;
}
screenSave(screensaverinterval - screensaverintervals);
}
}
/*!
Returns true if the screen saver is active; otherwise returns
false.
Note that this function can only be used in the server process.
\sa screenSaverActivate()
*/
bool QWSServer::screenSaverActive()
{
return qwsServerPrivate->screensaverinterval
&& !qwsServerPrivate->screensavertimer->isActive();
}
/*!
\internal
*/
void QWSServer::updateWindowRegions() const
{
qwsServerPrivate->update_regions();
}
/*!
Activates the screen saver if \a activate is true; otherwise it is
deactivated.
Note that this function can only be used in the server process.
\sa screenSaverActive(), setScreenSaver()
*/
void QWSServer::screenSaverActivate(bool activate)
{
if (activate)
qwsServerPrivate->_q_screenSaverSleep();
else
qwsServerPrivate->_q_screenSaverWake();
}
void QWSServerPrivate::disconnectClient(QWSClient *c)
{
QTimer::singleShot(0, c, SLOT(closeHandler()));
}
void QWSServerPrivate::updateClientCursorPos()
{
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);
}
#ifndef QT_NO_QWS_INPUTMETHODS
/*!
\class QWSInputMethod
\preliminary
\ingroup qws
\brief The QWSInputMethod class provides international input methods
in Qt for Embedded Linux.
Note that this class is only available in \l{Qt for Embedded Linux}.
A \l{Qt for Embedded Linux} application requires a server application to be
running, or to be the server application itself. All system
generated events, including keyboard and mouse events, are passed
to the server application which then propagates the event to the
appropriate client.
An input method consists of a filter and optionally a graphical
interface, and is used to filter input events between the server
and the client application.
\tableofcontents
\section1 Creating Custom Input Methods
To implement a custom input method, derive from the QWSInputMethod
class, and use the server's \l
{QWSServer::}{setCurrentInputMethod()} function to install it.
When subclassing QWSInputMethod, you can reimplement the filter()
functions to handle input from both physical and virtual keyboards
as well as mouse devices. Note that the default implementations do
nothing. Use the setInputResolution() function to control the
number of bits shifted when filtering mouse input, i.e., when
going from pointer resolution to screen resolution (the current
resolution can be retrieved using the inputResolutionShift()
function).
Reimplement the reset() function to restore the state of the input
method. Note that the default implementation calls the sendEvent()
function with empty preedit and commit strings if the input method
is in compose mode (i.e., if the input method is actively
composing a preedit string).
To receive replies to an input method query (sent using the
sendQuery() function), you must reimplement the queryResponse()
function, while the mouseHandler() function must be reimplemented
if you want to handle mouse events within the preedit
text. Reimplement the updateHandler() function to handle update
events including resets and focus changes. The UpdateType enum
describes the various types of update events recognized by the
input method.
\section1 Using Input Methods
In addition to the filter(), reset(), queryResponse(),
mouseHandler() and updateHandler() function mentioned in the
previous section, the QWSInputMethod provides several other
functions helping the window system to manage the installed input
methods.
The sendEvent() function sends the given event to the focus
widget, while the sendPreeditString() function sends the given
preedit text (encapsulated by an event). QWSInputMethod also
provides the sendCommitString() convenience function which sends
an event encapsulating the given commit string to the current
focus widget, and the sendMouseEvent() function which sends the
given mouse event.
Finally, the QWSInputMethod class provides the sendQuery()
function for sending input method queries. This function
encapsulates the event with a QWSEvent instance of the \l
{QWSEvent::}{IMQuery} type.
\sa QWSServer, {Qt for Embedded Linux Architecture}
*/
/*!
Constructs a new input method.
Use the QWSServer::setCurrentInputMethod() function to install it.
*/
QWSInputMethod::QWSInputMethod()
{
}
/*!
Destroys this input method, uninstalling it if it is installed.
*/
QWSInputMethod::~QWSInputMethod()
{
if (current_IM == this)
current_IM = 0;
}
/*!
Filters the key input identified by the given \a unicode, \a
keycode, \a modifiers, \a isPress and \a autoRepeat parameters.
Note that the default implementation does nothing; reimplement
this function to handle input from both physical and virtual
devices.
The \a keycode is a Qt::Key value, and the \a modifiers is an OR
combination of Qt::KeyboardModifiers. The \a isPress parameter is
telling whether the input is a key press or key release, and the
\a autoRepeat parameter determines whether the input is
autorepeated ( i.e., in which case the
QWSKeyboardHandler::beginAutoRepeat() function has been called).
To block the event from further processing, return true when
reimplementing this function; the default implementation returns
false.
\sa setInputResolution(), inputResolutionShift()
*/
bool QWSInputMethod::filter(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat)
{
Q_UNUSED(unicode);
Q_UNUSED(keycode);
Q_UNUSED(modifiers);
Q_UNUSED(isPress);
Q_UNUSED(autoRepeat);
return false;
}
/*!
\overload
Filters the mouse input identified by the given \a position, \a
state, and \a wheel parameters.
*/
bool QWSInputMethod::filter(const QPoint &position, int state, int wheel)
{
Q_UNUSED(position);
Q_UNUSED(state);
Q_UNUSED(wheel);
return false;
}
/*!
Resets the state of the input method.
If the input method is in compose mode, i.e., the input method is
actively composing a preedit string, the default implementation
calls sendEvent() with empty preedit and commit strings; otherwise
it does nothing. Reimplement this function to alter this behavior.
\sa sendEvent()
*/
void QWSInputMethod::reset()
{
if (current_IM_composing_win) {
QInputMethodEvent ime;
sendEvent(&ime);
}
}
/*!
\enum QWSInputMethod::UpdateType
This enum describes the various types of update events recognized
by the input method.
\value Update The input widget is updated in some way; use sendQuery() with
Qt::ImMicroFocus as an argument for more information.
\value FocusIn A new input widget receives focus.
\value FocusOut The input widget loses focus.
\value Reset The input method should be reset.
\value Destroyed The input widget is destroyed.
\sa updateHandler()
*/
/*!
Handles update events including resets and focus changes. The
update events are specified by the given \a type which is one of
the UpdateType enum values.
Note that reimplementations of this function must call the base
implementation for all cases that it does not handle itself.
\sa UpdateType
*/
void QWSInputMethod::updateHandler(int type)
{
switch (type) {
case FocusOut:
case Reset:
reset();
break;
default:
break;
}
}
/*!
Receive replies to an input method query.
Note that the default implementation does nothing; reimplement
this function to receive such replies.
Internally, an input method query is passed encapsulated by an \l
{QWSEvent::IMQuery}{IMQuery} event generated by the sendQuery()
function. The queried property and the result is passed in the \a
property and \a result parameters.
\sa sendQuery(), QWSServer::sendIMQuery()
*/
void QWSInputMethod::queryResponse(int property, const QVariant &result)
{
Q_UNUSED(property);
Q_UNUSED(result);
}
/*!
\fn void QWSInputMethod::mouseHandler(int offset, int state)
Handles mouse events within the preedit text.
Note that the default implementation resets the input method on
all mouse presses; reimplement this function to alter this
behavior.
The \a offset parameter specifies the position of the mouse event
within the string, and \a state specifies the type of the mouse
event as described by the QWSServer::IMMouse enum. If \a state is
less than 0, the mouse event is inside the associated widget, but
outside the preedit text. When clicking in a different widget, the
\a state is QWSServer::MouseOutside.
\sa sendPreeditString(), reset()
*/
void QWSInputMethod::mouseHandler(int, int state)
{
if (state == QWSServer::MousePress || state == QWSServer::MouseOutside)
reset();
}
/*!
Sends an event encapsulating the given \a preeditString, to the
focus widget.
The specified \a selectionLength is the number of characters to be
marked as selected (starting at the given \a cursorPosition). If
\a selectionLength is negative, the text \e before \a
cursorPosition is marked.
The preedit string is marked with QInputContext::PreeditFormat,
and the selected part is marked with
QInputContext::SelectionFormat.
Sending an input method event with a non-empty preedit string will
cause the input method to enter compose mode. Sending an input
method event with an empty preedit string will cause the input
method to leave compose mode, i.e., the input method will no longer
be actively composing the preedit string.
Internally, the event is represented by a QWSEvent object of the
\l {QWSEvent::IMEvent}{IMEvent} type.
\sa sendEvent(), sendCommitString()
*/
void QWSInputMethod::sendPreeditString(const QString &preeditString, int cursorPosition, int selectionLength)
{
QList<QInputMethodEvent::Attribute> attributes;
int selPos = cursorPosition;
if (selectionLength == 0) {
selPos = 0;
} else if (selectionLength < 0) {
selPos += selectionLength;
selectionLength = -selectionLength;
}
if (selPos > 0)
attributes += QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, selPos,
QVariant(int(QInputContext::PreeditFormat)));
if (selectionLength)
attributes += QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, selPos, selectionLength,
QVariant(int(QInputContext::SelectionFormat)));
if (selPos + selectionLength < preeditString.length())
attributes += QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat,
selPos + selectionLength,
preeditString.length() - selPos - selectionLength,
QVariant(int(QInputContext::PreeditFormat)));
attributes += QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, cursorPosition, 0, QVariant());
QInputMethodEvent ime(preeditString, attributes);
qwsServer->sendIMEvent(&ime);
}
/*!
\fn void QWSInputMethod::sendCommitString(const QString &commitString, int replaceFromPosition, int replaceLength)
Sends an event encapsulating the given \a commitString, to the
focus widget.
Note that this will cause the input method to leave compose mode,
i.e., the input method will no longer be actively composing the
preedit string.
If the specified \a replaceLength is greater than 0, the commit
string will replace the given number of characters of the
receiving widget's previous text, starting at the given \a
replaceFromPosition relative to the start of the current preedit
string.
Internally, the event is represented by a QWSEvent object of the
\l {QWSEvent::IMEvent}{IMEvent} type.
\sa sendEvent(), sendPreeditString()
*/
void QWSInputMethod::sendCommitString(const QString &commitString, int replaceFrom, int replaceLength)
{
QInputMethodEvent ime;
ime.setCommitString(commitString, replaceFrom, replaceLength);
qwsServer->sendIMEvent(&ime);
}
/*!
\fn QWSInputMethod::sendIMEvent(QWSServer::IMState state, const QString &text, int cursorPosition, int selectionLength)
\obsolete
Sends a QInputMethodEvent object to the focus widget.
If the specified \a state is QWSServer::IMCompose, \a text is a
preedit string, \a cursorPosition is the cursor's position within
the preedit string, and \a selectionLength is the number of
characters (starting at \a cursorPosition) that should be marked
as selected by the input widget receiving the event. If the
specified \a state is QWSServer::IMEnd, \a text is a commit
string.
Use sendEvent(), sendPreeditString() or sendCommitString() instead.
*/
/*!
\fn QWSInputMethod::sendEvent(const QInputMethodEvent *event)
Sends the given \a event to the focus widget.
The \c QInputMethodEvent class is derived from QWSEvent, i.e., the
given \a event is a QWSEvent object of the \l
{QWSEvent::IMEvent}{IMEvent} type.
\sa sendPreeditString(), sendCommitString(), reset()
*/
/*!
\fn void QWSInputMethod::sendQuery(int property)
Sends an input method query (internally encapsulated by a QWSEvent
of the \l {QWSEvent::IMQuery}{IMQuery} type) for the specified \a
property.
To receive responses to input method queries, the virtual
queryResponse() function must be reimplemented.
\sa queryResponse(), QWSServer::sendIMQuery()
*/
/*!
Sets and returns the number of bits shifted to go from pointer
resolution to screen resolution when filtering mouse input.
If \a isHigh is true and the device has a pointer device
resolution twice or more of the screen resolution, the positions
passed to the filter() function will be presented at the higher
resolution; otherwise the resolution will be equal to that of the
screen resolution.
\sa inputResolutionShift(), filter()
*/
uint QWSInputMethod::setInputResolution(bool isHigh)
{
mIResolution = isHigh;
return inputResolutionShift();
}
/*!
Returns the number of bits shifted to go from pointer resolution
to screen resolution when filtering mouse input.
\sa setInputResolution(), filter()
*/
uint QWSInputMethod::inputResolutionShift() const
{
return 0; // default for devices with single resolution.
}
/*!
\fn void QWSInputMethod::sendMouseEvent( const QPoint &position, int state, int wheel )
Sends a mouse event specified by the given \a position, \a state
and \a wheel parameters.
The given \a position will be transformed if the screen
coordinates do not match the pointer device coordinates.
Note that the event will be not be tested by the active input
method, but calling the QWSServer::sendMouseEvent() function will
make the current input method filter the event.
\sa mouseHandler(), sendEvent()
*/
void QWSInputMethod::sendMouseEvent( const QPoint &pos, int state, int wheel )
{
if (qt_last_x) {
*qt_last_x = pos.x();
*qt_last_y = pos.y();
}
QWSServer::mousePosition = pos;
qwsServerPrivate->mouseState = state;
QWSServerPrivate::sendMouseEventUnfiltered(pos, state, wheel);
}
#endif // QT_NO_QWS_INPUTMETHODS
/*!
\fn QWSWindow::QWSWindow(int i, QWSClient * client)
\internal
Constructs a new top-level window, associated with the client \a
client and giving it the id \a i.
*/
/*!
\fn QWSServer::windowEvent(QWSWindow * window, QWSServer::WindowEvent eventType)
This signal is emitted whenever something happens to a top-level
window (e.g., it's created or destroyed), passing a pointer to the
window and the event's type in the \a window and \a eventType
parameters, respectively.
\sa markedText()
*/
/*!
\class QWSServer::KeyboardFilter
\ingroup qws
\brief The KeyboardFilter class is a base class for global
keyboard event filters in Qt for Embedded Linux.
Note that this class is only available in \l{Qt for Embedded Linux}.
In \l{Qt for Embedded Linux}, all system generated events, including
keyboard events, are passed to the server application which then
propagates the event to the appropriate client. The KeyboardFilter
class is used to implement a global, low-level filter on the
server side. The server applies the filter to all keyboard events
before passing them on to the clients:
\image qwsserver_keyboardfilter.png
This feature can, for example, be used to filter things like APM
(advanced power management) suspended from a button without having
to filter for it in all applications.
To add a new keyboard filter you must first create the filter by
deriving from this class, reimplementing the pure virtual filter()
function. Then you can install the filter on the server using
QWSServer's \l {QWSServer::}{addKeyboardFilter()}
function. QWSServer also provides a \l
{QWSServer::}{removeKeyboardFilter()} function.
\sa {Qt for Embedded Linux Architecture}, QWSServer, QWSInputMethod
*/
/*!
\fn QWSServer::KeyboardFilter::~KeyboardFilter()
Destroys the keyboard filter.
*/
/*!
\fn bool QWSServer::KeyboardFilter::filter(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat)
Implement this function to return true if a given key event should
be stopped from being processed any further; otherwise it should
return false.
A key event can be identified by the given \a unicode value and
the \a keycode, \a modifiers, \a isPress and \a autoRepeat
parameters.
The \a keycode parameter is the Qt keycode value as defined by the
Qt::Key enum. The \a modifiers is an OR combination of
Qt::KeyboardModifier values, indicating whether \gui
Shift/Alt/Ctrl keys are pressed. The \a isPress parameter is true
if the event is a key press event and \a autoRepeat is true if the
event is caused by an auto-repeat mechanism and not an actual key
press.
*/
QT_END_NAMESPACE
#include "moc_qwindowsystem_qws.cpp"