kget/mainwindow.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2002 by Patrick Charbonnier <pch@freeshell.org>
   4    Based On Caitoo v.0.7.3 (c) 1998 - 2000, Matej Koss
   5    Copyright (C) 2002 Carsten Pfeiffer <pfeiffer@kde.org>
   6    Copyright (C) 2006 - 2008 Urs Wolfer <uwolfer @ kde.org>
   7    Copyright (C) 2006 Dario Massarin <nekkar@libero.it>
   8    Copyright (C) 2008 Lukas Appelhans <l.appelhans@gmx.de>
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public
  12    License as published by the Free Software Foundation; either
  13    version 2 of the License, or (at your option) any later version.
  14 */
  15
  16 #include "mainwindow.h"
  17
  18 #include "core/kget.h"
  19 #include "core/transferhandler.h"
  20 #include "core/transfergrouphandler.h"
  21 #include "core/transfertreeselectionmodel.h"
  22 #include "dbus/dbusmodelobserver.h"
  23 #include "settings.h"
  24 #include "conf/preferencesdialog.h"
  25 #include "ui/viewscontainer.h"
  26 #include "ui/tray.h"
  27 #include "ui/droptarget.h"
  28 #include "ui/newtransferdialog.h"
  29 #include "ui/history/transferhistory.h"
  30 #include "ui/groupsettingsdialog.h"
  31 #include "ui/transfersettingsdialog.h"
  32 #include "ui/linkview/kget_linkview.h"
  33 #include "extensions/webinterface/httpserver.h"
  34
  35 #include <kapplication.h>
  36 #include <kstandarddirs.h>
  37 #include <KInputDialog>
  38 #include <kmessagebox.h>
  39 #include <kshortcutsdialog.h>
  40 #include <kedittoolbar.h>
  41 #include <knotifyconfigwidget.h>
  42 #include <kfiledialog.h>
  43 #include <ktoolinvocation.h>
  44 #include <kmenubar.h>
  45 #include <kiconloader.h>
  46 #include <kstandardaction.h>
  47 #include <klocale.h>
  48 #include <kicon.h>
  49 #include <kactionmenu.h>
  50 #include <krun.h>
  51 #include <kicondialog.h>
  52
  53 #include <QClipboard>
  54 #include <QTimer>
  55
  56 MainWindow::MainWindow(bool showMainwindow, bool startWithoutAnimation, QWidget *parent)
  57     : KXmlGuiWindow( parent ),
  58       m_drop(0),
  59       m_dock(0),
  60       m_startWithoutAnimation(startWithoutAnimation),
  61       m_webinterface(0)
  62 {
  63     // do not quit the app when it has been minimized to system tray and a new transfer dialog
  64     // gets opened and closed again.
  65     qApp->setQuitOnLastWindowClosed(false);
  66     setAttribute(Qt::WA_DeleteOnClose, false);
  67
  68     // create the model
  69     KGet::self( this );
  70
  71     // create actions
  72     setupActions();
  73
  74     createGUI("kgetui.rc");
  75
  76     m_viewsContainer = new ViewsContainer(this);
  77     // initialize the model observer to export percents over dbus
  78     m_dbusModelObserver = new DBusModelObserver();
  79
  80     setCentralWidget(m_viewsContainer);
  81
  82     // restore position, size and visibility
  83     move( Settings::mainPosition() );
  84     setAutoSaveSettings();
  85     setPlainCaption(i18n("KGet"));
  86
  87     if ( Settings::showMain() && showMainwindow)
  88         show();
  89     else
  90         hide();
  91
  92     //Some of the widgets are initialized in slotDelayedInit()
  93     QTimer::singleShot( 0, this, SLOT(slotDelayedInit()) );
  94
  95     // Update the title with the active transfers percent using the mainwindowmodelobserver
  96     KGet::addObserver(new MainWindowModelObserver(this));
  97 }
  98
  99 MainWindow::~MainWindow()
 100 {
 101     //Save the user's transfers
 102     KGet::save();
 103
 104     slotSaveMyself();
 105     delete clipboardTimer;
 106     delete m_drop;
 107     delete m_dock;
 108     // reset konqueror integration (necessary if user enabled / disabled temporarily integration from tray)
 109     slotKonquerorIntegration( Settings::konquerorIntegration() );
 110     // the following call saves options set in above dtors
 111     Settings::self()->writeConfig();
 112 }
 113
 114 QSize MainWindow::sizeHint() const
 115 {
 116     return QSize(720, 380);
 117 }
 118
 119 int MainWindow::transfersPercent()
 120 {
 121     int percent = 0;
 122     int activeTransfers = 0;
 123     foreach (const TransferHandler *handler, KGet::allTransfers()) {
 124         if (handler->status() == Job::Running) {
 125             activeTransfers ++;
 126             percent += handler->percent();
 127         }
 128     }
 129
 130     if (activeTransfers > 0) {
 131         return percent/activeTransfers;
 132     }
 133     else {
 134         return -1;
 135     }
 136 }
 137
 138 void MainWindow::exportTransfers(bool plain)
 139 {
 140     QString filter = "";
 141     if (!plain) {
 142         filter = "*.kgt|" + i18n("KGet Transfer List") + " (*.kgt)";
 143     }
 144
 145     QString filename = KFileDialog::getSaveFileName
 146         (KUrl(),
 147          filter,
 148          this,
 149          i18n("Export Transfers")
 150         );
 151
 152     if(!filename.isEmpty())
 153         KGet::save(filename, plain);
 154 }
 155
 156 void MainWindow::setupActions()
 157 {
 158     KAction *newDownloadAction = actionCollection()->addAction("new_download");
 159     newDownloadAction->setText(i18n("&New Download..."));
 160     newDownloadAction->setIcon(KIcon("document-new"));
 161     newDownloadAction->setShortcuts(KShortcut("Ctrl+N"));
 162     connect(newDownloadAction, SIGNAL(triggered()), SLOT(slotNewTransfer()));
 163
 164     KAction *openAction = actionCollection()->addAction("import_transfers");
 165     openAction->setText(i18n("&Import Transfers..."));
 166     openAction->setIcon(KIcon("document-open"));
 167     openAction->setShortcuts(KShortcut("Ctrl+I"));
 168     connect(openAction, SIGNAL(triggered()), SLOT(slotImportTransfers()));
 169
 170     KAction *exportAction = actionCollection()->addAction("export_transfers");
 171     exportAction->setText(i18n("&Export Transfers List..."));
 172     exportAction->setIcon(KIcon("document-export"));
 173     exportAction->setShortcuts(KShortcut("Ctrl+E"));
 174     connect(exportAction, SIGNAL(triggered()), SLOT(slotExportTransfers()));
 175
 176     KAction *exportPlainAction = actionCollection()->addAction("export_plain_transfers");
 177     exportPlainAction->setText(i18n("&Export Transfers as Plain Text"));
 178     exportPlainAction->setIcon(KIcon("document-export"));
 179     exportPlainAction->setShortcuts(KShortcut("Ctrl+P"));
 180     connect(exportPlainAction, SIGNAL(triggered()), SLOT(slotExportPlainTransfers()));
 181
 182     KAction *deleteGroupAction = actionCollection()->addAction("delete_groups");
 183     deleteGroupAction->setText(i18n("Delete Group"));
 184     deleteGroupAction->setIcon(KIcon("edit-delete"));
 185     connect(deleteGroupAction, SIGNAL(triggered()), SLOT(slotDeleteGroup()));
 186
 187     KAction *renameGroupAction = actionCollection()->addAction("rename_groups");
 188     renameGroupAction->setText(i18n("Rename Group"));
 189     renameGroupAction->setIcon(KIcon("edit-rename"));
 190     connect(renameGroupAction, SIGNAL(triggered()), SLOT(slotRenameGroup()));
 191
 192     KAction *setIconGroupAction = actionCollection()->addAction("seticon_groups");
 193     setIconGroupAction->setText(i18n("Set Icon"));
 194     setIconGroupAction->setIcon(KIcon("preferences-desktop-icons"));
 195     connect(setIconGroupAction, SIGNAL(triggered()), SLOT(slotSetIconGroup()));
 196
 197     m_autoPasteAction = new KToggleAction(KIcon("edit-paste"),
 198                                           i18n("Auto-Paste Mode"), actionCollection());
 199     actionCollection()->addAction("auto_paste", m_autoPasteAction);
 200     m_autoPasteAction->setChecked(Settings::autoPaste());
 201     m_autoPasteAction->setWhatsThis(i18n("<b>Auto paste</b> button toggles the auto-paste mode "
 202                                          "on and off.\nWhen set, KGet will periodically scan "
 203                                          "the clipboard for URLs and paste them automatically."));
 204     connect(m_autoPasteAction, SIGNAL(triggered()), SLOT(slotToggleAutoPaste()));
 205
 206     m_konquerorIntegration = new KToggleAction(KIcon("konqueror"),
 207                                                i18n("Use KGet as Konqueror Download Manager"), actionCollection());
 208     actionCollection()->addAction("konqueror_integration", m_konquerorIntegration);
 209     connect(m_konquerorIntegration, SIGNAL(triggered(bool)), SLOT(slotTrayKonquerorIntegration(bool)));
 210     m_konquerorIntegration->setChecked(Settings::konquerorIntegration());
 211
 212     // local - Destroys all sub-windows and exits
 213     KStandardAction::quit(this, SLOT(slotQuit()), actionCollection());
 214     // local - Standard configure actions
 215     KStandardAction::preferences(this, SLOT(slotPreferences()), actionCollection());
 216     KStandardAction::configureToolbars(this, SLOT(slotConfigureToolbars()), actionCollection());
 217     KStandardAction::keyBindings(this, SLOT(slotConfigureKeys()), actionCollection());
 218
 219     KStandardAction::configureNotifications(this, SLOT(slotConfigureNotifications()), actionCollection());
 220     m_menubarAction = KStandardAction::showMenubar(this, SLOT(slotShowMenubar()), actionCollection());
 221     m_menubarAction->setChecked(!menuBar()->isHidden());
 222
 223     // Transfer related actions
 224     KAction *deleteSelectedAction = actionCollection()->addAction("delete_selected_download");
 225     deleteSelectedAction->setText(i18nc("delete selected transfer item", "Delete Selected"));
 226     deleteSelectedAction->setIcon(KIcon("edit-delete"));
 227     deleteSelectedAction->setShortcuts(KShortcut("Del"));
 228     connect(deleteSelectedAction, SIGNAL(triggered()), SLOT(slotDeleteSelected()));
 229
 230     KAction *deleteAllFinishedAction = actionCollection()->addAction("delete_all_finished");
 231     deleteAllFinishedAction->setText(i18nc("delete all finished transfers", "Delete all finished"));
 232     deleteAllFinishedAction->setIcon(KIcon("edit-clear-list"));
 233     connect(deleteAllFinishedAction, SIGNAL(triggered()), SLOT(slotDeleteFinished()));
 234
 235     KAction *redownloadSelectedAction = actionCollection()->addAction("redownload_selected_download");
 236     redownloadSelectedAction->setText(i18nc("redownload selected transfer item", "Redownload Selected"));
 237     redownloadSelectedAction->setIcon(KIcon("view-refresh"));
 238     connect(redownloadSelectedAction, SIGNAL(triggered()), SLOT(slotRedownloadSelected()));
 239
 240     KAction *startAllAction = actionCollection()->addAction("start_all_download");
 241     startAllAction->setText(i18n("Start / Resume All"));
 242     startAllAction->setIcon(KIcon("media-seek-forward"));
 243     startAllAction->setShortcuts(KShortcut("Ctrl+R"));
 244     connect(startAllAction, SIGNAL(triggered()), SLOT(slotStartAllDownload()));
 245
 246     KAction *startSelectedAction = actionCollection()->addAction("start_selected_download");
 247     startSelectedAction->setText(i18n("Start / Resume Selected"));
 248     startSelectedAction->setIcon(KIcon("media-playback-start"));
 249     connect(startSelectedAction, SIGNAL(triggered()), SLOT(slotStartSelectedDownload()));
 250
 251     KAction *stopAllAction = actionCollection()->addAction("stop_all_download");
 252     stopAllAction->setText(i18n("Stop All"));
 253     stopAllAction->setIcon(KIcon("media-playback-pause"));
 254     stopAllAction->setShortcuts(KShortcut("Ctrl+P"));
 255     connect(stopAllAction, SIGNAL(triggered()), SLOT(slotStopAllDownload()));
 256
 257     KAction *stopSelectedAction = actionCollection()->addAction("stop_selected_download");
 258     stopSelectedAction->setText(i18n("Stop Selected"));
 259     stopSelectedAction->setIcon(KIcon("media-playback-pause"));
 260     connect(stopSelectedAction, SIGNAL(triggered()), SLOT(slotStopSelectedDownload()));
 261
 262     KActionMenu *startActionMenu = new KActionMenu(KIcon("media-playback-start"), i18n("Start / Resume"),
 263                                                      actionCollection());
 264     actionCollection()->addAction("start_menu", startActionMenu);
 265     startActionMenu->setDelayed(true);
 266     startActionMenu->addAction(startAllAction);
 267     startActionMenu->addAction(startSelectedAction);
 268     connect(startActionMenu, SIGNAL(triggered()), SLOT(slotStartDownload()));
 269
 270     KActionMenu *stopActionMenu = new KActionMenu(KIcon("media-playback-pause"), i18n("Stop"),
 271                                                     actionCollection());
 272     actionCollection()->addAction("stop_menu", stopActionMenu);
 273     stopActionMenu->setDelayed(true);
 274     stopActionMenu->addAction(stopAllAction);
 275     stopActionMenu->addAction(stopSelectedAction);
 276     connect(stopActionMenu, SIGNAL(triggered()), SLOT(slotStopDownload()));
 277
 278     KAction *openDestAction = actionCollection()->addAction("transfer_open_dest");
 279     openDestAction->setText(i18n("Open Destination"));
 280     openDestAction->setIcon(KIcon("document-open"));
 281     connect(openDestAction, SIGNAL(triggered()), SLOT(slotTransfersOpenDest()));
 282
 283     KAction *openFileAction = actionCollection()->addAction("transfer_open_file");
 284     openFileAction->setText(i18n("Open File"));
 285     openFileAction->setIcon(KIcon("document-open"));
 286     connect(openFileAction, SIGNAL(triggered()), SLOT(slotTransfersOpenFile()));
 287
 288     KAction *showDetailsAction = actionCollection()->addAction("transfer_show_details");
 289     showDetailsAction->setText(i18n("Show Details"));
 290     showDetailsAction->setIcon(KIcon("document-properties"));
 291     connect(showDetailsAction, SIGNAL(triggered()), SLOT(slotTransfersShowDetails()));
 292
 293     KAction *copyUrlAction = actionCollection()->addAction("transfer_copy_source_url");
 294     copyUrlAction->setText(i18n("Copy URL to Clipboard"));
 295     copyUrlAction->setIcon(KIcon("edit-copy"));
 296     connect(copyUrlAction, SIGNAL(triggered()), SLOT(slotTransfersCopySourceUrl()));
 297
 298     KToggleAction *showDropTargetAction = new KToggleAction(KIcon("kget"),
 299                                           i18n("Show Drop Target"), actionCollection());
 300     actionCollection()->addAction("show_drop_target", showDropTargetAction);
 301     showDropTargetAction->setChecked(Settings::showDropTarget());
 302     connect(showDropTargetAction, SIGNAL(triggered()), SLOT(slotToggleDropTarget()));
 303
 304     KAction *transferHistoryAction = actionCollection()->addAction("transfer_history");
 305     transferHistoryAction->setText(i18n("&Transfer History..."));
 306     transferHistoryAction->setIcon(KIcon("view-history"));
 307     transferHistoryAction->setShortcuts(KShortcut("Ctrl+H"));
 308     connect(transferHistoryAction, SIGNAL(triggered()), SLOT(slotTransferHistory()));
 309
 310     KAction *transferGroupSettingsAction = actionCollection()->addAction("transfer_group_settings");
 311     transferGroupSettingsAction->setText(i18n("&Group Settings..."));
 312     transferGroupSettingsAction->setIcon(KIcon("preferences-system"));
 313     transferGroupSettingsAction->setShortcuts(KShortcut("Ctrl+G"));
 314     connect(transferGroupSettingsAction, SIGNAL(triggered()), SLOT(slotTransferGroupSettings()));
 315
 316     KAction *transferSettingsAction = actionCollection()->addAction("transfer_settings");
 317     transferSettingsAction->setText(i18n("&Transfer Settings..."));
 318     transferSettingsAction->setIcon(KIcon("preferences-system"));
 319     transferSettingsAction->setShortcuts(KShortcut("Ctrl+T"));
 320     connect(transferSettingsAction, SIGNAL(triggered()), SLOT(slotTransferSettings()));
 321
 322     KAction *listLinksAction = actionCollection()->addAction("import_links");
 323     listLinksAction->setText(i18n("Import &Links..."));
 324     listLinksAction->setIcon(KIcon("view-list-text"));
 325     listLinksAction->setShortcuts(KShortcut("Ctrl+L"));
 326     connect(listLinksAction, SIGNAL(triggered()), SLOT(slotShowListLinks()));
 327 }
 328
 329 void MainWindow::slotDelayedInit()
 330 {
 331     //Here we import the user's transfers.
 332     KGet::load( KStandardDirs::locateLocal("appdata", "transfers.kgt") );
 333
 334     m_dock = new Tray(this);
 335
 336     if(Settings::enableSystemTray()) {
 337         // DockWidget
 338         m_dock->show();
 339     }
 340
 341     // enable dropping
 342     setAcceptDrops(true);
 343
 344     // enable hide toolbar
 345     setStandardToolBarMenuEnabled(true);
 346
 347     // session management stuff
 348     connect(kapp, SIGNAL(saveYourself()), SLOT(slotSaveMyself()));
 349
 350     // set auto-resume in kioslaverc (is there a cleaner way?)
 351     KConfig cfg("kioslaverc", KConfig::NoGlobals);
 352     cfg.group(QString()).writeEntry("AutoResume", true);
 353     cfg.sync();
 354
 355     // DropTarget
 356     m_drop = new DropTarget(this);
 357
 358     if (Settings::firstRun()) {
 359         if (KMessageBox::questionYesNoCancel(this ,i18n("This is the first time you have run KGet.\n"
 360                                              "Would you like to enable KGet as the download manager for Konqueror?"),
 361                                              i18n("Konqueror Integration"), KGuiItem(i18n("Enable")),
 362                                              KGuiItem(i18n("Do Not Enable")))
 363                                              == KMessageBox::Yes) {
 364             Settings::setKonquerorIntegration(true);
 365             slotKonquerorIntegration(true);
 366         }
 367
 368         m_drop->setDropTargetVisible(true);
 369
 370         // reset the FirstRun config option
 371         Settings::setFirstRun(false);
 372     }
 373
 374     if (Settings::showDropTarget() && !m_startWithoutAnimation)
 375         m_drop->setDropTargetVisible(true);
 376
 377     //auto paste stuff
 378     lastClipboard = QApplication::clipboard()->text( QClipboard::Clipboard ).trimmed();
 379     clipboardTimer = new QTimer(this);
 380     connect(clipboardTimer, SIGNAL(timeout()), SLOT(slotCheckClipboard()));
 381     if ( Settings::autoPaste() )
 382         clipboardTimer->start(1000);
 383
 384     // kget kuiserver integration
 385     KGet::reloadKJobs();
 386
 387     if (Settings::webinterfaceEnabled())
 388         m_webinterface = new HttpServer(this);
 389
 390     if (Settings::speedLimit())
 391     {
 392         KGet::setGlobalDownloadLimit(Settings::globalDownloadLimit());
 393         KGet::setGlobalUploadLimit(Settings::globalUploadLimit());
 394     }
 395     else
 396     {
 397         KGet::setGlobalDownloadLimit(0);
 398         KGet::setGlobalUploadLimit(0);
 399     }
 400 }
 401
 402 void MainWindow::slotToggleDropTarget()
 403 {
 404     actionCollection()->action("show_drop_target")->setChecked(!m_drop->isVisible());
 405
 406     m_drop->setDropTargetVisible(!m_drop->isVisible());
 407 }
 408
 409 void MainWindow::slotNewTransfer()
 410 {
 411     NewTransferDialog::instance(this)->showDialog();
 412 }
 413
 414 void MainWindow::slotImportTransfers()
 415 {
 416     QString filename = KFileDialog::getOpenFileName(KUrl(),
 417                                                     "*.kgt *.metalink *.torrent|" + i18n("All Openable Files") +
 418                                                     " (*.kgt *.metalink *.torrent)", this, i18n("Open File"));
 419
 420     if(filename.endsWith(".kgt"))
 421     {
 422         KGet::load(filename);
 423         return;
 424     }
 425
 426     if(!filename.isEmpty())
 427         KGet::addTransfer( KUrl( filename ) );
 428 }
 429
 430 void MainWindow::slotUpdateTitlePercent()
 431 {
 432     int percent = transfersPercent();
 433     if (percent != -1) {
 434         setPlainCaption(i18nc("window title including overall download progress in percent", "KGet - %1%", percent));
 435     } else {
 436         setPlainCaption(i18n("KGet"));
 437     }
 438 }
 439
 440 void MainWindow::slotQuit()
 441 {
 442     if (KGet::schedulerRunning()) {
 443         if (KMessageBox::warningYesNoCancel(this,
 444                 i18n("Some transfers are still running.\n"
 445                      "Are you sure you want to close KGet?"),
 446                 i18n("Confirm Quit"),
 447                 KStandardGuiItem::yes(), KStandardGuiItem::no(), KStandardGuiItem::cancel(),
 448                 "ExitWithActiveTransfers") != KMessageBox::Yes)
 449             return;
 450
 451         KGet::setSchedulerRunning(false);
 452     }
 453
 454     Settings::self()->writeConfig();
 455     qApp->quit();
 456 }
 457
 458 void MainWindow::slotPreferences()
 459 {
 460     // an instance the dialog could be already created and could be cached,
 461     // in which case you want to display the cached dialog
 462     if ( PreferencesDialog::showDialog( "preferences" ) )
 463         return;
 464
 465     // we didn't find an instance of this dialog, so lets create it
 466     PreferencesDialog * dialog = new PreferencesDialog( this, Settings::self() );
 467
 468     // keep us informed when the user changes settings
 469     connect( dialog, SIGNAL(settingsChanged(const QString&)),
 470              this, SLOT(slotNewConfig()) );
 471
 472     dialog->show();
 473 }
 474
 475 void MainWindow::slotExportTransfers()
 476 {
 477     exportTransfers(false);
 478 }
 479
 480 void MainWindow::slotExportPlainTransfers()
 481 {
 482     exportTransfers(true);
 483 }
 484
 485 void MainWindow::slotDeleteGroup()
 486 {
 487     foreach(TransferGroupHandler * it, KGet::selectedTransferGroups())
 488     {
 489         it->stop();
 490         KGet::delGroup(it->name());
 491     }
 492 }
 493
 494 void MainWindow::slotRenameGroup()
 495 {
 496     bool ok = true;
 497     QString groupName;
 498
 499     foreach(TransferGroupHandler * it, KGet::selectedTransferGroups())
 500     {
 501         groupName = KInputDialog::getText(i18n("Enter Group Name"),
 502                                           i18n("Group name:"), it->name(), &ok, this);
 503         if(ok)
 504             it->setName(groupName);
 505     }
 506 }
 507
 508 void MainWindow::slotSetIconGroup()
 509 {
 510     KIconDialog dialog(this);
 511     QString iconName = dialog.getIcon();
 512     TransferTreeSelectionModel *selModel = KGet::selectionModel();
 513
 514     QModelIndexList indexList = selModel->selectedRows();
 515
 516     if (!iconName.isEmpty())
 517     {
 518         foreach (TransferGroupHandler *group, KGet::selectedTransferGroups())
 519         {
 520             group->setIconName(iconName);
 521         }
 522     }
 523     //emit dataChanged(indexList.first(),indexList.last());
 524 }
 525
 526 void MainWindow::slotStartDownload()
 527 {
 528     if(KGet::selectedTransfers().size() == 0)
 529         slotStartAllDownload();
 530     else
 531         slotStartSelectedDownload();
 532 }
 533
 534 void MainWindow::slotStartAllDownload()
 535 {
 536     KGet::setSchedulerRunning(true);
 537 }
 538
 539 void MainWindow::slotStartSelectedDownload()
 540 {
 541     foreach(TransferHandler * it, KGet::selectedTransfers())
 542         it->start();
 543 }
 544
 545 void MainWindow::slotStopDownload()
 546 {
 547     if(KGet::selectedTransfers().size() == 0)
 548         slotStopAllDownload();
 549     else
 550         slotStopSelectedDownload();
 551 }
 552
 553 void MainWindow::slotStopAllDownload()
 554 {
 555     KGet::setSchedulerRunning(false);
 556 }
 557
 558 void MainWindow::slotStopSelectedDownload()
 559 {
 560     foreach (TransferHandler * it, KGet::selectedTransfers())
 561         it->stop();
 562 }
 563
 564 void MainWindow::slotDeleteSelected()
 565 {
 566     foreach(TransferHandler * it, KGet::selectedTransfers())
 567     {
 568         it->stop();
 569         m_viewsContainer->closeTransferDetails(it);
 570         KGet::delTransfer(it);
 571     }
 572 }
 573
 574 void MainWindow::slotRedownloadSelected()
 575 {
 576     foreach(TransferHandler * it, KGet::selectedTransfers())
 577     {
 578         KGet::redownloadTransfer(it);
 579     }
 580 }
 581
 582 void MainWindow::slotTransfersOpenDest()
 583 {
 584     QStringList openedDirs;
 585     foreach(TransferHandler * it, KGet::selectedTransfers())
 586     {
 587         QString directory = it->dest().directory();
 588         if( !openedDirs.contains( directory ) )
 589         {
 590             new KRun(directory, this, 0, true, false);
 591             openedDirs.append( directory );
 592         }
 593     }
 594 }
 595
 596 void MainWindow::slotTransfersOpenFile()
 597 {
 598     foreach(TransferHandler * it, KGet::selectedTransfers())
 599     {
 600         new KRun(it->dest(), this, 0, true, false);
 601     }
 602 }
 603
 604 void MainWindow::slotTransfersShowDetails()
 605 {
 606     foreach(TransferHandler * it, KGet::selectedTransfers())
 607     {
 608         m_viewsContainer->showTransferDetails(it);
 609     }
 610 }
 611
 612 void MainWindow::slotTransfersCopySourceUrl()
 613 {
 614     foreach(TransferHandler * it, KGet::selectedTransfers())
 615     {
 616         QString sourceurl = it->source().url();
 617         QClipboard *cb = QApplication::clipboard();
 618         cb->setText(sourceurl, QClipboard::Selection);
 619         cb->setText(sourceurl, QClipboard::Clipboard);
 620     }
 621 }
 622
 623 void MainWindow::slotDeleteFinished()
 624 {
 625     foreach(TransferHandler * it, KGet::finishedTransfers())
 626     {
 627         it->stop();
 628         m_viewsContainer->closeTransferDetails(it);
 629         KGet::delTransfer(it);
 630     }
 631 }
 632
 633 void MainWindow::slotConfigureNotifications()
 634 {
 635     KNotifyConfigWidget::configure(this);
 636 }
 637
 638 void MainWindow::slotConfigureKeys()
 639 {
 640     KShortcutsDialog::configure(actionCollection());
 641 }
 642
 643 void MainWindow::slotConfigureToolbars()
 644 {
 645     KEditToolBar edit( actionCollection() );
 646     connect(&edit, SIGNAL( newToolbarConfig() ), this, SLOT( slotNewToolbarConfig() ));
 647     edit.exec();
 648 }
 649
 650
 651 void MainWindow::slotSaveMyself()
 652 {
 653     // save last parameters ..
 654     Settings::setMainPosition( pos() );
 655     // .. and write config to disk
 656     Settings::self()->writeConfig();
 657 }
 658
 659 void MainWindow::slotNewToolbarConfig()
 660 {
 661     createGUI();
 662 }
 663
 664 void MainWindow::slotNewConfig()
 665 {
 666     // Update here properties modified in the config dialog and not
 667     // parsed often by the code. When clicking Ok or Apply of
 668     // PreferencesDialog, this function is called.
 669
 670     m_viewsContainer->setExpandableDetails(Settings::showExpandableTransferDetails());
 671     m_drop->setDropTargetVisible(Settings::showDropTarget(), false);
 672     m_dock->setVisible(Settings::enableSystemTray());
 673
 674     if(!Settings::enableSystemTray())
 675         setVisible(true);
 676
 677     slotKonquerorIntegration(Settings::konquerorIntegration());
 678     m_konquerorIntegration->setChecked(Settings::konquerorIntegration());
 679
 680     KGet::reloadKJobs();
 681
 682     if (Settings::autoPaste())
 683         clipboardTimer->start(1000);
 684     else
 685         clipboardTimer->stop();
 686     m_autoPasteAction->setChecked(Settings::autoPaste());
 687
 688     if (Settings::webinterfaceEnabled() && !m_webinterface) {
 689         m_webinterface = new HttpServer(this);
 690     } else if (m_webinterface && !Settings::webinterfaceEnabled()) {
 691         delete m_webinterface;
 692         m_webinterface = 0;
 693     }
 694
 695     if (Settings::speedLimit())
 696     {
 697         KGet::setGlobalDownloadLimit(Settings::globalDownloadLimit());
 698         KGet::setGlobalUploadLimit(Settings::globalUploadLimit());
 699     }
 700     else
 701     {
 702         KGet::setGlobalDownloadLimit(0);
 703         KGet::setGlobalUploadLimit(0);
 704     }
 705
 706     KGet::settingsChanged();
 707 }
 708
 709 void MainWindow::slotToggleAutoPaste()
 710 {
 711     bool autoPaste = !Settings::autoPaste();
 712     Settings::setAutoPaste( autoPaste );
 713
 714     if (autoPaste)
 715         clipboardTimer->start(1000);
 716     else
 717         clipboardTimer->stop();
 718     m_autoPasteAction->setChecked(autoPaste);
 719 }
 720
 721 void MainWindow::slotCheckClipboard()
 722 {
 723     QString clipData = QApplication::clipboard()->text( QClipboard::Clipboard ).trimmed();
 724
 725     if (clipData != lastClipboard)
 726     {
 727         lastClipboard = clipData;
 728         if (lastClipboard.isEmpty())
 729             return;
 730
 731         KUrl url = KUrl(lastClipboard);
 732
 733         if (url.isValid() && !url.isLocalFile())
 734             KGet::addTransfer( url );
 735     }
 736 }
 737
 738 void MainWindow::slotTrayKonquerorIntegration(bool enable)
 739 {
 740     slotKonquerorIntegration(enable);
 741     if (!enable && Settings::konquerorIntegration() && !Settings::expertMode())
 742     {
 743         KGet::showNotification(this, KNotification::Notification,
 744                                      i18n("KGet has been temporarily disabled as download manager for Konqueror. "
 745             "If you want to disable it forever, go to Settings->Advanced and disable \"Use "
 746             "as download manager for Konqueror\"."),
 747                                      "dialog-info");
 748         /*KMessageBox::information(this,
 749             i18n("KGet has been temporarily disabled as download manager for Konqueror. "
 750             "If you want to disable it forever, go to Settings->Advanced and disable \"Use "
 751             "as download manager for Konqueror\"."),
 752             i18n("Konqueror Integration disabled"),
 753             "KonquerorIntegrationDisabled");*/
 754     }
 755 }
 756
 757 void MainWindow::slotKonquerorIntegration(bool konquerorIntegration)
 758 {
 759     KConfig cfgKonqueror("konquerorrc", KConfig::NoGlobals);
 760     cfgKonqueror.group("HTML Settings").writeEntry("DownloadManager",
 761                                                    QString(konquerorIntegration ? "kget" : QString()));
 762     cfgKonqueror.sync();
 763 }
 764
 765 void MainWindow::slotShowMenubar()
 766 {
 767     if (m_menubarAction->isChecked())
 768         menuBar()->show();
 769     else
 770         menuBar()->hide();
 771 }
 772
 773 void MainWindow::setSystemTrayDownloading(bool running)
 774 {
 775     kDebug(5001);
 776
 777     m_dock->setDownloading(running);
 778 }
 779
 780 void MainWindow::importLinks(const QList <QString> &links)
 781 {
 782     KGetLinkView *link_view = new KGetLinkView(this);
 783     link_view->setLinks(links);
 784     link_view->show();
 785 }
 786
 787 void MainWindow::slotTransferHistory()
 788 {
 789     TransferHistory *history = new TransferHistory();
 790     history->exec();
 791 }
 792
 793 void MainWindow::slotTransferGroupSettings()
 794 {
 795     kDebug(5001);
 796     QList<TransferGroupHandler*> list = KGet::selectedTransferGroups();
 797     foreach(TransferGroupHandler* group, list)
 798     {
 799         GroupSettingsDialog *settings = new GroupSettingsDialog(this, group);
 800         settings->exec();
 801     }
 802 }
 803
 804 void MainWindow::slotTransferSettings()
 805 {
 806     kDebug(5001);
 807     QList<TransferHandler*> list = KGet::selectedTransfers();
 808     foreach(TransferHandler* transfer, list)
 809     {
 810         TransferSettingsDialog *settings = new TransferSettingsDialog(this, transfer);
 811         settings->exec();
 812     }
 813 }
 814
 815 /** slots for link list **/
 816 void MainWindow::slotShowListLinks()
 817 {
 818     KGetLinkView *link_view = new KGetLinkView(this);
 819     link_view->importUrl();
 820     link_view->show();
 821 }
 822
 823 void MainWindow::slotImportUrl(const QString &url)
 824 {
 825     KGetLinkView *link_view = new KGetLinkView(this);
 826     link_view->importUrl(url);
 827     link_view->show();
 828 }
 829
 830 /** widget events */
 831 void MainWindow::closeEvent( QCloseEvent * e )
 832 {
 833     // if the event comes from out the application (close event) we decide between close or hide
 834     // if the event comes from the application (system shutdown) we say goodbye
 835     if(e->spontaneous()) {
 836         e->ignore();
 837         if(!Settings::enableSystemTray()) {
 838             slotQuit();
 839         }
 840         else {
 841             hide();
 842         }
 843     }
 844 }
 845
 846 void MainWindow::dragEnterEvent(QDragEnterEvent * event)
 847 {
 848     event->setAccepted(KUrl::List::canDecode(event->mimeData())
 849                   || event->mimeData()->hasText());
 850 }
 851
 852 void MainWindow::dropEvent(QDropEvent * event)
 853 {
 854     KUrl::List list = KUrl::List::fromMimeData(event->mimeData());
 855     QString str;
 856
 857     if (!list.isEmpty())
 858     {
 859         if (list.count() == 1 && list.first().url().endsWith(".kgt"))
 860         {
 861             int msgBoxResult = KMessageBox::questionYesNoCancel(this, i18n("The dropped file is a KGet-Transferlist"), "KGet",
 862                                    KGuiItem(i18n("&Download"), KIcon("document-save")),
 863                                        KGuiItem(i18n("&Load transferlist"), KIcon("list-add")), KStandardGuiItem::cancel());
 864
 865             if (msgBoxResult == 3) //Download
 866                 NewTransferDialog::instance(this)->showDialog(list.first().url());
 867             if (msgBoxResult == 4) //Load
 868                 KGet::load(list.first().url());
 869         }
 870         else
 871         {
 872             if (list.count() == 1)
 873             {
 874                 str = event->mimeData()->text();
 875                 NewTransferDialog::instance(this)->showDialog(str);
 876             }
 877             else
 878                 NewTransferDialog::instance(this)->showDialog(list);
 879         }
 880     }
 881     else
 882     {
 883         NewTransferDialog::instance(this)->showDialog();
 884     }
 885 }
 886
 887
 888 /** DBUS interface */
 889
 890 void MainWindow::addTransfer(const QString& src, const QString& dest, bool start)
 891 {
 892     // split src for the case it is a QStringList (e.g. from konqueror plugin)
 893     KGet::addTransfer(src.split(';'), dest, QString(), start);
 894 }
 895
 896 void MainWindow::showNewTransferDialog(const QStringList &urls)
 897 {
 898     NewTransferDialog::instance(this)->showDialog(urls);
 899 }
 900
 901 bool MainWindow::dropTargetVisible() const
 902 {
 903     return m_drop->isVisible();
 904 }
 905
 906 void MainWindow::setDropTargetVisible( bool setVisible )
 907 {
 908     if ( setVisible != Settings::showDropTarget() )
 909         m_drop->setDropTargetVisible( setVisible );
 910 }
 911
 912 void MainWindow::setOfflineMode( bool offline )
 913 {
 914     KGet::setSchedulerRunning(offline);
 915 }
 916
 917 bool MainWindow::offlineMode() const
 918 {
 919     return !KGet::schedulerRunning();
 920 }
 921
 922 QVariantMap MainWindow::transfers() const
 923 {
 924     return m_dbusModelObserver->transfers();
 925 }
 926
 927 int MainWindow::transfersSpeed() const
 928 {
 929     return m_dbusModelObserver->transfersSpeed();
 930 }
 931
 932 MainWindowModelObserver::MainWindowModelObserver(MainWindow *window)
 933     : QObject(window)
 934 {
 935     m_window = window;
 936     m_groupObserver = new MainWindowGroupObserver(window);
 937 }
 938
 939 void MainWindowModelObserver::addedTransferGroupEvent(TransferGroupHandler *group)
 940 {
 941     group->addObserver(m_groupObserver);
 942 }
 943
 944 void MainWindowModelObserver::removedTransferGroupEvent(TransferGroupHandler *group)
 945 {
 946     group->delObserver(m_groupObserver);
 947 }
 948
 949 MainWindowGroupObserver::MainWindowGroupObserver(MainWindow *window)
 950     : QObject(window)
 951 {
 952     m_window = window;
 953 }
 954
 955 void MainWindowGroupObserver::groupChangedEvent(TransferGroupHandler * group)
 956 {
 957     TransferGroupHandler::ChangesFlags transferFlags = group->changesFlags(this);
 958     if (transferFlags & TransferGroup::Gc_Percent) {
 959         m_window->slotUpdateTitlePercent();
 960     }
 961     group->resetChangesFlags(this);
 962 }
 963
 964 /**void MainWindowGroupObserver::addedTransferEvent(TransferHandler * transfer, TransferHandler * after)
 965 {
 966     Q_UNUSED(transfer);
 967     Q_UNUSED(after);
 968 }
 969
 970 void MainWindowGroupObserver::removedTransferEvent(TransferHandler * transfer)
 971 {
 972     Q_UNUSED(transfer);
 973 }
 974
 975 void MainWindowGroupObserver::movedTransferEvent(TransferHandler * transfer, TransferHandler * after)
 976 {
 977     Q_UNUSED(transfer);
 978     Q_UNUSED(after);
 979 }**/
 980
 981 #include "mainwindow.moc"