/****************************************************************************
**
** Copyright (C) 2009 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$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qglobal.h"
#include "qlibrary.h"
#include "qcursor.h"
#include "qapplication.h"
#include "private/qapplication_p.h"
#include "qwidget.h"
#include "qbitarray.h"
#include "qpainter.h"
#include "qpixmapcache.h"
#include "qdatetime.h"
#include "qtextcodec.h"
#include "qdatastream.h"
#include "qbuffer.h"
#include "qsocketnotifier.h"
#include "qsessionmanager.h"
#include "qclipboard.h"
#include "qbitmap.h"
#include "qwssocket_qws.h"
#include "qtransportauth_qws.h"
#include "private/qtransportauth_qws_p.h"
#include "qwsevent_qws.h"
#include "private/qwscommand_qws_p.h"
#include "qwsproperty_qws.h"
#include "qscreen_qws.h"
#include "qscreenproxy_qws.h"
#include "qcopchannel_qws.h"
#include "private/qlock_p.h"
#include "private/qwslock_p.h"
//#include "qmemorymanager_qws.h"
#include "qwsmanager_qws.h"
//#include "qwsregionmanager_qws.h"
#include "qwindowsystem_qws.h"
#include "private/qwindowsystem_p.h"
#include "qdecorationfactory_qws.h"
#include "qwsdisplay_qws.h"
#include "private/qwsdisplay_qws_p.h"
#include "private/qwsinputcontext_p.h"
#include "qfile.h"
#include "qhash.h"
#include "qdesktopwidget.h"
#include "qcolormap.h"
#include "private/qcursor_p.h"
#include "qsettings.h"
#include "qdebug.h"
#include "qeventdispatcher_qws_p.h"
#if !defined(QT_NO_GLIB)
# include "qeventdispatcher_glib_qws_p.h"
#endif
#include "private/qwidget_p.h"
#include "private/qbackingstore_p.h"
#include "private/qwindowsurface_qws_p.h"
#include "private/qfont_p.h"
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <errno.h>
#include <fcntl.h>
#ifdef Q_OS_VXWORKS
# include <sys/times.h>
#else
# include <sys/time.h>
#endif
#include <sys/stat.h>
#include <sys/types.h>
#include <qvfbhdr.h>
#ifndef QT_NO_QWS_MULTIPROCESS
#ifdef QT_NO_QSHM
#include <sys/ipc.h>
#include <sys/shm.h>
#ifndef Q_OS_DARWIN
# include <sys/sem.h>
#endif
#include <sys/socket.h>
#else
#include "private/qwssharedmemory_p.h"
#endif
#endif
QT_BEGIN_NAMESPACE
#ifndef QT_NO_DIRECTPAINTER
class QDirectPainter;
extern void qt_directpainter_region(QDirectPainter *dp, const QRegion &alloc, int type);
#ifndef QT_NO_QWSEMBEDWIDGET
extern void qt_directpainter_embedevent(QDirectPainter *dp,
const QWSEmbedEvent *e);
#endif
#endif // QT_NO_DIRECTPAINTER
const int qwsSharedRamSize = 1 * 1024; // misc data, written by server, read by clients
extern QApplication::Type qt_appType;
extern QDesktopWidget *qt_desktopWidget;
//these used to be environment variables, they are initialized from
//environment variables in
bool qws_savefonts = false;
bool qws_screen_is_interlaced=false; //### should be detected
bool qws_shared_memory = false;
bool qws_sw_cursor = true;
bool qws_accel = true; // ### never set
QByteArray qws_display_spec(":0");
Q_GUI_EXPORT int qws_display_id = 0;
Q_GUI_EXPORT int qws_client_id = 0;
QWidget *qt_pressGrab = 0;
QWidget *qt_mouseGrb = 0;
int *qt_last_x = 0;
int *qt_last_y = 0;
static int mouse_x_root = -1;
static int mouse_y_root = -1;
static int mouse_state = 0;
static int mouse_double_click_distance = 5;
int qt_servershmid = -1;
bool qws_overrideCursor = false;
#ifndef QT_NO_QWS_MANAGER
extern Q_GUI_EXPORT QWSServer *qwsServer;
static QDecoration *qws_decoration = 0;
#endif
#if defined(QT_DEBUG)
/*
extern "C" void dumpmem(const char* m)
{
static int init=0;
static int prev=0;
FILE* f = fopen("/proc/meminfo","r");
// char line[100];
int total=0,used=0,free=0,shared=0,buffers=0,cached=0;
fscanf(f,"%*[^M]Mem: %d %d %d %d %d %d",&total,&used,&free,&shared,&buffers,&cached);
used -= buffers + cached;
if (!init) {
init=used;
} else {
printf("%40s: %+8d = %8d\n",m,used-init-prev,used-init);
prev = used-init;
}
fclose(f);
}
*/
#endif
// Get the name of the directory where Qt for Embedded Linux temporary data should
// live.
QString qws_dataDir()
{
static QString result;
if (!result.isEmpty())
return result;
result = QT_VFB_DATADIR(qws_display_id);
QByteArray dataDir = result.toLocal8Bit();
if (QT_MKDIR(dataDir, 0700)) {
if (errno != EEXIST) {
qFatal("Cannot create Qt for Embedded Linux data directory: %s", dataDir.constData());
}
}
QT_STATBUF buf;
if (QT_LSTAT(dataDir, &buf))
qFatal("stat failed for Qt for Embedded Linux data directory: %s", dataDir.constData());
if (!S_ISDIR(buf.st_mode))
qFatal("%s is not a directory", dataDir.constData());
#if !defined(Q_OS_INTEGRITY) && !defined(Q_OS_VXWORKS)
if (buf.st_uid != getuid())
qFatal("Qt for Embedded Linux data directory is not owned by user %d", getuid());
if ((buf.st_mode & 0677) != 0600)
qFatal("Qt for Embedded Linux data directory has incorrect permissions: %s", dataDir.constData());
#endif
result.append("/");
return result;
}
// Get the filename of the pipe Qt for Embedded Linux uses for server/client comms
Q_GUI_EXPORT QString qws_qtePipeFilename()
{
qws_dataDir();
return QTE_PIPE(qws_display_id);
}
static void setMaxWindowRect(const QRect &rect)
{
const QList<QScreen*> subScreens = qt_screen->subScreens();
QScreen *screen = qt_screen;
int screenNo = 0;
for (int i = 0; i < subScreens.size(); ++i) {
if (subScreens.at(i)->region().contains(rect)) {
screen = subScreens.at(i);
screenNo = i;
break;
}
}
QApplicationPrivate *ap = QApplicationPrivate::instance();
ap->setMaxWindowRect(screen, screenNo, rect);
}
void QApplicationPrivate::setMaxWindowRect(const QScreen *screen, int screenNo,
const QRect &rect)
{
if (maxWindowRects.value(screen) == rect)
return;
maxWindowRects[screen] = rect;
// Re-resize any maximized windows
QWidgetList l = QApplication::topLevelWidgets();
for (int i = 0; i < l.size(); ++i) {
QWidget *w = l.at(i);
QScreen *s = w->d_func()->getScreen();
if (w->isMaximized() && s == screen)
w->d_func()->setMaxWindowState_helper();
}
if ( qt_desktopWidget ) // XXX workaround crash
emit QApplication::desktop()->workAreaResized(screenNo);
}
#ifndef QT_NO_QWS_DYNAMICSCREENTRANSFORMATION
typedef void (*TransformFunc)(QScreen *, int);
#ifndef QT_NO_QWS_TRANSFORMED
extern "C" void qws_setScreenTransformation(QScreen *, int);
#endif
static TransformFunc getTransformationFunction()
{
static TransformFunc func = 0;
if (!func) {
#ifdef QT_NO_QWS_TRANSFORMED
# ifndef QT_NO_LIBRARY
// symbol is not built into the library, search for the plugin
const QStringList paths = QApplication::libraryPaths();
foreach (const QString &path, paths) {
const QString file = path + QLatin1String("/gfxdrivers/libqgfxtransformed");
func = (TransformFunc)QLibrary::resolve(file,
"qws_setScreenTransformation");
if (func)
break;
}
# endif
#else
func = qws_setScreenTransformation;
#endif
if (!func)
func = (TransformFunc)-1;
}
if (func == (TransformFunc)-1)
return 0;
return func;
}
static void setScreenTransformation(int screenNo, int transformation)
{
QScreen *screen = QScreen::instance();
const QList<QScreen*> subScreens = screen->subScreens();
if (screenNo == -1)
screenNo = 0;
if (screenNo == -1 && !subScreens.isEmpty())
screenNo = 0;
if (subScreens.isEmpty() && screenNo == 0) {
// nothing
} else if (screenNo < 0 || screenNo >= subScreens.size()) {
qWarning("setScreenTransformation: invalid screen %i", screenNo);
return;
}
if (screenNo < subScreens.size())
screen = subScreens.at(screenNo);
QApplicationPrivate *ap = QApplicationPrivate::instance();
ap->setScreenTransformation(screen, screenNo, transformation);
}
void QApplicationPrivate::setScreenTransformation(QScreen *screen,
int screenNo,
int transformation)
{
QScreen *transformed = screen;
while (transformed->classId() == QScreen::ProxyClass)
transformed = static_cast<QProxyScreen*>(transformed)->screen();
if (transformed->classId() != QScreen::TransformedClass)
return;
TransformFunc setScreenTransformation = getTransformationFunction();
if (!setScreenTransformation)
return;
setScreenTransformation(transformed, transformation);
// need to re-configure() proxies bottom-up
if (screen->classId() == QScreen::ProxyClass) {
QList<QProxyScreen*> proxies;
QScreen *s = screen;
do {
QProxyScreen *proxy = static_cast<QProxyScreen*>(s);
proxies.append(proxy);
s = proxy->screen();
} while (s->classId() == QScreen::ProxyClass);
do {
QProxyScreen *proxy = proxies.takeLast();
proxy->setScreen(proxy->screen()); // triggers configure()
} while (!proxies.isEmpty());
}
if (qt_desktopWidget) { // XXX workaround crash for early screen transform events
QDesktopWidget *desktop = QApplication::desktop();
emit desktop->resized(screenNo);
if (maxWindowRect(screen).isEmpty()) // not explicitly set
emit desktop->workAreaResized(screenNo);
}
QWSServer *server = QWSServer::instance();
if (server) {
server->updateWindowRegions();
QRegion r = screen->region();
server->refresh(r);
}
// make sure maximized and fullscreen windows are updated
QWidgetList list = QApplication::topLevelWidgets();
for (int i = list.size() - 1; i >= 0; --i) {
QWidget *w = list.at(i);
if (w->isFullScreen())
w->d_func()->setFullScreenSize_helper();
else if (w->isMaximized())
w->d_func()->setMaxWindowState_helper();
}
}
#endif // QT_NO_QWS_DYNAMICSCREENTRANSFORMATION
/*****************************************************************************
Internal variables and functions
*****************************************************************************/
static QString appName; // application name
static const char *appFont = 0; // application font
static const char *appBGCol = 0; // application bg color
static const char *appFGCol = 0; // application fg color
static const char *appBTNCol = 0; // application btn color
static const char *mwGeometry = 0; // main widget geometry
static const char *mwTitle = 0; // main widget title
//static bool mwIconic = false; // main widget iconified
static bool app_do_modal = false; // modal mode
Q_GUI_EXPORT QWSDisplay *qt_fbdpy = 0; // QWS `display'
QLock *QWSDisplay::lock = 0;
static int mouseButtonPressed = 0; // last mouse button pressed
static int mouseButtonPressTime = 0; // when was a button pressed
static short mouseXPos, mouseYPos; // mouse position in act window
extern QWidgetList *qt_modal_stack; // stack of modal widgets
static QWidget *popupButtonFocus = 0;
static QWidget *popupOfPopupButtonFocus = 0;
static bool popupCloseDownMode = false;
static bool popupGrabOk;
static QPointer<QWidget> *mouseInWidget = 0;
QPointer<QWidget> qt_last_mouse_receiver = 0;
static bool sm_blockUserInput = false; // session management
QWidget *qt_button_down = 0; // widget got last button-down
WId qt_last_cursor = 0xffffffff; // Was -1, but WIds are unsigned
class QWSMouseEvent;
class QWSKeyEvent;
class QETWidget : public QWidget // event translator widget
{
public:
bool translateMouseEvent(const QWSMouseEvent *, int oldstate);
bool translateKeyEvent(const QWSKeyEvent *, bool grab);
bool translateRegionEvent(const QWSRegionEvent *);
#ifndef QT_NO_QWSEMBEDWIDGET
void translateEmbedEvent(const QWSEmbedEvent *event);
#endif
bool translateWheelEvent(const QWSMouseEvent *me);
void repaintDecoration(QRegion r, bool post);
void updateRegion();
bool raiseOnClick()
{
// With limited windowmanagement/taskbar/etc., raising big windows
// (eg. spreadsheet) over the top of everything else (eg. calculator)
// is just annoying.
return !isMaximized() && !isFullScreen();
}
};
void QApplicationPrivate::createEventDispatcher()
{
Q_Q(QApplication);
#if !defined(QT_NO_GLIB)
if (qgetenv("QT_NO_GLIB").isEmpty() && QEventDispatcherGlib::versionSupported())
eventDispatcher = (q->type() != QApplication::Tty
? new QWSEventDispatcherGlib(q)
: new QEventDispatcherGlib(q));
else
#endif
eventDispatcher = (q->type() != QApplication::Tty
? new QEventDispatcherQWS(q)
: new QEventDispatcherUNIX(q));
}
// Single-process stuff. This should maybe move into qwindowsystem_qws.cpp
static bool qws_single_process;
static QList<QWSEvent*> incoming;
static QList<QWSCommand*> outgoing;
void qt_client_enqueue(const QWSEvent *event)
{
QWSEvent *copy = QWSEvent::factory(event->type);
copy->copyFrom(event);
incoming.append(copy);
}
QList<QWSCommand*> *qt_get_server_queue()
{
return &outgoing;
}
void qt_server_enqueue(const QWSCommand *command)
{
QWSCommand *copy = QWSCommand::factory(command->type);
QT_TRY {
copy->copyFrom(command);
outgoing.append(copy);
} QT_CATCH(...) {
delete copy;
QT_RETHROW;
}
}
QWSDisplay::Data::Data(QObject* parent, bool singleProcess)
{
#ifdef QT_NO_QWS_MULTIPROCESS
Q_UNUSED(parent);
Q_UNUSED(singleProcess);
#else
if (singleProcess)
csocket = 0;
else {
csocket = new QWSSocket(parent);
QObject::connect(csocket, SIGNAL(disconnected()),
qApp, SLOT(quit()));
}
clientLock = 0;
#endif
init();
}
QWSDisplay::Data::~Data()
{
// delete rgnMan; rgnMan = 0;
// delete memorymanager; memorymanager = 0;
qt_screen->disconnect();
delete qt_screen; qt_screen = 0;
#ifndef QT_NO_QWS_CURSOR
delete qt_screencursor; qt_screencursor = 0;
#endif
#ifndef QT_NO_QWS_MULTIPROCESS
shm.detach();
if (csocket) {
QWSCommand shutdownCmd(QWSCommand::Shutdown, 0, 0);
shutdownCmd.write(csocket);
csocket->flush(); // may be pending QCop message, eg.
delete csocket;
}
delete clientLock;
clientLock = 0;
#endif
delete connected_event;
delete mouse_event;
delete current_event;
qDeleteAll(queue);
#ifndef QT_NO_COP
delete qcop_response;
#endif
}
#ifndef QT_NO_QWS_MULTIPROCESS
bool QWSDisplay::Data::lockClient(QWSLock::LockType type, int timeout)
{
return !clientLock || clientLock->lock(type, timeout);
}
void QWSDisplay::Data::unlockClient(QWSLock::LockType type)
{
if (clientLock) clientLock->unlock(type);
}
bool QWSDisplay::Data::waitClient(QWSLock::LockType type, int timeout)
{
return !clientLock || clientLock->wait(type, timeout);
}
QWSLock* QWSDisplay::Data::getClientLock()
{
return clientLock;
}
#endif // QT_NO_QWS_MULTIPROCESS
void QWSDisplay::Data::flush()
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket) {
csocket->waitForReadyRead(0);
csocket->flush();
}
#endif
}
#if 0
void QWSDisplay::Data::debugQueue() {
for (int i = 0; i < queue.size(); ++i) {
QWSEvent *e = queue.at(i);
qDebug( " ev %d type %d sl %d rl %d", i, e->type, e->simpleLen, e->rawLen);
}
}
#endif
bool QWSDisplay::Data::queueNotEmpty()
{
return mouse_event/*||region_event*/||queue.count() > 0;
}
QWSEvent* QWSDisplay::Data::dequeue()
{
QWSEvent *r=0;
if (queue.count()) {
r = queue.first();
queue.removeFirst();
if (r->type == QWSEvent::Region)
region_events_count--;
} else if (mouse_event) {
r = mouse_event;
mouse_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
mouse_event_count = 0;
#endif
}
return r;
}
QWSEvent* QWSDisplay::Data::peek()
{
return queue.first();
}
bool QWSDisplay::Data::directServerConnection()
{
#ifndef QT_NO_QWS_MULTIPROCESS
return csocket == 0;
#else
return true;
#endif
}
void QWSDisplay::Data::create(int n)
{
QWSCreateCommand cmd(n);
sendCommand(cmd);
}
void QWSDisplay::Data::flushCommands()
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket)
csocket->flush();
#endif
}
void QWSDisplay::Data::sendCommand(QWSCommand & cmd)
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket)
cmd.write(csocket);
else
#endif
qt_server_enqueue(&cmd);
}
void QWSDisplay::Data::sendSynchronousCommand(QWSCommand & cmd)
{
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket) {
lockClient(QWSLock::Communication);
cmd.write(csocket);
bool ok = true;
while (csocket->bytesToWrite() > 0) {
if (!csocket->waitForBytesWritten(-1)) {
qCritical("QWSDisplay::Data::sendSynchronousCommand: %s",
qPrintable(csocket->errorString()));
ok = false;
break;
}
}
if (ok)
waitClient(QWSLock::Communication);
} else
#endif
qt_server_enqueue(&cmd);
}
int QWSDisplay::Data::takeId()
{
int unusedIdCount = unused_identifiers.count();
if (unusedIdCount <= 10)
create(15);
if (unusedIdCount == 0) {
create(1); // Make sure we have an incoming id to wait for, just in case we're recursive
waitForCreation();
}
return unused_identifiers.takeFirst();
}
void QWSDisplay::Data::setMouseFilter(void (*filter)(QWSMouseEvent*))
{
mouseFilter = filter;
}
#ifndef QT_NO_QWS_MULTIPROCESS
QWSLock* QWSDisplay::Data::clientLock = 0;
void Q_GUI_EXPORT qt_app_reinit( const QString& newAppName )
{
qt_fbdpy->d->reinit( newAppName );
}
#endif // QT_NO_QWS_MULTIPROCESS
class QDesktopWidget;
#ifndef QT_NO_QWS_MULTIPROCESS
void QWSDisplay::Data::reinit( const QString& newAppName )
{
Q_ASSERT(csocket);
delete connected_event;
connected_event = 0;
region_events_count = 0;
// region_ack = 0;
delete mouse_event;
mouse_event = 0;
// region_event = 0;
region_offset_window = 0;
#ifndef QT_NO_COP
delete qcop_response;
qcop_response = 0;
#endif
delete current_event;
current_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
mouse_event_count = 0;
#endif
mouseFilter = 0;
qt_desktopWidget = 0;
delete QWSDisplay::Data::clientLock;
QWSDisplay::Data::clientLock = 0;
QString pipe = qws_qtePipeFilename();
// QWS client
// Cleanup all cached ids
unused_identifiers.clear();
delete csocket;
appName = newAppName;
qApp->setObjectName( appName );
csocket = new QWSSocket();
QObject::connect(csocket, SIGNAL(disconnected()),
qApp, SLOT(quit()));
csocket->connectToLocalFile(pipe);
QWSDisplay::Data::clientLock = new QWSLock();
QWSIdentifyCommand cmd;
cmd.setId(appName, QWSDisplay::Data::clientLock->id());
#ifndef QT_NO_SXE
QTransportAuth *a = QTransportAuth::getInstance();
QTransportAuth::Data *d = a->connectTransport(
QTransportAuth::UnixStreamSock |
QTransportAuth::Trusted,
csocket->socketDescriptor());
QAuthDevice *ad = a->authBuf( d, csocket );
ad->setClient( csocket );
cmd.write(ad);
#else
cmd.write(csocket);
#endif
// wait for connect confirmation
waitForConnection();
qws_client_id = connected_event->simpleData.clientId;
if (!QWSDisplay::initLock(pipe, false))
qFatal("Cannot get display lock");
if (shm.attach(connected_event->simpleData.servershmid)) {
sharedRam = static_cast<uchar *>(shm.address());
QScreen *s = qt_get_screen(qws_display_id, qws_display_spec.constData());
if (s)
sharedRamSize += s->memoryNeeded(QLatin1String(qws_display_spec.constData()));
} else {
perror("QWSDisplay::Data::init");
qFatal("Client can't attach to main ram memory.");
}
qApp->desktop();
// We wait for creation mainly so that we can process important
// initialization events such as MaxWindowRect that are sent
// before object id creation. Waiting here avoids later window
// resizing since we have the MWR before windows are displayed.
waitForCreation();
sharedRamSize -= sizeof(int);
qt_last_x = reinterpret_cast<int *>(sharedRam + sharedRamSize);
sharedRamSize -= sizeof(int);
qt_last_y = reinterpret_cast<int *>(sharedRam + sharedRamSize);
#ifndef QT_NO_COP
QCopChannel::reregisterAll();
#endif
csocket->flush();
}
#endif
void QWSDisplay::Data::init()
{
connected_event = 0;
region_events_count = 0;
// region_ack = 0;
mouse_event = 0;
mouse_state = -1;
mouse_winid = 0;
// region_event = 0;
region_offset_window = 0;
#ifndef QT_NO_COP
qcop_response = 0;
#endif
current_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
mouse_event_count = 0;
#endif
mouseFilter = 0;
QString pipe = qws_qtePipeFilename();
sharedRamSize = qwsSharedRamSize;
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket) {
// QWS client
connectToPipe();
QWSDisplay::Data::clientLock = new QWSLock();
QWSIdentifyCommand cmd;
cmd.setId(appName, QWSDisplay::Data::clientLock->id());
#ifndef QT_NO_SXE
QTransportAuth *a = QTransportAuth::getInstance();
QTransportAuth::Data *d = a->connectTransport(
QTransportAuth::UnixStreamSock |
QTransportAuth::Trusted,
csocket->socketDescriptor());
QAuthDevice *ad = a->authBuf( d, csocket );
ad->setClient( csocket );
cmd.write(ad);
#else
cmd.write(csocket);
#endif
// create(30); // not necessary, server will send ids anyway
waitForConnection();
qws_client_id = connected_event->simpleData.clientId;
// now we want to get the exact display spec to use if we haven't
// specified anything.
if (qws_display_spec.at(0) == ':')
qws_display_spec = connected_event->display;
if (!QWSDisplay::initLock(pipe, false))
qFatal("Cannot get display lock");
if (shm.attach(connected_event->simpleData.servershmid)) {
sharedRam = static_cast<uchar *>(shm.address());
QScreen *s = qt_get_screen(qws_display_id, qws_display_spec.constData());
if (s)
sharedRamSize += s->memoryNeeded(QLatin1String(qws_display_spec.constData()));
} else {
perror("QWSDisplay::Data::init");
qFatal("Client can't attach to main ram memory.");
}
// We wait for creation mainly so that we can process important
// initialization events such as MaxWindowRect that are sent
// before object id creation. Waiting here avoids later window
// resizing since we have the MWR before windows are displayed.
waitForCreation();
} else
#endif
{
create(30);
// QWS server
if (!QWSDisplay::initLock(pipe, true))
qFatal("Cannot get display lock");
QScreen *s = qt_get_screen(qws_display_id, qws_display_spec.constData());
if (s)
sharedRamSize += s->memoryNeeded(QLatin1String(qws_display_spec.constData()));
#ifndef QT_NO_QWS_MULTIPROCESS
if (!shm.create(sharedRamSize)) {
perror("Cannot create main ram shared memory\n");
qFatal("Unable to allocate %d bytes of shared memory", sharedRamSize);
}
qt_servershmid = shm.id();
sharedRam = static_cast<uchar *>(shm.address());
#else
sharedRam=static_cast<uchar *>(malloc(sharedRamSize));
#endif
// Need to zero index count at end of block, might as well zero
// the rest too
memset(sharedRam,0,sharedRamSize);
QWSIdentifyCommand cmd;
cmd.setId(appName, -1);
qt_server_enqueue(&cmd);
}
// Allow some memory for the graphics driver too
//### Note that sharedRamSize() has side effects; it must be called
//### once, and only once, and before initDevice()
sharedRamSize -= qt_screen->sharedRamSize(sharedRam+sharedRamSize);
#ifndef QT_NO_QWS_MULTIPROCESS
if(!csocket)
#endif
{
//QWS server process
if (!qt_screen->initDevice())
qFatal("Unable to initialize screen driver!");
}
sharedRamSize -= sizeof(int);
qt_last_x = reinterpret_cast<int *>(sharedRam + sharedRamSize);
sharedRamSize -= sizeof(int);
qt_last_y = reinterpret_cast<int *>(sharedRam + sharedRamSize);
/* Initialise framebuffer memory manager */
/* Add 4k for luck and to avoid clobbering hardware cursor */
// int screensize=qt_screen->screenSize();
// memorymanager=new QMemoryManager(qt_screen->base()+screensize+4096,
// qt_screen->totalSize()-(screensize+4096),0);
// #ifndef QT_NO_QWS_MULTIPROCESS
// rgnMan = new QWSRegionManager(pipe, csocket);
// #else
// rgnMan = new QWSRegionManager(pipe, 0); //####### not necessary
// #endif
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket)
csocket->flush();
#endif
}
QWSEvent* QWSDisplay::Data::readMore()
{
#ifdef QT_NO_QWS_MULTIPROCESS
return incoming.isEmpty() ? 0 : incoming.takeFirst();
#else
if (!csocket)
return incoming.isEmpty() ? 0 : incoming.takeFirst();
// read next event
if (!current_event) {
int event_type = qws_read_uint(csocket);
if (event_type >= 0) {
current_event = QWSEvent::factory(event_type);
}
}
if (current_event) {
if (current_event->read(csocket)) {
// Finished reading a whole event.
QWSEvent* result = current_event;
current_event = 0;
return result;
}
}
// Not finished reading a whole event.
return 0;
#endif
}
void QWSDisplay::Data::fillQueue()
{
QWSServer::processEventQueue();
QWSEvent *e = readMore();
#ifndef QT_NO_QWS_MULTIPROCESS
int bytesAvailable = csocket ? csocket->bytesAvailable() : 0;
int bytesRead = 0;
#endif
while (e) {
#ifndef QT_NO_QWS_MULTIPROCESS
bytesRead += QWS_PROTOCOL_ITEM_SIZE((*e));
#endif
if (e->type == QWSEvent::Connected) {
connected_event = static_cast<QWSConnectedEvent *>(e);
return;
} else if (e->type == QWSEvent::Creation) {
QWSCreationEvent *ce = static_cast<QWSCreationEvent*>(e);
int id = ce->simpleData.objectid;
int count = ce->simpleData.count;
for (int i = 0; i < count; ++i)
unused_identifiers.append(id++);
delete e;
} else if (e->type == QWSEvent::Mouse) {
if (!qt_screen) {
delete e;
} else {
QWSMouseEvent *me = static_cast<QWSMouseEvent*>(e);
if (mouseFilter)
mouseFilter(me);
#ifdef QAPPLICATION_EXTRA_DEBUG
static const char *defaultAction= "INITIAL";
const char * action = defaultAction;
#endif
delete mouse_event;
if (mouse_winid != me->window ()
|| mouse_state != me->simpleData.state) {
queue.append(me);
mouse_winid = me->window();
mouse_state = me->simpleData.state;
mouse_event = 0;
#ifdef QAPPLICATION_EXTRA_DEBUG
mouse_event_count = 0;
action = "ENQUEUE";
#endif
} else {
#ifdef QAPPLICATION_EXTRA_DEBUG
if (mouse_event)
action = "COMPRESS";
mouse_event_count++;
#endif
mouse_event = me;
}
#ifdef QAPPLICATION_EXTRA_DEBUG
if (me->simpleData.state !=0 || action != defaultAction || mouse_event_count != 0)
qDebug("fillQueue %s (%d,%d), state %x win %d count %d", action,
me->simpleData.x_root, me->simpleData.y_root, me->simpleData.state,
me->window(), mouse_event_count);
#endif
}
#ifndef QT_NO_QWS_MULTIPROCESS
} else if (e->type == QWSEvent::Region && clientLock) {
// not really an unlock, decrements the semaphore
region_events_count++;
clientLock->unlock(QWSLock::RegionEvent);
queue.append(e);
#endif
#ifndef QT_NO_QWS_PROPERTIES
} else if (e->type == QWSEvent::PropertyReply) {
QWSPropertyReplyEvent *pe = static_cast<QWSPropertyReplyEvent*>(e);
int len = pe->simpleData.len;
char *data;
if (len <= 0) {
data = 0;
} else {
data = new char[len];
memcpy(data, pe->data, len) ;
}
QPaintDevice::qwsDisplay()->getPropertyLen = len;
QPaintDevice::qwsDisplay()->getPropertyData = data;
delete e;
#endif // QT_NO_QWS_PROPERTIES
} else if (e->type==QWSEvent::MaxWindowRect && qt_screen) {
// Process this ASAP, in case new widgets are created (startup)
setMaxWindowRect((static_cast<QWSMaxWindowRectEvent*>(e))->simpleData.rect);
delete e;
#ifndef QT_NO_QWS_DYNAMICSCREENTRANSFORMATION
} else if (e->type == QWSEvent::ScreenTransformation) {
QWSScreenTransformationEvent *pe = static_cast<QWSScreenTransformationEvent*>(e);
setScreenTransformation(pe->simpleData.screen,
pe->simpleData.transformation);
delete e;
#endif
#ifndef QT_NO_COP
} else if (e->type == QWSEvent::QCopMessage) {
QWSQCopMessageEvent *pe = static_cast<QWSQCopMessageEvent*>(e);
if (pe->simpleData.is_response) {
qcop_response = pe;
} else {
queue.append(e);
}
#endif
} else {
queue.append(e);
}
//debugQueue();
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket && bytesRead >= bytesAvailable)
break;
#endif
e = readMore();
}
}
#ifndef QT_NO_QWS_MULTIPROCESS
static int qws_connection_timeout = 5;
void QWSDisplay::Data::connectToPipe()
{
Q_ASSERT(csocket);
int timeout = qgetenv("QWS_CONNECTION_TIMEOUT").toInt();
if (timeout)
qws_connection_timeout = timeout;
const QString pipe = qws_qtePipeFilename();
int i = 0;
while (!csocket->connectToLocalFile(pipe)) {
if (++i > qws_connection_timeout) {
qWarning("No Qt for Embedded Linux server appears to be running.");
qWarning("If you want to run this program as a server,");
qWarning("add the \"-qws\" command-line option.");
exit(1);
}
sleep(1);
}
}
void QWSDisplay::Data::waitForConnection()
{
connected_event = 0;
for (int i = 0; i < qws_connection_timeout; i++) {
fillQueue();
if (connected_event)
return;
csocket->flush();
csocket->waitForReadyRead(1000);
}
csocket->flush();
if (!connected_event)
qFatal("Did not receive a connection event from the qws server");
}
void QWSDisplay::Data::waitForRegionAck(int winId)
{
QWSEvent *ack = 0;
if (csocket) { // GuiClient
int i = 0;
while (!ack) {
fillQueue();
while (i < queue.size()) {
QWSEvent *e = queue.at(i);
if (e->type == QWSEvent::Region && e->window() == winId) {
ack = e;
queue.removeAt(i);
break;
}
++i;
}
if (!ack) {
csocket->flush();
csocket->waitForReadyRead(1000);
}
}
} else { // GuiServer
fillQueue();
for (int i = 0; i < queue.size(); /* nothing */) {
QWSEvent *e = queue.at(i);
if (e->type == QWSEvent::Region && e->window() == winId) {
ack = e;
queue.removeAt(i);
break;
}
++i;
}
if (!ack) // already processed
return;
}
Q_ASSERT(ack);
qApp->qwsProcessEvent(ack);
delete ack;
region_events_count--;
}
void QWSDisplay::Data::waitForRegionEvents(int winId, bool ungrabDisplay)
{
if (!clientLock)
return;
int removedEventsCount = 0;
// fill queue with unreceived region events
if (!clientLock->hasLock(QWSLock::RegionEvent)) {
bool ungrabbed = false;
if (ungrabDisplay && QWSDisplay::grabbed()) {
QWSDisplay::ungrab();
ungrabbed = true;
}
for (;;) {
fillQueue();
if (clientLock->hasLock(QWSLock::RegionEvent))
break;
csocket->flush();
csocket->waitForReadyRead(1000);
}
if (ungrabbed)
QWSDisplay::grab(true);
}
// check the queue for pending region events
QWSEvent *regionEvent = 0;
for (int i = 0; i < queue.size(); /* nothing */) {
QWSEvent *e = queue.at(i);
if (e->type == QWSEvent::Region && e->window() == winId) {
QWSRegionEvent *re = static_cast<QWSRegionEvent*>(e);
if (re->simpleData.type == QWSRegionEvent::Allocation) {
delete regionEvent;
regionEvent = re;
}
queue.removeAt(i);
removedEventsCount++;
} else {
++i;
}
}
if (regionEvent) {
qApp->qwsProcessEvent(regionEvent);
delete regionEvent;
}
region_events_count -= removedEventsCount;
}
bool QWSDisplay::Data::hasPendingRegionEvents() const
{
if (clientLock && !clientLock->hasLock(QWSLock::RegionEvent))
return true;
return region_events_count > 0;
}
#endif // QT_NO_QWS_MULTIPROCESS
void QWSDisplay::Data::waitForCreation()
{
fillQueue();
#ifndef QT_NO_QWS_MULTIPROCESS
while (unused_identifiers.count() == 0) {
if (csocket) {
csocket->flush();
csocket->waitForReadyRead(1000);
}
fillQueue();
}
#endif
}
#ifndef QT_NO_QWS_MULTIPROCESS
void QWSDisplay::Data::waitForPropertyReply()
{
if (!csocket)
return;
fillQueue();
while (qt_fbdpy->getPropertyLen == -2) {
csocket->flush();
csocket->waitForReadyRead(1000);
fillQueue();
}
}
#endif
#ifndef QT_NO_COP
void QWSDisplay::Data::waitForQCopResponse()
{
for (;;) {
fillQueue();
if (qcop_response)
break;
#ifndef QT_NO_QWS_MULTIPROCESS
if (csocket) {
csocket->flush();
csocket->waitForReadyRead(1000);
}
#endif
}
queue.prepend(qcop_response);
qcop_response = 0;
}
#endif
/*!
\class QWSDisplay
\brief The QWSDisplay class provides a display for QWS; it is an internal class.
\internal
\ingroup qws
*/
QWSDisplay::QWSDisplay()
{
d = new Data(0, qws_single_process);
}
QWSDisplay::~QWSDisplay()
{
delete d;
delete lock;
lock = 0;
}
bool QWSDisplay::grabbed()
{
return lock->locked();
}
void QWSDisplay::grab()
{
lock->lock(QLock::Read);
}
void QWSDisplay::grab(bool write)
{
lock->lock(write ? QLock::Write : QLock::Read);
}
void QWSDisplay::ungrab()
{
lock->unlock();
}
#if 0
QWSRegionManager *QWSDisplay::regionManager() const
{
return d->rgnMan;
}
#endif
bool QWSDisplay::eventPending() const
{
#ifndef QT_NO_QWS_MULTIPROCESS
d->flush();
#endif
d->fillQueue();
return d->queueNotEmpty();
}
/*
Caller must delete return value!
*/
QWSEvent *QWSDisplay::getEvent()
{
d->fillQueue();
Q_ASSERT(d->queueNotEmpty());
QWSEvent* e = d->dequeue();
return e;
}
uchar* QWSDisplay::frameBuffer() const { return qt_screen->base(); }
int QWSDisplay::width() const { return qt_screen->width(); }
int QWSDisplay::height() const { return qt_screen->height(); }
int QWSDisplay::depth() const { return qt_screen->depth(); }
int QWSDisplay::pixmapDepth() const { return qt_screen->pixmapDepth(); }
bool QWSDisplay::supportsDepth(int depth) const { return qt_screen->supportsDepth(depth); }
uchar *QWSDisplay::sharedRam() const { return d->sharedRam; }
int QWSDisplay::sharedRamSize() const { return d->sharedRamSize; }
#ifndef QT_NO_QWS_PROPERTIES
void QWSDisplay::addProperty(int winId, int property)
{
QWSAddPropertyCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.property = property;
d->sendCommand(cmd);
}
void QWSDisplay::setProperty(int winId, int property, int mode, const QByteArray &data)
{
QWSSetPropertyCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.property = property;
cmd.simpleData.mode = mode;
cmd.setData(data.constData(), data.size());
d->sendCommand(cmd);
}
void QWSDisplay::setProperty(int winId, int property, int mode,
const char * data)
{
QWSSetPropertyCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.property = property;
cmd.simpleData.mode = mode;
cmd.setData(data, strlen(data));
d->sendCommand(cmd);
}
void QWSDisplay::removeProperty(int winId, int property)
{
QWSRemovePropertyCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.property = property;
d->sendCommand(cmd);
}
/*
It is the caller's responsibility to delete[] \a data.
*/
bool QWSDisplay::getProperty(int winId, int property, char *&data, int &len)
{
if (d->directServerConnection()) {
const char *propertyData;
bool retval = qwsServer->d_func()->get_property(winId, property, propertyData, len);
if (len <= 0) {
data = 0;
} else {
data = new char[len];
memcpy(data, propertyData, len) ;
}
return retval;
}
QWSGetPropertyCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.property = property;
d->sendCommand(cmd);
getPropertyLen = -2;
getPropertyData = 0;
#ifndef QT_NO_QWS_MULTIPROCESS
d->waitForPropertyReply();
#endif
len = getPropertyLen;
data = getPropertyData;
getPropertyLen = -2;
getPropertyData = 0;
return len != -1;
}
#endif // QT_NO_QWS_PROPERTIES
void QWSDisplay::setAltitude(int winId, int alt, bool fixed)
{
QWSChangeAltitudeCommand cmd;
#ifdef QT_DEBUG
memset(cmd.simpleDataPtr, 0, sizeof(cmd.simpleData)); //shut up Valgrind
#endif
cmd.simpleData.windowid = winId;
cmd.simpleData.altitude = QWSChangeAltitudeCommand::Altitude(alt);
cmd.simpleData.fixed = fixed;
if (d->directServerConnection()) {
qwsServer->d_func()->set_altitude(&cmd);
} else {
d->sendSynchronousCommand(cmd);
}
}
void QWSDisplay::setOpacity(int winId, int opacity)
{
QWSSetOpacityCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.opacity = opacity;
if (d->directServerConnection()) {
qwsServer->d_func()->set_opacity(&cmd);
} else {
d->sendCommand(cmd);
}
}
void QWSDisplay::requestFocus(int winId, bool get)
{
QWSRequestFocusCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.flag = get;
if (d->directServerConnection())
qwsServer->d_func()->request_focus(&cmd);
else
d->sendCommand(cmd);
}
void QWSDisplay::setIdentity(const QString &appName)
{
QWSIdentifyCommand cmd;
#ifdef QT_NO_QWS_MULTIPROCESS
const int id = -1;
#else
const int id = QWSDisplay::Data::clientLock ? QWSDisplay::Data::clientLock->id() : -1;
#endif
cmd.setId(appName, id);
if (d->directServerConnection())
qwsServer->d_func()->set_identity(&cmd);
else
d->sendCommand(cmd);
}
void QWSDisplay::nameRegion(int winId, const QString& n, const QString &c)
{
QWSRegionNameCommand cmd;
cmd.simpleData.windowid = winId;
cmd.setName(n, c);
if (d->directServerConnection())
qwsServer->d_func()->name_region(&cmd);
else
d->sendCommand(cmd);
}
void QWSDisplay::requestRegion(int winId, const QString &surfaceKey,
const QByteArray &surfaceData,
const QRegion ®ion)
{
if (d->directServerConnection()) {
qwsServer->d_func()->request_region(winId, surfaceKey,
surfaceData, region);
} else {
QWSRegionCommand cmd;
cmd.setData(winId, surfaceKey, surfaceData, region);
d->sendSynchronousCommand(cmd);
}
}
void QWSDisplay::repaintRegion(int winId, int windowFlags, bool opaque, QRegion r)
{
if (d->directServerConnection()) {
qwsServer->d_func()->repaint_region(winId, windowFlags, opaque, r);
} else {
QVector<QRect> ra = r.rects();
/*
for (int i = 0; i < ra.size(); i++) {
QRect r(ra[i]);
qDebug("rect: %d %d %d %d", r.x(), r.y(), r.right(), r.bottom());
}
*/
QWSRepaintRegionCommand cmd;
/* XXX QWSRegionCommand is padded out in a compiler dependent way.
Zeroed out to avoid valgrind reporting uninitialized memory usage.
*/
#ifdef QT_DEBUG
memset(cmd.simpleDataPtr, 0, sizeof(cmd.simpleData)); //shut up Valgrind
#endif
cmd.simpleData.windowid = winId;
cmd.simpleData.windowFlags = windowFlags;
cmd.simpleData.opaque = opaque;
cmd.simpleData.nrectangles = ra.count();
cmd.setData(reinterpret_cast<const char *>(ra.constData()),
ra.count() * sizeof(QRect), false);
d->sendSynchronousCommand(cmd);
}
}
void QWSDisplay::moveRegion(int winId, int dx, int dy)
{
QWSRegionMoveCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.dx = dx;
cmd.simpleData.dy = dy;
if (d->directServerConnection()) {
qwsServer->d_func()->move_region(&cmd);
} else {
d->sendSynchronousCommand(cmd);
}
// d->offsetPendingExpose(winId, QPoint(cmd.simpleData.dx, cmd.simpleData.dy));
}
void QWSDisplay::destroyRegion(int winId)
{
QWSRegionDestroyCommand cmd;
cmd.simpleData.windowid = winId;
if (d->directServerConnection()) {
qwsServer->d_func()->destroy_region(&cmd);
} else {
d->sendCommand(cmd);
}
}
#ifndef QT_NO_QWS_INPUTMETHODS
void QWSDisplay::sendIMUpdate(int type, int winId, int widgetid)
{
QWSIMUpdateCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.widgetid = widgetid;
cmd.simpleData.type = type;
if (d->directServerConnection()) {
qwsServer->d_func()->im_update(&cmd);
} else {
d->sendCommand(cmd);
}
}
void QWSDisplay::sendIMResponse(int winId, int property, const QVariant &result)
{
QWSIMResponseCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.property = property;
cmd.setResult(result);
if (d->directServerConnection()) {
qwsServer->d_func()->im_response(&cmd);
} else {
d->sendCommand(cmd);
}
}
void QWSDisplay::resetIM()
{
sendIMUpdate(QWSInputMethod::Reset, -1, -1);
}
void QWSDisplay::sendIMMouseEvent(int index, bool isPress)
{
QWSIMMouseCommand cmd;
cmd.simpleData.index = index;
cmd.simpleData.state = isPress ? QWSServer::MousePress : QWSServer::MouseRelease;
if (d->directServerConnection()) {
qwsServer->d_func()->send_im_mouse(&cmd);
} else {
d->sendCommand(cmd);
}
}
#endif
int QWSDisplay::takeId()
{
return d->takeId();
}
bool QWSDisplay::initLock(const QString &filename, bool create)
{
if (!lock) {
lock = new QLock(filename, 'd', create);
if (!lock->isValid()) {
delete lock;
lock = 0;
return false;
}
}
return true;
}
void QWSDisplay::setSelectionOwner(int winId, const QTime &time)
{
QWSSetSelectionOwnerCommand cmd;
cmd.simpleData.windowid = winId;
cmd.simpleData.hour = time.hour();
cmd.simpleData.minute = time.minute();
cmd.simpleData.sec = time.second();
cmd.simpleData.ms = time.msec();
d->sendCommand(cmd);
}
void QWSDisplay::convertSelection(int winId, int selectionProperty, const QString &mimeTypes)
{
#ifdef QT_NO_QWS_PROPERTIES
Q_UNUSED(mimeTypes);
#else
// ### we need the atom/property thingy like in X here
addProperty(winId, QT_QWS_PROPERTY_CONVERTSELECTION);
setProperty(winId, QT_QWS_PROPERTY_CONVERTSELECTION,
int(QWSPropertyManager::PropReplace), mimeTypes.toLatin1());
#endif
QWSConvertSelectionCommand cmd;
cmd.simpleData.requestor = winId;
cmd.simpleData.selection = selectionProperty;
cmd.simpleData.mimeTypes = QT_QWS_PROPERTY_CONVERTSELECTION;
d->sendCommand(cmd);
}
void QWSDisplay::defineCursor(int id, const QBitmap &curs, const QBitmap &mask,
int hotX, int hotY)
{
const QImage cursImg = curs.toImage().convertToFormat(QImage::Format_MonoLSB);
const QImage maskImg = mask.toImage().convertToFormat(QImage::Format_MonoLSB);
QWSDefineCursorCommand cmd;
cmd.simpleData.width = curs.width();
cmd.simpleData.height = curs.height();
cmd.simpleData.hotX = hotX;
cmd.simpleData.hotY = hotY;
cmd.simpleData.id = id;
// must copy each scanline since there might be gaps between them
const int height = curs.height();
const int width = curs.width();
const int dst_bpl = (width + 7) / 8;
int dataLen = dst_bpl * height;
uchar *data = new uchar[dataLen*2];
uchar *dst = data;
int src_bpl = cursImg.bytesPerLine();
const uchar *cursSrc = cursImg.bits();
for (int i = 0; i < height; ++i) {
memcpy(dst, cursSrc + i*src_bpl, dst_bpl);
dst += dst_bpl;
}
src_bpl = maskImg.bytesPerLine();
const uchar *maskSrc = maskImg.bits();
for (int i = 0; i < height; ++i) {
memcpy(dst, maskSrc + i*src_bpl, dst_bpl);
dst += dst_bpl;
}
cmd.setData(reinterpret_cast<char*>(data), dataLen*2);
delete [] data;
d->sendCommand(cmd);
}
void QWSDisplay::destroyCursor(int id)
{
QWSDefineCursorCommand cmd;
cmd.simpleData.width = 0;
cmd.simpleData.height = 0;
cmd.simpleData.hotX = 0;
cmd.simpleData.hotY = 0;
cmd.simpleData.id = id;
cmd.setData(0, 0);
d->sendCommand(cmd);
}
#ifndef QT_NO_SOUND
void QWSDisplay::playSoundFile(const QString& f)
{
QWSPlaySoundCommand cmd;
cmd.setFileName(f);
d->sendCommand(cmd);
}
#endif
#ifndef QT_NO_COP
void QWSDisplay::registerChannel(const QString& channel)
{
QWSQCopRegisterChannelCommand reg;
reg.setChannel(channel);
qt_fbdpy->d->sendCommand(reg);
}
void QWSDisplay::sendMessage(const QString &channel, const QString &msg,
const QByteArray &data)
{
QWSQCopSendCommand com;
com.setMessage(channel, msg, data);
qt_fbdpy->d->sendCommand(com);
}
void QWSDisplay::flushCommands()
{
qt_fbdpy->d->flushCommands();
}
/*
caller deletes result
*/
QWSQCopMessageEvent* QWSDisplay::waitForQCopResponse()
{
qt_fbdpy->d->waitForQCopResponse();
QWSQCopMessageEvent *e = static_cast<QWSQCopMessageEvent*>(qt_fbdpy->d->dequeue());
Q_ASSERT(e->type == QWSEvent::QCopMessage);
return e;
}
#endif
void QWSDisplay::sendFontCommand(int type, const QByteArray &fontName)
{
QWSFontCommand cmd;
cmd.simpleData.type = type;
cmd.setFontName(fontName);
d->sendCommand(cmd);
}
void QWSDisplay::setWindowCaption(QWidget *w, const QString &c)
{
if (w->isWindow()) {
nameRegion(w->internalWinId(), w->objectName(), c);
static_cast<QETWidget *>(w)->repaintDecoration(qApp->desktop()->rect(), true);
}
}
void QWSDisplay::selectCursor(QWidget *w, unsigned int cursId)
{
if (cursId != qt_last_cursor)
{
QWidget *top = w->window();
qt_last_cursor = cursId;
QWSSelectCursorCommand cmd;
cmd.simpleData.windowid = top->internalWinId();
cmd.simpleData.id = cursId;
d->sendCommand(cmd);
d->flush();
}
}
void QWSDisplay::setCursorPosition(int x, int y)
{
QWSPositionCursorCommand cmd;
cmd.simpleData.newX = x;
cmd.simpleData.newY = y;
d->sendCommand(cmd);
d->flush();
}
void QWSDisplay::grabMouse(QWidget *w, bool grab)
{
QWidget *top = w->window();
QWSGrabMouseCommand cmd;
#ifdef QT_DEBUG
memset(cmd.simpleDataPtr, 0, sizeof(cmd.simpleData)); //shut up Valgrind
#endif
cmd.simpleData.windowid = top->winId();
cmd.simpleData.grab = grab;
d->sendCommand(cmd);
d->flush();
}
void QWSDisplay::grabKeyboard(QWidget *w, bool grab)
{
QWidget *top = w->window();
QWSGrabKeyboardCommand cmd;
#ifdef QT_DEBUG
memset(cmd.simpleDataPtr, 0, sizeof(cmd.simpleData)); //shut up Valgrind
#endif
cmd.simpleData.windowid = top->winId();
cmd.simpleData.grab = grab;
d->sendCommand(cmd);
d->flush();
}
QList<QWSWindowInfo> QWSDisplay::windowList()
{
QList<QWSWindowInfo> ret;
if(d->directServerConnection()) {
QList<QWSInternalWindowInfo*> * qin=QWSServer::windowList();
for (int i = 0; i < qin->count(); ++i) {
QWSInternalWindowInfo * qwi = qin->at(i);
QWSWindowInfo tmp;
tmp.winid = qwi->winid;
tmp.clientid = qwi->clientid;
tmp.name = QString(qwi->name);
ret.append(tmp);
}
qDeleteAll(*qin);
delete qin;
}
return ret;
}
int QWSDisplay::windowAt(const QPoint &p)
{
//### currently only implemented for the server process
int ret = 0;
if(d->directServerConnection()) {
QWSWindow *win = qwsServer->windowAt(p);
if (win)
return win->winId();
}
return ret;
}
void QWSDisplay::setRawMouseEventFilter(void (*filter)(QWSMouseEvent *))
{
if (qt_fbdpy)
qt_fbdpy->d->setMouseFilter(filter);
}
/*!
\relates QScreen
Here it is. \a transformation and \a screenNo
*/
void QWSDisplay::setTransformation(int transformation, int screenNo)
{
QWSScreenTransformCommand cmd;
cmd.setTransformation(screenNo, transformation);
QWSDisplay::instance()->d->sendCommand(cmd);
}
static bool qt_try_modal(QWidget *, QWSEvent *);
/*****************************************************************************
qt_init() - initializes Qt/FB
*****************************************************************************/
static void qt_set_qws_resources()
{
if (QApplication::desktopSettingsAware())
QApplicationPrivate::qws_apply_settings();
if (appFont)
QApplication::setFont(QFont(QString::fromLocal8Bit(appFont)));
if (appBGCol || appBTNCol || appFGCol) {
(void) QApplication::style(); // trigger creation of application style and system palettes
QColor btn;
QColor bg;
QColor fg;
if (appBGCol)
bg = QColor(appBGCol);
else
bg = QApplicationPrivate::sys_pal->color(QPalette::Window);
if (appFGCol)
fg = QColor(appFGCol);
else
fg = QApplicationPrivate::sys_pal->color(QPalette::WindowText);
if (appBTNCol)
btn = QColor(appBTNCol);
else
btn = QApplicationPrivate::sys_pal->color(QPalette::Button);
int h,s,v;
fg.getHsv(&h,&s,&v);
QColor base = Qt::white;
bool bright_mode = false;
if (v >= 255 - 50) {
base = btn.darker(150);
bright_mode = true;
}
QPalette pal(fg, btn, btn.lighter(), btn.darker(), btn.darker(150), fg, Qt::white, base, bg);
if (bright_mode) {
pal.setColor(QPalette::HighlightedText, base);
pal.setColor(QPalette::Highlight, Qt::white);
} else {
pal.setColor(QPalette::HighlightedText, Qt::white);
pal.setColor(QPalette::Highlight, Qt::darkBlue);
}
QColor disabled((fg.red() + btn.red()) / 2,
(fg.green() + btn.green())/ 2,
(fg.blue() + btn.blue()) / 2);
pal.setColorGroup(QPalette::Disabled, disabled, btn, btn.lighter(125),
btn.darker(), btn.darker(150), disabled, Qt::white, Qt::white, bg);
if (bright_mode) {
pal.setColor(QPalette::Disabled, QPalette::HighlightedText, base);
pal.setColor(QPalette::Disabled, QPalette::Highlight, Qt::white);
} else {
pal.setColor(QPalette::Disabled, QPalette::HighlightedText, Qt::white);
pal.setColor(QPalette::Disabled, QPalette::Highlight, Qt::darkBlue);
}
QApplicationPrivate::setSystemPalette(pal);
}
}
void QApplicationPrivate::initializeWidgetPaletteHash()
{
}
/*! \internal
apply the settings to the application
*/
bool QApplicationPrivate::qws_apply_settings()
{
#ifndef QT_NO_SETTINGS
QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
settings.beginGroup(QLatin1String("Qt"));
QStringList strlist;
int i;
QPalette pal(Qt::black);
int groupCount = 0;
strlist = settings.value(QLatin1String("Palette/active")).toStringList();
if (strlist.count() == QPalette::NColorRoles) {
++groupCount;
for (i = 0; i < QPalette::NColorRoles; i++)
pal.setColor(QPalette::Active, (QPalette::ColorRole) i,
QColor(strlist[i]));
}
strlist = settings.value(QLatin1String("Palette/inactive")).toStringList();
if (strlist.count() == QPalette::NColorRoles) {
++groupCount;
for (i = 0; i < QPalette::NColorRoles; i++)
pal.setColor(QPalette::Inactive, (QPalette::ColorRole) i,
QColor(strlist[i]));
}
strlist = settings.value(QLatin1String("Palette/disabled")).toStringList();
if (strlist.count() == QPalette::NColorRoles) {
++groupCount;
for (i = 0; i < QPalette::NColorRoles; i++)
pal.setColor(QPalette::Disabled, (QPalette::ColorRole) i,
QColor(strlist[i]));
}
if (groupCount == QPalette::NColorGroups)
QApplicationPrivate::setSystemPalette(pal);
QString str = settings.value(QLatin1String("font")).toString();
if (!str.isEmpty()) {
QFont font(QApplication::font());
font.fromString(str);
QApplicationPrivate::setSystemFont(font);
}
// read library (ie. plugin) path list
QString libpathkey =
QString::fromLatin1("%1.%2/libraryPath")
.arg(QT_VERSION >> 16)
.arg((QT_VERSION & 0xff00) >> 8);
QStringList pathlist = settings.value(libpathkey).toString().split(QLatin1Char(':'));
#ifndef QT_NO_LIBRARY
if (! pathlist.isEmpty()) {
QStringList::ConstIterator it = pathlist.constBegin();
while (it != pathlist.constEnd())
QApplication::addLibraryPath(*it++);
}
#endif
// read new QStyle
QString stylename = settings.value(QLatin1String("style")).toString();
if (QCoreApplication::startingUp()) {
if (!stylename.isEmpty() && QApplicationPrivate::styleOverride.isNull())
QApplicationPrivate::styleOverride = stylename;
} else {
QApplication::setStyle(stylename);
}
int num =
settings.value(QLatin1String("doubleClickInterval"),
QApplication::doubleClickInterval()).toInt();
QApplication::setDoubleClickInterval(num);
num =
settings.value(QLatin1String("cursorFlashTime"),
QApplication::cursorFlashTime()).toInt();
QApplication::setCursorFlashTime(num);
#ifndef QT_NO_WHEELEVENT
num =
settings.value(QLatin1String("wheelScrollLines"),
QApplication::wheelScrollLines()).toInt();
QApplication::setWheelScrollLines(num);
#endif
QString colorspec = settings.value(QLatin1String("colorSpec"),
QVariant(QLatin1String("default"))).toString();
if (colorspec == QLatin1String("normal"))
QApplication::setColorSpec(QApplication::NormalColor);
else if (colorspec == QLatin1String("custom"))
QApplication::setColorSpec(QApplication::CustomColor);
else if (colorspec == QLatin1String("many"))
QApplication::setColorSpec(QApplication::ManyColor);
else if (colorspec != QLatin1String("default"))
colorspec = QLatin1String("default");
#ifndef QT_NO_TEXTCODEC
QString defaultcodec = settings.value(QLatin1String("defaultCodec"),
QVariant(QLatin1String("none"))).toString();
if (defaultcodec != QLatin1String("none")) {
QTextCodec *codec = QTextCodec::codecForName(defaultcodec.toLatin1());
if (codec)
QTextCodec::setCodecForTr(codec);
}
#endif
int w = settings.value(QLatin1String("globalStrut/width")).toInt();
int h = settings.value(QLatin1String("globalStrut/height")).toInt();
QSize strut(w, h);
if (strut.isValid())
QApplication::setGlobalStrut(strut);
QStringList effects = settings.value(QLatin1String("GUIEffects")).toStringList();
QApplication::setEffectEnabled(Qt::UI_General,
effects.contains(QLatin1String("general")));
QApplication::setEffectEnabled(Qt::UI_AnimateMenu,
effects.contains(QLatin1String("animatemenu")));
QApplication::setEffectEnabled(Qt::UI_FadeMenu,
effects.contains(QLatin1String("fademenu")));
QApplication::setEffectEnabled(Qt::UI_AnimateCombo,
effects.contains(QLatin1String("animatecombo")));
QApplication::setEffectEnabled(Qt::UI_AnimateTooltip,
effects.contains(QLatin1String("animatetooltip")));
QApplication::setEffectEnabled(Qt::UI_FadeTooltip,
effects.contains(QLatin1String("fadetooltip")));
QApplication::setEffectEnabled(Qt::UI_AnimateToolBox,
effects.contains(QLatin1String("animatetoolbox")));
settings.beginGroup(QLatin1String("Font Substitutions"));
QStringList fontsubs = settings.childKeys();
if (!fontsubs.isEmpty()) {
QStringList::Iterator it = fontsubs.begin();
for (; it != fontsubs.end(); ++it) {
QString fam = *it;
QStringList subs = settings.value(fam).toStringList();
QFont::insertSubstitutions(fam, subs);
}
}
settings.endGroup();
settings.endGroup(); // Qt
settings.beginGroup(QLatin1String("QWS Font Fallbacks"));
if (!settings.childKeys().isEmpty()) {
// from qfontdatabase_qws.cpp
extern void qt_applyFontDatabaseSettings(const QSettings &);
qt_applyFontDatabaseSettings(settings);
}
settings.endGroup();
return true;
#else
return false;
#endif // QT_NO_SETTINGS
}
static void init_display()
{
if (qt_fbdpy) return; // workaround server==client case
// Connect to FB server
qt_fbdpy = new QWSDisplay();
// Get display parameters
// Set paintdevice parameters
// XXX initial info sent from server
// Misc. initialization
QColormap::initialize();
QFont::initialize();
#ifndef QT_NO_CURSOR
QCursorData::initialize();
#endif
qApp->setObjectName(appName);
if (!QApplicationPrivate::sys_font) {
#ifdef QT_NO_FREETYPE
QFont f = QFont(QLatin1String("helvetica"), 10);
#else
QFont f = QFont(QLatin1String("DejaVu Sans"), 12);
#endif
QApplicationPrivate::setSystemFont(f);
}
qt_set_qws_resources();
}
void qt_init_display()
{
qt_is_gui_used = true;
qws_single_process = true;
init_display();
}
static bool read_bool_env_var(const char *var, bool defaultvalue)
{
// returns true if env variable is set to non-zero
// returns false if env var is set to zero
// returns defaultvalue if env var not set
char *x = ::getenv(var);
return (x && *x) ? (strcmp(x,"0") != 0) : defaultvalue;
}
static int read_int_env_var(const char *var, int defaultvalue)
{
bool ok;
int r = qgetenv(var).toInt(&ok);
return ok ? r : defaultvalue;
}
void qt_init(QApplicationPrivate *priv, int type)
{
#ifdef QT_NO_QWS_MULTIPROCESS
if (type == QApplication::GuiClient)
type = QApplication::GuiServer;
#endif
if (type == QApplication::GuiServer)
qt_is_gui_used = false; //we'll turn it on in a second
qws_sw_cursor = read_bool_env_var("QWS_SW_CURSOR",qws_sw_cursor);
qws_screen_is_interlaced = read_bool_env_var("QWS_INTERLACE",false);
const char *display = ::getenv("QWS_DISPLAY");
if (display)
qws_display_spec = display; // since we setenv later!
//qws_savefonts = qgetenv("QWS_SAVEFONTS") != 0;
//qws_shared_memory = qgetenv("QWS_NOSHARED") == 0;
mouse_double_click_distance = read_int_env_var("QWS_DBLCLICK_DISTANCE", 5);
priv->inputContext = 0;
int flags = 0;
char *p;
int argc = priv->argc;
char **argv = priv->argv;
int j;
// Set application name
if (argv && *argv) { //apparently, we allow people to pass 0 on the other platforms
p = strrchr(argv[0], '/');
appName = QString::fromLocal8Bit(p ? p + 1 : argv[0]);
}
// Get command line params
j = argc ? 1 : 0;
QString decoration;
for (int i=1; i<argc; i++) {
if (argv[i] && *argv[i] != '-') {
argv[j++] = argv[i];
continue;
}
QByteArray arg = argv[i];
if (arg == "-fn" || arg == "-font") {
if (++i < argc)
appFont = argv[i];
} else if (arg == "-bg" || arg == "-background") {
if (++i < argc)
appBGCol = argv[i];
} else if (arg == "-btn" || arg == "-button") {
if (++i < argc)
appBTNCol = argv[i];
} else if (arg == "-fg" || arg == "-foreground") {
if (++i < argc)
appFGCol = argv[i];
} else if (arg == "-name") {
if (++i < argc)
appName = QString::fromLocal8Bit(argv[i]);
} else if (arg == "-title") {
if (++i < argc)
mwTitle = argv[i];
} else if (arg == "-geometry") {
if (++i < argc)
mwGeometry = argv[i];
} else if (arg == "-shared") {
qws_shared_memory = true;
} else if (arg == "-noshared") {
qws_shared_memory = false;
} else if (arg == "-savefonts") {
qws_savefonts = true;
} else if (arg == "-nosavefonts") {
qws_savefonts = false;
} else if (arg == "-swcursor") {
qws_sw_cursor = true;
} else if (arg == "-noswcursor") {
qws_sw_cursor = false;
} else if (arg == "-keyboard") {
flags &= ~QWSServer::DisableKeyboard;
} else if (arg == "-nokeyboard") {
flags |= QWSServer::DisableKeyboard;
} else if (arg == "-mouse") {
flags &= ~QWSServer::DisableMouse;
} else if (arg == "-nomouse") {
flags |= QWSServer::DisableMouse;
} else if (arg == "-qws") {
type = QApplication::GuiServer;
} else if (arg == "-interlaced") {
qws_screen_is_interlaced = true;
} else if (arg == "-display") {
if (++i < argc)
qws_display_spec = argv[i];
} else if (arg == "-decoration") {
if (++i < argc)
decoration = QString::fromLocal8Bit(argv[i]);
} else {
argv[j++] = argv[i];
}
}
if(j < priv->argc) {
priv->argv[j] = 0;
priv->argc = j;
}
mouseInWidget = new QPointer<QWidget>;
const QString disp = QString::fromLatin1(qws_display_spec);
QRegExp regexp(QLatin1String(":(\\d+)$"));
if (regexp.lastIndexIn(disp) != -1) {
const QString capture = regexp.cap(1);
bool ok = false;
int id = capture.toInt(&ok);
if (ok)
qws_display_id = id;
}
if (type == QApplication::GuiServer) {
qt_appType = QApplication::Type(type);
qws_single_process = true;
QWSServer::startup(flags);
if (!display) // if not already set
qputenv("QWS_DISPLAY", qws_display_spec);
}
if(qt_is_gui_used) {
init_display();
#ifndef QT_NO_QWS_MANAGER
if (decoration.isEmpty() && !qws_decoration) {
const QStringList keys = QDecorationFactory::keys();
if (!keys.isEmpty())
decoration = keys.first();
}
if (!decoration.isEmpty())
qws_decoration = QApplication::qwsSetDecoration(decoration);
#endif // QT_NO_QWS_MANAGER
#ifndef QT_NO_QWS_INPUTMETHODS
qApp->setInputContext(new QWSInputContext(qApp));
#endif
}
/*### convert interlace style
if (qws_screen_is_interlaced)
QApplication::setStyle(new QInterlaceStyle);
*/
}
/*****************************************************************************
qt_cleanup() - cleans up when the application is finished
*****************************************************************************/
void qt_cleanup()
{
QPixmapCache::clear();
#ifndef QT_NO_CURSOR
QCursorData::cleanup();
#endif
QFont::cleanup();
QColormap::cleanup();
if (qws_single_process) {
QWSServer::closedown();
}
qDeleteAll(outgoing);
outgoing.clear();
qDeleteAll(incoming);
incoming.clear();
if (qt_is_gui_used) {
delete qt_fbdpy;
}
qt_fbdpy = 0;
#ifndef QT_NO_QWS_MANAGER
delete qws_decoration;
qws_decoration = 0;
#endif
delete mouseInWidget;
mouseInWidget = 0;
#if !defined(QT_NO_IM)
delete QApplicationPrivate::inputContext;
QApplicationPrivate::inputContext = 0;
#endif
}
/*****************************************************************************
Platform specific global and internal functions
*****************************************************************************/
QString QApplicationPrivate::appName() const // get application name
{
return QT_PREPEND_NAMESPACE(appName);
}
/*****************************************************************************
Platform specific QApplication members
*****************************************************************************/
#define NoValue 0x0000
#define XValue 0x0001
#define YValue 0x0002
#define WidthValue 0x0004
#define HeightValue 0x0008
#define AllValues 0x000F
#define XNegative 0x0010
#define YNegative 0x0020
/* Copyright notice for ReadInteger and parseGeometry
Copyright (c) 1985, 1986, 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall
not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization
from the X Consortium.
*/
/*
* XParseGeometry parses strings of the form
* "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
* width, height, xoffset, and yoffset are unsigned integers.
* Example: "=80x24+300-49"
* The equal sign is optional.
* It returns a bitmask that indicates which of the four values
* were actually found in the string. For each value found,
* the corresponding argument is updated; for each value
* not found, the corresponding argument is left unchanged.
*/
static int
ReadInteger(char *string, char **NextString)
{
register int Result = 0;
int Sign = 1;
if (*string == '+')
string++;
else if (*string == '-')
{
string++;
Sign = -1;
}
for (; (*string >= '0') && (*string <= '9'); string++)
{
Result = (Result * 10) + (*string - '0');
}
*NextString = string;
if (Sign >= 0)
return Result;
else
return -Result;
}
static int parseGeometry(const char* string,
int* x, int* y, int* width, int* height)
{
int mask = NoValue;
register char *strind;
unsigned int tempWidth=0, tempHeight=0;
int tempX=0, tempY=0;
char *nextCharacter;
if (!string || (*string == '\0')) return mask;
if (*string == '=')
string++; /* ignore possible '=' at beg of geometry spec */
strind = const_cast<char *>(string);
if (*strind != '+' && *strind != '-' && *strind != 'x') {
tempWidth = ReadInteger(strind, &nextCharacter);
if (strind == nextCharacter)
return 0;
strind = nextCharacter;
mask |= WidthValue;
}
if (*strind == 'x' || *strind == 'X') {
strind++;
tempHeight = ReadInteger(strind, &nextCharacter);
if (strind == nextCharacter)
return 0;
strind = nextCharacter;
mask |= HeightValue;
}
if ((*strind == '+') || (*strind == '-')) {
if (*strind == '-') {
strind++;
tempX = -ReadInteger(strind, &nextCharacter);
if (strind == nextCharacter)
return 0;
strind = nextCharacter;
mask |= XNegative;
}
else
{ strind++;
tempX = ReadInteger(strind, &nextCharacter);
if (strind == nextCharacter)
return 0;
strind = nextCharacter;
}
mask |= XValue;
if ((*strind == '+') || (*strind == '-')) {
if (*strind == '-') {
strind++;
tempY = -ReadInteger(strind, &nextCharacter);
if (strind == nextCharacter)
return 0;
strind = nextCharacter;
mask |= YNegative;
}
else
{
strind++;
tempY = ReadInteger(strind, &nextCharacter);
if (strind == nextCharacter)
return 0;
strind = nextCharacter;
}
mask |= YValue;
}
}
/* If strind isn't at the end of the string then it's an invalid
geometry specification. */
if (*strind != '\0') return 0;
if (mask & XValue)
*x = tempX;
if (mask & YValue)
*y = tempY;
if (mask & WidthValue)
*width = tempWidth;
if (mask & HeightValue)
*height = tempHeight;
return mask;
}
#ifdef QT3_SUPPORT
void QApplication::setMainWidget(QWidget *mainWidget)
{
QApplicationPrivate::main_widget = mainWidget;
if (QApplicationPrivate::main_widget) // give WM command line
QApplicationPrivate::applyQWSSpecificCommandLineArguments(QApplicationPrivate::main_widget);
}
#endif
void QApplicationPrivate::applyQWSSpecificCommandLineArguments(QWidget *main_widget)
{
static bool beenHereDoneThat = false;
if (beenHereDoneThat)
return;
beenHereDoneThat = true;
if (qApp->windowIcon().isNull() && main_widget->testAttribute(Qt::WA_SetWindowIcon))
qApp->setWindowIcon(main_widget->windowIcon());
if (mwTitle) // && main_widget->windowTitle().isEmpty())
main_widget->setWindowTitle(QString::fromLocal8Bit(mwTitle));
if (mwGeometry) { // parse geometry
int x = 0;
int y = 0;
int w = 0;
int h = 0;
int m = parseGeometry(mwGeometry, &x, &y, &w, &h);
QSize minSize = main_widget->minimumSize();
QSize maxSize = main_widget->maximumSize();
if ((m & XValue) == 0)
x = main_widget->geometry().x();
if ((m & YValue) == 0)
y = main_widget->geometry().y();
if ((m & WidthValue) == 0)
w = main_widget->width();
if ((m & HeightValue) == 0)
h = main_widget->height();
w = qMin(w,maxSize.width());
h = qMin(h,maxSize.height());
w = qMax(w,minSize.width());
h = qMax(h,minSize.height());
if ((m & XNegative)) {
x = qApp->desktop()->width() + x - w;
x -= (main_widget->frameGeometry().width() - main_widget->width()) / 2;
} else {
x += (main_widget->geometry().x() - main_widget->x());
}
if ((m & YNegative)) {
y = qApp->desktop()->height() + y - h;
} else {
y += (main_widget->geometry().y() - main_widget->y());
}
main_widget->setGeometry(x, y, w, h);
}
}
/*****************************************************************************
QApplication cursor stack
*****************************************************************************/
#ifndef QT_NO_CURSOR
void QApplication::setOverrideCursor(const QCursor &cursor)
{
qApp->d_func()->cursor_list.prepend(cursor);
QWidget *w = QWidget::mouseGrabber();
if (!w && qt_last_x)
w = topLevelAt(*qt_last_x, *qt_last_y);
if (!w)
w = desktop();
QPaintDevice::qwsDisplay()->selectCursor(w, qApp->d_func()->cursor_list.first().handle());
}
void QApplication::restoreOverrideCursor()
{
if (qApp->d_func()->cursor_list.isEmpty())
return;
qApp->d_func()->cursor_list.removeFirst();
QWidget *w = QWidget::mouseGrabber();
if (!w && qt_last_x)
w = topLevelAt(*qt_last_x, *qt_last_y);
if (!w)
w = desktop();
int cursor_handle = Qt::ArrowCursor;
if (qApp->d_func()->cursor_list.isEmpty()) {
qws_overrideCursor = false;
QWidget *upw = QApplication::widgetAt(*qt_last_x, *qt_last_y);
if (upw)
cursor_handle = upw->cursor().handle();
} else {
cursor_handle = qApp->d_func()->cursor_list.first().handle();
}
QPaintDevice::qwsDisplay()->selectCursor(w, cursor_handle);
}
#endif// QT_NO_CURSOR
/*****************************************************************************
Routines to find a Qt widget from a screen position
*****************************************************************************/
/*!
\internal
*/
QWidget *QApplicationPrivate::findWidget(const QObjectList& list,
const QPoint &pos, bool rec)
{
QWidget *w;
for (int i = list.size()-1; i >= 0; --i) {
if (list.at(i)->isWidgetType()) {
w = static_cast<QWidget*>(list.at(i));
if (w->isVisible() && !w->testAttribute(Qt::WA_TransparentForMouseEvents) && w->geometry().contains(pos)
&& (!w->d_func()->extra || w->d_func()->extra->mask.isEmpty() || w->d_func()->extra->mask.contains(pos - w->geometry().topLeft()) )) {
if (!rec)
return w;
QWidget *c = w->childAt(w->mapFromParent(pos));
return c ? c : w;
}
}
}
return 0;
}
QWidget *QApplication::topLevelAt(const QPoint &pos)
{
//### QWSDisplay::windowAt() is currently only implemented in the server process
int winId = QPaintDevice::qwsDisplay()->windowAt(pos);
if (winId !=0)
return QWidget::find(winId);
#if 1
// fallback implementation for client processes
//### This is slightly wrong: we have no guarantee that the list is in
//### stacking order, so if the topmost window is transparent, we may
//### return the wrong widget
QWidgetList list = topLevelWidgets();
for (int i = list.size()-1; i >= 0; --i) {
QWidget *w = list[i];
if (w != QApplication::desktop() &&
w->isVisible() && w->d_func()->localAllocatedRegion().contains(w->mapFromParent(pos))
)
return w;
}
#endif
return 0;
}
void QApplication::beep()
{
}
void QApplication::alert(QWidget *, int)
{
}
int QApplication::qwsProcessEvent(QWSEvent* event)
{
Q_D(QApplication);
QScopedLoopLevelCounter loopLevelCounter(d->threadData);
int oldstate = -1;
bool isMove = false;
if (event->type == QWSEvent::Mouse) {
QWSMouseEvent::SimpleData &mouse = event->asMouse()->simpleData;
isMove = mouse_x_root != mouse.x_root || mouse_y_root != mouse.y_root;
oldstate = mouse_state;
mouse_x_root = mouse.x_root;
mouse_y_root = mouse.y_root;
mouse_state = mouse.state;
}
long unused;
if (filterEvent(event, &unused)) // send through app filter
return 1;
if (qwsEventFilter(event)) // send through app filter
return 1;
#ifndef QT_NO_QWS_PROPERTIES
if (event->type == QWSEvent::PropertyNotify) {
QWSPropertyNotifyEvent *e = static_cast<QWSPropertyNotifyEvent*>(event);
if (e->simpleData.property == 424242) { // Clipboard
#ifndef QT_NO_CLIPBOARD
if (qt_clipboard) {
QClipboardEvent e(reinterpret_cast<QEventPrivate*>(event));
QApplication::sendEvent(qt_clipboard, &e);
}
#endif
}
}
#endif //QT_NO_QWS_PROPERTIES
#ifndef QT_NO_COP
else if (event->type == QWSEvent::QCopMessage) {
QWSQCopMessageEvent *e = static_cast<QWSQCopMessageEvent*>(event);
QCopChannel::sendLocally(QLatin1String(e->channel), QLatin1String(e->message), e->data);
return 0;
}
#endif
#if !defined(QT_NO_QWS_QPF2)
else if (event->type == QWSEvent::Font) {
QWSFontEvent *e = static_cast<QWSFontEvent *>(event);
if (e->simpleData.type == QWSFontEvent::FontRemoved) {
QFontCache::instance()->removeEngineForFont(e->fontName);
}
}
#endif
QPointer<QETWidget> widget = static_cast<QETWidget*>(QWidget::find(WId(event->window())));
#ifdef Q_BACKINGSTORE_SUBSURFACES
if (!widget) { // XXX: hw: hack for accessing subsurfaces
extern QWSWindowSurface* qt_findWindowSurface(int);
QWSWindowSurface *s = qt_findWindowSurface(event->window());
if (s)
widget = static_cast<QETWidget*>(s->window());
}
#endif
#ifndef QT_NO_DIRECTPAINTER
if (!widget && d->directPainters) {
QDirectPainter *dp = d->directPainters->value(WId(event->window()));
if (dp == 0) {
} else if (event->type == QWSEvent::Region) {
QWSRegionEvent *e = static_cast<QWSRegionEvent*>(event);
QRegion reg;
reg.setRects(e->rectangles, e->simpleData.nrectangles);
qt_directpainter_region(dp, reg, e->simpleData.type);
return 1;
#ifndef QT_NO_QWSEMBEDWIDGET
} else if (event->type == QWSEvent::Embed) {
QWSEmbedEvent *e = static_cast<QWSEmbedEvent*>(event);
qt_directpainter_embedevent(dp, e);
return 1;
#endif // QT_NO_QWSEMBEDWIDGET
}
}
#endif // QT_NO_DIRECTPAINTER
#ifndef QT_NO_QWS_MANAGER
if (d->last_manager && event->type == QWSEvent::Mouse) {
QPoint pos(event->asMouse()->simpleData.x_root, event->asMouse()->simpleData.y_root);
if (!d->last_manager->cachedRegion().contains(pos)) {
// MouseEvent not yet delivered, so QCursor::pos() is not yet updated, sending 2 x pos
QMouseEvent outside(QEvent::MouseMove, pos, pos, Qt::NoButton, 0, 0);
QApplication::sendSpontaneousEvent(d->last_manager, &outside);
d->last_manager = 0;
qt_last_cursor = 0xffffffff; //decoration is like another window; must redo cursor
}
}
#endif // QT_NO_QWS_MANAGER
QETWidget *keywidget=0;
bool grabbed=false;
if (event->type==QWSEvent::Key || event->type == QWSEvent::IMEvent || event->type == QWSEvent::IMQuery) {
keywidget = static_cast<QETWidget*>(QWidget::keyboardGrabber());
if (keywidget) {
grabbed = true;
} else {
if (QWidget *popup = QApplication::activePopupWidget()) {
if (popup->focusWidget())
keywidget = static_cast<QETWidget*>(popup->focusWidget());
else
keywidget = static_cast<QETWidget*>(popup);
} else if (QApplicationPrivate::focus_widget && QApplicationPrivate::focus_widget->isVisible())
keywidget = static_cast<QETWidget*>(QApplicationPrivate::focus_widget);
else if (widget)
keywidget = static_cast<QETWidget*>(widget->window());
}
} else if (event->type==QWSEvent::MaxWindowRect) {
QRect r = static_cast<QWSMaxWindowRectEvent*>(event)->simpleData.rect;
setMaxWindowRect(r);
return 0;
#ifndef QT_NO_QWS_DYNAMICSCREENTRANSFORMATION
} else if (event->type == QWSEvent::ScreenTransformation) {
QWSScreenTransformationEvent *pe = static_cast<QWSScreenTransformationEvent*>(event);
setScreenTransformation(pe->simpleData.screen,
pe->simpleData.transformation);
return 0;
#endif
} else if (widget && event->type==QWSEvent::Mouse) {
// The mouse event is to one of my top-level widgets
// which one?
const int btnMask = Qt::LeftButton | Qt::RightButton | Qt::MidButton;
QPoint p(event->asMouse()->simpleData.x_root,
event->asMouse()->simpleData.y_root);
int mouseButtonState = event->asMouse()->simpleData.state & btnMask;
static int btnstate = 0;
QETWidget *w = static_cast<QETWidget*>(QWidget::mouseGrabber());
if (w && !mouseButtonState && qt_pressGrab == w)
qt_pressGrab = 0;
#ifndef QT_NO_QWS_MANAGER
if (!w)
w = static_cast<QETWidget*>(QWSManager::grabbedMouse());
#endif
if (w) {
// Our mouse is grabbed - send it.
widget = w;
btnstate = mouseButtonState;
} else {
static QWidget *gw = 0;
// Three jobs to do here:
// 1. find the child widget this event belongs to.
// 2. make sure the cursor is correct.
// 3. handle implicit mouse grab due to button press.
w = widget; // w is the widget the cursor is in.
//### ??? alloc_region
//#### why should we get events outside alloc_region ????
if (1 /*widget->data->alloc_region.contains(dp) */) {
// Find the child widget that the cursor is in.
w = static_cast<QETWidget*>(widget->childAt(widget->mapFromParent(p)));
if (!w)
w = widget;
#ifndef QT_NO_CURSOR
// Update Cursor.
if (!gw || gw != w || qt_last_cursor == 0xffffffff) {
QCursor *curs = 0;
if (!qApp->d_func()->cursor_list.isEmpty())
curs = &qApp->d_func()->cursor_list.first();
else if (w->d_func()->extraData())
curs = w->d_func()->extraData()->curs;
QWidget *pw = w;
// If this widget has no cursor set, try parent.
while (!curs) {
pw = pw->parentWidget();
if (!pw)
break;
if (pw->d_func()->extraData())
curs = pw->d_func()->extraData()->curs;
}
if (!qws_overrideCursor) {
if (curs)
QPaintDevice::qwsDisplay()->selectCursor(widget, curs->handle());
else
QPaintDevice::qwsDisplay()->selectCursor(widget, Qt::ArrowCursor);
}
}
#endif
gw = w;
} else {
// This event is not for any of our widgets
gw = 0;
}
if (mouseButtonState && !btnstate) {
// The server has grabbed the mouse for us.
// Remember which of my widgets has it.
qt_pressGrab = w;
if (!widget->isActiveWindow() &&
(!app_do_modal || QApplication::activeModalWidget() == widget) &&
!((widget->windowFlags() & Qt::FramelessWindowHint) || (widget->windowType() == Qt::Tool))) {
widget->activateWindow();
if (widget->raiseOnClick())
widget->raise();
}
}
btnstate = mouseButtonState;
widget = w;
}
}
if (!widget) { // don't know this window
if (!QWidget::mouseGrabber()
#ifndef QT_NO_QWS_MANAGER
&& !QWSManager::grabbedMouse()
#endif
) {
qt_last_cursor = 0xffffffff; // cursor can be changed by another application
}
QWidget* popup = QApplication::activePopupWidget();
if (popup) {
/*
That is more than suboptimal. The real solution should
do some keyevent and buttonevent translation, so that
the popup still continues to work as the user expects.
Unfortunately this translation is currently only
possible with a known widget. I'll change that soon
(Matthias).
*/
// Danger - make sure we don't lock the server
switch (event->type) {
case QWSEvent::Mouse:
case QWSEvent::Key:
do {
popup->close();
} while ((popup = qApp->activePopupWidget()));
return 1;
}
}
if (event->type == QWSEvent::Mouse && *mouseInWidget) {
QApplicationPrivate::dispatchEnterLeave(0, *mouseInWidget);
(*mouseInWidget) = 0;
}
return -1;
}
if (app_do_modal) // modal event handling
if (!qt_try_modal(widget, event)) {
return 1;
}
if (widget->qwsEvent(event)) // send through widget filter
return 1;
switch (event->type) {
case QWSEvent::Mouse: { // mouse event
QWSMouseEvent *me = event->asMouse();
QWSMouseEvent::SimpleData &mouse = me->simpleData;
// Translate a QWS event into separate move
// and press/release events
// Beware of reentrancy: we can enter a modal state
// inside translateMouseEvent
if (isMove) {
QWSMouseEvent move = *me;
move.simpleData.state = oldstate;
widget->translateMouseEvent(&move, oldstate);
}
if ((mouse.state&Qt::MouseButtonMask) != (oldstate&Qt::MouseButtonMask)) {
widget->translateMouseEvent(me, oldstate);
}
if (mouse.delta != 0)
widget->translateWheelEvent(me);
if (qt_button_down && (mouse_state & Qt::MouseButtonMask) == 0)
qt_button_down = 0;
break;
}
case QWSEvent::Key: // keyboard event
if (keywidget) // should always exist
keywidget->translateKeyEvent(static_cast<QWSKeyEvent*>(event), grabbed);
break;
#ifndef QT_NO_QWS_INPUTMETHODS
case QWSEvent::IMEvent:
if (keywidget) // should always exist
QWSInputContext::translateIMEvent(keywidget, static_cast<QWSIMEvent*>(event));
break;
case QWSEvent::IMQuery:
if (keywidget) // should always exist
QWSInputContext::translateIMQueryEvent(keywidget, static_cast<QWSIMQueryEvent*>(event));
break;
case QWSEvent::IMInit:
QWSInputContext::translateIMInitEvent(static_cast<QWSIMInitEvent*>(event));
break;
#endif
case QWSEvent::Region:
widget->translateRegionEvent(static_cast<QWSRegionEvent*>(event));
break;
case QWSEvent::Focus:
if ((static_cast<QWSFocusEvent*>(event))->simpleData.get_focus) {
if (widget == static_cast<QWidget *>(desktop()))
return true; // not interesting
if (activeWindow() != widget) {
setActiveWindow(widget);
if (QApplicationPrivate::active_window)
static_cast<QETWidget *>(QApplicationPrivate::active_window)->repaintDecoration(desktop()->rect(), false);
if (widget && !d->inPopupMode()) {
QWidget *w = widget->focusWidget();
while (w && w->focusProxy())
w = w->focusProxy();
if (w && (w->focusPolicy() != Qt::NoFocus))
w->setFocus();
else
widget->QWidget::focusNextPrevChild(true);
if (!QApplicationPrivate::focus_widget) {
if (widget->focusWidget())
widget->focusWidget()->setFocus();
else
widget->window()->setFocus();
}
}
}
} else { // lost focus
if (widget == static_cast<QWidget *>(desktop()))
return true; // not interesting
if (QApplicationPrivate::focus_widget) {
QETWidget *old = static_cast<QETWidget *>(QApplicationPrivate::active_window);
setActiveWindow(0);
qt_last_cursor = 0xffffffff;
//QApplicationPrivate::active_window = 0;
if (old)
old->repaintDecoration(desktop()->rect(), false);
/* activateWindow() sends focus events
QApplication::setFocusWidget(0);
*/
}
}
break;
case QWSEvent::WindowOperation:
if (static_cast<QWidget *>(widget) == desktop())
return true;
switch ((static_cast<QWSWindowOperationEvent *>(event))->simpleData.op) {
case QWSWindowOperationEvent::Show:
widget->show();
break;
case QWSWindowOperationEvent::Hide:
widget->hide();
break;
case QWSWindowOperationEvent::ShowMaximized:
widget->showMaximized();
break;
case QWSWindowOperationEvent::ShowMinimized:
widget->showMinimized();
break;
case QWSWindowOperationEvent::ShowNormal:
widget->showNormal();
break;
case QWSWindowOperationEvent::Close:
widget->d_func()->close_helper(QWidgetPrivate::CloseWithSpontaneousEvent);
break;
}
break;
#ifndef QT_NO_QWSEMBEDWIDGET
case QWSEvent::Embed:
widget->translateEmbedEvent(static_cast<QWSEmbedEvent*>(event));
break;
#endif
default:
break;
}
return 0;
}
bool QApplication::qwsEventFilter(QWSEvent *)
{
return false;
}
void QApplication::qwsSetCustomColors(QRgb *colorTable, int start, int numColors)
{
if (start < 0 || start > 39) {
qWarning("QApplication::qwsSetCustomColors: start < 0 || start > 39");
return;
}
if (start + numColors > 40) {
numColors = 40 - start;
qWarning("QApplication::qwsSetCustomColors: Too many colors");
}
start += 216;
for (int i = 0; i < numColors; i++) {
qt_screen->set(start + i, qRed(colorTable[i]), qGreen(colorTable[i]),
qBlue(colorTable[i]));
}
}
#ifndef QT_NO_QWS_MANAGER
QDecoration &QApplication::qwsDecoration()
{
return *qws_decoration;
}
void QApplication::qwsSetDecoration(QDecoration *dec)
{
if (dec) {
delete qws_decoration;
qws_decoration = dec;
QWidgetList widgets = topLevelWidgets();
for (int i = 0; i < widgets.size(); ++i) {
QWidget *w = widgets[i];
if (w->isVisible() && w != desktop()) {
static_cast<QETWidget *>(w)->updateRegion();
static_cast<QETWidget *>(w)->repaintDecoration(desktop()->rect(), false);
if (w->isMaximized())
w->showMaximized();
}
}
}
}
QDecoration* QApplication::qwsSetDecoration(const QString &decoration)
{
QDecoration *decore = QDecorationFactory::create(decoration);
if (!decore)
return 0;
qwsSetDecoration(decore);
return decore;
}
#endif
bool QApplicationPrivate::modalState()
{
return app_do_modal;
}
void QApplicationPrivate::enterModal_sys(QWidget *widget)
{
if (!qt_modal_stack)
qt_modal_stack = new QWidgetList;
qt_modal_stack->insert(0, widget);
app_do_modal = true;
}
void QApplicationPrivate::leaveModal_sys(QWidget *widget)
{
if (qt_modal_stack && qt_modal_stack->removeAll(widget)) {
if (qt_modal_stack->isEmpty()) {
delete qt_modal_stack;
qt_modal_stack = 0;
}
}
app_do_modal = qt_modal_stack != 0;
}
static bool qt_try_modal(QWidget *widget, QWSEvent *event)
{
QWidget * top = 0;
if (QApplicationPrivate::tryModalHelper(widget, &top))
return true;
bool block_event = false;
bool paint_event = false;
switch (event->type) {
case QWSEvent::Focus:
if (!static_cast<QWSFocusEvent*>(event)->simpleData.get_focus)
break;
// drop through
case QWSEvent::Mouse: // disallow mouse/key events
case QWSEvent::Key:
block_event = true;
break;
}
if (top->parentWidget() == 0 && (block_event || paint_event))
top->raise();
return !block_event;
}
static int openPopupCount = 0;
void QApplicationPrivate::openPopup(QWidget *popup)
{
openPopupCount++;
if (!popupWidgets) { // create list
popupWidgets = new QWidgetList;
/* only grab if you are the first/parent popup */
QPaintDevice::qwsDisplay()->grabMouse(popup,true);
QPaintDevice::qwsDisplay()->grabKeyboard(popup,true);
popupGrabOk = true;
}
popupWidgets->append(popup); // add to end of list
// popups are not focus-handled by the window system (the first
// popup grabbed the keyboard), so we have to do that manually: A
// new popup gets the focus
if (popup->focusWidget()) {
popup->focusWidget()->setFocus(Qt::PopupFocusReason);
} else if (popupWidgets->count() == 1) { // this was the first popup
if (QWidget *fw = QApplication::focusWidget()) {
QFocusEvent e(QEvent::FocusOut, Qt::PopupFocusReason);
QApplication::sendEvent(fw, &e);
}
}
}
void QApplicationPrivate::closePopup(QWidget *popup)
{
if (!popupWidgets)
return;
popupWidgets->removeAll(popup);
if (popup == popupOfPopupButtonFocus) {
popupButtonFocus = 0;
popupOfPopupButtonFocus = 0;
}
if (popupWidgets->count() == 0) { // this was the last popup
popupCloseDownMode = true; // control mouse events
delete popupWidgets;
popupWidgets = 0;
if (popupGrabOk) { // grabbing not disabled
QPaintDevice::qwsDisplay()->grabMouse(popup,false);
QPaintDevice::qwsDisplay()->grabKeyboard(popup,false);
popupGrabOk = false;
// XXX ungrab keyboard
}
if (active_window) {
if (QWidget *fw = active_window->focusWidget()) {
if (fw != QApplication::focusWidget()) {
fw->setFocus(Qt::PopupFocusReason);
} else {
QFocusEvent e(QEvent::FocusIn, Qt::PopupFocusReason);
QApplication::sendEvent(fw, &e);
}
}
}
} else {
// popups are not focus-handled by the window system (the
// first popup grabbed the keyboard), so we have to do that
// manually: A popup was closed, so the previous popup gets
// the focus.
QWidget* aw = popupWidgets->last();
if (QWidget *fw = aw->focusWidget())
fw->setFocus(Qt::PopupFocusReason);
}
}
/*****************************************************************************
Event translation; translates FB events to Qt events
*****************************************************************************/
//
// Mouse event translation
//
// FB doesn't give mouse double click events, so we generate them by
// comparing window, time and position between two mouse press events.
//
// Needed for QCursor::pos
static const int AnyButton = (Qt::LeftButton | Qt::MidButton | Qt::RightButton);
//
// Wheel event translation
//
bool QETWidget::translateWheelEvent(const QWSMouseEvent *me)
{
#ifdef QT_NO_WHEELEVENT
Q_UNUSED(me);
return false;
#else
const QWSMouseEvent::SimpleData &mouse = me->simpleData;
// Figure out wheeling direction:
// Horizontal wheel w/o Alt
// OR Vertical wheel w/ Alt ==> Horizontal wheeling
// ..all other permutations ==> Vertical wheeling
int axis = mouse.delta / 120; // WHEEL_DELTA?
Qt::Orientation orient = ((axis == 2 || axis == -2) && ((mouse.state & Qt::AltModifier) == 0))
||((axis == 1 || axis == -1) && mouse.state & Qt::AltModifier)
? Qt::Horizontal : Qt::Vertical;
QPoint mousePoint = QPoint(mouse.x_root, mouse.y_root);
// send the event to the widget or its ancestors
QWidget* popup = qApp->activePopupWidget();
if (popup && window() != popup)
popup->close();
QWheelEvent we(mapFromGlobal(mousePoint), mousePoint, mouse.delta,
Qt::MouseButtons(mouse.state & Qt::MouseButtonMask),
Qt::KeyboardModifiers(mouse.state & Qt::KeyboardModifierMask), orient);
if (QApplication::sendSpontaneousEvent(this, &we))
return true;
// send the event to the widget that has the focus or its ancestors, if different
QWidget *w = this;
if (w != qApp->focusWidget() && (w = qApp->focusWidget())) {
QWidget* popup = qApp->activePopupWidget();
if (popup && w != popup)
popup->hide();
if (QApplication::sendSpontaneousEvent(w, &we))
return true;
}
return false;
#endif
}
bool QETWidget::translateMouseEvent(const QWSMouseEvent *event, int prevstate)
{
static bool manualGrab = false;
QPoint pos;
QPoint globalPos;
int button = 0;
if (sm_blockUserInput) // block user interaction during session management
return true;
const QWSMouseEvent::SimpleData &mouse = event->simpleData;
pos = mapFromGlobal(QPoint(mouse.x_root, mouse.y_root));
// if (qt_last_x) {
// *qt_last_x=mouse.x_root;
// *qt_last_y=mouse.y_root;
// }
globalPos.rx() = mouse.x_root;
globalPos.ry() = mouse.y_root;
QEvent::Type type = QEvent::None;
Qt::MouseButtons buttonstate = Qt::MouseButtons(mouse.state & Qt::MouseButtonMask);
Qt::KeyboardModifiers keystate = Qt::KeyboardModifiers(mouse.state & Qt::KeyboardModifierMask);
if (mouse.state == prevstate) {
// mouse move
type = QEvent::MouseMove;
} else if ((mouse.state&AnyButton) != (prevstate&AnyButton)) {
Qt::MouseButtons current_buttons = Qt::MouseButtons(prevstate&Qt::MouseButtonMask);
for (button = Qt::LeftButton; !type && button <= Qt::MidButton; button<<=1) {
if ((mouse.state&button) != (current_buttons&button)) {
// button press or release
current_buttons = Qt::MouseButtons(current_buttons ^ button);
#ifndef QT_NO_QWS_INPUTMETHODS
//############ We used to do a QInputContext::reset(oldFocus);
// when we changed the focus widget. See change 93389 for where the
// focus code went. The IM code was (after testing for ClickToFocus):
//if (mouse.state&button && w != QInputContext::microFocusWidget()) //button press
// QInputContext::reset(oldFocus);
#endif
if (mouse.state&button) { //button press
qt_button_down = childAt(pos);
if (!qt_button_down)
qt_button_down = this;
if (/*XXX mouseActWindow == this &&*/
mouseButtonPressed == button &&
long(mouse.time) -long(mouseButtonPressTime)
< QApplication::doubleClickInterval() &&
qAbs(mouse.x_root - mouseXPos) < mouse_double_click_distance &&
qAbs(mouse.y_root - mouseYPos) < mouse_double_click_distance ) {
type = QEvent::MouseButtonDblClick;
mouseButtonPressTime -= 2000; // no double-click next time
} else {
type = QEvent::MouseButtonPress;
mouseButtonPressTime = mouse.time;
}
mouseButtonPressed = button; // save event params for
mouseXPos = globalPos.x(); // future double click tests
mouseYPos = globalPos.y();
} else { // mouse button released
if (manualGrab) { // release manual grab
manualGrab = false;
// XXX XUngrabPointer(x11Display(), CurrentTime);
}
type = QEvent::MouseButtonRelease;
}
}
}
button >>= 1;
}
//XXX mouseActWindow = winId(); // save some event params
if (type == 0) { // event consumed
return false; //EXIT in the normal case
}
if (qApp->d_func()->inPopupMode()) { // in popup mode
QWidget *popup = qApp->activePopupWidget();
// in X11, this would be the window we are over.
// in QWS this is the top level popup. to allow mouse
// events to other widgets, need to go through qApp->QApplicationPrivate::popupWidgets.
QSize s(qt_screen->width(), qt_screen->height());
for (int i = 0; i < QApplicationPrivate::popupWidgets->size(); ++i) {
QWidget *w = QApplicationPrivate::popupWidgets->at(i);
if ((w->windowType() == Qt::Popup) && w->d_func()->localAllocatedRegion().contains(globalPos - w->geometry().topLeft()))
{
popup = w;
break;
}
}
pos = popup->mapFromGlobal(globalPos);
bool releaseAfter = false;
QWidget *popupChild = popup->childAt(pos);
QWidget *popupTarget = popupChild ? popupChild : popup;
if (popup != popupOfPopupButtonFocus){
popupButtonFocus = 0;
popupOfPopupButtonFocus = 0;
}
if (!popupTarget->isEnabled()) {
return false; //EXIT special case
}
switch (type) {
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
popupButtonFocus = popupChild;
popupOfPopupButtonFocus = popup;
break;
case QEvent::MouseButtonRelease:
releaseAfter = true;
break;
default:
break; // nothing for mouse move
}
int oldOpenPopupCount = openPopupCount;
if (popupButtonFocus) {
QMouseEvent e(type, popupButtonFocus->mapFromGlobal(globalPos),
globalPos, Qt::MouseButton(button), buttonstate, keystate);
QApplication::sendSpontaneousEvent(popupButtonFocus, & e);
if (releaseAfter) {
popupButtonFocus = 0;
popupOfPopupButtonFocus = 0;
}
} else if (popupChild) {
QMouseEvent e(type, popupChild->mapFromGlobal(globalPos),
globalPos, Qt::MouseButton(button), buttonstate, keystate);
QApplication::sendSpontaneousEvent(popupChild, & e);
} else {
QMouseEvent e(type, pos, globalPos, Qt::MouseButton(button), buttonstate, keystate);
QApplication::sendSpontaneousEvent(popupChild ? popupChild : popup, & e);
}
#ifndef QT_NO_CONTEXTMENU
if (type == QEvent::MouseButtonPress && button == Qt::RightButton && (openPopupCount == oldOpenPopupCount)) {
QWidget *popupEvent = popup;
if(popupButtonFocus)
popupEvent = popupButtonFocus;
else if(popupChild)
popupEvent = popupChild;
QContextMenuEvent e(QContextMenuEvent::Mouse, pos, globalPos, keystate);
QApplication::sendSpontaneousEvent(popupEvent, &e);
}
#endif // QT_NO_CONTEXTMENU
if (releaseAfter)
qt_button_down = 0;
} else { //qApp not in popup mode
QWidget *widget = this;
QWidget *w = QWidget::mouseGrabber();
if (!w && qt_button_down)
w = qt_button_down;
if (w && w != this) {
widget = w;
pos = mapToGlobal(pos);
pos = w->mapFromGlobal(pos);
}
if (popupCloseDownMode) {
popupCloseDownMode = false;
if ((windowType() == Qt::Popup)) // ignore replayed event
return true; //EXIT
}
QPointer<QWidget> leaveAfterRelease = 0;
if (type == QEvent::MouseButtonRelease &&
(mouse.state & (~button) & (Qt::LeftButton |
Qt::MidButton |
Qt::RightButton)) == 0) {
// Button released outside the widget -> leave the widget after the
// release event has been delivered.
if (widget == qt_button_down && (pos.x() < 0 || pos.y() < 0))
leaveAfterRelease = qt_button_down;
qt_button_down = 0;
}
int oldOpenPopupCount = openPopupCount;
QMouseEvent e(type, pos, globalPos, Qt::MouseButton(button), buttonstate, keystate);
#ifndef QT_NO_QWS_MANAGER
if (widget->isWindow() && widget->d_func()->topData()->qwsManager
&& (widget->d_func()->topData()->qwsManager->region().contains(globalPos)
|| QWSManager::grabbedMouse() )) {
if ((*mouseInWidget)) {
QApplicationPrivate::dispatchEnterLeave(0, *mouseInWidget);
(*mouseInWidget) = 0;
}
QApplication::sendSpontaneousEvent(widget->d_func()->topData()->qwsManager, &e);
qApp->d_func()->last_manager = widget->d_func()->topData()->qwsManager;
} else
#endif
{
if (widget != (*mouseInWidget)) {
QApplicationPrivate::dispatchEnterLeave(widget, *mouseInWidget);
(*mouseInWidget) = widget;
qt_last_mouse_receiver = widget;
}
QApplication::sendSpontaneousEvent(widget, &e);
if (leaveAfterRelease && !QWidget::mouseGrabber()) {
*mouseInWidget = QApplication::widgetAt(globalPos);
qt_last_mouse_receiver = *mouseInWidget;
QApplicationPrivate::dispatchEnterLeave(*mouseInWidget, leaveAfterRelease);
leaveAfterRelease = 0;
}
}
#ifndef QT_NO_CONTEXTMENU
if (type == QEvent::MouseButtonPress && button == Qt::RightButton && (openPopupCount == oldOpenPopupCount)) {
QContextMenuEvent e(QContextMenuEvent::Mouse, pos, globalPos, keystate);
QApplication::sendSpontaneousEvent(widget, &e);
}
#endif // QT_NO_CONTEXTMENU
}
return true;
}
bool QETWidget::translateKeyEvent(const QWSKeyEvent *event, bool grab) /* grab is used in the #ifdef */
{
int code = -1;
//### Qt assumes keyboard state is state *before*, while QWS uses state after the event
static Qt::KeyboardModifiers oldstate;
Qt::KeyboardModifiers state = oldstate;
oldstate = event->simpleData.modifiers;
if (sm_blockUserInput) // block user interaction during session management
return true;
if (!isEnabled())
return true;
QEvent::Type type = event->simpleData.is_press ?
QEvent::KeyPress : QEvent::KeyRelease;
bool autor = event->simpleData.is_auto_repeat;
QString text;
char ascii = 0;
if (event->simpleData.unicode) {
QChar ch(event->simpleData.unicode);
if (ch.unicode() != 0xffff)
text += ch;
ascii = ch.toLatin1();
}
code = event->simpleData.keycode;
#if defined QT3_SUPPORT && !defined(QT_NO_SHORTCUT)
if (type == QEvent::KeyPress && !grab
&& static_cast<QApplicationPrivate*>(qApp->d_ptr.data())->use_compat()) {
// send accel events if the keyboard is not grabbed
QKeyEvent a(type, code, state, text, autor, int(text.length()));
if (static_cast<QApplicationPrivate*>(qApp->d_ptr.data())->qt_tryAccelEvent(this, &a))
return true;
}
#else
Q_UNUSED(grab);
#endif
if (!text.isEmpty() && testAttribute(Qt::WA_KeyCompression)) {
// the widget wants key compression so it gets it
// XXX not implemented
}
QKeyEvent e(type, code, state, text, autor, int(text.length()));
return QApplication::sendSpontaneousEvent(this, &e);
}
bool QETWidget::translateRegionEvent(const QWSRegionEvent *event)
{
QWSWindowSurface *surface = static_cast<QWSWindowSurface*>(windowSurface());
Q_ASSERT(surface);
QRegion region;
region.setRects(event->rectangles, event->simpleData.nrectangles);
switch (event->simpleData.type) {
case QWSRegionEvent::Allocation:
region.translate(-mapToGlobal(QPoint()));
surface->setClipRegion(region);
break;
#ifdef QT_QWS_CLIENTBLIT
case QWSRegionEvent::DirectPaint:
surface->setDirectRegion(region, event->simpleData.id);
break;
#endif
default:
break;
}
return true;
}
#ifndef QT_NO_QWSEMBEDWIDGET
void QETWidget::translateEmbedEvent(const QWSEmbedEvent *event)
{
if (event->simpleData.type | QWSEmbedEvent::Region) {
const QRegion region = event->region;
setGeometry(region.boundingRect());
setVisible(!region.isEmpty());
}
}
#endif // QT_NO_QWSEMBEDWIDGET
void QETWidget::repaintDecoration(QRegion r, bool post)
{
Q_UNUSED(post);
#ifdef QT_NO_QWS_MANAGER
Q_UNUSED(r);
#else
//please note that qwsManager is a QObject, not a QWidget.
//therefore, normal ways of painting do not work.
// However, it does listen to paint events.
Q_D(QWidget);
if (isWindow() && d->topData()->qwsManager && isVisible()) {
QWSManager *manager = d->topData()->qwsManager;
r &= manager->region();
if (!r.isEmpty())
manager->repaintRegion(QDecoration::All, QDecoration::Normal);
}
#endif
}
void QETWidget::updateRegion()
{
Q_D(QWidget);
QTLWExtra *topextra = d->maybeTopData();
if (!topextra)
return;
QRegion myregion = d->localRequestedRegion();
myregion.translate(geometry().topLeft());
#ifndef QT_NO_QWS_MANAGER
QWSManager *manager = topextra->qwsManager;
if (manager)
myregion += manager->region();
#endif
QRect br(myregion.boundingRect());
topextra->frameStrut.setCoords(d->data.crect.x() - br.x(),
d->data.crect.y() - br.y(),
br.right() - d->data.crect.right(),
br.bottom() - d->data.crect.bottom());
}
void QApplication::setCursorFlashTime(int msecs)
{
QApplicationPrivate::cursor_flash_time = msecs;
}
int QApplication::cursorFlashTime()
{
return QApplicationPrivate::cursor_flash_time;
}
void QApplication::setDoubleClickInterval(int ms)
{
QApplicationPrivate::mouse_double_click_time = ms;
}
int QApplication::doubleClickInterval()
{
return QApplicationPrivate::mouse_double_click_time;
}
void QApplication::setKeyboardInputInterval(int ms)
{
QApplicationPrivate::keyboard_input_time = ms;
}
int QApplication::keyboardInputInterval()
{
return QApplicationPrivate::keyboard_input_time;
}
#ifndef QT_NO_WHEELEVENT
void QApplication::setWheelScrollLines(int lines)
{
QApplicationPrivate::wheel_scroll_lines = lines;
}
int QApplication::wheelScrollLines()
{
return QApplicationPrivate::wheel_scroll_lines;
}
#endif
void QApplication::setEffectEnabled(Qt::UIEffect effect, bool enable)
{
switch (effect) {
case Qt::UI_AnimateMenu:
QApplicationPrivate::animate_menu = enable;
break;
case Qt::UI_FadeMenu:
if (enable)
QApplicationPrivate::animate_menu = true;
QApplicationPrivate::fade_menu = enable;
break;
case Qt::UI_AnimateCombo:
QApplicationPrivate::animate_combo = enable;
break;
case Qt::UI_AnimateTooltip:
QApplicationPrivate::animate_tooltip = enable;
break;
case Qt::UI_FadeTooltip:
if (enable)
QApplicationPrivate::animate_tooltip = true;
QApplicationPrivate::fade_tooltip = enable;
break;
case Qt::UI_AnimateToolBox:
QApplicationPrivate::animate_toolbox = enable;
break;
default:
QApplicationPrivate::animate_ui = enable;
break;
}
}
bool QApplication::isEffectEnabled(Qt::UIEffect effect)
{
if (QColormap::instance().depth() < 16 || !QApplicationPrivate::animate_ui)
return false;
switch(effect) {
case Qt::UI_AnimateMenu:
return QApplicationPrivate::animate_menu;
case Qt::UI_FadeMenu:
return QApplicationPrivate::fade_menu;
case Qt::UI_AnimateCombo:
return QApplicationPrivate::animate_combo;
case Qt::UI_AnimateTooltip:
return QApplicationPrivate::animate_tooltip;
case Qt::UI_FadeTooltip:
return QApplicationPrivate::fade_tooltip;
case Qt::UI_AnimateToolBox:
return QApplicationPrivate::animate_toolbox;
default:
return QApplicationPrivate::animate_ui;
}
}
void QApplication::setArgs(int c, char **v)
{
Q_D(QApplication);
d->argc = c;
d->argv = v;
}
void QApplicationPrivate::initializeMultitouch_sys()
{ }
void QApplicationPrivate::cleanupMultitouch_sys()
{ }
/* \internal
This is used to clean up the qws server
in case the QApplication constructor threw an exception
*/
QWSServerCleaner::~QWSServerCleaner()
{
if (qwsServer && qws_single_process)
QWSServer::closedown();
}
QT_END_NAMESPACE