- keep an eye on resize events on the desktop widget, which are an

  indication for things like life rotation. upon a resize re-layout things
  (taskbar, tabs and maxwindow rect)

3 files changed, 28 insertions, 8 deletions

diff --git a/core/launcher/desktop.cpp b/core/launcher/desktop.cpp
index 86527f6..6def126 100644
--- a/core/launcher/desktop.cpp
+++ b/core/launcher/desktop.cpp
@@ -414,209 +414,210 @@ bool DesktopApplication::qwsEventFilter( QWSEvent *e )
                         // i.e. one shot
                  
                         if ( keycode != 0 && press && !autoRepeat ) {
                                 for ( KeyRegisterList::Iterator it = keyRegisterList.begin(); it != keyRegisterList.end(); ++it ) {
                                         if (( *it ). getKeyCode ( ) == keycode ) {
                                                 QCopEnvelope (( *it ). getChannel ( ), ( *it ). getMessage ( ));
                                                 return true;
                                         }
                                 }
                         }
                 }
 
                 if ( keycode == HardKey_Suspend ) {
                         if ( press )
                                 emit power ( );
                         return true;
                 }
                 else if ( keycode == HardKey_Backlight ) {
                         if ( press )
                                 emit backlight ( );
                         return true;
                 }
                 else if ( keycode == Key_F32 ) {
                         if ( press )
                                 QCopEnvelope e( "QPE/Desktop", "startSync()" );
                         return true;
                 }
                 else if ( keycode == Key_F31 && !ke-> simpleData. modifiers ) { // Symbol Key -> show Unicode IM
                         if ( press )
                                 emit symbol ( );
                         return true;
                 }
                 else if ( keycode == Key_NumLock ) {
                         if ( press )
                                 emit numLockStateToggle ( );
                 }
                 else if ( keycode == Key_CapsLock ) {
                         if ( press )
                                 emit capsLockStateToggle();
                 }
                 if (( press && !autoRepeat ) || ( !press && autoRepeat )) {
                         if ( m_keyclick_sound )
                                 ODevice::inst ( )-> keySound ( );
                 }
         }
         else if ( e-> type == QWSEvent::Mouse ) {
                 QWSMouseEvent * me = ( QWSMouseEvent * ) e;
                 static bool up = true;
 
                 if ( me-> simpleData. state & LeftButton ) {
                         if ( up ) {
                                 up = false;
                                 if ( m_screentap_sound )
                                         ODevice::inst ( ) -> touchSound ( );
                         }
                 }
                 else {
                         up = true;
                 }
         }
 
         return QPEApplication::qwsEventFilter ( e );
 }
 #endif
 
 
 
 #if defined(QPE_HAVE_MEMALERTER)
 QPE_MEMALERTER_IMPL
 #endif
 
 //===========================================================================
 
 Desktop::Desktop() :
                 QWidget( 0, 0, WStyle_Tool | WStyle_Customize ),
                 qcopBridge( 0 ),
                 transferServer( 0 ),
                 packageSlave( 0 )
 {
         qpedesktop = this;
 
         //    bg = new Info( this );
         tb = new TaskBar;
 
         launcher = new Launcher( 0, 0, WStyle_Customize | QWidget::WGroupLeader );
 
         connect( launcher, SIGNAL( busy() ), tb, SLOT( startWait() ) );
         connect( launcher, SIGNAL( notBusy( const QString& ) ), tb, SLOT( stopWait( const QString& ) ) );
 
         int displayw = qApp->desktop() ->width();
         int displayh = qApp->desktop() ->height();
 
 
         QSize sz = tb->sizeHint();
 
         setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
-        tb->setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
+        layout();
 
         tb->show();
         launcher->showMaximized();
         launcher->show();
         launcher->raise();
 #if defined(QPE_HAVE_MEMALERTER)
 
         initMemalerter();
 #endif
         // start services
         startTransferServer();
         ( void ) new IrServer( this );
 
         packageSlave = new PackageSlave( this );
 
         qApp->installEventFilter( this );
+        qApp->desktop()->installEventFilter( this );
 
         qApp-> setMainWidget ( launcher );
 }
 
 void Desktop::show()
 {
         login( TRUE );
         QWidget::show();
 }
 
 Desktop::~Desktop()
 {
         delete launcher;
         delete tb;
         delete qcopBridge;
         delete transferServer;
 }
 
 bool Desktop::recoverMemory()
 {
         return tb->recoverMemory();
 }
 
 void Desktop::checkMemory()
 {
 #if defined(QPE_HAVE_MEMALERTER)
         static bool ignoreNormal = FALSE;
         static bool existingMessage = FALSE;
 
         if ( existingMessage )
                 return ; // don't show a second message while still on first
 
         existingMessage = TRUE;
         switch ( memstate ) {
                 case Unknown:
                         break;
                 case Low:
                         memstate = Unknown;
                         if ( recoverMemory() )
                                 ignoreNormal = TRUE;
                         else
                                 QMessageBox::warning( 0 , "Memory Status",
                                                       "The memory smacks of shortage. \n"
                                                       "Please save data. " );
                         break;
                 case Normal:
                         memstate = Unknown;
                         if ( ignoreNormal )
                                 ignoreNormal = FALSE;
                         //       else
                         //         QMessageBox::information ( 0 , "Memory Status",
                         //                                    "There is enough memory again." );
                         break;
                 case VeryLow:
                         memstate = Unknown;
                         QMessageBox::critical( 0 , "Memory Status",
                                                "The memory is very low. \n"
                                                "Please end this application \n"
                                                "immediately." );
                         recoverMemory();
         }
         existingMessage = FALSE;
 #endif
 }
 
 static bool isVisibleWindow( int wid )
 {
 #ifdef QWS
         const QList<QWSWindow> &list = qwsServer->clientWindows();
         QWSWindow* w;
         for ( QListIterator<QWSWindow> it( list ); ( w = it.current() ); ++it ) {
                 if ( w->winId() == wid )
                         return !w->isFullyObscured();
         }
 #endif
         return FALSE;
 }
 
 static bool hasVisibleWindow( const QString& clientname )
 {
 #ifdef QWS
         const QList<QWSWindow> &list = qwsServer->clientWindows();
         QWSWindow* w;
         for ( QListIterator<QWSWindow> it( list ); ( w = it.current() ); ++it ) {
                 if ( w->client() ->identity() == clientname && !w->isFullyObscured() )
                         return TRUE;
         }
 #endif
         return FALSE;
 }
 
 
 void Desktop::executeOrModify( const QString& appLnkFile )
 {
         AppLnk lnk( MimeType::appsFolderName() + "/" + appLnkFile );
         if ( lnk.isValid() ) {
@@ -639,223 +640,239 @@ void Desktop::executeOrModify( const QString& appLnkFile )
 void Desktop::execAutoStart()
 {
         QString appName;
         int delay;
         QDateTime now = QDateTime::currentDateTime();
         Config cfg( "autostart" );
         cfg.setGroup( "AutoStart" );
         appName = cfg.readEntry( "Apps", "" );
         delay = ( cfg.readEntry( "Delay", "0" ) ).toInt();
         // If the time between suspend and resume was longer then the
         // value saved as delay, start the app
         if ( suspendTime.secsTo( now ) >= ( delay * 60 ) && !appName.isEmpty() ) {
                 QCopEnvelope e( "QPE/System", "execute(QString)" );
                 e << QString( appName );
         }
 }
 
 #if defined(QPE_HAVE_TOGGLELIGHT)
 #include <qpe/config.h>
 
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <linux/ioctl.h>
 #include <time.h>
 #endif
 
 
 void Desktop::togglePower()
 {
         static bool excllock = false;
 
         if ( excllock )
                 return ;
 
         excllock = true;
 
         bool wasloggedin = loggedin;
         loggedin = 0;
         suspendTime = QDateTime::currentDateTime();
 
 #ifdef QWS
 
         if ( Password::needToAuthenticate ( true ) && qt_screen ) {
                 // Should use a big black window instead.
                 // But this would not show up fast enough
                 QGfx *g = qt_screen-> screenGfx ( );
                 g-> fillRect ( 0, 0, qt_screen-> width ( ), qt_screen-> height ( ));
                 delete g;
         }
 #endif
 
         ODevice::inst ( )-> suspend ( );
 
         DesktopApplication::switchLCD ( true ); // force LCD on without slow qcop call
         QWSServer::screenSaverActivate ( false );
 
         {
                 QCopEnvelope( "QPE/Card", "mtabChanged()" ); // might have changed while asleep
         }
 
         if ( wasloggedin )
                 login ( true );
 
         execAutoStart();
         //qcopBridge->closeOpenConnections();
 
         excllock = false;
 }
 
 void Desktop::toggleLight()
 {
         QCopEnvelope e( "QPE/System", "setBacklight(int)" );
         e << -2; // toggle
 }
 
 void Desktop::toggleSymbolInput()
 {
         tb->toggleSymbolInput();
 }
 
 void Desktop::toggleNumLockState()
 {
         tb->toggleNumLockState();
 }
 
 void Desktop::toggleCapsLockState()
 {
         tb->toggleCapsLockState();
 }
 
 void Desktop::styleChange( QStyle &s )
 {
         QWidget::styleChange( s );
-        int displayw = qApp->desktop() ->width();
-        int displayh = qApp->desktop() ->height();
-
-        QSize sz = tb->sizeHint();
-
-        tb->setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
+        layout();
 }
 
 void DesktopApplication::shutdown()
 {
         if ( type() != GuiServer )
                 return ;
         ShutdownImpl *sd = new ShutdownImpl( 0, 0, WDestructiveClose );
         connect( sd, SIGNAL( shutdown( ShutdownImpl::Type ) ),
                  this, SLOT( shutdown( ShutdownImpl::Type ) ) );
         sd->showMaximized();
 }
 
 void DesktopApplication::shutdown( ShutdownImpl::Type t )
 {
         char *opt = 0;
 
         switch ( t ) {
                 case ShutdownImpl::ShutdownSystem:
                         opt = "-h";
                         // fall through
                 case ShutdownImpl::RebootSystem:
                         if ( opt == 0 )
                                 opt = "-r";
 
                         if ( execl( "/sbin/shutdown", "shutdown", opt, "now", ( void* ) 0) < 0 )
                                 perror("shutdown");
         //                      ::syslog ( LOG_ERR, "Erroring execing shutdown\n" );
 
                         break;
                 case ShutdownImpl::RestartDesktop:
                         restart();
                         break;
                 case ShutdownImpl::TerminateDesktop:
                         prepareForTermination( FALSE );
 
                         // This is a workaround for a Qt bug
                         // clipboard applet has to stop its poll timer, or Qt/E
                         // will hang on quit() right before it emits aboutToQuit()
                         emit aboutToQuit ( );
 
                         quit();
                         break;
         }
 }
 
 void DesktopApplication::restart()
 {
         prepareForTermination( TRUE );
 
 #ifdef Q_WS_QWS
 
         for ( int fd = 3; fd < 100; fd++ )
                 close( fd );
 #if defined(QT_DEMO_SINGLE_FLOPPY)
 
         execl( "/sbin/init", "qpe", 0 );
 #elif defined(QT_QWS_CASSIOPEIA)
 
         execl( "/bin/sh", "sh", 0 );
 #else
 
         execl( ( qpeDir() + "/bin/qpe" ).latin1(), "qpe", 0 );
 #endif
 
         exit( 1 );
 #endif
 }
 
+void Desktop::layout()
+{
+        int displayw = qApp->desktop() ->width();
+        int displayh = qApp->desktop() ->height();
+
+        QSize sz = tb->sizeHint();
+
+        tb->setGeometry( 0, displayh - sz.height(), displayw, sz.height() );
+        tb->calcMaxWindowRect();
+}
+
 void Desktop::startTransferServer()
 {
         // start qcop bridge server
         qcopBridge = new QCopBridge( 4243 );
         if ( !qcopBridge->ok() ) {
                 delete qcopBridge;
                 qcopBridge = 0;
         }
         // start transfer server
         transferServer = new TransferServer( 4242 );
         if ( !transferServer->ok() ) {
                 delete transferServer;
                 transferServer = 0;
         }
         if ( !transferServer || !qcopBridge )
                 startTimer( 2000 );
 }
 
 void Desktop::timerEvent( QTimerEvent *e )
 {
         killTimer( e->timerId() );
         startTransferServer();
 }
 
+bool Desktop::eventFilter( QObject *o, QEvent *ev )
+{
+    if ( o != qApp->desktop() || ev->type() != QEvent::Resize )
+        return QWidget::eventFilter( o, ev );
+
+    layout();
+
+    return QWidget::eventFilter( o, ev );
+}
+
 void Desktop::terminateServers()
 {
         delete transferServer;
         delete qcopBridge;
         transferServer = 0;
         qcopBridge = 0;
 }
 
 void DesktopApplication::rereadVolumes()
 {
         Config cfg( "qpe" );
         cfg. setGroup ( "Volume" );
         
         m_screentap_sound = cfg. readBoolEntry ( "TouchSound" );
         m_keyclick_sound  = cfg. readBoolEntry ( "KeySound" );
         m_alarm_sound     = cfg. readBoolEntry ( "AlarmSound" );
 }
 
 void DesktopApplication::soundAlarm()
 {
         if ( me ( )-> m_alarm_sound )
                 ODevice::inst ( )-> alarmSound ( );
 }
 
 DesktopApplication *DesktopApplication::me ( )
 {
         return (DesktopApplication *) qApp;
 }
 
diff --git a/core/launcher/desktop.h b/core/launcher/desktop.h
index 4024c38..86d8aa8 100644
--- a/core/launcher/desktop.h
+++ b/core/launcher/desktop.h
@@ -41,115 +41,117 @@ class PackageSlave;
 class OpieScreenSaver;
 
 class DesktopApplication : public QPEApplication
 {
         Q_OBJECT
 public:
         DesktopApplication( int& argc, char **argv, Type t );
         ~DesktopApplication();
 
         static void switchLCD ( bool on ); // only for togglePower in Desktop
 
         static void soundAlarm(); // only because QCop soundAlarm() is defined in QPE/TaskBar
 
 signals:
         void menu();
         void home();
         void launch();
         void backlight();
         void power();
         void symbol();
         void numLockStateToggle();
         void capsLockStateToggle();
         void prepareForRestart();
 
 protected:
 #ifdef Q_WS_QWS
 
         bool qwsEventFilter( QWSEvent * );
 #endif
 
         void shutdown();
         void restart();
 
 public slots:
         virtual void systemMessage ( const QCString &msg, const QByteArray &data );
         virtual void launcherMessage ( const QCString &msg, const QByteArray &data );
         void rereadVolumes();
 
 protected slots:
         void shutdown ( ShutdownImpl::Type );
         void apmTimeout ( );
         void sendHeldAction ( );
 
 protected:
         virtual bool eventFilter ( QObject *o, QEvent *e );
         bool checkButtonAction ( const Opie::ODeviceButton *db, int keycode, bool press, bool autoRepeat );
         
 private:
         static DesktopApplication *me ( );
         
 private:
         void reloadPowerWarnSettings();
         DesktopPowerAlerter *pa;
         PowerStatus *m_ps, *m_ps_last;
         QTimer *cardSendTimer;
         QCopChannel *channel;
         OpieScreenSaver *m_screensaver;
         QTimer * m_apm_timer;
         int m_powerVeryLow;
         int m_powerCritical;
         int m_currentPowerLevel;
 
         const Opie::ODeviceButton *m_last_button;
                 QTimer *m_button_timer;
 
         bool m_keyclick_sound  : 1;
         bool m_screentap_sound : 1;
         bool m_alarm_sound     : 1;
 };
 
 
 class Desktop : public QWidget
 {
         Q_OBJECT
 public:
         Desktop();
         ~Desktop();
 
         static bool screenLocked();
 
         void show();
         void checkMemory();
 
 public slots:
         void execAutoStart();
         void togglePower();
         void toggleLight();
         void toggleNumLockState();
         void toggleCapsLockState();
         void toggleSymbolInput();
         void terminateServers();
 
 protected:
         void executeOrModify( const QString& appLnkFile );
         void styleChange( QStyle & );
         void timerEvent( QTimerEvent *e );
+        virtual bool eventFilter( QObject *o, QEvent *ev );
 
         QWidget *bg;
         Launcher *launcher;
         TaskBar *tb;
 
 private:
+        void layout();
         void startTransferServer();
         bool recoverMemory();
 
         QCopBridge *qcopBridge;
         TransferServer *transferServer;
         PackageSlave *packageSlave;
 
         QDateTime suspendTime;
 };
 
 
 #endif // __DESKTOP_H__
 
diff --git a/core/launcher/taskbar.h b/core/launcher/taskbar.h
index cd631ef..a0bf395 100644
--- a/core/launcher/taskbar.h
+++ b/core/launcher/taskbar.h
@@ -1,84 +1,85 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 #ifndef __TASKBAR_H__
 #define __TASKBAR_H__
 
 #include <qhbox.h>
 
 class QLabel;
 class QTimer;
 class InputMethods;
 class Wait;
 class SysTray;
 //class MRUList;
 class RunningAppBar;
 class QWidgetStack;
 class QTimer;
 class QLabel;
 class StartMenu;
 class LockKeyState;
 
 class TaskBar : public QHBox {
     Q_OBJECT
 public:
     TaskBar();
     ~TaskBar();
 
     static QWidget *calibrate( bool );
 
     bool recoverMemory();
 
     StartMenu *startMenu() const { return sm; }
 public slots:
     void startWait();
     void stopWait(const QString&);
     void stopWait();
     void clearStatusBar();
     void toggleNumLockState();
     void toggleCapsLockState();
     void toggleSymbolInput();
 
 protected:
     void resizeEvent( QResizeEvent * );
     void styleChange( QStyle & );
     void setStatusMessage( const QString &text );
 
-private slots:
+public slots:
     void calcMaxWindowRect();
+private slots:
     void receive( const QCString &msg, const QByteArray &data );
 
 private:
 
     QTimer *waitTimer;
     Wait *waitIcon;
     InputMethods *inputMethods;
     SysTray *sysTray;
     //  MRUList *mru;
     RunningAppBar* runningAppBar;
     QWidgetStack *stack;
     QTimer *clearer;
     QLabel *label;
     LockKeyState* lockState;
     StartMenu *sm;
 };
 
 
 #endif // __TASKBAR_H__