Small interface update. If we add doctypes disable the viewport() for

updates

4 files changed, 20 insertions, 2 deletions

diff --git a/core/launcher/documentlist.cpp b/core/launcher/documentlist.cpp
index 59dd721..19ceb0f 100644
--- a/core/launcher/documentlist.cpp
+++ b/core/launcher/documentlist.cpp
@@ -1,398 +1,402 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #include "documentlist.h"
 #include "serverinterface.h"
 #include "mediadlg.h"
 
 /* OPIE */
 #include <opie2/oglobal.h>
 #include <opie2/odebug.h>
 #include <qtopia/config.h>
 #include <qtopia/mimetype.h>
 #include <qtopia/resource.h>
 #include <qtopia/private/categories.h>
 #include <qtopia/qpeapplication.h>
 #include <qtopia/applnk.h>
 #include <qtopia/storage.h>
 #ifdef Q_WS_QWS
 #include <qtopia/qcopenvelope_qws.h>
 #endif
 using namespace Opie::Core;
 
 /* QT */
 #include <qtimer.h>
 #include <qfileinfo.h>
 #include <qtextstream.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <qpainter.h>
 #include <qimage.h>
 #include <qcopchannel_qws.h>
 #include <qlistview.h>
 #include <qlist.h>
 #include <qpixmap.h>
 
 
 AppLnkSet *DocumentList::appLnkSet = 0;
 
 static const int MAX_SEARCH_DEPTH = 10;
 
 
 class DocumentListPrivate : public QObject {
     Q_OBJECT
 public:
     DocumentListPrivate( ServerInterface *gui );
     ~DocumentListPrivate();
 
     void initialize();
 
     const QString nextFile();
     const DocLnk *iterate();
     bool store( DocLnk* dl );
     void estimatedPercentScanned();
     void appendDocpath(FileSystem*);
-    
+
 
     DocLnkSet dls;
     QDict<void> reference;
     QDictIterator<void> *dit;
     enum { Find, RemoveKnownFiles, MakeUnknownFiles, Done } state;
 
     QStringList docPaths;
     unsigned int docPathsSearched;
 
     int searchDepth;
     QDir *listDirs[MAX_SEARCH_DEPTH];
     const QFileInfoList *lists[MAX_SEARCH_DEPTH];
     unsigned int listPositions[MAX_SEARCH_DEPTH];
 
     StorageInfo *storage;
 
     int tid;
 
     ServerInterface *serverGui;
 
     bool needToSendAllDocLinks;
     bool sendAppLnks;
     bool sendDocLnks;
     bool scanDocs;
 };
 
 
 /*
  * scandocs will be read from Config
  */
 DocumentList::DocumentList( ServerInterface *serverGui, bool /*scanDocs*/,
                             QObject *parent, const char *name )
  : QObject( parent, name )
 {
     appLnkSet = new AppLnkSet( MimeType::appsFolderName() );
     d = new DocumentListPrivate( serverGui );
     d->needToSendAllDocLinks = false;
 
     Config cfg( "Launcher" );
     cfg.setGroup( "DocTab" );
     d->scanDocs = cfg.readBoolEntry( "Enable", true );
     odebug << "DocumentList::DocumentList() : scanDocs = " << d->scanDocs << "" << oendl;
 
     QTimer::singleShot( 10, this, SLOT( startInitialScan() ) );
 }
 
 void DocumentList::startInitialScan()
 {
     reloadAppLnks();
     reloadDocLnks();
 }
 
 DocumentList::~DocumentList()
 {
     delete appLnkSet;
     delete d;
 }
 
 
 void DocumentList::add( const DocLnk& doc )
 {
     if ( d->serverGui && QFile::exists( doc.file() ) )
         d->serverGui->documentAdded( doc );
 }
 
 
 void DocumentList::start()
 {
     resume();
 }
 
 
 void DocumentList::pause()
 {
     //odebug << "pause " << d->tid << "" << oendl;
     killTimer( d->tid );
     d->tid = 0;
 }
 
 
 void DocumentList::resume()
 {
     if ( d->tid == 0 ) {
         d->tid = startTimer( 20 );
     //odebug << "resumed " << d->tid << "" << oendl;
     }
 }
 
 /*
 void DocumentList::resend()
 {
     // Re-emits all the added items to the list (firstly letting everyone know to
     // clear what they have as it is being sent again)
     pause();
     emit allRemoved();
     QTimer::singleShot( 5, this, SLOT( resendWorker() ) );
 }
 
 
 void DocumentList::resendWorker()
 {
     const QList<DocLnk> &list = d->dls.children();
     for ( QListIterator<DocLnk> it( list ); it.current(); ++it )
         add( *(*it) );
     resume();
 }
 */
 
 void DocumentList::rescan()
 {
     //odebug << "rescan" << oendl;
     pause();
     d->initialize();
     resume();
 }
 
 
 void DocumentList::timerEvent( QTimerEvent *te )
 {
     if ( te->timerId() == d->tid ) {
         // Do 3 at a time
+        if ( d->serverGui )
+            d->serverGui->aboutToAddBegin();
         for (int i = 0; i < 3; i++ ) {
             const DocLnk *lnk = d->iterate();
             if ( lnk ) {
                 add( *lnk );
             } else {
                 // stop when done
                 pause();
                 if ( d->serverGui )
                     d->serverGui->documentScanningProgress( 100 );
                 if ( d->needToSendAllDocLinks )
                     sendAllDocLinks();
                 break;
             }
-        }
+        }
+        if ( d->serverGui )
+            d->serverGui->aboutToAddEnd();
     }
 }
 
 
 void DocumentList::reloadAppLnks()
 {
     if ( d->sendAppLnks && d->serverGui ) {
         d->serverGui->applicationScanningProgress( 0 );
         d->serverGui->allApplicationsRemoved();
     }
 
     delete appLnkSet;
     appLnkSet = new AppLnkSet( MimeType::appsFolderName() );
 
     if ( d->sendAppLnks && d->serverGui ) {
         static QStringList prevTypeList;
         QStringList types = appLnkSet->types();
         for ( QStringList::Iterator ittypes=types.begin(); ittypes!=types.end(); ++ittypes) {
             if ( !(*ittypes).isEmpty() ) {
                 if ( !prevTypeList.contains(*ittypes) ) {
                     QString name = appLnkSet->typeName(*ittypes);
                     QPixmap pm = appLnkSet->typePixmap(*ittypes);
                     QPixmap bgPm = appLnkSet->typeBigPixmap(*ittypes);
 
                     if (pm.isNull()) {
                         QImage img( Resource::loadImage( "UnknownDocument" ) );
                         pm = img.smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() );
                         bgPm = img.smoothScale( AppLnk::bigIconSize(), AppLnk::bigIconSize() );
                     }
 
             //odebug << "adding type " << (*ittypes) << "" << oendl;
 
                     // ### our current launcher expects docs tab to be last
                     d->serverGui->typeAdded( *ittypes, name.isNull() ? (*ittypes) : name, pm, bgPm );
                 }
                 prevTypeList.remove(*ittypes);
             }
         }
         for ( QStringList::Iterator ittypes=prevTypeList.begin(); ittypes!=prevTypeList.end(); ++ittypes) {
         //odebug << "removing type " << (*ittypes) << "" << oendl;
             d->serverGui->typeRemoved(*ittypes);
         }
         prevTypeList = types;
     }
 
     QListIterator<AppLnk> itapp( appLnkSet->children() );
     AppLnk* l;
     while ( (l=itapp.current()) ) {
         ++itapp;
         if ( d->sendAppLnks && d->serverGui )
             d->serverGui->applicationAdded( l->type(), *l );
     }
 
     if ( d->sendAppLnks && d->serverGui )
         d->serverGui->applicationScanningProgress( 100 );
 }
 
 void DocumentList::reloadDocLnks()
 {
     if ( !d->scanDocs )
         return;
 
     if ( d->sendDocLnks && d->serverGui ) {
         d->serverGui->documentScanningProgress( 0 );
         d->serverGui->allDocumentsRemoved();
     }
 
     rescan();
 }
 
 void DocumentList::linkChanged( QString arg )
 {
     //odebug << "linkchanged( " << arg << " )" << oendl;
 
     if ( arg.isNull() || OGlobal::isAppLnkFileName( arg ) ) {
         reloadAppLnks();
     } else {
 
         const QList<DocLnk> &list = d->dls.children();
         QListIterator<DocLnk> it( list );
         while ( it.current() ) {
             DocLnk *doc = it.current();
             ++it;
             if ( ( doc->linkFileKnown() && doc->linkFile() == arg )
                 || ( doc->fileKnown() && doc->file() == arg ) ) {
         //odebug << "found old link" << oendl;
                 DocLnk* dl = new DocLnk( arg );
                 // add new one if it exists and matches the mimetype
                 if ( d->store( dl ) ) {
                     // Existing link has been changed, send old link ref and a ref
                     // to the new link
             //odebug << "change case" << oendl;
                     if ( d->serverGui )
                         d->serverGui->documentChanged( *doc, *dl );
 
                 } else {
                     // Link has been removed or doesn't match the mimetypes any more
                     // so we aren't interested in it, so take it away from the list
             //odebug << "removal case" << oendl;
                     if ( d->serverGui )
                         d->serverGui->documentRemoved( *doc );
 
                 }
                 d->dls.remove( doc ); // remove old link from docLnkSet
                 delete doc;
                 return;
             }
         }
         // Didn't find existing link, must be new
         DocLnk* dl = new DocLnk( arg );
         if ( d->store( dl ) ) {
             // Add if it's a link we are interested in
         //odebug << "add case" << oendl;
             add( *dl );
         }
 
     }
 }
 
 void DocumentList::restoreDone()
 {
     reloadAppLnks();
     reloadDocLnks();
 }
 
 void DocumentList::DiffAppLnks()
 {
     static AppLnkSet *appLnkSet2;
 
     appLnkSet2 = new AppLnkSet( MimeType::appsFolderName() );
 
     if ( d->sendAppLnks && d->serverGui ) {
         static QStringList prevTypeList = appLnkSet->types();
         QStringList types = appLnkSet2->types();
         for ( QStringList::Iterator ittypes=types.begin(); ittypes!=types.end(); ++ittypes) {
             if ( !(*ittypes).isEmpty() ) {
                 if ( !prevTypeList.contains(*ittypes) ) {
                     QString name = appLnkSet2->typeName(*ittypes);
                     QPixmap pm = appLnkSet2->typePixmap(*ittypes);
                     QPixmap bgPm = appLnkSet2->typeBigPixmap(*ittypes);
 
                     if (pm.isNull()) {
                         QImage img( Resource::loadImage( "UnknownDocument" ) );
                         pm = img.smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() );
                         bgPm = img.smoothScale( AppLnk::bigIconSize(), AppLnk::bigIconSize() );
                     }
 
             odebug << "adding type " << (*ittypes) << "" << oendl;
 
                     // ### our current launcher expects docs tab to be last
                     d->serverGui->typeAdded( *ittypes, name.isNull() ? (*ittypes) : name, pm, bgPm );
                 }
                 prevTypeList.remove(*ittypes);
             }
         }
         for ( QStringList::Iterator ittypes=prevTypeList.begin(); ittypes!=prevTypeList.end(); ++ittypes) {
         odebug << "removing type " << (*ittypes) << "" << oendl;
             d->serverGui->typeRemoved(*ittypes);
         }
         prevTypeList = types;
     }
 
 
     QListIterator<AppLnk> it1( appLnkSet->children() );
     QListIterator<AppLnk> it2( appLnkSet2->children() );
 
     AppLnk *i;
     AppLnk *j;
     bool found;
 
     while ( (j=it2.current()) ) {
         it1 = appLnkSet->children();
         found = false;
         while ( (i=it1.current()) ){
             if (strcmp(i->name().ascii(),j->name().ascii()) == 0)
                 found = true;
             ++it1;
         }
         if (!found) {
             qDebug("Item %s needs to be added",j->name().ascii() );
             d->serverGui->applicationAdded( j->type(), *j );
                 }           
             ++it2; 
     }
 
     it1 = appLnkSet->children();
      while ( (i=it1.current()) ) {
         it2 = appLnkSet2->children();
         found = false;
         while ( (j=it2.current()) ){
             if (strcmp(i->name().ascii(),j->name().ascii()) == 0)
                 found = true;
diff --git a/core/launcher/launcher.cpp b/core/launcher/launcher.cpp
index bf2287d..6afbcd8 100644
--- a/core/launcher/launcher.cpp
+++ b/core/launcher/launcher.cpp
@@ -507,270 +507,280 @@ Launcher::~Launcher()
 void Launcher::makeVisible()
 {
     showMaximized();
 }
 
 void Launcher::destroyGUI()
 {
     delete tb;
     tb = 0;
     delete tabs;
     tabs =0;
 }
 
 bool Launcher::eventFilter( QObject*, QEvent *ev )
 {
 #ifdef QT_QWS_CUSTOM
     if ( ev->type() == QEvent::KeyPress ) {
         QKeyEvent *ke = (QKeyEvent *)ev;
         if ( ke->key() == Qt::Key_F11 ) { // menu key
             QWidget *active = qApp->activeWindow();
             if ( active && active->isPopup() )
                 active->close();
             else {
                 Global::terminateBuiltin("calibrate"); // No tr
                 tb->launchStartMenu();
             }
             return TRUE;
         }
     }
 #else
     Q_UNUSED(ev);
 #endif
     return FALSE;
 }
 
 void Launcher::toggleSymbolInput()
 {
     tb->toggleSymbolInput();
 }
 
 void Launcher::toggleNumLockState()
 {
     tb->toggleNumLockState();
 }
 
 void Launcher::toggleCapsLockState()
 {
     tb->toggleCapsLockState();
 }
 
 static bool isVisibleWindow(int wid)
 {
 #ifdef Q_WS_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;
 }
 
 void Launcher::viewSelected(const QString& s)
 {
     setCaption( s + tr(" - Launcher") );
 }
 
 void Launcher::showTab(const QString& id)
 {
     tabs->categoryBar->showTab(id);
     raise();
 }
 
 void Launcher::select( const AppLnk *appLnk )
 {
     if ( appLnk->type() == "Folder" ) { // No tr
         // Not supported: flat is simpler for the user
     } else {
         if ( appLnk->exec().isNull() ) {
             int i = QMessageBox::information(this,tr("No application"),
                 tr("<p>No application is defined for this document."
                 "<p>Type is %1.").arg(appLnk->type()), tr("OK"), tr("View as text"), 0, 0, 1);
 
             /* ### Fixme */
             if ( i == 1 )
                 Global::execute("textedit",appLnk->file());
 
             return;
         }
         tabs->setBusy(TRUE);
         emit executing( appLnk );
         appLnk->execute();
     }
 }
 
 void Launcher::properties( AppLnk *appLnk )
 {
     if ( appLnk->type() == "Folder" ) { // No tr
         // Not supported: flat is simpler for the user
     } else {
 /* ### libqtopia FIXME also moving docLnks... */
         LnkProperties prop(appLnk,0 );
 
         QPEApplication::execDialog( &prop );
     }
 }
 
 void Launcher::storageChanged( const QList<FileSystem> &fs )
 {
     // ### update combo boxes if we had a combo box for the storage type
 }
 
 void Launcher::systemMessage( const QCString &msg, const QByteArray &data)
 {
     QDataStream stream( data, IO_ReadOnly );
     if ( msg == "busy()" ) {
         tb->startWait();
     } else if ( msg == "notBusy(QString)" ) {
         QString app;
         stream >> app;
         tabs->setBusy(FALSE);
         tb->stopWait(app);
     } else if (msg == "applyStyle()") {
         tabs->currentView()->relayout();
     }
 }
 
 // These are the update functions from the server
 void Launcher::typeAdded( const QString& type, const QString& name,
                                     const QPixmap& pixmap, const QPixmap& )
 {
     tabs->newView( type, pixmap, name );
     ids.append( type );
     /* this will be called in applicationScanningProgress with value 100! */
 //    tb->refreshStartMenu();
 
     static bool first = TRUE;
     if ( first ) {
         first = FALSE;
         tabs->categoryBar->showTab(type);
     }
 
     tabs->view( type )->setUpdatesEnabled( FALSE );
     tabs->view( type )->setSortEnabled( FALSE );
 }
 
 void Launcher::typeRemoved( const QString& type )
 {
     tabs->view( type )->removeAllItems();
     tabs->deleteView( type );
     ids.remove( type );
     /* this will be called in applicationScanningProgress with value 100! */
 //    tb->refreshStartMenu();
 }
 
 void Launcher::applicationAdded( const QString& type, const AppLnk& app )
 {
     if ( app.type() == "Separator" )  // No tr
         return;
 
     LauncherView *view = tabs->view( type );
     if ( view )
         view->addItem( new AppLnk( app ), FALSE );
     else
         qWarning("addAppLnk: No view for type %s. Can't add app %s!",
                                   type.latin1(),app.name().latin1()  );
 
     MimeType::registerApp( app );
 }
 
 void Launcher::applicationRemoved( const QString& type, const AppLnk& app )
 {
     LauncherView *view = tabs->view( type );
     if ( view )
         view->removeLink( app.linkFile() );
     else
     owarn << "removeAppLnk: No view for " << type << "!" << oendl;
 }
 
 void Launcher::allApplicationsRemoved()
 {
     MimeType::clear();
     for ( QStringList::ConstIterator it=ids.begin(); it!= ids.end(); ++it)
         tabs->view( (*it) )->removeAllItems();
 }
 
 void Launcher::documentAdded( const DocLnk& doc )
 {
     tabs->docView()->addItem( new DocLnk( doc ), FALSE );
 }
 
+void Launcher::aboutToAddBegin()
+{
+    tabs->docView()->setUpdatesEnabled( false );
+}
+
+void Launcher::aboutToAddEnd()
+{
+    tabs->docView()->setUpdatesEnabled( true );
+}
+
 void Launcher::showLoadingDocs()
 {
     tabs->docView()->hide();
 }
 
 void Launcher::showDocTab()
 {
     if ( tabs->categoryBar->currentView() == tabs->docView() )
         tabs->docView()->show();
 }
 
 void Launcher::documentRemoved( const DocLnk& doc )
 {
     tabs->docView()->removeLink( doc.linkFile() );
 }
 
 void Launcher::documentChanged( const DocLnk& oldDoc, const DocLnk& newDoc )
 {
     documentRemoved( oldDoc );
     documentAdded( newDoc );
 }
 
 void Launcher::allDocumentsRemoved()
 {
     tabs->docView()->removeAllItems();
 }
 
 void Launcher::applicationStateChanged( const QString& name, ApplicationState state )
 {
     tb->setApplicationState( name, state );
 }
 
 void Launcher::applicationScanningProgress( int percent )
 {
     switch ( percent ) {
         case 0: {
             for ( QStringList::ConstIterator it=ids.begin(); it!= ids.end(); ++it) {
                 tabs->view( (*it) )->setUpdatesEnabled( FALSE );
                 tabs->view( (*it) )->setSortEnabled( FALSE );
             }
             break;
         }
         case 100: {
             for ( QStringList::ConstIterator it=ids.begin(); it!= ids.end(); ++it) {
                 tabs->view( (*it) )->setUpdatesEnabled( TRUE );
                 tabs->view( (*it) )->setSortEnabled( TRUE );
             }
             tb->refreshStartMenu();
             break;
         }
         default:
             break;
     }
 }
 
 void Launcher::documentScanningProgress( int percent )
 {
     switch ( percent ) {
         case 0: {
             tabs->setLoadingProgress( 0 );
             tabs->setLoadingWidgetEnabled( TRUE );
             tabs->docView()->setUpdatesEnabled( FALSE );
             tabs->docView()->setSortEnabled( FALSE );
             break;
         }
         case 100: {
             tabs->docView()->updateTools();
             tabs->docView()->setSortEnabled( TRUE );
             tabs->docView()->setUpdatesEnabled( TRUE );
             tabs->setLoadingWidgetEnabled( FALSE );
             break;
         }
         default:
             tabs->setLoadingProgress( percent );
             break;
     }
 }
 
diff --git a/core/launcher/launcher.h b/core/launcher/launcher.h
index 4f3ff8c..29bd7db 100644
--- a/core/launcher/launcher.h
+++ b/core/launcher/launcher.h
@@ -1,157 +1,159 @@
 /**********************************************************************
 ** 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 LAUNCHER_H
 #define LAUNCHER_H
 
 #include <qtopia/config.h>
 #include <qtopia/storage.h>
 #include <qtopia/applnk.h>
 #include <qmainwindow.h>
 #include <qstringlist.h>
 #include <qprogressbar.h>
 #include <qvbox.h>
 #include <qlist.h>
 #include <qdict.h>
 #include "launcherview.h"
 #include "launchertab.h"
 #include "serverinterface.h"
 
 class QWidgetStack;
 class TaskBar;
 class Launcher;
 
 class LauncherTabWidget : public QVBox {
     // can't use a QTabWidget, since it won't let us set the frame style.
     Q_OBJECT
 public:
     LauncherTabWidget( Launcher* parent );
 
     void updateDocs(AppLnkSet* docFolder);
     void setBusy(bool on);
     LauncherView *currentView(void);
 
     LauncherView* newView( const QString&, const QPixmap& pm, const QString& label );
     void deleteView( const QString& );
     void setTabViewAppearance( LauncherView *v, Config &cfg );
     void setTabAppearance( LauncherTab *, Config &cfg );
 
     LauncherView *view( const QString & );
     LauncherView *docView();
 
     void createDocLoadingWidget();
     void setLoadingWidgetEnabled( bool v );
     void setLoadingProgress( int percent );
 
     LauncherTabBar* categoryBar;
 
     void setBusyIndicatorType( const QString& type );
 
 signals:
     void selected(const QString&);
     void clicked(const AppLnk*);
     void rightPressed(AppLnk*);
 
 protected slots:
     void raiseTabWidget();
     void tabProperties();
     void initLayout();
 
 private slots:
     void launcherMessage( const QCString &, const QByteArray &);
     void appMessage( const QCString &, const QByteArray &);
     void setProgressStyle();
 
 protected:
     void paletteChange( const QPalette &p );
     void styleChange( QStyle & );
 
 private:
     Launcher *launcher;
     LauncherView *docview;
 
     QWidgetStack *stack;
     LauncherView *docLoadingWidget;
     QProgressBar *docLoadingWidgetProgress;
     bool docLoadingWidgetEnabled;
 };
 
 class Launcher : public QMainWindow, public ServerInterface
 {
     Q_OBJECT
 public:
     Launcher();
     ~Launcher();
 
     // implementing ServerInterface
     void createGUI();
     void destroyGUI();
     void typeAdded( const QString& type, const QString& name, const QPixmap& pixmap, const QPixmap& bgPixmap );
     void typeRemoved( const QString& type );
     void applicationAdded( const QString& type, const AppLnk& doc );
     void applicationRemoved( const QString& type, const AppLnk& doc );
     void allApplicationsRemoved();
     void applicationStateChanged( const QString& name, ApplicationState state );
     void documentAdded( const DocLnk& doc );
     void documentRemoved( const DocLnk& doc );
+    void aboutToAddBegin();
+    void aboutToAddEnd();
     void allDocumentsRemoved();
     void documentChanged( const DocLnk& oldDoc, const DocLnk& newDoc );
     void storageChanged( const QList<FileSystem> & );
     void applicationScanningProgress( int percent );
     void documentScanningProgress( int percent );
     bool requiresApplications() const { return TRUE; }
     bool requiresDocuments() const;
     void showLoadingDocs();
     void showDocTab();
 
     QStringList idList() const { return ids; }
 
 public slots:
     void viewSelected(const QString&);
     void showTab(const QString&);
     void select( const AppLnk * );
     void properties( AppLnk * );
     void makeVisible();
 
 signals:
     void executing( const AppLnk * );
 
 private slots:
     void systemMessage( const QCString &, const QByteArray &);
     void toggleSymbolInput();
     void toggleNumLockState();
     void toggleCapsLockState();
 
 protected:
     bool eventFilter( QObject *o, QEvent *ev );
 
 private:
     void updateApps();
     void loadDocs();
     void updateDocs();
     void updateTabs();
 
     LauncherTabWidget *tabs;
     QStringList ids;
     TaskBar *tb;
 
     bool docTabEnabled;
 };
 
 #endif // LAUNCHERVIEW_H
diff --git a/core/launcher/serverinterface.h b/core/launcher/serverinterface.h
index e57ea51..132766f 100644
--- a/core/launcher/serverinterface.h
+++ b/core/launcher/serverinterface.h
@@ -1,72 +1,74 @@
 /**********************************************************************
 ** 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 SERVER_INTERFACE_H
 #define SERVER_INTERFACE_H
 
 
 #include <qstring.h>
 #include <qpixmap.h>
 #include <qwidget.h>
 #include <qtopia/applnk.h>
 #include <qtopia/storage.h>
 
 
 class ServerInterface {
 public:
     virtual ~ServerInterface();
 
     virtual void createGUI() = 0;
     virtual void destroyGUI() = 0;
 
     // These notify of the application categories, like what is used in the current launcher tabs,
     // for example "Applications", "Games" etc.
     virtual void typeAdded( const QString& type, const QString& name, const QPixmap& pixmap, const QPixmap& bgPixmap ) = 0;
     virtual void typeRemoved( const QString& type ) = 0;
 
     // These functions notify when an application is added or removed and to which category it belongs
     virtual void applicationAdded( const QString& type, const AppLnk& doc ) = 0;
     virtual void applicationRemoved( const QString& type, const AppLnk& doc ) = 0;
     virtual void allApplicationsRemoved() = 0;
     // Useful for wait icons, or running application lists etc
     enum ApplicationState { Launching, Running, Terminated };
     virtual void applicationStateChanged( const QString& name, ApplicationState state ) = 0;
     static const AppLnkSet& appLnks();
 
     // These functions notify of adding, removal and changes of document links used in the documents tab for example
+    virtual void aboutToAddBegin() {}
+    virtual void aboutToAddEnd() {}
     virtual void documentAdded( const DocLnk& doc ) = 0;
     virtual void documentRemoved( const DocLnk& doc ) = 0;
     virtual void allDocumentsRemoved() = 0;
     virtual void documentChanged( const DocLnk& oldDoc, const DocLnk& newDoc ) = 0;
 
     virtual void storageChanged( const QList<FileSystem> & ) = 0;
 
     virtual void applicationScanningProgress( int percent ) = 0;
     virtual void documentScanningProgress( int percent ) = 0;
 
     // Tells the server if the GUI needs to be updated about documents or applnks
     virtual bool requiresApplications() const = 0;
     virtual bool requiresDocuments() const = 0;
 
     enum DockArea { Top, Bottom, Left, Right };
     static void dockWidget( QWidget *w, DockArea placement );
 };
 
 
 #endif // SERVER_INTERFACE_H