From 15318cad33835e4e2dc620d033e43cd930676cdd Mon Sep 17 00:00:00 2001 From: kergoth Date: Fri, 25 Jan 2002 22:14:26 +0000 Subject: Initial revision --- (limited to 'library/qpeapplication.cpp') 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 +#include +#include +#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 +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "qpeapplication.h" +#include "qpestyle.h" +#if QT_VERSION >= 300 +#include +#else +#include +#include +#include +#include +#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 +#include +#include +#include + +// for setBacklight() +#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX) +#include +#include +#include +#endif +#include + + +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 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 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 +# 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/appname 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; apreloaded = 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* inputMethodDict=0; +static void createInputMethodDict() +{ + if ( !inputMethodDict ) + inputMethodDict = new QPtrDict; +} + +/*! + 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 $QPEDIR/. +*/ +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 appsList = apps.children(); + for ( QListIterator 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* stylusDict=0; +static void createDict() +{ + if ( !stylusDict ) + stylusDict = new QPtrDict; +} + +/*! + 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 +#include +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 -- cgit v0.9.0.2