Use a QQueue as in Qtopia

1 files changed, 11 insertions, 9 deletions

diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index 4d0b0ea..98af70a 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -1,413 +1,415 @@
 /**********************************************************************
 ** 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.
 **
 */
 #define QTOPIA_INTERNAL_LANGLIST
 #include <stdlib.h>
 #include <unistd.h>
 #include <linux/limits.h> // needed for some toolchains (PATH_MAX)
 #include <qfile.h>
+#include <qqueue.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 <qtextcodec.h>
 #include <qevent.h>
 #include <qtooltip.h>
 #include <qsignal.h>
 #include <qmainwindow.h>
 #include <qwidgetlist.h>
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #define QTOPIA_INTERNAL_INITAPP
 #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 ), rightpressed( false ), kbgrabbed( false ),
                   notbusysent( false ), preloaded( false ), forceshow( false ), nomaximize( false ),
                   keep_running( true ), qpe_main_widget( 0 ), qcopQok( false )
 
-        {
-                qcopq.setAutoDelete( TRUE );
-        }
+        {}
 
         int presstimer;
         QWidget* presswidget;
         QPoint presspos;
 
         bool rightpressed : 1;
         bool kbgrabbed    : 1;
         bool notbusysent  : 1;
         bool preloaded    : 1;
         bool forceshow    : 1;
         bool nomaximize   : 1;
         bool qcopQok      : 1;
         bool keep_running : 1;
 
 
         QStringList langs;
         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;
         QGuardedPtr<QWidget> lastraised;
-        QList<QCopRec> qcopq;
+        QQueue<QCopRec> qcopq;
         QString styleName;
         QString decorationName;
 
         void enqueueQCop( const QCString &ch, const QCString &msg,
                           const QByteArray &data )
         {
-                qcopq.append( new QCopRec( ch, msg, data ) );
+                qcopq.enqueue( new QCopRec( ch, msg, data ) );
         }
         void sendQCopQ()
         {
             if (!qcopQok )
                 return;
 
                 QCopRec * r;
 #ifndef QT_NO_COP
-
-                for ( QListIterator<QCopRec> it( qcopq ); ( r = it.current() ); ++it )
-                        QCopChannel::sendLocally( r->channel, r->message, r->data );
+           while((r=qcopq.dequeue())) {
+               // remove from queue before sending...
+               // event loop can come around again before getting
+               // back from sendLocally
+               QCopChannel::sendLocally( r->channel, r->message, r->data );
 #endif
 
-                qcopq.clear();
+               delete r;
+           }
         }
         static void show_mx(QWidget* mw, bool nomaximize,  const QString & = QString::null )
         {
 
             // ugly hack, remove that later after finding a sane solution
             // Addendum: Only Sharp currently has models with high resolution but (physically) small displays,
             // so this is only useful if QT_QWS_SIMPAD is NOT defined. E.g. SIMpad has 800x600 but has
             // a (physically) large enough display to use the small icons
 #ifndef QT_QWS_SIMPAD
             if ( QPEApplication::desktop() ->width() >= 600 && ( mw->inherits("QMainWindow") || mw->isA("QMainWindow") ) )  {
                 ( (  QMainWindow* ) mw )->setUsesBigPixmaps( true );
             }
 #endif
 
                 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
                 // 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;
         }
 
 
         void show(QWidget* mw, bool nomax)
         {
                 setWidgetCaptionFromAppName( mw, appName, QPEApplication::qpeDir() + "apps" );
                 nomaximize = nomax;
                 qpe_main_widget = mw;
 #ifndef QT_NO_COP
 
                 sendQCopQ();
 #endif
 
                 if ( preloaded ) {
                         if (forceshow)
                                 show_mx(mw, nomax);
                 }
                 else if ( keep_running ) {
                         show_mx(mw, nomax);
                 }
         }
 
         void loadTextCodecs()
         {
                 QString path = QPEApplication::qpeDir() + "/plugins/textcodecs";
                 QDir dir( path, "lib*.so" );
                 QStringList list;
                 if ( dir. exists ( ))
                     list = dir.entryList();
                 QStringList::Iterator it;
                 for ( it = list.begin(); it != list.end(); ++it ) {
                         TextCodecInterface *iface = 0;
                         QLibrary *lib = new QLibrary( path + "/" + *it );
                         if ( lib->queryInterface( IID_QtopiaTextCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
                                 QValueList<int> mibs = iface->mibEnums();
                                 for (QValueList<int>::ConstIterator i = mibs.begin(); i != mibs.end(); ++i) {
                                         (void)iface->createForMib(*i);
                                         // ### it exists now; need to remember if we can delete it
                                 }
                         }
                         else {
                                 lib->unload();
                                 delete lib;
                         }
                 }
         }
 
         void loadImageCodecs()
         {
                 QString path = QPEApplication::qpeDir() + "/plugins/imagecodecs";
                 QDir dir( path, "lib*.so" );
                 QStringList list;
                 if ( dir. exists ( ))
                     list = dir.entryList();
                 QStringList::Iterator it;
                 for ( it = list.begin(); it != list.end(); ++it ) {
                         ImageCodecInterface *iface = 0;
                         QLibrary *lib = new QLibrary( path + "/" + *it );
                         if ( lib->queryInterface( IID_QtopiaImageCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
                                 QStringList formats = iface->keys();
                                 for (QStringList::ConstIterator i = formats.begin(); i != formats.end(); ++i) {
                                         (void)iface->installIOHandler(*i);
                                         // ### it exists now; need to remember if we can delete it
                                 }
                         }
                         else {
                                 lib->unload();
                                 delete lib;
                         }
                 }
         }
 };
 
 class ResourceMimeFactory : public QMimeSourceFactory
 {
 public:
         ResourceMimeFactory() : resImage( 0 )
         {
                 setFilePath( Global::helpPath() );
                 setExtensionType( "html", "text/html;charset=UTF-8" );
         }
         ~ResourceMimeFactory() {
             delete resImage;
         }
 
         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() ) {
                                     delete resImage;
                                     resImage = new QImageDrag( img );
                                     r = resImage;
                                 }
                         }
                         while ( !r && sl > 0 );
                 }
                 return r;
         }
 private:
     mutable QImageDrag *resImage;
 };
 
 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 int muted = 0;
 static int micMuted = 0;
 
 static void setVolume( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "VolumePercent", 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;
         }
 }
 
 static void setMic( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "Mic", 50 );
 
                                 int fd = 0;
                                 int mic = micMuted ? 0 : percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_MIC ), &mic );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }
 
 
 static void setBass( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "BassPercent", 50 );
 
                                 int fd = 0;
                                 int bass = percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_BASS ), &bass );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }
 
 
 static void setTreble( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "TreblePercent", 50 );
 
                                 int fd = 0;
                                 int treble = percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_TREBLE ), &treble );
                                         ::close( fd );
                                 }
                         }
                         break;
         }
 }