1 files changed, 1 insertions, 1 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());