path: root/core/launcher/launcher.cpp

/*
                             This file is part of the Opie Project
              =.             (C) 2000-2002 Trolltech AS
            .=l.             (C) 2002-2005 The Opie Team <opie-devel@handhelds.org>
           .>+-=
 _;:,     .>    :=|.         This program is free software; you can
.> <`_,   >  .   <=          redistribute it and/or  modify it under
    :`=1 )Y*s>-.--   :       the terms of the GNU Library General Public
.="- .-=="i,     .._         License as published by the Free Software
 - .   .-<_>     .<>         Foundation; version 2 of the License.
     ._= =}       :
    .%`+i>       _;_.
    .i_,=:_.      -<s.       This program is distributed in the hope that
     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
    : ..    .:,     . . .    without even the implied warranty of
    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
..}^=.=       =       ;      Library General Public License for more
++=   -.     .`     .:       details.
    :     =  ...= . :.=-
 -.   .:....=;==+<;          You should have received a copy of the GNU
  -_. . .   )=.  =           Library General Public License along with
    --        :-=`           this library; see the file COPYING.LIB.
                             If not, write to the Free Software Foundation,
                             Inc., 59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.
*/
#include "startmenu.h"
#include "taskbar.h"
#include "serverinterface.h"
#include "launcherview.h"
#include "launcher.h"
#include "server.h"
/* OPIE */
#include <opie2/odebug.h>
#include <opie2/oresource.h>
using namespace Opie::Core;

#include <qtopia/global.h>
#ifdef Q_WS_QWS
#include <qtopia/qcopenvelope_qws.h>
#endif
#include <qtopia/applnk.h>
#include <qtopia/config.h>
#include <qtopia/qpeapplication.h>
#include <qtopia/mimetype.h>
#include <qtopia/private/categories.h>
#define QTOPIA_INTERNAL_FSLP
#include <qtopia/lnkproperties.h>

/* QT */
#include <qdir.h>
#ifdef Q_WS_QWS
#include <qkeyboard_qws.h>
#include <qwindowsystem_qws.h>
#endif
#include <qtimer.h>
#include <qcombobox.h>
#include <qvbox.h>
#include <qlayout.h>
#include <qstyle.h>
#include <qpushbutton.h>
#include <qtabbar.h>
#include <qwidgetstack.h>
#include <qregexp.h>
#include <qmessagebox.h>
#include <qframe.h>
#include <qpainter.h>
#include <qlabel.h>
#include <qtextstream.h>
#include <qpopupmenu.h>

/* STD */
#include <stdlib.h>
#include <assert.h>
#if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
#include <unistd.h>
#include <stdio.h>
#include <sys/vfs.h>
#include <mntent.h>
#endif


static bool isVisibleWindow( int );
//===========================================================================

LauncherTabWidget::LauncherTabWidget( Launcher* parent ) :
    QVBox( parent ), docview( 0 ),docTabEnabled(true),m_DocumentTabId(0)
{
    docLoadingWidgetEnabled = false;
    docLoadingWidget = 0;
    docLoadingWidgetProgress = 0;
    launcher = parent;
    categoryBar = new LauncherTabBar( this );
    QPalette pal = categoryBar->palette();
    pal.setColor( QColorGroup::Light, pal.color(QPalette::Active,QColorGroup::Shadow) );
    pal.setColor( QColorGroup::Background, pal.active().background().light(110) );
    categoryBar->setPalette( pal );
    stack = new QWidgetStack(this);
    connect( categoryBar, SIGNAL(selected(int)), this, SLOT(raiseTabWidget()) );
    categoryBar->show();
    stack->show();

#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
    QCopChannel *channel = new QCopChannel( "QPE/Launcher", this );
    connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
             this, SLOT(launcherMessage(const QCString&,const QByteArray&)) );
    connect( qApp, SIGNAL(appMessage(const QCString&,const QByteArray&)),
         this, SLOT(appMessage(const QCString&,const QByteArray&)));
#endif

    createDocLoadingWidget();
}

void LauncherTabWidget::createDocLoadingWidget()
{
    // Construct the 'doc loading widget' shown when finding documents

    // ### LauncherView class needs changing to be more generic so
    // this widget can change its background similar to the iconviews
    // so the background for this matches
    docLoadingWidget = new LauncherView( stack );
    docLoadingWidget->hideIcons();
    QVBox *docLoadingVBox = new QVBox( docLoadingWidget );

    docLoadingVBox->setSpacing( 20 );
    docLoadingVBox->setMargin( 10 );

    QWidget *space1 = new QWidget( docLoadingVBox );
    docLoadingVBox->setStretchFactor( space1, 1 );

    QLabel *waitPixmap = new QLabel( "Please Wait...", docLoadingVBox );
    waitPixmap->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)5, (QSizePolicy::SizeType)5, waitPixmap->sizePolicy().hasHeightForWidth() ) );
    waitPixmap->setAlignment( int( QLabel::AlignCenter ) );

    Config cfg( "Launcher" );
    cfg.setGroup( "DocTab" );
    docTabEnabled = cfg.readBoolEntry( "Enable", true );

    QLabel *textLabel = new QLabel( docLoadingVBox );
    textLabel->setAlignment( int( QLabel::AlignCenter ) );
    docLoadingWidgetProgress = new QProgressBar( docLoadingVBox );
    docLoadingWidgetProgress->setProgress( 0 );
    docLoadingWidgetProgress->setCenterIndicator( TRUE );
    docLoadingWidgetProgress->setBackgroundMode( NoBackground ); // No flicker
    setProgressStyle();

    if ( docTabEnabled )
    {
        textLabel->setText( tr( "<b>Finding Documents...</b>" ) );
    }
    else
    {
        textLabel->setText( tr( "<b>The Documents Tab<p>has been disabled.<p>"
                                "Use Settings->Launcher->DocTab<p>to reenable it.</b></center>" ) );
        docLoadingWidgetProgress->hide();
        docLoadingWidgetEnabled = true;
    }

    QWidget *space2 = new QWidget( docLoadingVBox );
    docLoadingVBox->setStretchFactor( space2, 1 );

    cfg.setGroup( "Tab Documents" ); // No tr
    setTabViewAppearance( docLoadingWidget, cfg );

    stack->addWidget( docLoadingWidget, 0 );
}

void LauncherTabWidget::initLayout()
{
    layout()->activate();
    docView()->setFocus();
    categoryBar->showTab("Documents");
}

void LauncherTabWidget::appMessage(const QCString& message, const QByteArray&)
{
    if ( message == "nextView()" )
        categoryBar->nextTab();
}

void LauncherTabWidget::raiseTabWidget()
{
    if ( categoryBar->currentView() == docView()
         && docLoadingWidgetEnabled ) {
        stack->raiseWidget( docLoadingWidget );
        docLoadingWidget->updateGeometry();
    } else {
        stack->raiseWidget( categoryBar->currentView() );
    }
}

void LauncherTabWidget::tabProperties()
{
    LauncherView *view = categoryBar->currentView();
    QPopupMenu *m = new QPopupMenu( this );
    m->insertItem( tr("Icon View"), LauncherView::Icon );
    m->insertItem( tr("List View"), LauncherView::List );
    m->setItemChecked( (int)view->viewMode(), TRUE );
    int rv = m->exec( QCursor::pos() );
    if ( rv >= 0 && rv != view->viewMode() ) {
        view->setViewMode( (LauncherView::ViewMode)rv );
    }

    delete m;
}

void LauncherTabWidget::deleteView( const QString& id )
{
    LauncherTab *t = categoryBar->launcherTab(id);
    if ( t ) {
        stack->removeWidget( t->view );
        delete t->view;
        categoryBar->removeTab( t );
    }
}

LauncherView* LauncherTabWidget::newView( const QString& id, const QPixmap& pm, const QString& label )
{
    LauncherView* view = new LauncherView( stack );
    connect( view, SIGNAL(clicked(const AppLnk*)),
        this, SIGNAL(clicked(const AppLnk*)));
    connect( view, SIGNAL(rightPressed(AppLnk*)),
        this, SIGNAL(rightPressed(AppLnk*)));


    int n = categoryBar->count();

    stack->addWidget( view, n );

    LauncherTab *tab = new LauncherTab( id, view, pm, label );
    categoryBar->insertTab( tab, n-1 );
    if ( id == "Documents" ) {
        docview = view;
        m_DocumentTabId = n;
    }

    odebug << "inserting " << id << " at " << n-1 << "" << oendl;

    Config cfg("Launcher");
    setTabAppearance( tab, cfg );

    cfg.setGroup( "GUI" );
    view->setBusyIndicatorType( cfg.readEntry( "BusyType", QString::null ) );

    return view;
}

LauncherView *LauncherTabWidget::view( const QString &id )
{
    LauncherTab *t = categoryBar->launcherTab(id);
    if ( !t )
        return 0;
    return t->view;
}

LauncherView *LauncherTabWidget::docView()
{
    return docview;
}

void LauncherTabWidget::setLoadingWidgetEnabled( bool v )
{
    if ( v != docLoadingWidgetEnabled && docLoadingWidget ) {
        docLoadingWidgetEnabled = v;
        raiseTabWidget();
    }
}

void LauncherTabWidget::setLoadingProgress( int percent )
{
    docLoadingWidgetProgress->setProgress( (percent / 4) * 4 );
}

// ### this function could more to LauncherView
void LauncherTabWidget::setTabViewAppearance( LauncherView *v, Config &cfg )
{
    // View
    QString view = cfg.readEntry( "View", "Icon" );
    if ( view == "List" ) // No tr
    v->setViewMode( LauncherView::List );
    QString bgType = cfg.readEntry( "BackgroundType", "Image" );
    if ( bgType == "Image" ) { // No tr
    QString pm = cfg.readEntry( "BackgroundImage", "launcher/opie-background" );
    v->setBackgroundType( LauncherView::Image, pm );
    } else if ( bgType == "SolidColor" ) {
    QString c = cfg.readEntry( "BackgroundColor" );
    v->setBackgroundType( LauncherView::SolidColor, c );
    } else {
    v->setBackgroundType( LauncherView::Ruled, QString::null );
    }
    QString textCol = cfg.readEntry( "TextColor" );
    if ( textCol.isEmpty() )
    v->setTextColor( QColor() );
    else
    v->setTextColor( QColor(textCol) );
//    bool customFont = cfg.readBoolEntry( "CustomFont", FALSE );

    v->setColNumber( cfg.readNumEntry( "Columns", 0 ) );

    QStringList font = cfg.readListEntry( "Font", ',' );
    if ( font.count() == 4 )
        v->setViewFont( QFont(font[0], font[1].toInt(), font[2].toInt(), font[3].toInt()!=0) );

    // ### FIXME TabColor TabTextColor

}

// ### Could move to LauncherTab
void LauncherTabWidget::setTabAppearance( LauncherTab *tab, Config &cfg )
{
    cfg.setGroup( QString( "Tab %1" ).arg(tab->type) ); // No tr

    setTabViewAppearance( tab->view, cfg );

    // Tabs
    QString tabCol = cfg.readEntry( "TabColor" );
    if ( tabCol.isEmpty() )
    tab->bgColor = QColor();
    else
    tab->bgColor = QColor(tabCol);
    QString tabTextCol = cfg.readEntry( "TabTextColor" );
    if ( tabTextCol.isEmpty() )
    tab->fgColor = QColor();
    else
    tab->fgColor = QColor(tabTextCol);
}

void LauncherTabWidget::paletteChange( const QPalette &p )
{
    QVBox::paletteChange( p );
    QPalette pal = palette();
    pal.setColor( QColorGroup::Light, pal.color(QPalette::Active,QColorGroup::Shadow) );
    pal.setColor( QColorGroup::Background, pal.active().background().light(110) );
    categoryBar->setPalette( pal );
    categoryBar->update();
}

void LauncherTabWidget::styleChange( QStyle & )
{
    QTimer::singleShot( 0, this, SLOT(setProgressStyle()) );
}

void LauncherTabWidget::setProgressStyle()
{
    if (docLoadingWidgetProgress) {
    docLoadingWidgetProgress->setFrameShape( QProgressBar::Box );
    docLoadingWidgetProgress->setFrameShadow( QProgressBar::Plain );
    docLoadingWidgetProgress->setMargin( 1 );
    docLoadingWidgetProgress->setLineWidth( 1 );
    }
}

/*
 * FIXME
 * The following NULL check is triggered by inserting, then removing a tab on the fly
 * as you would if you had removable media (which I do). Without this check
 * the first app launched after a tab removal causes qpe to Segfault.
 * This obviously has a more sinister cause, but this works around it with no
 * obvious adverse effects. Please FIXME
 * bkc - 17/6/2004
 *
 */

void LauncherTabWidget::setBusy(bool on)
{
    if ( on )
    currentView()->setBusy(TRUE);
    else {
    for ( int i = 0; i < categoryBar->count(); i++ ) {
    if (categoryBar->tab(i)) {
        LauncherView *view = ((LauncherTab *)categoryBar->tab(i))->view;
        view->setBusy( FALSE );
    } else {
        odebug << "Averting Disaster with tab " << i << " == NULL! " << oendl;
    }
    }
    }
}

void LauncherTabWidget::setBusyIndicatorType( const QString& str ) {
    for (int i = 0; i < categoryBar->count(); i++ ) {
        LauncherView* view = static_cast<LauncherTab*>( categoryBar->tab(i) )->view;
        view->setBusyIndicatorType( str );
    }
}

LauncherView *LauncherTabWidget::currentView(void)
{
    return (LauncherView*)stack->visibleWidget();
}



void LauncherTabWidget::launcherMessage( const QCString &msg, const QByteArray &data)
{
    QDataStream stream( data, IO_ReadOnly );
    if ( msg == "setTabView(QString,int)" ) {
        QString id;
        stream >> id;
        int mode;
        stream >> mode;
        if ( view(id) )
            view(id)->setViewMode( (LauncherView::ViewMode)mode );
    } else if ( msg == "setTabBackground(QString,int,QString)" ) {
        QString id;
        stream >> id;
        int mode;
        stream >> mode;
        QString pixmapOrColor;
        stream >> pixmapOrColor;
        if ( view(id) )
            view(id)->setBackgroundType( (LauncherView::BackgroundType)mode, pixmapOrColor );
        if ( id == "Documents" )
            docLoadingWidget->setBackgroundType( (LauncherView::BackgroundType)mode, pixmapOrColor );
    } else if ( msg == "setTextColor(QString,QString)" ) {
        QString id;
        stream >> id;
        QString color;
        stream >> color;
        if ( view(id) )
            view(id)->setTextColor( QColor(color) );
        if ( id == "Documents" )
            docLoadingWidget->setTextColor( QColor(color) );
    } else if ( msg == "setIconColumns(QString,int)" ) {
        QString id;
        stream >> id;
        int number;
        stream >> number;
        if ( view(id ) )
            view(id)->setColNumber( number );
    } else if ( msg == "setFont(QString,QString,int,int,int)" ) {
        QString id;
        stream >> id;
        QString fam;
        stream >> fam;
        int size;
        stream >> size;
        int weight;
        stream >> weight;
        int italic;
        stream >> italic;
        if ( view(id) ) {
            if ( !fam.isEmpty() ) {
                view(id)->setViewFont( QFont(fam, size, weight, italic!=0) );
                odebug << "setFont: " << fam << ", " << size << ", " << weight << ", " << italic << "" << oendl;
            } else {
                view(id)->clearViewFont();
            }
        }
    }else if ( msg == "setBusyIndicatorType(QString)" ) {
        QString type;
        stream >> type;
        setBusyIndicatorType( type );
    }else if ( msg == "home()" ) {
        if ( isVisibleWindow( static_cast<QWidget*>(parent())->winId() ) ) {
            if (categoryBar)
                categoryBar->nextTab();
        }else {
            static_cast<QWidget*>(parent())->raise();
        }
    } else if (msg=="doctabEnabled(int)") {
        int id; stream >> id;
        odebug << "Doctab enabled " << id << oendl;
        reCheckDoctab(id);
    } else if ( msg == "setStaticBackground(bool)" ) {
        int set; stream >> set;
        odebug << "setStaticBackground " << set << oendl;
        for (int i = 0; i < categoryBar->count(); i++ )
        {
            LauncherView* view = static_cast<LauncherTab*>( categoryBar->tab(i) )->view;
            view->iconView()->setStaticBackgroundPicture( set );
        }
    }
}

void LauncherTabWidget::reCheckDoctab(int how)
{
    if ((bool)how == docTabEnabled) {
        /* nothing to do */
        return;
    }
    if (docLoadingWidget) {
        stack->removeWidget(docLoadingWidget);
        delete docLoadingWidget;
        docLoadingWidget = 0;
    }
    createDocLoadingWidget();
    {
        QCopEnvelope( "QPE/System", "reforceDocuments()" );
        odebug << "Sending doc rescan" << oendl;
    }
}

//---------------------------------------------------------------------------

Launcher::Launcher()
    : QMainWindow( 0, "PDA User Interface", QWidget::WStyle_Customize | QWidget::WGroupLeader )
{
    tabs = 0;
    tb = 0;
    Config cfg( "Launcher" );
    cfg.setGroup( "DocTab" );
    docTabEnabled = cfg.readBoolEntry( "Enable", true );
}

void Launcher::createGUI()
{
    setCaption( tr("Launcher") );

    // we have a pretty good idea how big we'll be
    setGeometry( 0, 0, qApp->desktop()->width(), qApp->desktop()->height() );

    tb = new TaskBar;
    tabs = new LauncherTabWidget( this );
    setCentralWidget( tabs );

    ServerInterface::dockWidget( tb, ServerInterface::Bottom );
    tb->show();

    qApp->installEventFilter( this );

    connect( tb, SIGNAL(tabSelected(const QString&)),
    this, SLOT(showTab(const QString&)) );
    connect( tabs, SIGNAL(selected(const QString&)),
    this, SLOT(viewSelected(const QString&)) );
    connect( tabs, SIGNAL(clicked(const AppLnk*)),
    this, SLOT(select(const AppLnk*)));
    connect( tabs, SIGNAL(rightPressed(AppLnk*)),
    this, SLOT(properties(AppLnk*)));

#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
    QCopChannel* sysChannel = new QCopChannel( "QPE/System", this );
    connect( sysChannel, SIGNAL(received(const QCString&,const QByteArray&)),
             this, SLOT(systemMessage(const QCString&,const QByteArray&)) );
#endif

    // all documents
    QPixmap pm = OResource::loadPixmap( "DocsIcon", OResource::SmallIcon );
    // It could add this itself if it handles docs
    tabs->newView("Documents", pm, tr("Documents") )->setToolsEnabled( TRUE );

    QTimer::singleShot( 0, tabs, SLOT( initLayout() ) );
    qApp->setMainWidget( this );
    QTimer::singleShot( 500, this, SLOT( makeVisible() ) );
}

Launcher::~Launcher()
{
    if ( tb )
    destroyGUI();
}

 bool Launcher::requiresDocuments() const
 {
    Config cfg( "Launcher" );
    cfg.setGroup( "DocTab" );
    return cfg.readBoolEntry( "Enable", true );
}

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;
}

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 );

        if (QPEApplication::execDialog( &prop )==QDialog::Accepted && tabs->currentView()==tabs->docView()) {
        }
    }
}

void Launcher::storageChanged( const QList<FileSystem> & )
{
    // ### 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
    owarn << "addAppLnk: No view for type " << type.latin1() << ". Can't add app "
             << 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 )
{
#if 0
    documentRemoved( oldDoc );
    documentAdded( newDoc );
//    tabs->docView()->updateTools();
#else
    tabs->docView()->changeItem(oldDoc,new DocLnk(newDoc));
#endif
}

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;
    }
}