Use A higher prime number in AppLnk

Somehow the Launcher triggers issues with libqpe and MimeType.

Due the mix of calling MimeType::clear, MimeType type(doclnk.linkFile()),
MimeType::clear
the registration of Application was cleared and not reentered due the
inner static variable in MimeType::init which was set.
Now make sure that if we clear that we will reenter the Application in all cases!

2 files changed, 8 insertions, 4 deletions

diff --git a/library/applnk.cpp b/library/applnk.cpp
index 5f7da8e..e9d519e 100644
--- a/library/applnk.cpp
+++ b/library/applnk.cpp
@@ -1087,385 +1087,385 @@ void AppLnkSet::findChildren(const QString &dr, const QString& typ, const QStrin
     if ( dir.exists( ".directory" ) ) {
   Config config( dr + "/.directory", Config::File );
   config.setGroup( "Desktop Entry" );
   typNameLocal = config.readEntry( "Name", typNameLocal );
   if ( !typ.isEmpty() ) {
       QString iconFile = config.readEntry( "Icon", "AppsIcon" );
       QImage unscaledIcon = Resource::loadImage( iconFile );
       QPixmap pm, bpm;
       pm.convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
       bpm.convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
       d->typPix.insert(typ, new QPixmap(pm));
       d->typPixBig.insert(typ, new QPixmap(bpm));
       d->typName.insert(typ, new QString(typNameLocal));
   }
     }
 
     const QFileInfoList *list = dir.entryInfoList();
     if ( list ) {
   QFileInfo* fi;
   bool cadded=FALSE;
   for ( QFileInfoListIterator it(*list); (fi=*it); ++it ) {
       QString bn = fi->fileName();
 //      qDebug("findChildren "+bn);
       if ( bn[0] != '.' && bn != "CVS" ) {
     if ( fi->isDir() ) {
         QString c = typ.isNull() ? bn : typ+"/"+bn;
         QString d = typNameLocal.isNull() ? bn : typNameLocal+"/"+bn;
         findChildren(fi->filePath(), c, d, depth );
     } else {
         if ( fi->extension(FALSE) == "desktop" ) {
       AppLnk* app = new AppLnk( fi->filePath() );
 #ifdef QT_NO_QWS_MULTIPROCESS
       if ( !Global::isBuiltinCommand( app->exec() ) )
           delete app;
       else
 #endif
       {
           if ( !typ.isEmpty() ) {
         if ( !cadded ) {
             typs.append(typ);
             cadded = TRUE;
         }
         app->setType(typ);
           }
           add(app);
       }
         }
     }
       }
   }
     }
 }
 
 /*!
   Adds AppLnk \a f to the set. The set takes responsibility for
   deleting \a f.
 
   \sa remove()
 */
 void AppLnkSet::add( AppLnk *f )
 {
     if ( f->mId == 0 ) {
   AppLnk::lastId++;
   f->mId = AppLnk::lastId;
   mApps.append( f );
     } else {
   qWarning("Attempt to add an AppLnk twice");
     }
 }
 
 /*!
   Removes AppLnk \a f to the set. The caller becomes responsible for
   deleting \a f. Returns TRUE if \a f was in the set; otherwise
   returns FALSE.
 
   \sa add()
 */
 bool AppLnkSet::remove( AppLnk *f )
 {
     if ( mApps.remove( f ) ) {
   f->mId = 0;
   return TRUE;
     }
     return FALSE;
 }
 
 
 /*!
   Returns the localized name for type \a t.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 */
 QString AppLnkSet::typeName( const QString& t ) const
 {
     QString *st = d->typName.find(t);
     return st ? *st : QString::null;
 }
 
 /*!
   Returns the small pixmap associated with type \a t.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 */
 QPixmap AppLnkSet::typePixmap( const QString& t ) const
 {
     QPixmap *pm = d->typPix.find(t);
     return pm ? *pm : QPixmap();
 }
 
 /*!
   Returns the large pixmap associated with type \a t.
 
     For applications, games and settings the type is \c Application;
     for documents the type is the document's MIME type.
 */
 QPixmap AppLnkSet::typeBigPixmap( const QString& t ) const
 {
     QPixmap *pm = d->typPixBig.find(t);
     return pm ? *pm : QPixmap();
 }
 
 /*!
   Returns the AppLnk with the given \a id.
 */
 const AppLnk *AppLnkSet::find( int id ) const
 {
     QListIterator<AppLnk> it( children() );
 
     for ( ; it.current(); ++it ) {
   const AppLnk *app = it.current();
   if ( app->id() == id )
       return app;
     }
 
     return 0;
 }
 
 /*!
   Returns the AppLnk with the given \a exec attribute.
 */
 const AppLnk *AppLnkSet::findExec( const QString& exec ) const
 {
     QListIterator<AppLnk> it( children() );
 
     for ( ; it.current(); ++it ) {
   const AppLnk *app = it.current();
   if ( app->exec() == exec )
       return app;
     }
 
     return 0;
 }
 
 /*!
   \class DocLnkSet applnk.h
   \brief The DocLnkSet class is a set of DocLnk objects.
 */
 
 /*!
   \fn const QList<DocLnk>& DocLnkSet::children() const
 
   Returns the members of the set.
 */
 
 /*!
   Constructs an empty DocLnkSet.
 
   \sa appendFrom()
 */
 DocLnkSet::DocLnkSet()
 {
 }
 
 /*!
   Constructs a DocLnkSet that contains DocLnk objects representing all
   the files in the \a directory (and any subdirectories, recursively).
 
   If \a mimefilter is not null,
   only documents with a MIME type matching \a mimefilter are selected.
   The value may contain multiple wild-card patterns separated by ";",
   such as \c{*o/mpeg;audio/x-wav}.
 
   See also \link applnk.html#files-and-links Files and Links\endlink.
 
 */
 DocLnkSet::DocLnkSet( const QString &directory, const QString& mimefilter ) :
     AppLnkSet()
 {
     QDir dir( directory );
     mFile = dir.dirName();
-    QDict<void> reference;
+    QDict<void> reference(1021);
 
     QStringList subFilter = QStringList::split(";", mimefilter);
     QValueList<QRegExp> mimeFilters;
     for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++ it )
   mimeFilters.append( QRegExp(*it, FALSE, TRUE) );
 
     findChildren(directory, mimeFilters, reference);
 
     const QList<DocLnk> &list = children();
     for ( QListIterator<DocLnk> it( list ); it.current(); ++it ) {
   reference.remove( (*it)->file() );
     }
     for ( QDictIterator<void> dit(reference); dit.current(); ++dit ) {
   if ( dit.current() == (void*)2 ) {
       // Unreferenced, make an unwritten link
       DocLnk* dl = new DocLnk;
       QFileInfo fi( dit.currentKey() );
       dl->setFile(fi.filePath());
       dl->setName(fi.baseName());
       // #### default to current path?
       // dl->setCategories( ... );
       bool match = mimefilter.isNull();
       if ( !match )
     for( QValueList<QRegExp>::Iterator it = mimeFilters.begin(); it != mimeFilters.end() && !match; ++ it )
         if ( (*it).match(dl->type()) >= 0 )
       match = TRUE;
       if ( match /* && dl->type() != "application/octet-stream" */
         && !!dl->exec() )
     add(dl);
       else
     delete dl;
   }
     }
 }
 
 // other becomes empty
 /*!
   Transfers all DocLnk objects from \a other to this set. \a other becomes
   empty.
 */
 void DocLnkSet::appendFrom( DocLnkSet& other )
 {
     if ( &other == this )
   return;
     QListIterator<AppLnk> it( other.mApps );
     for ( ; it.current(); ) {
   mApps.append(*it);
   ++it;
     }
     other.mApps.clear();
 }
 
 void DocLnkSet::findChildren(const QString &dr, const QValueList<QRegExp> &mimeFilters, QDict<void> &reference, int depth)
 {
     depth++;
     if ( depth > 10 )
   return;
 
     QDir dir( dr );
 
     /* Opie got a different approach
      * I guess it's geek vs. consumer
      * in this case to be discussed
      */
     if ( dir.exists( ".Qtopia-ignore" ) )
   return;
 
     const QFileInfoList *list = dir.entryInfoList();
     if ( list ) {
   QFileInfo* fi;
   for ( QFileInfoListIterator it(*list); (fi=*it); ++it ) {
       QString bn = fi->fileName();
       if ( bn[0] != '.' ) {
     if ( fi->isDir()  ) {
         if ( bn != "CVS" && bn != "Qtopia" && bn != "QtPalmtop" )
       findChildren(fi->filePath(), mimeFilters, reference, depth);
     } else {
         if ( fi->extension(FALSE) == "desktop" ) {
       DocLnk* dl = new DocLnk( fi->filePath() );
       QFileInfo fi2(dl->file());
       bool match = FALSE;
       if ( !fi2.exists() ) {
           dir.remove( dl->file() );
       }
       if ( mimeFilters.count() == 0 ) {
           add( dl );
           match = TRUE;
       } else {
           for( QValueList<QRegExp>::ConstIterator it = mimeFilters.begin(); it != mimeFilters.end(); ++ it ) {
         if ( (*it).match(dl->type()) >= 0 ) {
             add(dl);
             match = TRUE;
         }
           }
       }
       if ( !match )
           delete dl;
         } else {
       if ( !reference.find(fi->fileName()) )
           reference.insert(fi->filePath(), (void*)2);
         }
     }
       }
   }
     }
 }
 
 /*!
   \class DocLnk applnk.h
   \brief The DocLnk class represents loaded document references.
 */
 
 /*!
   \fn DocLnk::DocLnk( const DocLnk &o )
 
   Copies \a o.
 */
 
 /*!
   Constructs a DocLnk from a valid .desktop \a file or a new .desktop
   \a file for other files.
 */
 DocLnk::DocLnk( const QString &file ) :
     AppLnk(file)
 {
     init(file);
 }
 
 /*!
   Constructs a DocLnk from a valid .desktop \a file or a new .desktop
   \a file for other files. If \a may_be_desktopfile is TRUE, then an
   attempt is made to read \a file as a .desktop file; if that fails it
   is read as a normal file.
 */
 DocLnk::DocLnk( const QString &file, bool may_be_desktopfile ) :
     AppLnk(may_be_desktopfile ? file : QString::null)
 {
     init(file);
 }
 
 void DocLnk::init(const QString &file)
 {
     if ( isValid() ) {
 #ifndef FORCED_DIR_STRUCTURE_WAY
   if ( mType.isNull() )
       // try to infer it
 #endif
   {
       int s0 = file.findRev('/');
       if ( s0 > 0 ) {
     int s1 = file.findRev('/',s0-1);
     if ( s1 > 0 ) {
         int s2 = file.findRev('/',s1-1);
         if ( s2 > 0 ) {
       mType = file.mid(s2+1,s0-s2-1);
         }
     }
       }
   }
     } else if ( QFile::exists(file) ) {
   QString n = file;
   n.replace(QRegExp(".*/"),"");
   n.replace(QRegExp("\\..*"),"");
   setName( n );
   setFile( file );
     }
     MimeType mt(mType);
     if( mt.application() )
   mExec = mt.application()->exec();
 }
 
 /*!
   Constructs an invalid DocLnk.
 */
 DocLnk::DocLnk()
 {
 }
 
 /*!
   Destroys the DocLnk. Just like AppLnk objects, a run-time error
   occurs if the DocLnk is a member of a DocLnkSet (or AppLnkSet).
 */
 DocLnk::~DocLnk()
 {
 }
 
 /*!
   \reimp
 */
 QString DocLnk::exec() const
 {
     MimeType mt(type());
diff --git a/library/mimetype.cpp b/library/mimetype.cpp
index 23de70b..ec45794 100644
--- a/library/mimetype.cpp
+++ b/library/mimetype.cpp
@@ -1,366 +1,370 @@
 /**********************************************************************
 ** 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_MIMEEXT
 #include "mimetype.h"
 #include "applnk.h"
 #include "resource.h"
 #include <qpe/qpeapplication.h>
 #include "config.h"
 
 #include <qfile.h>
 #include <qtextstream.h>
 
 
 static void cleanupMime()
 {
     MimeType::clear();
 }
 
 class MimeTypeData {
 public:
     MimeTypeData(const QString& i) :
 	id(i)
     {
 	apps.setAutoDelete(TRUE);
     }
     QString id;
     QString extension;
     QList<AppLnk> apps;
 
     QString description()
     {
 	if ( desc.isEmpty() )
 	    desc = QPEApplication::tr("%1 document").arg(apps.first()->name());
 	return desc;
     }
 
     QPixmap regIcon()
     {
 	if ( regicon.isNull() )
 	    loadPixmaps();
 	return regicon;
     }
 
     QPixmap bigIcon()
     {
 	if ( bigicon.isNull() )
 	    loadPixmaps();
 	return bigicon;
     }
 
 private:
     void loadPixmaps()
     {
 	if ( apps.count() ) {
 	    QString icon;
 	    for (AppLnk* lnk = apps.first(); icon.isNull() && lnk; lnk=apps.next()) {
 		QStringList icons = lnk->mimeTypeIcons();
 		if ( icons.count() ) {
 		    QStringList types = lnk->mimeTypes();
 		    for (QStringList::ConstIterator t=types.begin(),i=icons.begin(); t!=types.end() && i!=icons.end(); ++i,++t) {
 			if ( *t == id ) {
 			    icon = *i;
 			    break;
 			}
 		    }
 		}
 	    }
 	    if ( icon.isNull() ) {
 		AppLnk* lnk = apps.first();
 		regicon = lnk->pixmap();
 		bigicon = lnk->bigPixmap();
 	    } else {
 		QImage unscaledIcon = Resource::loadImage( icon );
 		regicon.convertFromImage( unscaledIcon.smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() ) );
 		bigicon.convertFromImage( unscaledIcon.smoothScale( AppLnk::bigIconSize(), AppLnk::bigIconSize() ) );
 	    }
 	}
     }
 
     QPixmap regicon;
     QPixmap bigicon;
     QString desc;
 };
 
 class MimeType::Private : public QDict<MimeTypeData> {
 public:
     Private() {}
     ~Private() {}
 
     // ...
 };
 
 MimeType::Private* MimeType::d=0;
 static QMap<QString,QString> *typeFor = 0;
 static QMap<QString,QStringList> *extFor = 0;
+static bool appsUpdated = FALSE;
 
 MimeType::Private& MimeType::data()
 {
     if ( !d ) {
 	d = new Private;
 	d->setAutoDelete(TRUE);
 	static bool setCleanup = FALSE;
 	if ( !setCleanup ) {
 	    qAddPostRoutine( cleanupMime );
 	    setCleanup = TRUE;
 	}
     }
     return *d;
 }
 
 /*!
     \class MimeType mimetype.h
     \brief The MimeType class provides MIME type information.
 
     A MimeType object is a light-weight value which
     provides information about a MIME type.
 
     \ingroup qtopiaemb
 */
 
 /*!
     Constructs a MimeType.
     Normally, \a ext_or_id is a MIME type,
     but if \a ext_or_id starts with / or contains no /,
     it is interpretted as a filename and the
     extension (eg. .txt) is used as the
     MIME type.
 */
 MimeType::MimeType( const QString& ext_or_id )
 {
     init(ext_or_id);
 }
 
 /*!
     Constructs a MimeType from the type() of \a lnk.
 */
 MimeType::MimeType( const DocLnk& lnk )
 {
     init(lnk.type());
 }
 
 /*!
     Returns the MIME type identifier.
 */
 QString MimeType::id() const
 {
     return i;
 }
 
 /*!
     Returns a description of the MIME Type. This is usually based
     on the application() associated with the type.
 */
 QString MimeType::description() const
 {
     MimeTypeData* d = data(i);
     return d ? d->description() : QString::null;
 }
 
 /*!
     Returns a small QPixmap appropriate for the MIME type.
 */
 QPixmap MimeType::pixmap() const
 {
     MimeTypeData* d = data(i);
     return d ? d->regIcon() : QPixmap();
 }
 
 /*!
     \internal
     This function is not generally available.
 */
 QString MimeType::extension() const
 {
     return extensions().first();
 }
 
 
 /*!
     \internal
     This function is not generally available.
 */
 QStringList MimeType::extensions() const
 {
     loadExtensions();
     return *(*extFor).find(i);
 }
 
 /*!
     Returns a larger QPixmap appropriate for the MIME type.
 */
 QPixmap MimeType::bigPixmap() const
 {
     MimeTypeData* d = data(i);
     return d ? d->bigIcon() : QPixmap();
 }
 
 /*!
     Returns the AppLnk defining the application associated
     with this MIME type, or 0 if none is associated.
 
     The caller must not retain the pointer,
     but of course you can dereference it to take a copy if needed.
 
     \sa Service::binding()
 */
 const AppLnk* MimeType::application() const
 {
     MimeTypeData* d = data(i);
     return d ? d->apps.first() : 0;
 }
 
 static QString serviceBinding(const QString& service)
 {
     // Copied from qtopiaservices
     QString svrc = service;
     for (int i=0; i<(int)svrc.length(); i++)
         if ( svrc[i]=='/' ) svrc[i] = '-';
     return "Service-"+svrc;
 }
 
 /*!
     \internal
 */
 void MimeType::registerApp( const AppLnk& lnk )
 {
     QStringList list = lnk.mimeTypes();
     for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it) {
 	MimeTypeData* cur = data()[*it];
 	AppLnk* l = new AppLnk(lnk);
 	if ( !cur ) {
 	    cur = new MimeTypeData( *it );
 	    data().insert( *it, cur );
 	    cur->apps.append(l);
 	} else if ( cur->apps.count() ) {
 	    Config binding(serviceBinding("Open/"+*it));
 	    binding.setGroup("Service");
 	    QString def = binding.readEntry("default");
 	    if ( l->exec() == def )
 		cur->apps.prepend(l);
 	    else
 		cur->apps.append(l);
 	} else {
 	    cur->apps.append(l);
 	}
     }
 }
 
 /*!
     \internal
 */
 void MimeType::clear()
 {
     delete d;
     d = 0;
+    delete typeFor; typeFor = 0;
+    delete extFor ; extFor  = 0;
+    appsUpdated = FALSE;
 }
 
 void MimeType::loadExtensions()
 {
     if ( !typeFor ) {
 	extFor = new QMap<QString,QStringList>;
 	typeFor = new QMap<QString,QString>;
 	loadExtensions("/etc/mime.types");
 	loadExtensions(QPEApplication::qpeDir()+"etc/mime.types");
     }
 }
 
 void MimeType::loadExtensions(const QString& filename)
 {
     QFile file(filename);
     if ( file.open(IO_ReadOnly) ) {
 	QTextStream in(&file);
 	QRegExp space("[ \t]+");
 	while (!in.atEnd()) {
 	    QStringList tokens = QStringList::split(space, in.readLine());
 	    QStringList::ConstIterator it = tokens.begin();
 	    if ( it != tokens.end() ) {
 		QString id = *it; ++it;
 		// new override old (though left overrides right)
 		QStringList exts = (*extFor)[id];
 		QStringList newexts;
 		while ( it != tokens.end() ) {
 		    exts.remove(*it);
 		    if ( !newexts.contains(*it) )
 			newexts.append(*it);
 		    (*typeFor)[*it] = id;
 		    ++it;
 		}
 		(*extFor)[id] = newexts + exts;
 	    }
 	}
     }
 }
 
 void MimeType::init( const QString& ext_or_id )
 {
     if ( ext_or_id[0] != '/' && ext_or_id.contains('/') ) {
 	i = ext_or_id.lower();
     } else {
 	loadExtensions();
 	int dot = ext_or_id.findRev('.');
 	QString ext = dot >= 0 ? ext_or_id.mid(dot+1) : ext_or_id;
 	i = (*typeFor)[ext.lower()];
 	if ( i.isNull() )
 	    i = "application/octet-stream";
     }
-    static bool appsUpdated = FALSE;
+
     if ( !appsUpdated ) {
-	appsUpdated = TRUE;
 	updateApplications();
     }
 }
 
 MimeTypeData* MimeType::data(const QString& id)
 {
     MimeTypeData* d = data()[id];
     if ( !d ) {
 	int s = id.find('/');
 	QString idw = id.left(s)+"/*";
 	d = data()[idw];
     }
     return d;
 }
 
 /*!
     Returns a Qtopia folder containing application definitions.
 */
 QString MimeType::appsFolderName()
 {
     return QPEApplication::qpeDir() + "apps";
 }
 
 /*!
     Reloads application definitions.
 */
 void MimeType::updateApplications()
 {
-    clear();
+//    clear();
+    appsUpdated = true;
     AppLnkSet apps( appsFolderName() );
     updateApplications(&apps);
 }
 
 void MimeType::updateApplications(AppLnkSet* folder)
 {
     for ( QListIterator<AppLnk> it( folder->children() ); it.current(); ++it ) {
 	registerApp(*it.current());
     }
 }