kontact/src/mainwindow.cpp

   1 /*
   2   This file is part of KDE Kontact.
   3
   4   Copyright (c) 2001 Matthias Hoelzer-Kluepfel <mhk@kde.org>
   5   Copyright (c) 2002-2005 Daniel Molkentin <molkentin@kde.org>
   6   Copyright (c) 2003-2005 Cornelius Schumacher <schumacher@kde.org>
   7
   8   This program is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU General Public License as published by
  10   the Free Software Foundation; either version 2 of the License, or
  11   (at your option) any later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License along
  19   with this program; if not, write to the Free Software Foundation, Inc.,
  20   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21 */
  22
  23 #include <config-enterprise.h>
  24
  25 #include "mainwindow.h"
  26 #include "aboutdialog.h"
  27 #include "iconsidepane.h"
  28 #include "prefs.h"
  29 #include "progressdialog.h"
  30 #include "statusbarprogresswidget.h"
  31 #include "broadcaststatus.h"
  32
  33 #include <kontactinterface/plugin.h>
  34 using namespace KontactInterface;
  35
  36 #include <kpimutils/kfileio.h>
  37
  38 #include <kparts/componentfactory.h>
  39 #include <ksettings/dialog.h>
  40 #include <ksettings/dispatcher.h>
  41 #include <kactioncollection.h>
  42 #include <kapplication.h>
  43 #include <kconfig.h>
  44 #include <kconfiggroup.h>
  45 #include <kdebug.h>
  46 #include <kdbusservicestarter.h>
  47 #include <kedittoolbar.h>
  48 #include <kguiitem.h>
  49 #include <khelpmenu.h>
  50 #include <kiconloader.h>
  51 #include <kshortcutsdialog.h>
  52 #include <klibloader.h>
  53 #include <ktoolbar.h>
  54 #include <klocale.h>
  55 #include <kmessagebox.h>
  56 #include <kplugininfo.h>
  57 #include <kmenu.h>
  58 #include <kshortcut.h>
  59 #include <kstandarddirs.h>
  60 #include <kstatusbar.h>
  61 #include <kstandardaction.h>
  62 #include <ktip.h>
  63 #include <kservice.h>
  64 #include <kservicetypetrader.h>
  65 #include <kstringhandler.h>
  66 #include <ksqueezedtextlabel.h>
  67 #include <khtml_part.h>
  68 #include <khtmlview.h>
  69 #include <krun.h>
  70 #include <kaboutdata.h>
  71 #include <kmenubar.h>
  72 #include <kstandardshortcut.h>
  73 #include <ktoolinvocation.h>
  74 #include <kactionmenu.h>
  75 #include <khbox.h>
  76 #include <kvbox.h>
  77 #include <kicon.h>
  78 #include <kxmlguifactory.h>
  79
  80 #include <QComboBox>
  81 #include <QCursor>
  82 #include <QDBusConnection>
  83 #include <QImage>
  84 #include <QLayout>
  85 #include <QList>
  86 #include <QObject>
  87 #include <QPushButton>
  88 #include <QSplitter>
  89 #include <QStackedWidget>
  90 #include <QTimer>
  91
  92 using namespace Kontact;
  93
  94 // This class extends the normal KDBusServiceStarter.
  95 //
  96 // When a service start is requested, it asks all plugins
  97 // to create their dbus interfaces in addition to the normal
  98 // way of starting a service.
  99 class ServiceStarter : public KDBusServiceStarter
 100 {
 101   public:
 102
 103     virtual int startServiceFor( const QString &serviceType,
 104                                  const QString &constraint = QString(),
 105                                  QString *error = 0, QString *dbusService = 0,
 106                                  int flags = 0 );
 107
 108     // We need to keep track of the plugins which are loaded, so pass a pointer
 109     // to the plugin list here. Be sure to reset it back to 0 with
 110     // setPluginList() as soon as the list gets destroyed.
 111     ServiceStarter( PluginList *pluginList ) {
 112       mPlugins = pluginList;
 113     }
 114
 115     static void setPluginList( PluginList *pluginList ) {
 116       mPlugins = pluginList;
 117     }
 118
 119   protected:
 120
 121     virtual ~ServiceStarter() {}
 122     static PluginList *mPlugins;
 123 };
 124
 125 PluginList *ServiceStarter::mPlugins = 0;
 126
 127 int ServiceStarter::startServiceFor( const QString &serviceType,
 128                                      const QString &constraint,
 129                                      QString *error, QString *dbusService,
 130                                      int flags )
 131 {
 132   if ( mPlugins ) {
 133     PluginList::ConstIterator end = mPlugins->constEnd();
 134     for ( PluginList::ConstIterator it = mPlugins->constBegin(); it != end; ++it ) {
 135       if ( (*it)->createDBUSInterface( serviceType ) ) {
 136         kDebug() << "found interface for" << serviceType;
 137         if ( dbusService ) {
 138           *dbusService = (*it)->registerClient();
 139         }
 140         return 0;
 141       }
 142     }
 143   }
 144
 145   kDebug() << "Didn't find dbus interface, falling back to external process";
 146   return KDBusServiceStarter::startServiceFor( serviceType, constraint,
 147                                                error, dbusService, flags );
 148 }
 149
 150 MainWindow::MainWindow()
 151   : KontactInterface::Core(), mSplitter( 0 ), mCurrentPlugin( 0 ), mAboutDialog( 0 ),
 152     mReallyClose( false ), mSyncActionsEnabled( true )
 153 {
 154   // The ServiceStarter created here will be deleted by the KDbusServiceStarter
 155   // base class, which is a global static.
 156   new ServiceStarter( &mPlugins );
 157
 158   QDBusConnection::sessionBus().registerObject(
 159     "/KontactInterface", this, QDBusConnection::ExportScriptableSlots );
 160
 161   // Set this to be the group leader for all subdialogs - this means
 162   // modal subdialogs will only affect this dialog, not the other windows
 163   setAttribute( Qt::WA_GroupLeader );
 164
 165   initGUI();
 166   initObject();
 167
 168   mSidePane->setMaximumWidth( mSidePane->sizeHint().width() );
 169   mSidePane->setMinimumWidth( mSidePane->sizeHint().width() );
 170
 171   factory()->plugActionList( this, QString( "navigator_actionlist" ), mActionPlugins );
 172
 173   restoreWindowSize( KConfigGroup( KGlobal::config(), "MainWindow" ) );
 174   setAutoSaveSettings();
 175 }
 176
 177 void MainWindow::initGUI()
 178 {
 179   initWidgets();
 180   setupActions();
 181   setHelpMenuEnabled( false );
 182   KHelpMenu *helpMenu = new KHelpMenu( this, 0, true, actionCollection() );
 183   connect( helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutDialog()) );
 184
 185   KStandardAction::keyBindings( this, SLOT(configureShortcuts()), actionCollection() );
 186   KStandardAction::configureToolbars( this, SLOT(configureToolbars()), actionCollection() );
 187   setXMLFile( "kontactui.rc" );
 188
 189   setStandardToolBarMenuEnabled( true );
 190
 191   createGUI( 0 );
 192
 193   KToolBar *navigatorToolBar = findToolBar( "navigatorToolBar" );
 194   Q_ASSERT( navigatorToolBar );
 195   if ( layoutDirection() == Qt::LeftToRight ) {
 196     navigatorToolBar->setLayoutDirection( Qt::RightToLeft );
 197   } else {
 198     navigatorToolBar->setLayoutDirection( Qt::LeftToRight );
 199   }
 200   Q_ASSERT( navigatorToolBar->sizeHint().isValid() );
 201   navigatorToolBar->setMinimumWidth( navigatorToolBar->sizeHint().width() );
 202 }
 203
 204 void MainWindow::initObject()
 205 {
 206   KService::List offers = KServiceTypeTrader::self()->query(
 207     QString::fromLatin1( "Kontact/Plugin" ),
 208     QString( "[X-KDE-KontactPluginVersion] == %1" ).arg( KONTACT_PLUGIN_VERSION ) );
 209   mPluginInfos = KPluginInfo::fromServices(
 210     offers, KConfigGroup( Prefs::self()->config(), "Plugins" ) );
 211
 212   KPluginInfo::List::Iterator it;
 213   for ( it = mPluginInfos.begin(); it != mPluginInfos.end(); ++it ) {
 214     it->load();
 215   }
 216
 217   // prepare the part manager
 218   mPartManager = new KParts::PartManager( this );
 219   connect( mPartManager, SIGNAL(activePartChanged(KParts::Part *)),
 220            this, SLOT(slotActivePartChanged(KParts::Part *)) );
 221
 222   loadPlugins();
 223
 224   if ( mSidePane ) {
 225     mSidePane->updatePlugins();
 226   }
 227
 228   KSettings::Dispatcher::registerComponent( componentData(), this, "updateConfig" );
 229
 230   loadSettings();
 231
 232   statusBar()->show();
 233
 234   QTimer::singleShot( 200, this, SLOT( slotShowTipOnStart() ) );
 235
 236   // done initializing
 237   slotShowStatusMsg( QString::null );   //krazy:exclude=nullstrassign for old broken gcc
 238
 239   connect( KPIM::BroadcastStatus::instance(), SIGNAL(statusMsg(const QString &)),
 240            this, SLOT(slotShowStatusMsg(const QString &)) );
 241
 242   // launch commandline specified module if any
 243   activatePluginModule();
 244
 245   if ( Prefs::lastVersionSeen() == KGlobal::mainComponent().aboutData()->version() ) {
 246     selectPlugin( mCurrentPlugin );
 247   }
 248
 249   paintAboutScreen( introductionString() );
 250   Prefs::setLastVersionSeen( KGlobal::mainComponent().aboutData()->version() );
 251 }
 252
 253 MainWindow::~MainWindow()
 254 {
 255   if ( mCurrentPlugin ) {
 256     saveMainWindowSettings( KGlobal::config()->group(
 257                               QString( "MainWindow%1" ).arg( mCurrentPlugin->identifier() ) ) );
 258   }
 259
 260   createGUI( 0 );
 261   ServiceStarter::setPluginList( 0 );
 262   saveSettings();
 263
 264   QList<KParts::Part*> parts = mPartManager->parts();
 265
 266 //  Q_FOREACH( KParts::Part *p, parts ) {
 267 //    delete p;
 268 //    p = 0;
 269 //  }
 270
 271   Prefs::self()->writeConfig();
 272
 273   // During deletion of plugins, we should not access the plugin list (bug #182176)
 274   delete mSidePane;
 275
 276   PluginList::ConstIterator end = mPlugins.constEnd();
 277   for ( PluginList::ConstIterator it = mPlugins.constBegin(); it != end; ++it ) {
 278     delete *it;
 279   }
 280 }
 281
 282 void MainWindow::setActivePluginModule( const QString &module )
 283 {
 284   mActiveModule = module;
 285   activatePluginModule();
 286 }
 287
 288 bool MainWindow::pluginActionWeightLessThan( const QAction *left, const QAction *right )
 289 {
 290   // Since this lessThan method is used only for the toolbar (which is on
 291   // the inverse layout direction than the rest of the system), we add the
 292   // elements on the exactly inverse order. (ereslibre)
 293   return !pluginWeightLessThan( left->data().value<KontactInterface::Plugin*>(),
 294                                 right->data().value<KontactInterface::Plugin*>() );
 295 }
 296
 297 bool MainWindow::pluginWeightLessThan( const KontactInterface::Plugin *left,
 298                                        const KontactInterface::Plugin *right )
 299 {
 300   return left->weight() < right->weight();
 301 }
 302
 303 void MainWindow::activatePluginModule()
 304 {
 305   if ( !mActiveModule.isEmpty() ) {
 306     PluginList::ConstIterator end = mPlugins.constEnd();
 307     for ( PluginList::ConstIterator it = mPlugins.constBegin(); it != end; ++it ) {
 308       if ( ( *it )->identifier().contains( mActiveModule ) ) {
 309         selectPlugin( *it );
 310         return;
 311       }
 312     }
 313   }
 314 }
 315
 316 void MainWindow::initWidgets()
 317 {
 318   QWidget *mTopWidget = new QWidget( this );
 319   QVBoxLayout *layout = new QVBoxLayout;
 320   layout->setMargin(0);
 321   layout->setSpacing(0);
 322   mTopWidget->setLayout( layout );
 323   setCentralWidget( mTopWidget );
 324
 325   mSplitter = new QSplitter( mTopWidget );
 326   layout->addWidget( mSplitter );
 327   mSidePane = new IconSidePane( this, mSplitter );
 328 /*
 329   // don't occupy screen estate on load
 330
 331   QList<int> sizes;
 332   sizes << 0;
 333   mSplitter->setSizes(sizes);
 334 */
 335   connect( mSidePane, SIGNAL(pluginSelected(KontactInterface::Plugin *)),
 336            SLOT(selectPlugin(KontactInterface::Plugin *)) );
 337
 338   mPartsStack = new QStackedWidget( mSplitter );
 339   mPartsStack->layout()->setSpacing( 0 );
 340
 341   initAboutScreen();
 342
 343   QString loading =
 344     i18n( "<h2 style='text-align:center; margin-top: 0px; margin-bottom: 0px'>%1</h2>",
 345           i18n( "Loading Kontact..." ) );
 346
 347   paintAboutScreen( loading );
 348
 349   /* Create a progress dialog and hide it. */
 350   KPIM::ProgressDialog *progressDialog = new KPIM::ProgressDialog( statusBar(), this );
 351   progressDialog->hide();
 352
 353   mLittleProgress = new KPIM::StatusbarProgressWidget( progressDialog, statusBar() );
 354
 355   mStatusMsgLabel = new KSqueezedTextLabel( i18n( " Initializing..." ), statusBar() );
 356   mStatusMsgLabel->setTextElideMode( Qt::ElideRight );
 357   mStatusMsgLabel->setAlignment( Qt::AlignLeft | Qt::AlignVCenter );
 358
 359   statusBar()->addWidget( mStatusMsgLabel, 10 );
 360   statusBar()->addPermanentWidget( mLittleProgress, 0 );
 361   mLittleProgress->show();
 362
 363   mSplitter->setCollapsible( 1, false );
 364 }
 365
 366 void MainWindow::paintAboutScreen( const QString &msg )
 367 {
 368   QString location = KStandardDirs::locate( "data", "kontact/about/main.html" );
 369   QString content = KPIMUtils::kFileToByteArray( location );
 370   content = content.arg( KStandardDirs::locate( "data", "kdeui/about/kde_infopage.css" ) );
 371   if ( QApplication::isRightToLeft() ) {
 372     content = content.arg( "@import \"%1\";" ).
 373               arg( KStandardDirs::locate( "data", "kdeui/about/kde_infopage_rtl.css" ) );
 374   } else {
 375     content = content.arg( "" );
 376   }
 377
 378   mIntroPart->begin( KUrl( location ) );
 379
 380   QString appName( i18n( "KDE Kontact" ) );
 381   QString catchPhrase( i18n( "Get Organized!" ) );
 382   QString quickDescription( i18n( "The KDE Personal Information Management Suite" ) );
 383
 384   mIntroPart->write(
 385     content.arg( QFont().pointSize() + 2 ).
 386     arg( appName ).arg( catchPhrase ).arg( quickDescription ).arg( msg ) );
 387   mIntroPart->end();
 388 }
 389
 390 void MainWindow::initAboutScreen()
 391 {
 392   KHBox *introbox = new KHBox( mPartsStack );
 393   mPartsStack->addWidget( introbox );
 394   mPartsStack->setCurrentWidget( introbox );
 395   mIntroPart = new KHTMLPart( introbox );
 396   mIntroPart->widget()->setFocusPolicy( Qt::WheelFocus );
 397   // Let's better be paranoid and disable plugins (it defaults to enabled):
 398   mIntroPart->setPluginsEnabled( false );
 399   mIntroPart->setJScriptEnabled( false ); // just make this explicit
 400   mIntroPart->setJavaEnabled( false );    // just make this explicit
 401   mIntroPart->setMetaRefreshEnabled( false );
 402   mIntroPart->setURLCursor( QCursor( Qt::PointingHandCursor ) );
 403   mIntroPart->view()->setLineWidth( 0 );
 404
 405   connect( mIntroPart->browserExtension(),
 406            SIGNAL(openUrlRequest(const KUrl &,const KParts::OpenUrlArguments &,
 407                                  const KParts::BrowserArguments &)),
 408            SLOT(slotOpenUrl(const KUrl &)) );
 409
 410   connect( mIntroPart->browserExtension(),
 411            SIGNAL(createNewWindow(const KUrl &,const KParts::OpenUrlArguments &,
 412                                   const KParts::BrowserArguments &)),
 413            SLOT(slotOpenUrl(const KUrl&)) );
 414 }
 415
 416 void MainWindow::setupActions()
 417 {
 418   actionCollection()->addAction( KStandardAction::Quit, this, SLOT(slotQuit()) );
 419
 420 #ifdef Q_WS_MACX
 421  // ### This quits the application prematurely, for example when the composer window
 422  // ### is closed while the main application is minimized to the systray
 423   connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()));
 424 #endif
 425
 426   mNewActions = new KActionMenu(
 427     KIcon( "" ),
 428     i18nc( "@title:menu create new pim items (message,calendar,to-do,etc.)", "New" ), this );
 429   actionCollection()->addAction( "action_new", mNewActions );
 430   mNewActions->setShortcut( KStandardShortcut::openNew() );
 431   connect( mNewActions, SIGNAL(triggered(bool)), this, SLOT(slotNewClicked()) );
 432
 433   // If the user is using disconnected imap mail folders as groupware, we add
 434   // plugins' Synchronize actions to the toolbar which trigger an imap sync.
 435   // Otherwise it's redundant and misleading.
 436   KConfig *_cfg = Prefs::self()->config();
 437   KConfigGroup cfg( _cfg, "Kontact Groupware Settings" );
 438 #if defined(KDEPIM_ENTERPRISE_BUILD)
 439   mSyncActionsEnabled = cfg.readEntry( "GroupwareMailFoldersEnabled", true );
 440 #else
 441   mSyncActionsEnabled = cfg.readEntry( "GroupwareMailFoldersEnabled", false );
 442 #endif
 443
 444   if ( mSyncActionsEnabled ) {
 445     mSyncActions = new KActionMenu(
 446       KIcon( "view-refresh" ),
 447       i18nc( "@title:menu synchronize pim items (message,calendar,to-do,etc.)", "Sync" ), this );
 448     actionCollection()->addAction( "action_sync", mSyncActions );
 449     mSyncActions->setShortcut( KStandardShortcut::reload() );
 450     connect( mSyncActions, SIGNAL(triggered(bool)), this, SLOT(slotSyncClicked()) );
 451   }
 452
 453   KAction *action = new KAction( KIcon( "configure" ), i18n( "Configure Kontact..." ), this );
 454   actionCollection()->addAction( "settings_configure_kontact", action );
 455   connect( action, SIGNAL(triggered(bool)), SLOT(slotPreferences()) );
 456
 457   action = new KAction( KIcon( "kontact" ), i18n( "&Kontact Introduction" ), this );
 458   actionCollection()->addAction( "help_introduction", action );
 459   connect( action, SIGNAL(triggered(bool)), SLOT(slotShowIntroduction()) );
 460   action = new KAction( KIcon( "ktip" ), i18n( "&Tip of the Day" ), this );
 461   actionCollection()->addAction( "help_tipofday", action );
 462   connect( action, SIGNAL(triggered(bool)), SLOT(slotShowTip()) );
 463 }
 464
 465 bool MainWindow::isPluginLoaded( const KPluginInfo &info )
 466 {
 467   return ( pluginFromInfo( info ) != 0 );
 468 }
 469
 470 Plugin *MainWindow::pluginFromInfo( const KPluginInfo &info )
 471 {
 472   PluginList::ConstIterator end = mPlugins.constEnd();
 473   for ( PluginList::ConstIterator it = mPlugins.constBegin(); it != end; ++it ) {
 474     if ( (*it)->identifier() == info.pluginName() ) {
 475       return *it;
 476     }
 477   }
 478   return 0;
 479 }
 480
 481 void MainWindow::loadPlugins()
 482 {
 483   QList<Plugin*> plugins;
 484
 485   int i;
 486   KPluginInfo::List::ConstIterator it;
 487   for ( it = mPluginInfos.constBegin(); it != mPluginInfos.constEnd(); ++it ) {
 488     if ( !it->isPluginEnabled() ) {
 489       continue;
 490     }
 491
 492     Plugin *plugin = 0;
 493     if ( isPluginLoaded( *it ) ) {
 494       plugin = pluginFromInfo( *it );
 495       if ( plugin ) {
 496         plugin->configUpdated();
 497       }
 498       continue;
 499     }
 500
 501     kDebug() << "Loading Plugin:" << it->name();
 502     plugin =  KService::createInstance<KontactInterface::Plugin>( it->service(), this );
 503
 504     if ( !plugin ) {
 505       kDebug() << "Unable to create plugin for " << it->name();
 506       continue;
 507     }
 508
 509     plugin->setIdentifier( it->pluginName() );
 510     plugin->setTitle( it->name() );
 511     plugin->setIcon( it->icon() );
 512
 513     QVariant libNameProp = it->property( "X-KDE-KontactPartLibraryName" );
 514     QVariant exeNameProp = it->property( "X-KDE-KontactPartExecutableName" );
 515     QVariant loadOnStart = it->property( "X-KDE-KontactPartLoadOnStart" );
 516     QVariant hasPartProp = it->property( "X-KDE-KontactPluginHasPart" );
 517
 518     if ( !loadOnStart.isNull() && loadOnStart.toBool() ) {
 519       mDelayedPreload.append( plugin );
 520     }
 521
 522     kDebug() << "LIBNAMEPART:" << libNameProp.toString();
 523
 524     plugin->setPartLibraryName( libNameProp.toString().toUtf8() );
 525     plugin->setExecutableName( exeNameProp.toString() );
 526     if ( hasPartProp.isValid() ) {
 527       plugin->setShowInSideBar( hasPartProp.toBool() );
 528     }
 529
 530     for ( i = 0; i < plugins.count(); ++i ) {
 531       Plugin *p = plugins.at( i );
 532       if ( plugin->weight() < p->weight() ) {
 533         break;
 534       }
 535     }
 536     plugins.insert( i, plugin );
 537
 538   }
 539
 540   for ( i = 0; i < plugins.count(); ++ i ) {
 541     Plugin *plugin = plugins.at( i );
 542
 543     const QList<KAction*> actionList = plugin->newActions();
 544     QList<KAction*>::const_iterator listIt;
 545
 546     for ( listIt = actionList.begin(); listIt != actionList.end(); ++listIt ) {
 547       kDebug() << "Plugging New actions" << (*listIt)->objectName();
 548       mNewActions->addAction( (*listIt) );
 549     }
 550
 551     if ( mSyncActionsEnabled ) {
 552       Q_FOREACH( KAction *listIt, plugin->syncActions() ) {
 553         kDebug() << "Plugging Sync actions" << listIt->objectName();
 554         mSyncActions->addAction( listIt );
 555       }
 556     }
 557     addPlugin( plugin );
 558   }
 559
 560   mNewActions->setEnabled( mPlugins.size() != 0 );
 561   if ( mSyncActionsEnabled ) {
 562     mSyncActions->setEnabled( mPlugins.size() != 0 );
 563   }
 564 }
 565
 566 void MainWindow::unloadPlugins()
 567 {
 568   KPluginInfo::List::ConstIterator end = mPluginInfos.constEnd();
 569   KPluginInfo::List::ConstIterator it;
 570   for ( it = mPluginInfos.constBegin(); it != end; ++it ) {
 571     if ( !it->isPluginEnabled() ) {
 572       removePlugin( *it );
 573     }
 574   }
 575 }
 576
 577 void MainWindow::updateShortcuts()
 578 {
 579   ActionPluginList::ConstIterator end = mActionPlugins.constEnd();
 580   ActionPluginList::ConstIterator it;
 581   int i = 0;
 582   for ( it = mActionPlugins.constBegin(); it != end; ++it ) {
 583     KAction *action = static_cast<KAction*>( *it );
 584     QString shortcut = QString( "Ctrl+%1" ).arg( mActionPlugins.count() - i );
 585     action->setShortcut( KShortcut( shortcut ) );
 586     i++;
 587   }
 588   factory()->plugActionList( this, QString( "navigator_actionlist" ), mActionPlugins );
 589 }
 590
 591 bool MainWindow::removePlugin( const KPluginInfo &info )
 592 {
 593   PluginList::Iterator end = mPlugins.end();
 594   for ( PluginList::Iterator it = mPlugins.begin(); it != end; ++it ) {
 595     Plugin *plugin = *it;
 596     if ( ( *it )->identifier() == info.pluginName() ) {
 597       QList<KAction*> actionList = plugin->newActions();
 598       QList<KAction*>::const_iterator listIt;
 599
 600       for ( listIt = actionList.constBegin(); listIt != actionList.constEnd(); ++listIt ) {
 601         kDebug() << "Unplugging New actions" << (*listIt)->objectName();
 602         mNewActions->removeAction( *listIt );
 603       }
 604
 605       if ( mSyncActionsEnabled ) {
 606         actionList = plugin->syncActions();
 607         for ( listIt = actionList.constBegin(); listIt != actionList.constEnd(); ++listIt ) {
 608             kDebug() << "Unplugging Sync actions" << (*listIt)->objectName();
 609             mSyncActions->removeAction( *listIt );
 610         }
 611       }
 612       removeChildClient( plugin );
 613
 614       if ( mCurrentPlugin == plugin ) {
 615         mCurrentPlugin = 0;
 616         createGUI( 0 );
 617       }
 618
 619       plugin->deleteLater(); // removes the part automatically
 620       mPlugins.erase( it );
 621       if ( plugin->showInSideBar() ) {
 622         QAction *q = mPluginAction[plugin]; // remove KAction, to free the shortcut for later use
 623         mActionPlugins.removeAll( q );
 624         mPluginAction.remove(plugin);
 625         delete q;
 626       }
 627
 628       if ( mCurrentPlugin == 0 ) {
 629         PluginList::Iterator it;
 630         for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
 631           if ( (*it)->showInSideBar() ) {
 632             selectPlugin( *it );
 633             return true;
 634           }
 635         }
 636       }
 637       return true;
 638     }
 639
 640   }
 641
 642   return false;
 643 }
 644
 645 void MainWindow::addPlugin( KontactInterface::Plugin *plugin )
 646 {
 647   kDebug();
 648
 649   mPlugins.append( plugin );
 650
 651   if ( plugin->showInSideBar() ) {
 652     KAction *action = new KAction( KIcon( plugin->icon() ), plugin->title(), this );
 653     action->setCheckable( true );
 654     action->setData( QVariant::fromValue( plugin ) ); // on the slot we can decode which action was
 655                                                       // triggered
 656     connect( action, SIGNAL(triggered(bool)), SLOT(slotActionTriggered()) );
 657     actionCollection()->addAction( plugin->title(), action );
 658     mActionPlugins.append( action );
 659     mPluginAction.insert( plugin, action );
 660   }
 661
 662   // merge the plugins GUI into the main window
 663   insertChildClient( plugin );
 664
 665   // sort the action plugins again and reset shortcuts. If we removed and then readded some plugins
 666   // we need to take in count their weights for setting shortcuts again
 667   qSort( mActionPlugins.begin(), mActionPlugins.end(), pluginActionWeightLessThan );
 668   qSort( mPlugins.begin(), mPlugins.end(), pluginWeightLessThan );
 669   int i = 0;
 670   foreach ( QAction *qaction, mActionPlugins ) {
 671     KAction *action = static_cast<KAction*>( qaction );
 672     QString shortcut = QString( "Ctrl+%1" ).arg( mActionPlugins.count() - i );
 673     action->setShortcut( KShortcut( shortcut ) );
 674     i++;
 675   }
 676 }
 677
 678 void MainWindow::partLoaded( KontactInterface::Plugin *plugin, KParts::ReadOnlyPart *part )
 679 {
 680   Q_UNUSED( plugin );
 681
 682   // See if we have this part already (e.g. due to two plugins sharing it)
 683   if ( mPartsStack->indexOf( part->widget() ) != -1 ) {
 684     return;
 685   }
 686
 687   mPartsStack->addWidget( part->widget() );
 688
 689   mPartManager->addPart( part, false );
 690   // Workaround for KParts misbehavior: addPart calls show!
 691   part->widget()->hide();
 692 }
 693
 694 void MainWindow::slotActivePartChanged( KParts::Part *part )
 695 {
 696   if ( !part ) {
 697     createGUI( 0 );
 698     return;
 699   }
 700
 701   kDebug() << "Part activated:" << part
 702            << "with stack id."<< mPartsStack->indexOf( part->widget() );
 703
 704   statusBar()->clearMessage();
 705 }
 706
 707 void MainWindow::slotNewClicked()
 708 {
 709   if ( !mCurrentPlugin->newActions().isEmpty() ) {
 710     mCurrentPlugin->newActions().first()->trigger();
 711   } else {
 712     PluginList::Iterator it;
 713     for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
 714       if ( !(*it)->newActions().isEmpty() ) {
 715         (*it)->newActions().first()->trigger();
 716         return;
 717       }
 718     }
 719   }
 720 }
 721
 722 void MainWindow::slotSyncClicked()
 723 {
 724   if ( !mCurrentPlugin->syncActions().isEmpty() ) {
 725     mCurrentPlugin->syncActions().first()->trigger();
 726   } else {
 727     PluginList::Iterator it;
 728     for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
 729       if ( !(*it)->syncActions().isEmpty() ) {
 730         (*it)->syncActions().first()->trigger();
 731         return;
 732       }
 733     }
 734   }
 735 }
 736
 737 KToolBar *KontactInterface::MainWindow::findToolBar( const char *name )
 738 {
 739   // like KMainWindow::toolBar, but which doesn't create the toolbar if not found
 740   return findChild<KToolBar *>( name );
 741 }
 742
 743 void MainWindow::selectPlugin( KontactInterface::Plugin *plugin )
 744 {
 745   if ( !plugin ) {
 746     return;
 747   }
 748
 749   if ( plugin->isRunningStandalone() ) {
 750     statusBar()->showMessage( i18n( "Application is running standalone. Foregrounding..." ), 1000 );
 751     plugin->bringToForeground();
 752     return;
 753   }
 754
 755   QApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
 756
 757   if ( mCurrentPlugin ) {
 758     saveMainWindowSettings( KGlobal::config()->group(
 759                               QString( "MainWindow%1" ).arg( mCurrentPlugin->identifier() ) ) );
 760   }
 761
 762   KParts::Part *part = plugin->part();
 763
 764   if ( !part ) {
 765     QApplication::restoreOverrideCursor();
 766     KMessageBox::error( this, i18n( "Cannot load part for %1.",
 767                                     plugin->title() ) + '\n' + lastErrorMessage() );
 768     plugin->setDisabled( true );
 769     mSidePane->updatePlugins();
 770     return;
 771   }
 772
 773   if ( mCurrentPlugin ) {
 774     KAction *action = mPluginAction[ mCurrentPlugin ];
 775     if ( action ) {
 776       action->setChecked( false );
 777     }
 778   }
 779   KAction *selectedPluginAction = mPluginAction[ plugin ];
 780   if ( selectedPluginAction ) {
 781     selectedPluginAction->setChecked( true );
 782   }
 783
 784   // store old focus widget
 785   QWidget *focusWidget = kapp->focusWidget();
 786   if ( mCurrentPlugin && focusWidget ) {
 787     // save the focus widget only when it belongs to the activated part
 788     QWidget *parent = focusWidget->parentWidget();
 789     while ( parent ) {
 790       if ( parent == mCurrentPlugin->part()->widget() ) {
 791         mFocusWidgets.insert( mCurrentPlugin->identifier(), QPointer<QWidget>( focusWidget ) );
 792       }
 793       parent = parent->parentWidget();
 794     }
 795   }
 796
 797   if ( mSidePane ) {
 798     mSidePane->setCurrentPlugin( plugin->identifier() );
 799   }
 800
 801   plugin->select();
 802
 803   mPartManager->setActivePart( part );
 804   QWidget *view = part->widget();
 805   Q_ASSERT( view );
 806
 807   if ( view ) {
 808     mPartsStack->setCurrentWidget( view );
 809     view->show();
 810
 811     if ( mFocusWidgets.contains( plugin->identifier() ) ) {
 812       focusWidget = mFocusWidgets[ plugin->identifier() ];
 813       if ( focusWidget ) {
 814         focusWidget->setFocus();
 815       }
 816     } else {
 817       view->setFocus();
 818     }
 819
 820     mCurrentPlugin = plugin;
 821
 822     QAction *newAction = 0;
 823     if ( !plugin->newActions().isEmpty() ) {
 824       newAction = plugin->newActions().first();
 825     }
 826
 827     QAction *syncAction = 0;
 828     if ( !plugin->syncActions().isEmpty() ) {
 829       syncAction = plugin->syncActions().first();
 830     }
 831
 832     removeInvisibleToolbarActions(plugin);
 833
 834     createGUI( plugin->part() );
 835
 836     setCaption( i18nc( "Plugin dependent window title", "%1 - Kontact", plugin->title() ) );
 837
 838     if ( newAction ) {
 839       mNewActions->setIcon( newAction->icon() );
 840       static_cast<QAction*>( mNewActions )->setText( newAction->text() );
 841       mNewActions->setWhatsThis( newAction->whatsThis() );
 842     } else { // we'll use the action of the first plugin which offers one
 843       PluginList::Iterator it;
 844       for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
 845         if ( (*it)->newActions().count() > 0 ) {
 846           newAction = (*it)->newActions().first();
 847         }
 848         if ( newAction ) {
 849           static_cast<QAction*>( mNewActions )->setIcon( newAction->icon() );
 850           mNewActions->setText( newAction->text() );
 851           mNewActions->setWhatsThis( newAction->whatsThis() );
 852           break;
 853         }
 854       }
 855     }
 856
 857     if ( mSyncActionsEnabled ) {
 858       if ( syncAction ) {
 859         mSyncActions->setIcon( syncAction->icon() );
 860         static_cast<QAction*>( mSyncActions )->setText( syncAction->text() );
 861       } else { // we'll use the action of the first plugin which offers one
 862         PluginList::Iterator it;
 863         for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
 864           if ( (*it)->syncActions().count() > 0 ) {
 865             syncAction = (*it)->syncActions().first();
 866           }
 867           if ( syncAction ) {
 868             static_cast<QAction*>( mSyncActions )->setIcon( syncAction->icon() );
 869             mSyncActions->setText( syncAction->text() );
 870             break;
 871           }
 872         }
 873       }
 874     }
 875   }
 876
 877   KToolBar *navigatorToolBar = findToolBar( "navigatorToolBar" );
 878   if ( navigatorToolBar && !navigatorToolBar->isHidden() &&
 879        ( toolBarArea( navigatorToolBar ) == Qt::TopToolBarArea ||
 880          toolBarArea( navigatorToolBar ) == Qt::BottomToolBarArea ) ) {
 881     addToolBar( toolBarArea( navigatorToolBar ), navigatorToolBar );
 882   }
 883
 884   applyMainWindowSettings( KGlobal::config()->group(
 885                              QString( "MainWindow%1" ).arg( plugin->identifier() ) ) );
 886
 887   QApplication::restoreOverrideCursor();
 888 }
 889
 890 // Hack to access KXMLGUIClient::setDOMDocument which should be public...
 891 class ReadOnlyPartAccess : public KParts::ReadOnlyPart
 892 {
 893   public:
 894   using KParts::ReadOnlyPart::setDOMDocument;
 895 };
 896
 897 void MainWindow::removeInvisibleToolbarActions(Plugin* plugin)
 898 {
 899   // Hide unwanted toolbar action by modifying the XML before createGUI, rather than
 900   // doing it by calling removeAction on the toolbar after createGUI. Both solutions
 901   // work visually, but only modifying the XML ensures that the actions don't appear
 902   // in "edit toolbars". #207296
 903   KParts::Part *part = plugin->part();
 904   const QStringList hideActions = plugin->invisibleToolbarActions();
 905   //kDebug() << "Hiding actions" << hideActions;
 906   QDomDocument doc = part->domDocument();
 907   QDomElement docElem = doc.documentElement();
 908   // 1. Iterate over containers
 909   for (QDomElement containerElem = docElem.firstChildElement();
 910        !containerElem.isNull(); containerElem = containerElem.nextSiblingElement()) {
 911     if (QString::compare(containerElem.tagName(), "ToolBar", Qt::CaseInsensitive) == 0) {
 912       // 2. Iterate over actions in toolbars
 913       QDomElement actionElem = containerElem.firstChildElement();
 914       while (!actionElem.isNull()) {
 915         QDomElement nextActionElem = actionElem.nextSiblingElement();
 916         if (actionElem.attribute("remove_in_kontact") == "true") {
 917             containerElem.removeChild(actionElem);
 918         }
 919         if (QString::compare(actionElem.tagName(), "Action", Qt::CaseInsensitive) == 0) {
 920           //kDebug() << "Looking at action" << actionElem.attribute("name");
 921           if (hideActions.contains(actionElem.attribute("name"))) {
 922             //kDebug() << "REMOVING";
 923             containerElem.removeChild(actionElem);
 924           }
 925         }
 926         actionElem = nextActionElem;
 927       }
 928     }
 929   }
 930   //kDebug() << doc.toString();
 931   static_cast<ReadOnlyPartAccess *>(part)->setDOMDocument(doc);
 932 }
 933
 934 void MainWindow::slotActionTriggered()
 935 {
 936   KAction *actionSender = static_cast<KAction*>( sender() );
 937   actionSender->setChecked( true );
 938   KontactInterface::Plugin *plugin = actionSender->data().value<KontactInterface::Plugin*>();
 939   if ( !plugin ) {
 940     return;
 941   }
 942   mSidePane->setCurrentPlugin( plugin->identifier() );
 943 }
 944
 945 void MainWindow::selectPlugin( const QString &pluginName )
 946 {
 947   PluginList::ConstIterator end = mPlugins.constEnd();
 948   for ( PluginList::ConstIterator it = mPlugins.constBegin(); it != end; ++it ) {
 949     if ( ( *it )->identifier() == pluginName ) {
 950       selectPlugin( *it );
 951       return;
 952     }
 953   }
 954 }
 955
 956 void MainWindow::loadSettings()
 957 {
 958   if ( mSplitter ) {
 959     // if the preferences do not contain useful values, the side pane part of the splitter
 960     // takes up the full width of the window, so leave the splitter sizing at the widget defaults
 961     QList<int> sizes = Prefs::self()->sidePaneSplitter();
 962     if ( sizes.count() == mSplitter->count() ) {
 963       mSplitter->setSizes( sizes );
 964     }
 965   }
 966
 967   // Preload Plugins. This _must_ happen before the default part is loaded
 968   PluginList::ConstIterator it;
 969   for ( it = mDelayedPreload.constBegin(); it != mDelayedPreload.constEnd(); ++it ) {
 970     selectPlugin( *it );
 971   }
 972   selectPlugin( Prefs::self()->mActivePlugin );
 973 }
 974
 975 void MainWindow::saveSettings()
 976 {
 977   if ( mSplitter ) {
 978     Prefs::self()->mSidePaneSplitter = mSplitter->sizes();
 979   }
 980
 981   if ( mCurrentPlugin ) {
 982     Prefs::self()->mActivePlugin = mCurrentPlugin->identifier();
 983   }
 984 }
 985
 986 void MainWindow::slotShowTip()
 987 {
 988   showTip( true );
 989 }
 990
 991 void MainWindow::slotShowTipOnStart()
 992 {
 993   showTip( false );
 994 }
 995
 996 void MainWindow::slotShowIntroduction()
 997 {
 998   mPartsStack->setCurrentIndex( 0 );
 999 }
1000
1001 void MainWindow::showTip( bool force )
1002 {
1003   QStringList tips;
1004   PluginList::ConstIterator end = mPlugins.constEnd();
1005   for ( PluginList::ConstIterator it = mPlugins.constBegin(); it != end; ++it ) {
1006     QString file = (*it)->tipFile();
1007     if ( !file.isEmpty() ) {
1008       tips.append( file );
1009     }
1010   }
1011
1012   KTipDialog::showMultiTip( this, tips, force );
1013 }
1014
1015 void MainWindow::slotQuit()
1016 {
1017   mReallyClose = true;
1018   close();
1019 }
1020
1021 void MainWindow::slotPreferences()
1022 {
1023   static KSettings::Dialog *dlg = 0;
1024   if ( !dlg ) {
1025     dlg = new KSettings::Dialog( this );
1026     dlg->setAllowComponentSelection( true );
1027
1028     // do not show settings of components running standalone
1029     KPluginInfo::List filteredPlugins = mPluginInfos;
1030     PluginList::ConstIterator it;
1031     for ( it = mPlugins.constBegin(); it != mPlugins.constEnd(); ++it ) {
1032       if ( (*it)->isRunningStandalone() ) {
1033         KPluginInfo::List::ConstIterator infoIt;
1034         for ( infoIt = filteredPlugins.constBegin();
1035               infoIt != filteredPlugins.constEnd(); ++infoIt ) {
1036           if ( infoIt->pluginName() == (*it)->identifier() ) {
1037             filteredPlugins.removeAll( *infoIt );
1038             break;
1039           }
1040         }
1041       }
1042     }
1043
1044     dlg->setHelp( "main-config", "kontact" );
1045     dlg->addPluginInfos( filteredPlugins );
1046     connect( dlg, SIGNAL(pluginSelectionChanged()), SLOT(pluginsChanged()) );
1047   }
1048
1049   dlg->show();
1050 }
1051
1052 void MainWindow::pluginsChanged()
1053 {
1054   unplugActionList( "navigator_actionlist" );
1055   unloadPlugins();
1056   loadPlugins();
1057   mSidePane->updatePlugins();
1058   updateShortcuts();
1059 }
1060
1061 void MainWindow::updateConfig()
1062 {
1063   kDebug();
1064
1065   saveSettings();
1066   loadSettings();
1067 }
1068
1069 void MainWindow::showAboutDialog()
1070 {
1071   QApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
1072
1073   if ( !mAboutDialog ) {
1074     mAboutDialog = new AboutDialog( this );
1075   }
1076
1077   mAboutDialog->show();
1078   mAboutDialog->raise();
1079   QApplication::restoreOverrideCursor();
1080 }
1081
1082 void MainWindow::configureShortcuts()
1083 {
1084   KShortcutsDialog dialog(
1085     KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsAllowed, this );
1086   dialog.addCollection( actionCollection() );
1087
1088   if ( mCurrentPlugin && mCurrentPlugin->part() ) {
1089     dialog.addCollection( mCurrentPlugin->part()->actionCollection() );
1090   }
1091
1092   dialog.configure();
1093 }
1094
1095 void MainWindow::configureToolbars()
1096 {
1097   if ( mCurrentPlugin ) {
1098     saveMainWindowSettings( KGlobal::config()->group(
1099                               QString( "MainWindow%1" ).arg( mCurrentPlugin->identifier() ) ) );
1100   }
1101   KEditToolBar edit( factory() );
1102   connect( &edit, SIGNAL(newToolbarConfig()), this, SLOT(slotNewToolbarConfig()) );
1103   edit.exec();
1104 }
1105
1106 void MainWindow::slotNewToolbarConfig()
1107 {
1108   if ( mCurrentPlugin && mCurrentPlugin->part() ) {
1109     removeInvisibleToolbarActions(mCurrentPlugin);
1110     createGUI( mCurrentPlugin->part() );
1111   }
1112   if ( mCurrentPlugin ) {
1113     applyMainWindowSettings( KGlobal::config()->group(
1114                                QString( "MainWindow%1" ).arg( mCurrentPlugin->identifier() ) ) );
1115   }
1116   updateShortcuts(); // for the plugActionList call
1117 }
1118
1119 void MainWindow::slotOpenUrl( const KUrl &url )
1120 {
1121   if ( url.protocol() == "exec" ) {
1122     if ( url.path() == "/switch" ) {
1123       if ( mCurrentPlugin ) {
1124         mPartsStack->setCurrentIndex( mPartsStack->indexOf( mCurrentPlugin->part()->widget() ) );
1125       }
1126     }
1127     if ( url.path() == "/gwwizard" ) {
1128       KRun::runCommand( "groupwarewizard", this );
1129       slotQuit();
1130     }
1131   } else {
1132     new KRun( url, this );
1133   }
1134 }
1135
1136 void MainWindow::readProperties( const KConfigGroup &config )
1137 {
1138   Core::readProperties( config );
1139
1140   QSet<QString> activePlugins =
1141     QSet<QString>::fromList( config.readEntry( "ActivePlugins", QStringList() ) );
1142   foreach ( Plugin *plugin, mPlugins ) {
1143     if ( !plugin->isRunningStandalone() && activePlugins.contains( plugin->identifier() ) ) {
1144       plugin->readProperties( config );
1145     }
1146   }
1147 }
1148
1149 void MainWindow::saveProperties( KConfigGroup &config )
1150 {
1151   Core::saveProperties( config );
1152
1153   QStringList activePlugins;
1154
1155   foreach ( const KPluginInfo &pluginInfo, mPluginInfos ) {
1156     if ( pluginInfo.isPluginEnabled() ) {
1157       Plugin *plugin = pluginFromInfo( pluginInfo );
1158       if ( plugin ) {
1159         activePlugins.append( plugin->identifier() );
1160         plugin->saveProperties( config );
1161       }
1162     }
1163   }
1164
1165   config.writeEntry( "ActivePlugins", activePlugins );
1166 }
1167
1168 bool MainWindow::queryClose()
1169 {
1170   if ( kapp->sessionSaving() || mReallyClose ) {
1171     return true;
1172   }
1173
1174   foreach ( Plugin *plugin, mPlugins ) {
1175     if ( !plugin->isRunningStandalone() ) {
1176       if ( !plugin->queryClose() ) {
1177         return false;
1178       }
1179     }
1180   }
1181   return true;
1182 }
1183
1184 void MainWindow::slotShowStatusMsg( const QString &msg )
1185 {
1186   if ( !statusBar() || !mStatusMsgLabel ) {
1187      return;
1188   }
1189
1190   mStatusMsgLabel->setText( msg );
1191 }
1192
1193 QString MainWindow::introductionString()
1194 {
1195   KIconLoader *iconloader = KIconLoader::global();
1196   int iconSize = iconloader->currentSize( KIconLoader::Desktop );
1197
1198   QString handbook_icon_path = iconloader->iconPath( "help-contents", KIconLoader::Desktop );
1199   QString html_icon_path = iconloader->iconPath( "text-html", KIconLoader::Desktop );
1200   QString wizard_icon_path = iconloader->iconPath( "tools-wizard", KIconLoader::Desktop );
1201
1202   QString info = ki18n( "<h2 style='text-align:center; margin-top: 0px;'>Welcome to Kontact %1</h2>"
1203       "<p align=\"center\">%2</p>"
1204       "<table align=\"center\">"
1205       "<tr><td><a href=\"%3\"><img width=\"%4\" height=\"%5\" src=\"%6\" /></a></td>"
1206       "<td><a href=\"%7\">%8</a><br /><span id=\"subtext\"><nobr>%9</nobr></span></td></tr>"
1207       "<tr><td><a href=\"%10\"><img width=\"%11\" height=\"%12\" src=\"%13\" /></a></td>"
1208       "<td><a href=\"%14\">%15</a><br /><span id=\"subtext\"><nobr>%16</nobr></span></td></tr>"
1209       "<tr><td><a href=\"%17\"><img width=\"%18\" height=\"%19\" src=\"%20\" /></a></td>"
1210       "<td><a href=\"%21\">%22</a><br /><span id=\"subtext\"><nobr>%23</nobr></span></td></tr>"
1211       "</table>"
1212       "<p style=\"margin-bottom: 0px\"> <a href=\"%24\">Skip this introduction</a></p>" )
1213       .subs( KGlobal::mainComponent().aboutData()->version() )
1214       .subs( i18n( "Kontact handles your e-mail, address book, calendar, to-do list and more." ) )
1215       .subs( "help:/kontact" )
1216       .subs( iconSize )
1217       .subs( iconSize )
1218       .subs( handbook_icon_path )
1219       .subs( "help:/kontact" )
1220       .subs( i18n( "Read Manual" ) )
1221       .subs( i18n( "Learn more about Kontact and its components" ) )
1222       .subs( "http://kontact.org" )
1223       .subs( iconSize )
1224       .subs( iconSize )
1225       .subs( html_icon_path )
1226       .subs( "http://kontact.org" )
1227       .subs( i18n( "Visit Kontact Website" ) )
1228       .subs( i18n( "Access online resources and tutorials" ) )
1229       .subs( "exec:/gwwizard" )
1230       .subs( iconSize )
1231       .subs( iconSize )
1232       .subs( wizard_icon_path )
1233       .subs( "exec:/gwwizard" )
1234       .subs( i18n( "Configure Kontact as Groupware Client" ) )
1235       .subs( i18n( "Prepare Kontact for use in corporate networks" ) )
1236       .subs( "exec:/switch" )
1237       .toString();
1238   return info;
1239 }
1240
1241 #include "mainwindow.moc"