Initial revision

1 files changed, 1597 insertions, 0 deletions

diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
new file mode 100644
index 0000000..f0a68cf
--- a/dev/null
+++ b/library/qpeapplication.cpp
@@ -0,0 +1,1597 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+** $Id$
+**
+**********************************************************************/
+#include <stdlib.h>
+#include <unistd.h>
+#include <qfile.h>
+#ifdef Q_WS_QWS
+#ifndef QT_NO_COP
+#if QT_VERSION <= 231
+#define private public
+#define sendLocally processEvent
+#include "qcopenvelope_qws.h"
+#undef private
+#else
+#include "qcopenvelope_qws.h"
+#endif
+#endif
+#include <qwindowsystem_qws.h>
+#endif
+#include <qtextstream.h>
+#include <qpalette.h>
+#include <qbuffer.h>
+#include <qptrdict.h>
+#include <qregexp.h>
+#include <qdir.h>
+#include <qlabel.h>
+#include <qdialog.h>
+#include <qdragobject.h>
+#include <qevent.h>
+#include <qtooltip.h>
+#include <qsignal.h>
+#include "qpeapplication.h"
+#include "qpestyle.h"
+#if QT_VERSION >= 300
+#include <qstylefactory.h>
+#else
+#include <qplatinumstyle.h>
+#include <qwindowsstyle.h>
+#include <qmotifstyle.h>
+#include <qmotifplusstyle.h>
+#include "lightstyle.h"
+#endif
+#include "global.h"
+#include "resource.h"
+#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
+#include "qutfcodec.h"
+#endif
+#include "config.h"
+#include "network.h"
+#include "fontmanager.h"
+#include "power.h"
+#include "alarmserver.h"
+#include "applnk.h"
+#include "qpemenubar.h"
+
+#include <unistd.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+
+// for setBacklight()
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#include <linux/fb.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+#include <stdlib.h>
+
+
+class QPEApplicationData {
+public:
+    QPEApplicationData() : presstimer(0), presswidget(0), rightpressed(FALSE),
+        kbgrabber(0), kbregrab(FALSE), notbusysent(FALSE), preloaded(FALSE),
+        forceshow(FALSE), nomaximize(FALSE), qpe_main_widget(0),
+        keep_running(TRUE)
+    {
+        qcopq.setAutoDelete(TRUE);
+    }
+
+    int presstimer;
+    QWidget* presswidget;
+    QPoint presspos;
+    bool rightpressed;
+    int kbgrabber;
+    bool kbregrab;
+    bool notbusysent;
+    QString appName;
+    struct QCopRec {
+        QCopRec(const QCString &ch, const QCString &msg,
+                               const QByteArray &d) :
+            channel(ch), message(msg), data(d) { }
+
+        QCString channel;
+        QCString message;
+        QByteArray data;
+    };
+    bool preloaded;
+    bool forceshow;
+    bool nomaximize;
+    QWidget* qpe_main_widget;
+    bool keep_running;
+    QList<QCopRec> qcopq;
+
+    void enqueueQCop(const QCString &ch, const QCString &msg,
+                               const QByteArray &data)
+    {
+        qcopq.append(new QCopRec(ch,msg,data));
+    }
+    void sendQCopQ()
+    {
+        QCopRec* r;
+        for (QListIterator<QCopRec> it(qcopq); (r=it.current()); ++it)
+            QCopChannel::sendLocally(r->channel,r->message,r->data);
+        qcopq.clear();
+    }
+};
+
+class ResourceMimeFactory : public QMimeSourceFactory {
+public:
+    ResourceMimeFactory()
+    {
+        QStringList path;
+        QString lang = getenv("LANG");
+        if ( !lang.isEmpty() )
+            path += QPEApplication::qpeDir() + "/help/" + lang + "/html";
+        path += QPEApplication::qpeDir() + "/pics";
+        path += QPEApplication::qpeDir() + "/help/en/html";
+        path += QPEApplication::qpeDir() + "/docs";
+        QString dir = QDir::current().canonicalPath();
+        if ( dir == "/" )
+            dir += "/docs";
+        else {
+            path += dir + "/../pics";
+            dir += "/../docs";
+            path += dir;
+        }
+        setFilePath( path );
+        setExtensionType("html","text/html;charset=UTF-8");
+    }
+
+    const QMimeSource* data(const QString& abs_name) const
+    {
+        const QMimeSource* r = QMimeSourceFactory::data(abs_name);
+        if ( !r ) {
+            int sl = abs_name.length();
+            do {
+                sl = abs_name.findRev('/',sl-1);
+                QString name = sl>=0 ? abs_name.mid(sl+1) : abs_name;
+                int dot = name.findRev('.');
+                if ( dot >= 0 )
+                    name = name.left(dot);
+                QImage img = Resource::loadImage(name);
+                if ( !img.isNull() )
+                    r = new QImageDrag(img);
+            } while (!r && sl>0);
+        }
+        return r;
+    }
+};
+
+static int muted=0;
+
+static void setVolume(int t=0, int percent=-1)
+{
+    switch (t) {
+        case 0: {
+            Config cfg("Sound");
+            cfg.setGroup("System");
+            if ( percent < 0 )
+                percent = cfg.readNumEntry("Volume",50);
+            int fd = 0;
+            if ((fd = open("/dev/mixer", O_RDWR))>=0) {
+                int vol = muted ? 0 : percent;
+                // set both channels to same volume
+                vol |= vol << 8;
+                ioctl(fd, MIXER_WRITE(0), &vol);
+                ::close(fd);
+            }
+        } break;
+    }
+}
+
+int qpe_sysBrightnessSteps()
+{
+#if defined(QT_QWS_IPAQ)
+    return 255;
+#elif defined(QT_QWS_EBX)
+    return 4;
+#else
+    return 255; // ?
+#endif
+}
+
+
+static int& hack(int& i)
+{
+#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
+    // These should be created, but aren't in Qt 2.3.0
+    (void)new QUtf8Codec;
+    (void)new QUtf16Codec;
+#endif
+    return i;
+}
+
+static bool forced_off = FALSE;
+static int curbl=-1;
+
+static int backlight()
+{
+    if ( curbl == -1 ) {
+        // Read from config
+        Config config( "qpe" );
+        config.setGroup( "Screensaver" );
+        curbl = config.readNumEntry("Brightness",255);
+    }
+    return curbl;
+}
+
+static void setBacklight(int bright)
+{
+    if ( bright == -3 ) {
+        // Forced on
+        forced_off = FALSE;
+        bright = -1;
+    }
+    if ( forced_off && bright != -2 )
+        return;
+    if ( bright == -2 ) {
+        // Toggle between off and on
+        bright = curbl ? 0 : -1;
+        forced_off = !bright;
+    }
+    if ( bright == -1 ) {
+        // Read from config
+        Config config( "qpe" );
+        config.setGroup( "Screensaver" );
+        bright = config.readNumEntry("Brightness",255);
+    }
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+    if ( QFile::exists("/usr/bin/bl") ) {
+        QString cmd = "/usr/bin/bl 1 ";
+        cmd += bright<=0 ? "0 " : "1 ";
+        cmd += QString::number(bright);
+        system(cmd.latin1());
+#if defined(QT_QWS_EBX)
+    } else if ( QFile::exists("/dev/fl") ) {
+#define FL_IOCTL_STEP_CONTRAST    100
+        int fd = open("/dev/fl", O_WRONLY);
+        if (fd >= 0 ) {
+            int steps = qpe_sysBrightnessSteps();
+            int bl = ( bright * steps + 127 ) / 255;
+            if ( bright && !bl ) bl = 1;
+            bl = ioctl(fd, FL_IOCTL_STEP_CONTRAST, bl);
+            close(fd);
+        }
+    }
+#elif defined(QT_QWS_IPAQ)
+    } else if ( QFile::exists("/dev/ts") || QFile::exists("/dev/h3600_ts") ) {
+        typedef struct {
+            unsigned char mode;
+            unsigned char pwr;
+            unsigned char brightness;
+        } FLITE_IN;
+# ifndef FLITE_ON
+#  ifndef _LINUX_IOCTL_H
+#   include <linux/ioctl.h>
+#  endif
+#  define FLITE_ON                _IOW('f', 7, FLITE_IN)
+# endif
+        int fd;
+        if ( QFile::exists("/dev/ts") )
+            fd = open("/dev/ts", O_WRONLY);
+        else
+            fd = open("/dev/h3600_ts", O_WRONLY);
+        if (fd >= 0 ) {
+            FLITE_IN bl;
+            bl.mode = 1;
+            bl.pwr = bright ? 1 : 0;
+            bl.brightness = bright;
+            ioctl(fd, FLITE_ON, &bl);
+            close(fd);
+        }
+    }
+#endif
+#endif
+    curbl = bright;
+}
+
+void qpe_setBacklight(int bright) { setBacklight(bright); }
+
+static bool dim_on = FALSE;
+static bool lightoff_on = FALSE;
+static int disable_suspend = 100;
+
+static bool powerOnline()
+{
+    return PowerStatusManager::readStatus().acStatus() == PowerStatus::Online;
+}
+
+static bool networkOnline()
+{
+    return Network::networkOnline();
+}
+
+class QPEScreenSaver : public QWSScreenSaver
+{
+
+public:
+    QPEScreenSaver()
+    {
+    }
+    void restore()
+    {
+        setBacklight(-1);
+    }
+    bool save(int level)
+    {
+        switch ( level ) {
+         case 0:
+            if ( disable_suspend > 0 && dim_on ) {
+                if (backlight() > 1)
+                    setBacklight(1); // lowest non-off
+            }
+            return TRUE;
+            break;
+         case 1:
+            if ( disable_suspend > 1 && lightoff_on ) {
+                setBacklight(0); // off
+            }
+            return TRUE;
+            break;
+         case 2:
+             if ( disable_suspend > 2 && !powerOnline() && !networkOnline() ) {
+                QWSServer::sendKeyEvent( 0xffff, Qt::Key_F34, FALSE, TRUE, FALSE );
+                return TRUE;
+             }
+            break;
+        }
+        return FALSE;
+    }
+};
+
+static int ssi(int interval, Config &config, const QString &enable, const QString& value, int def)
+{
+    if ( !enable.isEmpty() && config.readNumEntry(enable,0) == 0 )
+        return 0;
+
+    if ( interval < 0 ) {
+        // Restore screen blanking and power saving state
+        interval = config.readNumEntry( value, def );
+    }
+    return interval;
+}
+
+static void setScreenSaverIntervals(int i1, int i2, int i3)
+{
+    Config config( "qpe" );
+    config.setGroup( "Screensaver" );
+
+    int v[4];
+    i1 = ssi(i1, config, "Dim","Interval_Dim", 30);
+    i2 = ssi(i2, config, "LightOff","Interval_LightOff", 20);
+    i3 = ssi(i3, config, "","Interval", 60);
+
+    //qDebug("screen saver intervals: %d %d %d", i1, i2, i3);
+
+    v[0] = QMAX( 1000*i1, 100);
+    v[1] = QMAX( 1000*i2, 100);
+    v[2] = QMAX( 1000*i3, 100);
+    v[3] = 0;
+    dim_on = ( (i1 != 0) ? config.readNumEntry("Dim",1) : FALSE );
+    lightoff_on = ( (i2 != 0 ) ? config.readNumEntry("LightOff",1) : FALSE );
+    if ( !i1 && !i2 && !i3 )
+        QWSServer::setScreenSaverInterval(0);
+    else
+        QWSServer::setScreenSaverIntervals(v);
+}
+
+static void setScreenSaverInterval(int interval)
+{
+    setScreenSaverIntervals(-1,-1,interval);
+}
+
+
+/*!
+  \class QPEApplication qpeapplication.h
+  \brief The QPEApplication class implements various system services
+    that are available to all Qtopia applications.
+
+  Simply by using QPEApplication instead of QApplication, a plain Qt
+  application becomes a Qtopia application. It automatically follows
+  style changes, quits and raises, and in the
+  case of \link docwidget.html document-oriented\endlink applications,
+  changes the current displayed document in response to the environment.
+*/
+
+/*!
+  \fn void QPEApplication::clientMoused()
+
+  \internal
+*/
+
+/*!
+  \fn void QPEApplication::timeChanged();
+
+  This signal is emitted when the time jumps forward or backwards
+  by more than the normal passage of time.
+*/
+
+/*!
+  \fn void QPEApplication::clockChanged( bool ampm );
+
+  This signal is emitted when the user changes the style
+  of clock. If \a ampm is TRUE, the user wants a 12-hour
+  AM/PM close, otherwise, they want a 24-hour clock.
+*/
+
+/*!
+  \fn void QPEApplication::appMessage( const QCString& msg, const QByteArray& data )
+
+  This signal is emitted when a message is received on the
+  QPE/Application/<i>appname</i> QCop channel for this application.
+
+  The slot to which you connect this signal uses \a msg and \a data
+  in the following way:
+
+\code
+    void MyWidget::receive( const QCString& msg, const QByteArray& data )
+    {
+        QDataStream stream( data, IO_ReadOnly );
+        if ( msg == "someMessage(int,int,int)" ) {
+            int a,b,c;
+            stream >> a >> b >> c;
+            ...
+        } else if ( msg == "otherMessage(QString)" ) {
+            ...
+        }
+    }
+\endcode
+
+  \sa qcop.html
+*/
+
+/*!
+  Constructs a QPEApplication just as you would construct
+  a QApplication, passing \a argc, \a argv, and \a t.
+*/
+QPEApplication::QPEApplication( int& argc, char **argv, Type t )
+    : QApplication( hack(argc), argv, t )
+{
+    int dw = desktop()->width();
+    if ( dw < 200 ) {
+        setFont( QFont( "helvetica", 8 ) );
+        AppLnk::setSmallIconSize(10);
+        AppLnk::setBigIconSize(28);
+    }
+
+    d = new QPEApplicationData;
+    QMimeSourceFactory::setDefaultFactory(new ResourceMimeFactory);
+
+    connect(this, SIGNAL(lastWindowClosed()), this, SLOT(hideOrQuit()));
+#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+
+    QString qcopfn("/tmp/qcop-msg-");
+    qcopfn += QString(argv[0]); // append command name
+
+    QFile f(qcopfn);
+    if ( f.open(IO_ReadOnly) ) {
+        flock(f.handle(), LOCK_EX);
+    }
+
+    sysChannel = new QCopChannel( "QPE/System", this );
+    connect( sysChannel, SIGNAL(received(const QCString &, const QByteArray &)),
+             this, SLOT(systemMessage( const QCString &, const QByteArray &)) );
+
+    QCString channel = QCString(argv[0]);
+    channel.replace(QRegExp(".*/"),"");
+    d->appName = channel;
+    channel = "QPE/Application/" + channel;
+    pidChannel = new QCopChannel( channel, this);
+    connect( pidChannel, SIGNAL(received(const QCString &, const QByteArray &)),
+            this, SLOT(pidMessage(const QCString &, const QByteArray &)));
+
+    if ( f.isOpen() ) {
+        d->keep_running = FALSE;
+        QDataStream ds(&f);
+        QCString channel, message;
+        QByteArray data;
+        while(!ds.atEnd()) {
+            ds >> channel >> message >> data;
+            d->enqueueQCop(channel,message,data);
+        }
+
+        flock(f.handle(), LOCK_UN);
+        f.close();
+        f.remove();
+    }
+
+    for (int a=0; a<argc; a++) {
+        if ( qstrcmp(argv[a],"-preload")==0 ) {
+            argv[a] = argv[a+1];
+            a++;
+            d->preloaded = TRUE;
+            argc-=1;
+        } else if ( qstrcmp(argv[a],"-preload-show")==0 ) {
+            argv[a] = argv[a+1];
+            a++;
+            d->preloaded = TRUE;
+            d->forceshow = TRUE;
+            argc-=1;
+        }
+    }
+
+    /* overide stored arguments */
+    setArgs(argc, argv);
+
+#endif
+
+    qwsSetDecoration( new QPEDecoration() );
+
+#ifndef QT_NO_TRANSLATION
+    char *l = getenv( "LANG" );
+    QString lang;
+    if ( l ) {
+        lang = l;
+
+        /*
+    Config config("qpe");
+    config.setGroup( "Appearance" );
+    lang = config.readEntry( "Language", lang );
+    */
+
+        QTranslator * trans = new QTranslator(this);
+        QString tfn = qpeDir()+"/i18n/"+lang+"/"+d->appName+".qm";
+        if ( trans->load( tfn ))
+            installTranslator( trans );
+        else
+            delete trans;
+
+        trans = new QTranslator(this);
+        tfn = qpeDir()+"/i18n/"+lang+"/libqpe.qm";
+        if ( trans->load( tfn ))
+            installTranslator( trans );
+        else
+            delete trans;
+
+    //###language/font hack; should look it up somewhere
+        if ( lang == "ja" || lang == "zh_CN" || lang == "zh_TW" || lang == "ko" ) {
+            QFont fn = FontManager::unicodeFont( FontManager::Proportional );
+            setFont( fn );
+        }
+    }
+#endif
+
+    applyStyle();
+
+    if ( type() == GuiServer ) {
+        setScreenSaverInterval(-1);
+        setVolume();
+        QWSServer::setScreenSaver(new QPEScreenSaver);
+    }
+
+    installEventFilter( this );
+
+    QPEMenuToolFocusManager::initialize();
+
+#ifdef QT_NO_QWS_CURSOR
+    // if we have no cursor, probably don't want tooltips
+    QToolTip::setEnabled( FALSE );
+#endif
+}
+
+static QPtrDict<void>* inputMethodDict=0;
+static void createInputMethodDict()
+{
+    if ( !inputMethodDict )
+        inputMethodDict = new QPtrDict<void>;
+}
+
+/*!
+  Returns the currently set hint to the system as to whether
+  \a w has any use for text input methods.
+
+  \sa setInputMethodHint()
+*/
+QPEApplication::InputMethodHint QPEApplication::inputMethodHint( QWidget* w )
+{
+    if ( inputMethodDict && w )
+        return (InputMethodHint)(int)inputMethodDict->find(w);
+    return Normal;
+}
+
+/*!
+    \enum QPEApplication::InputMethodHint
+
+    \value Normal the application sometimes needs text input (the default).
+    \value AlwaysOff the application never needs text input.
+    \value AlwaysOn the application always needs text input.
+*/
+
+/*!
+  Hints to the system that \a w has use for text input methods
+  as specified by \a mode.
+
+  \sa inputMethodHint()
+*/
+void QPEApplication::setInputMethodHint( QWidget* w, InputMethodHint mode )
+{
+    createInputMethodDict();
+    if ( mode == Normal ) {
+        inputMethodDict->remove(w);
+    } else {
+        inputMethodDict->insert(w,(void*)mode);
+    }
+}
+
+class HackDialog : public QDialog
+{
+public:
+    void acceptIt() { accept(); }
+    void rejectIt() { reject(); }
+};
+
+
+void QPEApplication::mapToDefaultAction( QWSKeyEvent *ke, int key )
+{
+    // specialised actions for certain widgets. May want to
+    // add more stuff here.
+    if ( activePopupWidget() && activePopupWidget()->inherits( "QListBox" )
+         && activePopupWidget()->parentWidget()
+         && activePopupWidget()->parentWidget()->inherits( "QComboBox" ) )
+        key = Qt::Key_Return;
+
+    if ( activePopupWidget() && activePopupWidget()->inherits( "QPopupMenu" ) )
+        key = Qt::Key_Return;
+
+    ke->simpleData.keycode = key;
+}
+
+class HackWidget : public QWidget
+{
+public:
+    bool needsOk()
+    { return (getWState() & WState_Reserved1 ); }
+};
+
+/*!
+  \internal
+*/
+bool QPEApplication::qwsEventFilter( QWSEvent *e )
+{
+    if ( !d->notbusysent && e->type == QWSEvent::Focus ) {
+        if ( qApp->type() != QApplication::GuiServer ) {
+            QCopEnvelope e("QPE/System", "notBusy(QString)" );
+            e << d->appName;
+        }
+        d->notbusysent=TRUE;
+    }
+    if ( type() == GuiServer ) {
+        switch ( e->type ) {
+            case QWSEvent::Mouse:
+                if ( e->asMouse()->simpleData.state && !QWidget::find(e->window()) )
+                    emit clientMoused();
+        }
+    }
+    if ( e->type == QWSEvent::Key ) {
+        if ( d->kbgrabber == 1 )
+            return TRUE;
+        QWSKeyEvent *ke = (QWSKeyEvent *)e;
+        if ( ke->simpleData.keycode == Qt::Key_F33 ) {
+            // Use special "OK" key to press "OK" on top level widgets
+            QWidget *active = activeWindow();
+            QWidget *popup = 0;
+            if ( active && active->isPopup() ) {
+                popup = active;
+                active = active->parentWidget();
+            }
+            if ( active && (int)active->winId() == ke->simpleData.window &&
+                 !active->testWFlags( WStyle_Customize|WType_Popup|WType_Desktop )) {
+                if ( ke->simpleData.is_press ) {
+                    if ( popup )
+                        popup->close();
+                    if ( active->inherits( "QDialog" ) ) {
+                        HackDialog *d = (HackDialog *)active;
+                        d->acceptIt();
+                        return TRUE;
+                    } else if ( ((HackWidget *)active)->needsOk() ) {
+                        QSignal s;
+                        s.connect( active, SLOT( accept() ) );
+                        s.activate();
+                    } else {
+                        // do the same as with the select key: Map to the default action of the widget:
+                        mapToDefaultAction( ke, Qt::Key_Return );
+                    }
+                }
+            }
+        } else if ( ke->simpleData.keycode == Qt::Key_F30 ) {
+            // Use special "select" key to do whatever default action a widget has
+            mapToDefaultAction( ke, Qt::Key_Space );
+        } else if ( ke->simpleData.keycode == Qt::Key_Escape && 
+                    ke->simpleData.is_press ) {
+            // Escape key closes app if focus on toplevel
+            QWidget *active = activeWindow();
+            if ( active && active->testWFlags( WType_TopLevel ) && 
+                 (int)active->winId() == ke->simpleData.window &&
+                 !active->testWFlags( WStyle_Dialog|WStyle_Customize|WType_Popup|WType_Desktop )) {
+                if ( active->inherits( "QDialog" ) ) {
+                    HackDialog *d = (HackDialog *)active;
+                    d->rejectIt();
+                    return TRUE;
+                } else if ( strcmp( argv()[0], "embeddedkonsole") != 0 ) {
+                    active->close();
+                }
+            }
+        }
+
+#if QT_VERSION < 231
+    // Filter out the F4/Launcher key from apps
+    // ### The launcher key may not always be F4 on all devices
+        if ( ((QWSKeyEvent *)e)->simpleData.keycode == Qt::Key_F4 )
+            return TRUE;
+#endif
+    }
+    if ( e->type == QWSEvent::Focus ) {
+        QWSFocusEvent *fe = (QWSFocusEvent*)e;
+        QWidget* nfw = QWidget::find(e->window());
+        if ( !fe->simpleData.get_focus ) {
+            QWidget *active = activeWindow();
+            while ( active && active->isPopup() ) {
+                active->close();
+                active = activeWindow();
+            }
+            if ( !nfw && d->kbgrabber == 2 ) {
+                ungrabKeyboard();
+                d->kbregrab = TRUE; // want kb back when we're active
+            }
+        } else {
+            // make sure our modal widget is ALWAYS on top
+            QWidget *topm = activeModalWidget();
+            if ( topm ) {
+                topm->raise();
+            }
+            if ( d->kbregrab ) {
+                grabKeyboard();
+                d->kbregrab = FALSE;
+            }
+        }
+        if ( fe->simpleData.get_focus && inputMethodDict ) {
+            InputMethodHint m = inputMethodHint( QWidget::find(e->window()) );
+            if ( m == AlwaysOff )
+                Global::hideInputMethod();
+            if ( m == AlwaysOn )
+                Global::showInputMethod();
+        }
+    }
+    return QApplication::qwsEventFilter( e );
+}
+
+/*!
+  Destroys the QPEApplication.
+*/
+QPEApplication::~QPEApplication()
+{
+    ungrabKeyboard();
+#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
+    // Need to delete QCopChannels early, since the display will
+    // be gone by the time we get to ~QObject().
+    delete sysChannel;
+    delete pidChannel;
+#endif
+    delete d;
+}
+
+/*!
+  Returns <tt>$QPEDIR/</tt>.
+*/
+QString QPEApplication::qpeDir()
+{
+    const char *base = getenv( "QPEDIR" );
+    if ( base )
+        return QString( base ) + "/";
+
+    return QString( "../" );
+}
+
+/*!
+  Returns the user's current Document directory. There is a trailing "/".
+*/
+QString QPEApplication::documentDir()
+{
+    const char *base = getenv( "HOME" );
+    if ( base )
+        return QString( base ) + "/Documents/";
+
+    return QString( "../Documents/" );
+}
+
+static int deforient=-1;
+
+/*!
+  \internal
+*/
+int QPEApplication::defaultRotation()
+{
+    if ( deforient < 0 ) {
+        QString d = getenv("QWS_DISPLAY");
+        if ( d.contains("Rot90") ) {
+            deforient = 90;
+        } else if ( d.contains("Rot180") ) {
+            deforient = 180;
+        } else if ( d.contains("Rot270") ) {
+            deforient = 270;
+        } else {
+            deforient=0;
+        }
+    }
+    return deforient;
+}
+
+/*!
+  \internal
+*/
+void QPEApplication::setDefaultRotation(int r)
+{
+    if ( qApp->type() == GuiServer ) {
+        deforient = r;
+        setenv("QWS_DISPLAY", QString("Transformed:Rot%1:0").arg(r).latin1(), 1);
+    } else {
+        QCopEnvelope("QPE/System", "setDefaultRotation(int)") << r;
+    }
+}
+
+/*!
+  \internal
+*/
+void QPEApplication::applyStyle()
+{
+    Config config( "qpe" );
+
+    config.setGroup( "Appearance" );
+
+    // Widget style
+    QString style = config.readEntry( "Style", "Light" );
+    internalSetStyle( style );
+
+    // Colors
+    QColor bgcolor( config.readEntry( "Background", "#E5E1D5" ) );
+    QColor btncolor( config.readEntry( "Button", "#D6CDBB" ) );
+    QPalette pal( btncolor, bgcolor );
+    QString color = config.readEntry( "Highlight", "#800000" );
+    pal.setColor( QColorGroup::Highlight, QColor(color) );
+    color = config.readEntry( "HighlightedText", "#FFFFFF" );
+    pal.setColor( QColorGroup::HighlightedText, QColor(color) );
+    color = config.readEntry( "Text", "#000000" );
+    pal.setColor( QColorGroup::Text, QColor(color) );
+    color = config.readEntry( "ButtonText", "#000000" );
+    pal.setColor( QPalette::Active, QColorGroup::ButtonText, QColor(color) );
+    color = config.readEntry( "Base", "#FFFFFF" );
+    pal.setColor( QColorGroup::Base, QColor(color) );
+
+    pal.setColor( QPalette::Disabled, QColorGroup::Text,
+                  pal.color(QPalette::Active, QColorGroup::Background).dark() );
+
+    setPalette( pal, TRUE );
+}
+
+void QPEApplication::systemMessage( const QCString &msg, const QByteArray &data)
+{
+#ifdef Q_WS_QWS
+    QDataStream stream( data, IO_ReadOnly );
+    if ( msg == "applyStyle()" ) {
+        applyStyle();
+    } else if ( msg == "setScreenSaverInterval(int)" ) {
+        if ( type() == GuiServer ) {
+            int time;
+            stream >> time;
+            setScreenSaverInterval(time);
+        }
+    } else if ( msg == "setScreenSaverIntervals(int,int,int)" ) {
+        if ( type() == GuiServer ) {
+            int t1,t2,t3;
+            stream >> t1 >> t2 >> t3;
+            setScreenSaverIntervals(t1,t2,t3);
+        }
+    } else if ( msg == "setBacklight(int)" ) {
+        if ( type() == GuiServer ) {
+            int bright;
+            stream >> bright;
+            setBacklight(bright);
+        }
+    } else if ( msg == "setDefaultRotation(int)" ) {
+        if ( type() == GuiServer ) {
+            int r;
+            stream >> r;
+            setDefaultRotation(r);
+        }
+    } else if ( msg == "shutdown()" ) {
+        if ( type() == GuiServer )
+            shutdown();
+    } else if ( msg == "quit()" ) {
+        if ( type() != GuiServer )
+            tryQuit();
+    } else if ( msg == "forceQuit()" ) {
+        if ( type() != GuiServer )
+            quit(); 
+    } else if ( msg == "restart()" ) {
+        if ( type() == GuiServer )
+            restart();
+    } else if ( msg == "grabKeyboard(QString)" ) {
+        QString who;
+        stream >> who;
+        if ( who.isEmpty() )
+            d->kbgrabber = 0;
+        else if ( who != d->appName )
+            d->kbgrabber = 1;
+        else
+            d->kbgrabber = 2;
+    } else if ( msg == "language(QString)" ) {
+        if ( type() == GuiServer ) {
+            QString l;
+            stream >> l;
+            QString cl = getenv("LANG");
+            if ( cl != l ) {
+                if ( l.isNull() )
+                    unsetenv( "LANG" );
+                else
+                    setenv( "LANG", l.latin1(), 1 );
+                restart();
+            }
+        }
+    } else if ( msg == "timeChange(QString)" ) {
+        QString t;
+        stream >> t;
+        if ( t.isNull() )
+            unsetenv( "TZ" );
+        else
+            setenv( "TZ", t.latin1(), 1 );
+        // emit the signal so everyone else knows...
+        emit timeChanged();
+    } else if ( msg == "execute(QString)" ) {
+        if ( type() == GuiServer ) {
+            QString t;
+            stream >> t;
+            Global::execute( t );
+        }
+    } else if ( msg == "execute(QString,QString)" ) {
+        if ( type() == GuiServer ) {
+            QString t,d;
+            stream >> t >> d;
+            Global::execute( t, d );
+        }
+    } else if ( msg == "addAlarm(QDateTime,QCString,QCString,int)" ) {
+        if ( type() == GuiServer ) {
+            QDateTime when;
+            QCString channel, message;
+            int data;
+            stream >> when >> channel >> message >> data;
+            AlarmServer::addAlarm( when, channel, message, data );
+        }
+    } else if ( msg == "deleteAlarm(QDateTime,QCString,QCString,int)" ) {
+        if ( type() == GuiServer ) {
+            QDateTime when;
+            QCString channel, message;
+            int data;
+            stream >> when >> channel >> message >> data;
+            AlarmServer::deleteAlarm( when, channel, message, data );
+        }
+    } else if ( msg == "clockChange(bool)" ) {
+        int tmp;
+        stream >> tmp;
+        emit clockChanged( tmp );
+    } else if ( msg == "weekChange(bool)" ) {
+        int tmp;
+        stream >> tmp;
+        emit weekChanged( tmp );
+    } else if ( msg == "setDateFormat(DateFormat)" ) {
+        DateFormat tmp;
+        stream >> tmp;
+        emit dateFormatChanged( tmp );
+    } else if ( msg == "setVolume(int,int)" ) {
+        int t,v;
+        stream >> t >> v;
+        setVolume(t,v);
+        emit volumeChanged( muted );
+    } else if ( msg == "volumeChange(bool)" ) {
+        stream >> muted;
+        setVolume();
+        emit volumeChanged( muted );
+    } else if ( msg == "setScreenSaverMode(int)" ) {
+        if ( type() == GuiServer ) {
+            int old = disable_suspend;
+            stream >> disable_suspend;
+            //qDebug("setScreenSaverMode(%d)", disable_suspend );
+            if ( disable_suspend > old )
+                setScreenSaverInterval( -1 );
+        }
+    }
+#endif
+}
+
+/*!
+  \internal
+*/
+bool QPEApplication::raiseAppropriateWindow()
+{
+    bool r=FALSE;
+    // ########## raise()ing main window should raise and set active
+    // ########## it and then all childen. This belongs in Qt/Embedded
+    QWidget *top = d->qpe_main_widget;
+    if ( !top ) top =mainWidget();
+    if ( top && d->keep_running ) {
+        if ( top->isVisible() )
+            r = TRUE;
+#ifdef Q_WS_QWS
+        if ( !d->nomaximize )
+            top->showMaximized();
+        else
+#endif
+            top->show();
+        top->raise();
+        top->setActiveWindow();
+    }
+    QWidget *topm = activeModalWidget();
+    if ( topm && topm != top ) {
+        topm->show();
+        topm->raise();
+        topm->setActiveWindow();
+        r = FALSE;
+    }
+    return r;
+}
+
+void QPEApplication::pidMessage( const QCString &msg, const QByteArray & data)
+{
+#ifdef Q_WS_QWS
+
+    if ( msg == "quit()" ) {
+        tryQuit();
+    } else if ( msg == "quitIfInvisible()" ) {
+        if ( d->qpe_main_widget && !d->qpe_main_widget->isVisible() )
+            quit();
+    } else if ( msg == "close()" ) {
+        hideOrQuit();
+    } else if ( msg == "disablePreload()" ) {
+        d->preloaded = FALSE;
+        d->keep_running = TRUE;
+        /* so that quit will quit */
+    } else if ( msg == "enablePreload()" ) {
+        d->preloaded = TRUE;
+        d->keep_running = TRUE;
+        /* so next quit won't quit */
+    } else if ( msg == "raise()" ) {
+        d->keep_running = TRUE;
+        d->notbusysent = FALSE;
+        raiseAppropriateWindow();
+    } else if ( msg == "flush()" ) {
+        emit flush();
+        // we need to tell the desktop
+        QCopEnvelope e( "QPE/Desktop", "flushDone(QString)" );
+        e << d->appName;
+    } else if ( msg == "reload()" ) {
+        emit reload();
+    } else if ( msg == "setDocument(QString)" ) {
+        d->keep_running = TRUE;
+        QDataStream stream( data, IO_ReadOnly );
+        QString doc;
+        stream >> doc;
+        QWidget *mw = mainWidget();
+        if ( !mw )
+            mw = d->qpe_main_widget;
+        if ( mw )
+            Global::setDocument( mw, doc );
+    } else if ( msg == "nextView()" ) {
+        if ( raiseAppropriateWindow() )
+            emit appMessage( msg, data);
+    } else {
+        emit appMessage( msg, data);
+    }
+#endif
+}
+
+
+static bool setWidgetCaptionFromAppName( QWidget* /*mw*/, const QString& /*appName*/, const QString& /*appsPath*/ )
+{
+/*
+    // This works but disable it for now until it is safe to apply
+    // What is does is scan the .desktop files of all the apps for
+    // the applnk that has the corresponding argv[0] as this program
+    // then it uses the name stored in the .desktop file as the caption
+    // for the main widget. This saves duplicating translations for
+    // the app name in the program and in the .desktop files.
+
+    AppLnkSet apps( appsPath );
+
+    QList<AppLnk> appsList = apps.children();
+    for ( QListIterator<AppLnk> it(appsList); it.current(); ++it ) {
+        if ( (*it)->exec() == appName ) {
+            mw->setCaption( (*it)->name() );
+            return TRUE;
+        }
+    }
+*/
+    return FALSE;
+}
+
+
+/*!
+  Sets \a mw as the mainWidget() and shows it. For small windows,
+  consider passing TRUE for \a nomaximize rather than the default FALSE.
+
+  \sa showMainDocumentWidget()
+*/
+void QPEApplication::showMainWidget( QWidget* mw, bool nomaximize )
+{
+    setWidgetCaptionFromAppName( mw, d->appName, qpeDir() + "apps" );
+
+    d->nomaximize = nomaximize;
+    d->qpe_main_widget = mw;
+    d->sendQCopQ();
+    if ( d->preloaded ) {
+        if(d->forceshow) {
+#ifdef Q_WS_QWS
+            if ( !nomaximize )
+                mw->showMaximized();
+            else
+#endif
+            mw->show();
+        }
+    } else if ( d->keep_running ) {
+#ifdef Q_WS_QWS
+        if ( !nomaximize )
+            mw->showMaximized();
+        else
+#endif
+        mw->show();
+    }
+}
+
+/*!
+  Sets \a mw as the mainWidget() and shows it. For small windows,
+  consider passing TRUE for \a nomaximize rather than the default FALSE.
+
+  This calls designates the application as
+  a \link docwidget.html document-oriented\endlink application.
+
+  The \a mw widget must have a slot: setDocument(const QString&).
+
+  \sa showMainWidget()
+*/
+void QPEApplication::showMainDocumentWidget( QWidget* mw, bool nomaximize )
+{
+    setWidgetCaptionFromAppName( mw, d->appName, qpeDir() + "apps" );
+
+    if ( mw && argc() == 2 )
+        Global::setDocument( mw, QString::fromUtf8(argv()[1]) );
+    d->nomaximize = nomaximize;
+    d->qpe_main_widget = mw;
+    d->sendQCopQ();
+    if ( d->preloaded ) {
+        if(d->forceshow) {
+#ifdef Q_WS_QWS
+            if ( !nomaximize )
+                mw->showMaximized();
+            else
+#endif
+            mw->show();
+        }
+    } else if ( d->keep_running ) {
+#ifdef Q_WS_QWS
+        if ( !nomaximize )
+            mw->showMaximized();
+        else
+#endif
+        mw->show();
+    }
+}
+
+
+/*!
+  Sets that the application should continue running after processing
+  qcop messages.  Normally if an application is started via a qcop message,
+  the application will process the qcop message and then quit.  If while
+  processing the qcop message it calls this function, then the application
+  will show and start proper once it has finished processing qcop messages.
+
+  \sa keepRunning()
+*/
+void QPEApplication::setKeepRunning()
+{
+    if ( qApp && qApp->inherits( "QPEApplication" ) ) {
+        QPEApplication *qpeApp = (QPEApplication*)qApp;
+        qpeApp->d->keep_running = TRUE;
+    }
+}
+
+/*!
+  Returns whether the application will quit after processing the current
+  list of qcop messages.  
+
+  \sa setKeepRunning()
+*/
+bool QPEApplication::keepRunning() const
+{
+    return d->keep_running;
+}
+
+/*!
+  \internal
+*/
+void QPEApplication::internalSetStyle( const QString &style )
+{
+#if QT_VERSION >= 300
+    if ( style == "QPE" ) {
+        setStyle( new QPEStyle );
+    } else {
+        QStyle *s = QStyleFactory::create(style);
+        if ( s ) setStyle(s);
+    }
+#else
+    if ( style == "Windows" ) {
+        setStyle( new QWindowsStyle );
+    } else if ( style == "QPE" ) {
+        setStyle( new QPEStyle );
+    } else if ( style == "Light" ) {
+        setStyle( new LightStyle );
+    }
+#ifndef QT_NO_STYLE_PLATINUM
+    else if ( style == "Platinum" ) {
+        setStyle( new QPlatinumStyle );
+    }
+#endif
+#ifndef QT_NO_STYLE_MOTIF
+    else if ( style == "Motif" ) {
+        setStyle( new QMotifStyle );
+    }
+#endif
+#ifndef QT_NO_STYLE_MOTIFPLUS
+    else if ( style == "MotifPlus" ) {
+        setStyle( new QMotifPlusStyle );
+    }
+#endif
+#endif
+}
+
+/*!
+  \internal
+*/
+void QPEApplication::prepareForTermination(bool willrestart)
+{
+    if ( willrestart ) {
+        // Draw a big wait icon, the image can be altered in later revisions
+        //QWidget *d = QApplication::desktop();
+        QImage img = Resource::loadImage( "wait" );
+        QPixmap pix;
+        pix.convertFromImage(img.smoothScale(3*img.width(), 3*img.height()));
+        QLabel *lblWait = new QLabel(0, "wait hack!", QWidget::WStyle_Customize |
+                                  QWidget::WStyle_NoBorder | QWidget::WStyle_Tool );
+        lblWait->setPixmap( pix );
+        lblWait->setAlignment( QWidget::AlignCenter );
+        lblWait->show();
+        lblWait->showMaximized();
+    }
+#ifndef SINGLE_APP
+    { QCopEnvelope envelope("QPE/System", "forceQuit()"); }
+    processEvents(); // ensure the message goes out.
+    sleep(1); // You have 1 second to comply.
+#endif
+}
+
+/*!
+  \internal
+*/
+void QPEApplication::shutdown()
+{
+    // Implement in server's QPEApplication subclass
+}
+
+/*!
+  \internal
+*/
+void QPEApplication::restart()
+{
+    // Implement in server's QPEApplication subclass
+}
+
+static QPtrDict<void>* stylusDict=0;
+static void createDict()
+{
+    if ( !stylusDict )
+        stylusDict = new QPtrDict<void>;
+}
+
+/*!
+  Returns the current StylusMode for \a w.
+
+  \sa setStylusOperation()
+*/
+QPEApplication::StylusMode QPEApplication::stylusOperation( QWidget* w )
+{
+    if ( stylusDict )
+        return (StylusMode)(int)stylusDict->find(w);
+    return LeftOnly;
+}
+
+/*!
+    \enum QPEApplication::StylusMode
+
+    \value LeftOnly the stylus only generates LeftButton
+                        events (the default).
+    \value RightOnHold the stylus generates RightButton events
+                        if the user uses the press-and-hold gesture.
+
+    See setStylusOperation().
+*/
+
+/*!
+  Causes \a w to receive mouse events according to \a mode.
+
+  \sa stylusOperation()
+*/
+void QPEApplication::setStylusOperation( QWidget* w, StylusMode mode )
+{
+    createDict();
+    if ( mode == LeftOnly ) {
+        stylusDict->remove(w);
+        w->removeEventFilter(qApp);
+    } else {
+        stylusDict->insert(w,(void*)mode);
+        connect(w,SIGNAL(destroyed()),qApp,SLOT(removeSenderFromStylusDict()));
+        w->installEventFilter(qApp);
+    }
+}
+
+
+/*!
+  \reimp
+*/
+bool QPEApplication::eventFilter( QObject *o, QEvent *e )
+{
+    if ( stylusDict && e->type() >= QEvent::MouseButtonPress && e->type() <= QEvent::MouseMove ) {
+        QMouseEvent* me = (QMouseEvent*)e;
+        if ( me->button() == LeftButton ) {
+            StylusMode mode = (StylusMode)(int)stylusDict->find(o);
+            switch (mode) {
+              case RightOnHold:
+                switch ( me->type() ) {
+                  case QEvent::MouseButtonPress:
+                    d->presstimer = startTimer(500); // #### pref.
+                    d->presswidget = (QWidget*)o;
+                    d->presspos = me->pos();
+                    d->rightpressed = FALSE;
+                    break;
+                  case QEvent::MouseButtonRelease:
+                    if ( d->presstimer ) {
+                        killTimer(d->presstimer);
+                        d->presstimer = 0;
+                    }
+                    if ( d->rightpressed && d->presswidget ) {
+                        // Right released
+                        postEvent( d->presswidget,
+                            new QMouseEvent( QEvent::MouseButtonRelease, me->pos(),
+                                    RightButton, LeftButton+RightButton ) );
+                        // Left released, off-widget
+                        postEvent( d->presswidget,
+                            new QMouseEvent( QEvent::MouseMove, QPoint(-1,-1),
+                                    LeftButton, LeftButton ) );
+                        postEvent( d->presswidget,
+                            new QMouseEvent( QEvent::MouseButtonRelease, QPoint(-1,-1),
+                                    LeftButton, LeftButton ) );
+                        d->rightpressed = FALSE;
+                        return TRUE; // don't send the real Left release
+                    }
+                    break;
+                  default:
+                    break;
+                }
+                break;
+              default:
+                ;
+            }
+        }
+    } else if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
+        QKeyEvent *ke = (QKeyEvent *)e;
+        if ( ke->key() == Key_Enter ) {
+            if ( o->isA( "QRadioButton" ) || o->isA( "QCheckBox" ) ) {
+                postEvent( o, new QKeyEvent( e->type(), Key_Space, ' ',
+                    ke->state(), " ", ke->isAutoRepeat(), ke->count() ) );
+                return TRUE;
+            }
+        }
+    }
+
+    return FALSE;
+}
+
+/*!
+  \reimp
+*/
+void QPEApplication::timerEvent( QTimerEvent *e )
+{
+    if ( e->timerId() == d->presstimer && d->presswidget ) {
+        // Right pressed
+        postEvent( d->presswidget,
+            new QMouseEvent( QEvent::MouseButtonPress, d->presspos,
+                        RightButton, LeftButton ) );
+        killTimer( d->presstimer );
+        d->presstimer = 0;
+        d->rightpressed = TRUE;
+    }
+}
+
+void QPEApplication::removeSenderFromStylusDict()
+{
+    stylusDict->remove((void*)sender());
+    if ( d->presswidget == sender() )
+        d->presswidget = 0;
+}
+
+/*!
+  \internal
+*/
+bool QPEApplication::keyboardGrabbed() const
+{
+    return d->kbgrabber;
+}
+
+
+/*!
+  Reverses the effect of grabKeyboard(). This is called automatically
+  on program exit.
+*/
+void QPEApplication::ungrabKeyboard()
+{
+    QPEApplicationData* d = ((QPEApplication*)qApp)->d;
+    if ( d->kbgrabber == 2 ) {
+        QCopEnvelope e("QPE/System", "grabKeyboard(QString)" );
+        e << QString::null;
+        d->kbregrab = FALSE;
+        d->kbgrabber = 0;
+    }
+}
+
+/*!
+  Grabs the keyboard such that the system's application launching
+  keys no longer work, and instead they are receivable by this
+  application.
+
+  \sa ungrabKeyboard()
+*/
+void QPEApplication::grabKeyboard()
+{
+    QPEApplicationData* d = ((QPEApplication*)qApp)->d;
+    if ( qApp->type() == QApplication::GuiServer )
+        d->kbgrabber = 0;
+    else {
+        QCopEnvelope e("QPE/System", "grabKeyboard(QString)" );
+        e << d->appName;
+        d->kbgrabber = 2; // me
+    }
+}
+
+/*!
+  \reimp
+*/
+int QPEApplication::exec()
+{
+    d->sendQCopQ();
+    if ( d->keep_running)
+        //|| d->qpe_main_widget && d->qpe_main_widget->isVisible() )
+        return QApplication::exec();
+
+    {
+    QCopEnvelope e("QPE/System", "closing(QString)" );
+    e << d->appName;
+    }
+    processEvents();
+    return 0;
+}
+
+/*!
+  \internal
+  External request for application to quit.  Quits if possible without
+  loosing state.
+*/
+void QPEApplication::tryQuit()
+{
+    if ( activeModalWidget() || strcmp( argv()[0], "embeddedkonsole") == 0 )
+        return; // Inside modal loop or konsole. Too hard to save state.
+    {
+       QCopEnvelope e("QPE/System", "closing(QString)" );
+       e << d->appName;
+    }
+    processEvents();
+
+    quit();
+}
+
+/*!
+  \internal
+  User initiated quit.  Makes the window 'Go Away'.  If preloaded this means
+  hiding the window.  If not it means quitting the application.
+  As this is user initiated we don't need to check state.
+*/
+void QPEApplication::hideOrQuit()
+{
+    // notify of our demise :)
+    {
+       QCopEnvelope e("QPE/System", "closing(QString)" );
+       e << d->appName;
+    }
+    processEvents();
+    if ( d->preloaded && d->qpe_main_widget )
+        d->qpe_main_widget->hide();
+    else
+        quit();
+}
+
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+
+// The libraries with the skiff package (and possibly others) have
+// completely useless implementations of builtin new and delete that
+// use about 50% of your CPU. Here we revert to the simple libc
+// functions.
+
+void* operator new[](size_t size)
+{
+    return malloc(size);
+}
+
+void* operator new(size_t size)
+{
+    return malloc(size);
+}
+
+void operator delete[](void* p)
+{
+    free(p);
+}
+
+void operator delete[](void* p, size_t /*size*/)
+{
+    free(p);
+}
+
+void operator delete(void* p)
+{
+    free(p);
+}
+
+void operator delete(void* p, size_t /*size*/)
+{
+    free(p);
+}
+
+#endif
+
+#if ( QT_VERSION <= 230 ) && !defined(SINGLE_APP)
+#include <qwidgetlist.h>
+#include <qgfx_qws.h>
+extern QRect qt_maxWindowRect;
+void qt_setMaxWindowRect(const QRect& r)
+{
+    qt_maxWindowRect = qt_screen->mapFromDevice(r,
+        qt_screen->mapToDevice(QSize(qt_screen->width(),qt_screen->height())));
+    // Re-resize any maximized windows
+    QWidgetList* l = QApplication::topLevelWidgets();
+    if ( l ) {
+        QWidget *w = l->first();
+        while ( w ) {
+            if ( w->isVisible() && w->isMaximized() )
+            {
+                w->showMaximized();
+            }
+            w = l->next();
+        }
+        delete l;
+    }
+}
+#endif