small additions to support grabbing the buttons back from a crashed

application

2 files changed, 13 insertions, 0 deletions

diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index 852671a..b26933b 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -42,128 +42,129 @@
 #include <qbuffer.h>
 #include <qptrdict.h>
 #include <qregexp.h>
 #include <qdir.h>
 #include <qlabel.h>
 #include <qdialog.h>
 #include <qdragobject.h>
 #include <qtextcodec.h>
 #include <qevent.h>
 #include <qtooltip.h>
 #include <qsignal.h>
 #include "qpeapplication.h"
 #include "qpestyle.h"
 #include "styleinterface.h"
 #if QT_VERSION >= 300
 #include <qstylefactory.h>
 #else
 #include <qplatinumstyle.h>
 #include <qwindowsstyle.h>
 #include <qmotifstyle.h>
 #include <qmotifplusstyle.h>
 #include "lightstyle.h"
 
 #include <qpe/qlibrary.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"
 #ifdef QWS
 #include "fontmanager.h"
 #endif
 
 #include "alarmserver.h"
 #include "applnk.h"
 #include "qpemenubar.h"
 #include "textcodecinterface.h"
 #include "imagecodecinterface.h"
 
 #include <unistd.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 
 #include "qt_override_p.h"
 
 
 class QPEApplicationData
 {
 public:
         QPEApplicationData() : presstimer( 0 ), presswidget( 0 ), kbgrabber( 0 ),
                         rightpressed( FALSE ),  kbregrab( FALSE ), notbusysent( FALSE ), preloaded( FALSE ),
                         forceshow( FALSE ), nomaximize( FALSE ), keep_running( TRUE ), qpe_main_widget( 0 )
 
         {
                 qcopq.setAutoDelete( TRUE );
         }
 
         int presstimer;
         QWidget* presswidget;
         int kbgrabber;
+        QString kbgrabber_appname;
         QPoint presspos;
 
         bool rightpressed : 1;
         bool kbregrab     : 1;
         bool notbusysent  : 1;
         bool preloaded    : 1;
         bool forceshow    : 1;
         bool nomaximize   : 1;
         bool keep_running : 1;
 
         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;
         };
         QWidget* qpe_main_widget;
         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;
 #ifndef QT_NO_COP
 
                 for ( QListIterator<QCopRec> it( qcopq ); ( r = it.current() ); ++it )
                         QCopChannel::sendLocally( r->channel, r->message, r->data );
 #endif
 
                 qcopq.clear();
         }
         static void show_mx(QWidget* mw, bool nomaximize)
         {
                 if ( mw->layout() && mw->inherits("QDialog") ) {
                         QPEApplication::showDialog((QDialog*)mw, nomaximize);
                 }
                 else {
 #ifdef Q_WS_QWS
                         if ( !nomaximize )
                                 mw->showMaximized();
                         else
 #endif
 
                                 mw->show();
                 }
         }
         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
@@ -1003,128 +1004,130 @@ void QPEApplication::applyStyle()
 
         //qDebug ( "Setting Deco: %s -- old %s (%d)", dec.latin1(), d-> decorationName.latin1(), nostyle);
 
         if ( dec != d->decorationName ) {
                 qwsSetDecoration( new QPEDecoration( dec ) );
                 d->decorationName = dec;
         }
 
         // Font
         QString ff = config.readEntry( "FontFamily", font().family() );
         int fs = config.readNumEntry( "FontSize", font().pointSize() );
 
         // don't set a custom font
         if ( nostyle & Opie::Force_Font ) {
                 ff = "Helvetica";
                 fs = 10;
         }
 
         setFont ( QFont ( ff, fs ), true );
 
         // revert to global blocking policy ...
         Opie::force_appearance = config. readBoolEntry ( "ForceStyle", false ) ? Opie::Force_All : Opie::Force_None;
         Opie::force_appearance &= ~nostyle;
 }
 
 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 == "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;
+                        
+                d-> kbgrabber_appname = who;
         }
         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;
@@ -1563,128 +1566,136 @@ bool QPEApplication::eventFilter( QObject *o, QEvent *e )
                                                                 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;
 }
 
+/*!
+  \internal
+*/
+QString QPEApplication::keyboardGrabbedBy() const
+{
+        return d->kbgrabber_appname;
+}
+
 
 /*!
   Reverses the effect of grabKeyboard(). This is called automatically
   on program exit.
 */
 void QPEApplication::ungrabKeyboard()
 {
         QPEApplicationData * d = ( ( QPEApplication* ) qApp ) ->d;
         if ( d->kbgrabber == 2 ) {
 #ifndef QT_NO_COP
                 QCopEnvelope e( "QPE/System", "grabKeyboard(QString)" );
                 e << QString::null;
 #endif
 
                 d->kbregrab = FALSE;
                 d->kbgrabber = 0;
         }
 }
 
 /*!
   Grabs the physical keyboard keys, e.g. the application's launching
   keys. Instead of launching applications when these keys are pressed
   the signals emitted are sent to this application instead. Some games
   programs take over the launch keys in this way to make interaction
   easier.
 
   \sa ungrabKeyboard()
 */
 void QPEApplication::grabKeyboard()
 {
         QPEApplicationData * d = ( ( QPEApplication* ) qApp ) ->d;
         if ( qApp->type() == QApplication::GuiServer )
                 d->kbgrabber = 0;
         else {
 #ifndef QT_NO_COP
                 QCopEnvelope e( "QPE/System", "grabKeyboard(QString)" );
                 e << d->appName;
 #endif
 
                 d->kbgrabber = 2; // me
         }
 }
 
 /*!
   \reimp
 */
 int QPEApplication::exec()
 {
 #ifndef QT_NO_COP
         d->sendQCopQ();
 #endif
 
         if ( d->keep_running )
                 //|| d->qpe_main_widget && d->qpe_main_widget->isVisible() )
                 return QApplication::exec();
 
 #ifndef QT_NO_COP
 
         {
                 QCopEnvelope e( "QPE/System", "closing(QString)" );
                 e << d->appName;
         }
 #endif
         processEvents();
diff --git a/library/qpeapplication.h b/library/qpeapplication.h
index 86affa6..f712077 100644
--- a/library/qpeapplication.h
+++ b/library/qpeapplication.h
@@ -1,148 +1,150 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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.
 **
 **********************************************************************/
 #ifndef __QPE_APPLICATION_H__
 #define __QPE_APPLICATION_H__
 
 
 #include <qapplication.h>
 #include <qdialog.h>
 #if defined(_WS_QWS_) && !defined(Q_WS_QWS)
 #define Q_WS_QWS
 #endif
 #include "qpedecoration_qws.h"
 #include "timestring.h"
 
 class QCopChannel;
 class QPEApplicationData;
 class QWSEvent;
 class QWSKeyEvent;
 
+
 class QPEApplication : public QApplication
 {
     Q_OBJECT
 public:
     QPEApplication( int& argc, char **argv, Type=GuiClient );
     ~QPEApplication();
 
     static QString qpeDir();
     static QString documentDir();
     void applyStyle();
     static int defaultRotation();
     static void setDefaultRotation(int r);
     static void grabKeyboard();
     static void ungrabKeyboard();
 
     enum StylusMode {
         LeftOnly,
         RightOnHold
         // RightOnHoldLeftDelayed, etc.
     };
     static void setStylusOperation( QWidget*, StylusMode );
     static StylusMode stylusOperation( QWidget* );
 
     enum InputMethodHint {
         Normal,
         AlwaysOff,
         AlwaysOn
     };
 
     enum screenSaverHint {
         Disable = 0,
         DisableLightOff = 1,
         DisableSuspend = 2,
         Enable = 100
     };
 
     static void setInputMethodHint( QWidget *, InputMethodHint );
     static InputMethodHint inputMethodHint( QWidget * );
 
     void showMainWidget( QWidget*, bool nomax=FALSE );
     void showMainDocumentWidget( QWidget*, bool nomax=FALSE );
     static void showDialog( QDialog*, bool nomax=FALSE );
     static int execDialog( QDialog*, bool nomax=FALSE );
 
     static void setKeepRunning();
     bool keepRunning() const;
 
     bool keyboardGrabbed() const;
+    QString keyboardGrabbedBy ( ) const;
 
     int exec();
 
 signals:
     void clientMoused();
     void timeChanged();
     void clockChanged( bool pm );
     void micChanged( bool muted );
     void volumeChanged( bool muted );
     void appMessage( const QCString& msg, const QByteArray& data);
     void weekChanged( bool startOnMonday );
     void dateFormatChanged( DateFormat );
     void flush();
     void reload();
 
 private slots:
     void systemMessage( const QCString &msg, const QByteArray &data );
     void pidMessage( const QCString &msg, const QByteArray &data );
     void removeSenderFromStylusDict();
     void hideOrQuit();
 
 protected:
     bool qwsEventFilter( QWSEvent * );
     void internalSetStyle( const QString &style );
     void prepareForTermination(bool willrestart);
     virtual void restart();
     virtual void shutdown();
     bool eventFilter( QObject *, QEvent * );
     void timerEvent( QTimerEvent * );
     bool raiseAppropriateWindow();
     virtual void tryQuit();
 
         virtual void polish ( QWidget * ); // this is actually implemented in qt_override.cpp (!)
 
 private:
     void mapToDefaultAction( QWSKeyEvent *ke, int defKey );
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     QCopChannel *sysChannel;
     QCopChannel *pidChannel;
 #endif
     QPEApplicationData *d;
 
     bool reserved_sh;
 
 
 
 };
 
 inline void QPEApplication::showDialog( QDialog* d, bool nomax )
 {
     QSize sh = d->sizeHint();
     int w = QMAX(sh.width(),d->width());
     int h = QMAX(sh.height(),d->height());
     if ( !nomax
         && ( w > qApp->desktop()->width()*3/4
             || h > qApp->desktop()->height()*3/4 ) )
     {
         d->showMaximized();
     } else {
         d->resize(w,h);
         d->show();
     }
 }