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     QAction *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     QAction *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     QAction *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     QAction *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     QAction *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     QAction *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     QAction *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     QAction *quitAction = KStandardAction::quit(this, SLOT(slotQuit()), actionCollection());
 214     actionCollection()->addAction("quit", quitAction);
 215     // local - Standard configure actions
 216     QAction *preferencesAction = KStandardAction::preferences(this, SLOT(slotPreferences()), actionCollection());
 217     actionCollection()->addAction("preferences", preferencesAction);
 218     QAction *configToolbarAction = KStandardAction::configureToolbars(this, SLOT(slotConfigureToolbars()), actionCollection());
 219     actionCollection()->addAction("configure_toolbars", configToolbarAction);
 220     QAction *keyBindingsAction = KStandardAction::keyBindings(this, SLOT(slotConfigureKeys()), actionCollection());
 221     actionCollection()->addAction("configure_keys", keyBindingsAction);
 222     QAction *cinfigNotifyAction = KStandardAction::configureNotifications(this, SLOT(slotConfigureNotifications()), actionCollection());
 223     actionCollection()->addAction("configure_notifications", cinfigNotifyAction);
 224     m_menubarAction = KStandardAction::showMenubar(this, SLOT(slotShowMenubar()), actionCollection());
 225     m_menubarAction->setChecked(!menuBar()->isHidden());
 226     actionCollection()->addAction("settings_showmenubar", m_menubarAction);
 227
 228     // Transfer related actions
 229     QAction *deleteSelectedAction = actionCollection()->addAction("delete_selected_download");
 230     deleteSelectedAction->setText(i18nc("delete selected transfer item", "Delete Selected"));
 231     deleteSelectedAction->setIcon(KIcon("edit-delete"));
 232     deleteSelectedAction->setShortcuts(KShortcut("Del"));
 233     connect(deleteSelectedAction, SIGNAL(triggered()), SLOT(slotDeleteSelected()));
 234
 235     QAction *deleteAllFinishedAction = actionCollection()->addAction("delete_all_finished");
 236     deleteAllFinishedAction->setText(i18nc("delete all finished transfers", "Delete all finished"));
 237     deleteAllFinishedAction->setIcon(KIcon("edit-clear-list"));
 238     connect(deleteAllFinishedAction, SIGNAL(triggered()), SLOT(slotDeleteFinished()));
 239
 240     QAction *redownloadSelectedAction = actionCollection()->addAction("redownload_selected_download");
 241     redownloadSelectedAction->setText(i18nc("redownload selected transfer item", "Redownload Selected"));
 242     redownloadSelectedAction->setIcon(KIcon("view-refresh"));
 243     connect(redownloadSelectedAction, SIGNAL(triggered()), SLOT(slotRedownloadSelected()));
 244
 245     QAction *startAllAction = actionCollection()->addAction("start_all_download");
 246     startAllAction->setText(i18n("Start / Resume All"));
 247     startAllAction->setIcon(KIcon("media-seek-forward"));
 248     startAllAction->setShortcuts(KShortcut("Ctrl+R"));
 249     connect(startAllAction, SIGNAL(triggered()), SLOT(slotStartAllDownload()));
 250
 251     QAction *startSelectedAction = actionCollection()->addAction("start_selected_download");
 252     startSelectedAction->setText(i18n("Start / Resume Selected"));
 253     startSelectedAction->setIcon(KIcon("media-playback-start"));
 254     connect(startSelectedAction, SIGNAL(triggered()), SLOT(slotStartSelectedDownload()));
 255
 256     QAction *stopAllAction = actionCollection()->addAction("stop_all_download");
 257     stopAllAction->setText(i18n("Stop All"));
 258     stopAllAction->setIcon(KIcon("media-playback-pause"));
 259     stopAllAction->setShortcuts(KShortcut("Ctrl+P"));
 260     connect(stopAllAction, SIGNAL(triggered()), SLOT(slotStopAllDownload()));
 261
 262     QAction *stopSelectedAction = actionCollection()->addAction("stop_selected_download");
 263     stopSelectedAction->setText(i18n("Stop Selected"));
 264     stopSelectedAction->setIcon(KIcon("media-playback-pause"));
 265     connect(stopSelectedAction, SIGNAL(triggered()), SLOT(slotStopSelectedDownload()));
 266
 267     KActionMenu *startActionMenu = new KActionMenu(KIcon("media-playback-start"), i18n("Start / Resume"),
 268                                                      actionCollection());
 269     actionCollection()->addAction("start_menu", startActionMenu);
 270     startActionMenu->setDelayed(true);
 271     startActionMenu->addAction(startAllAction);
 272     startActionMenu->addAction(startSelectedAction);
 273     connect(startActionMenu, SIGNAL(triggered()), SLOT(slotStartDownload()));
 274
 275     KActionMenu *stopActionMenu = new KActionMenu(KIcon("media-playback-pause"), i18n("Stop"),
 276                                                     actionCollection());
 277     actionCollection()->addAction("stop_menu", stopActionMenu);
 278     stopActionMenu->setDelayed(true);
 279     stopActionMenu->addAction(stopAllAction);
 280     stopActionMenu->addAction(stopSelectedAction);
 281     connect(stopActionMenu, SIGNAL(triggered()), SLOT(slotStopDownload()));
 282
 283     QAction *openDestAction = actionCollection()->addAction("transfer_open_dest");
 284     openDestAction->setText(i18n("Open Destination"));
 285     openDestAction->setIcon(KIcon("document-open"));
 286     connect(openDestAction, SIGNAL(triggered()), SLOT(slotTransfersOpenDest()));
 287
 288     QAction *openFileAction = actionCollection()->addAction("transfer_open_file");
 289     openFileAction->setText(i18n("Open File"));
 290     openFileAction->setIcon(KIcon("document-open"));
 291     connect(openFileAction, SIGNAL(triggered()), SLOT(slotTransfersOpenFile()));
 292
 293     QAction *showDetailsAction = actionCollection()->addAction("transfer_show_details");
 294     showDetailsAction->setText(i18n("Show Details"));
 295     showDetailsAction->setIcon(KIcon("document-properties"));
 296     connect(showDetailsAction, SIGNAL(triggered()), SLOT(slotTransfersShowDetails()));
 297
 298     QAction *copyUrlAction = actionCollection()->addAction("transfer_copy_source_url");
 299     copyUrlAction->setText(i18n("Copy URL to Clipboard"));
 300     copyUrlAction->setIcon(KIcon("edit-copy"));
 301     connect(copyUrlAction, SIGNAL(triggered()), SLOT(slotTransfersCopySourceUrl()));
 302
 303     KToggleAction *showDropTargetAction = new KToggleAction(KIcon("kget"),
 304                                           i18n("Show Drop Target"), actionCollection());
 305     actionCollection()->addAction("show_drop_target", showDropTargetAction);
 306     showDropTargetAction->setChecked(Settings::showDropTarget());
 307     connect(showDropTargetAction, SIGNAL(triggered()), SLOT(slotToggleDropTarget()));
 308
 309     QAction *transferHistoryAction = actionCollection()->addAction("Transfer History");
 310     transferHistoryAction->setText(i18n("&Transfer History..."));
 311     transferHistoryAction->setIcon(KIcon("view-history"));
 312     transferHistoryAction->setShortcuts(KShortcut("Ctrl+H"));
 313     connect(transferHistoryAction, SIGNAL(triggered()), SLOT(slotTransferHistory()));
 314
 315     QAction *transferGroupSettingsAction = actionCollection()->addAction("transfer_group_settings");
 316     transferGroupSettingsAction->setText(i18n("&Group Settings..."));
 317     transferGroupSettingsAction->setIcon(KIcon("preferences-system"));
 318     transferGroupSettingsAction->setShortcuts(KShortcut("Ctrl+G"));
 319     connect(transferGroupSettingsAction, SIGNAL(triggered()), SLOT(slotTransferGroupSettings()));
 320
 321     QAction *transferSettingsAction = actionCollection()->addAction("transfer_settings");
 322     transferSettingsAction->setText(i18n("&Transfer Settings..."));
 323     transferSettingsAction->setIcon(KIcon("preferences-system"));
 324     transferSettingsAction->setShortcuts(KShortcut("Ctrl+T"));
 325     connect(transferSettingsAction, SIGNAL(triggered()), SLOT(slotTransferSettings()));
 326
 327     QAction *listLinksAction = actionCollection()->addAction("import_links");
 328     listLinksAction->setText(i18n("Import &Links..."));
 329     listLinksAction->setIcon(KIcon("view-list-text"));
 330     listLinksAction->setShortcuts(KShortcut("Ctrl+L"));
 331     connect(listLinksAction, SIGNAL(triggered()), SLOT(slotShowListLinks()));
 332 }
 333
 334 void MainWindow::slotDelayedInit()
 335 {
 336     //Here we import the user's transfers.
 337     KGet::load( KStandardDirs::locateLocal("appdata", "transfers.kgt") );
 338
 339     m_dock = new Tray(this);
 340
 341     if(Settings::enableSystemTray()) {
 342         // DockWidget
 343         m_dock->show();
 344     }
 345
 346     // enable dropping
 347     setAcceptDrops(true);
 348
 349     // enable hide toolbar
 350     setStandardToolBarMenuEnabled(true);
 351
 352     // session management stuff
 353     connect(kapp, SIGNAL(saveYourself()), SLOT(slotSaveMyself()));
 354
 355     // set auto-resume in kioslaverc (is there a cleaner way?)
 356     KConfig cfg("kioslaverc", KConfig::NoGlobals);
 357     cfg.group(QString()).writeEntry("AutoResume", true);
 358     cfg.sync();
 359
 360     // DropTarget
 361     m_drop = new DropTarget(this);
 362
 363     if (Settings::firstRun()) {
 364         if (KMessageBox::questionYesNoCancel(this ,i18n("This is the first time you have run KGet.\n"
 365                                              "Would you like to enable KGet as the download manager for Konqueror?"),
 366                                              i18n("Konqueror Integration"), KGuiItem(i18n("Enable")),
 367                                              KGuiItem(i18n("Do Not Enable")))
 368                                              == KMessageBox::Yes) {
 369             Settings::setKonquerorIntegration(true);
 370             slotKonquerorIntegration(true);
 371         }
 372
 373         m_drop->setDropTargetVisible(true);
 374
 375         // reset the FirstRun config option
 376         Settings::setFirstRun(false);
 377     }
 378
 379     if (Settings::showDropTarget() && !m_startWithoutAnimation)
 380         m_drop->setDropTargetVisible(true);
 381
 382     //auto paste stuff
 383     lastClipboard = QApplication::clipboard()->text( QClipboard::Clipboard ).trimmed();
 384     clipboardTimer = new QTimer(this);
 385     connect(clipboardTimer, SIGNAL(timeout()), SLOT(slotCheckClipboard()));
 386     if ( Settings::autoPaste() )
 387         clipboardTimer->start(1000);
 388
 389     // kget kuiserver integration
 390     KGet::reloadKJobs();
 391
 392     if (Settings::webinterfaceEnabled())
 393         m_webinterface = new HttpServer(this);
 394
 395     if (Settings::speedLimit())
 396     {
 397         KGet::setGlobalDownloadLimit(Settings::globalDownloadLimit());
 398         KGet::setGlobalUploadLimit(Settings::globalUploadLimit());
 399     }
 400     else
 401     {
 402         KGet::setGlobalDownloadLimit(0);
 403         KGet::setGlobalUploadLimit(0);
 404     }
 405 }
 406
 407 void MainWindow::slotToggleDropTarget()
 408 {
 409     actionCollection()->action("show_drop_target")->setChecked(!m_drop->isVisible());
 410
 411     m_drop->setDropTargetVisible(!m_drop->isVisible());
 412 }
 413
 414 void MainWindow::slotNewTransfer()
 415 {
 416     NewTransferDialog::instance(this)->showDialog();
 417 }
 418
 419 void MainWindow::slotImportTransfers()
 420 {
 421     QString filename = KFileDialog::getOpenFileName(KUrl(),
 422                                                     "*.kgt *.metalink *.torrent|" + i18n("All Openable Files") +
 423                                                     " (*.kgt *.metalink *.torrent)", this, i18n("Open File"));
 424
 425     if(filename.endsWith(".kgt"))
 426     {
 427         KGet::load(filename);
 428         return;
 429     }
 430
 431     if(!filename.isEmpty())
 432         KGet::addTransfer( KUrl( filename ) );
 433 }
 434
 435 void MainWindow::slotUpdateTitlePercent()
 436 {
 437     int percent = transfersPercent();
 438     if (percent != -1) {
 439         setPlainCaption(i18nc("window title including overall download progress in percent", "KGet - %1%", percent));
 440     } else {
 441         setPlainCaption(i18n("KGet"));
 442     }
 443 }
 444
 445 void MainWindow::slotQuit()
 446 {
 447     if (KGet::schedulerRunning()) {
 448         if (KMessageBox::warningYesNoCancel(this,
 449                 i18n("Some transfers are still running.\n"
 450                      "Are you sure you want to close KGet?"),
 451                 i18n("Confirm Quit"),
 452                 KStandardGuiItem::yes(), KStandardGuiItem::no(), KStandardGuiItem::cancel(),
 453                 "ExitWithActiveTransfers") != KMessageBox::Yes)
 454             return;
 455
 456         KGet::setSchedulerRunning(false);
 457     }
 458
 459     Settings::self()->writeConfig();
 460     qApp->quit();
 461 }
 462
 463 void MainWindow::slotPreferences()
 464 {
 465     // an instance the dialog could be already created and could be cached,
 466     // in which case you want to display the cached dialog
 467     if ( PreferencesDialog::showDialog( "preferences" ) )
 468         return;
 469
 470     // we didn't find an instance of this dialog, so lets create it
 471     PreferencesDialog * dialog = new PreferencesDialog( this, Settings::self() );
 472
 473     // keep us informed when the user changes settings
 474     connect( dialog, SIGNAL(settingsChanged(const QString&)),
 475              this, SLOT(slotNewConfig()) );
 476
 477     dialog->show();
 478 }
 479
 480 void MainWindow::slotExportTransfers()
 481 {
 482     exportTransfers(false);
 483 }
 484
 485 void MainWindow::slotExportPlainTransfers()
 486 {
 487     exportTransfers(true);
 488 }
 489
 490 void MainWindow::slotDeleteGroup()
 491 {
 492     foreach(TransferGroupHandler * it, KGet::selectedTransferGroups())
 493     {
 494         it->stop();
 495         KGet::delGroup(it->name());
 496     }
 497 }
 498
 499 void MainWindow::slotRenameGroup()
 500 {
 501     bool ok = true;
 502     QString groupName;
 503
 504     foreach(TransferGroupHandler * it, KGet::selectedTransferGroups())
 505     {
 506         groupName = KInputDialog::getText(i18n("Enter Group Name"),
 507                                           i18n("Group name:"), it->name(), &ok, this);
 508         if(ok)
 509             it->setName(groupName);
 510     }
 511 }
 512
 513 void MainWindow::slotSetIconGroup()
 514 {
 515     KIconDialog dialog(this);
 516     QString iconName = dialog.getIcon();
 517     TransferTreeSelectionModel *selModel = KGet::selectionModel();
 518
 519     QModelIndexList indexList = selModel->selectedRows();
 520
 521     if (!iconName.isEmpty())
 522     {
 523         foreach (TransferGroupHandler *group, KGet::selectedTransferGroups())
 524         {
 525             group->setIconName(iconName);
 526         }
 527     }
 528     //emit dataChanged(indexList.first(),indexList.last());
 529 }
 530
 531 void MainWindow::slotStartDownload()
 532 {
 533     if(KGet::selectedTransfers().size() == 0)
 534         slotStartAllDownload();
 535     else
 536         slotStartSelectedDownload();
 537 }
 538
 539 void MainWindow::slotStartAllDownload()
 540 {
 541     KGet::setSchedulerRunning(true);
 542 }
 543
 544 void MainWindow::slotStartSelectedDownload()
 545 {
 546     foreach(TransferHandler * it, KGet::selectedTransfers())
 547         it->start();
 548 }
 549
 550 void MainWindow::slotStopDownload()
 551 {
 552     if(KGet::selectedTransfers().size() == 0)
 553         slotStopAllDownload();
 554     else
 555         slotStopSelectedDownload();
 556 }
 557
 558 void MainWindow::slotStopAllDownload()
 559 {
 560     KGet::setSchedulerRunning(false);
 561 }
 562
 563 void MainWindow::slotStopSelectedDownload()
 564 {
 565     foreach (TransferHandler * it, KGet::selectedTransfers())
 566         it->stop();
 567 }
 568
 569 void MainWindow::slotDeleteSelected()
 570 {
 571     foreach(TransferHandler * it, KGet::selectedTransfers())
 572     {
 573         it->stop();
 574         m_viewsContainer->closeTransferDetails(it);
 575         KGet::delTransfer(it);
 576     }
 577 }
 578
 579 void MainWindow::slotRedownloadSelected()
 580 {
 581     foreach(TransferHandler * it, KGet::selectedTransfers())
 582     {
 583         KGet::redownloadTransfer(it);
 584     }
 585 }
 586
 587 void MainWindow::slotTransfersOpenDest()
 588 {
 589     QStringList openedDirs;
 590     foreach(TransferHandler * it, KGet::selectedTransfers())
 591     {
 592         QString directory = it->dest().directory();
 593         if( !openedDirs.contains( directory ) )
 594         {
 595             new KRun(directory, this, 0, true, false);
 596             openedDirs.append( directory );
 597         }
 598     }
 599 }
 600
 601 void MainWindow::slotTransfersOpenFile()
 602 {
 603     foreach(TransferHandler * it, KGet::selectedTransfers())
 604     {
 605         new KRun(it->dest(), this, 0, true, false);
 606     }
 607 }
 608
 609 void MainWindow::slotTransfersShowDetails()
 610 {
 611     foreach(TransferHandler * it, KGet::selectedTransfers())
 612     {
 613         m_viewsContainer->showTransferDetails(it);
 614     }
 615 }
 616
 617 void MainWindow::slotTransfersCopySourceUrl()
 618 {
 619     foreach(TransferHandler * it, KGet::selectedTransfers())
 620     {
 621         QString sourceurl = it->source().url();
 622         QClipboard *cb = QApplication::clipboard();
 623         cb->setText(sourceurl, QClipboard::Selection);
 624         cb->setText(sourceurl, QClipboard::Clipboard);
 625     }
 626 }
 627
 628 void MainWindow::slotDeleteFinished()
 629 {
 630     foreach(TransferHandler * it, KGet::finishedTransfers())
 631     {
 632         it->stop();
 633         m_viewsContainer->closeTransferDetails(it);
 634         KGet::delTransfer(it);
 635     }
 636 }
 637
 638 void MainWindow::slotConfigureNotifications()
 639 {
 640     KNotifyConfigWidget::configure(this);
 641 }
 642
 643 void MainWindow::slotConfigureKeys()
 644 {
 645     KShortcutsDialog::configure(actionCollection());
 646 }
 647
 648 void MainWindow::slotConfigureToolbars()
 649 {
 650     KEditToolBar edit( actionCollection() );
 651     connect(&edit, SIGNAL( newToolbarConfig() ), this, SLOT( slotNewToolbarConfig() ));
 652     edit.exec();
 653 }
 654
 655
 656 void MainWindow::slotSaveMyself()
 657 {
 658     // save last parameters ..
 659     Settings::setMainPosition( pos() );
 660     // .. and write config to disk
 661     Settings::self()->writeConfig();
 662 }
 663
 664 void MainWindow::slotNewToolbarConfig()
 665 {
 666     createGUI();
 667 }
 668
 669 void MainWindow::slotNewConfig()
 670 {
 671     // Update here properties modified in the config dialog and not
 672     // parsed often by the code. When clicking Ok or Apply of
 673     // PreferencesDialog, this function is called.
 674
 675     m_viewsContainer->setExpandableDetails(Settings::showExpandableTransferDetails());
 676     m_drop->setDropTargetVisible(Settings::showDropTarget(), false);
 677     m_dock->setVisible(Settings::enableSystemTray());
 678
 679     if(!Settings::enableSystemTray())
 680         setVisible(true);
 681
 682     slotKonquerorIntegration(Settings::konquerorIntegration());
 683     m_konquerorIntegration->setChecked(Settings::konquerorIntegration());
 684
 685     KGet::reloadKJobs();
 686
 687     if (Settings::autoPaste())
 688         clipboardTimer->start(1000);
 689     else
 690         clipboardTimer->stop();
 691     m_autoPasteAction->setChecked(Settings::autoPaste());
 692
 693     if (Settings::webinterfaceEnabled() && !m_webinterface) {
 694         m_webinterface = new HttpServer(this);
 695     } else if (m_webinterface && !Settings::webinterfaceEnabled()) {
 696         delete m_webinterface;
 697         m_webinterface = 0;
 698     }
 699
 700     if (Settings::speedLimit())
 701     {
 702         KGet::setGlobalDownloadLimit(Settings::globalDownloadLimit());
 703         KGet::setGlobalUploadLimit(Settings::globalUploadLimit());
 704     }
 705     else
 706     {
 707         KGet::setGlobalDownloadLimit(0);
 708         KGet::setGlobalUploadLimit(0);
 709     }
 710
 711     KGet::settingsChanged();
 712 }
 713
 714 void MainWindow::slotToggleAutoPaste()
 715 {
 716     bool autoPaste = !Settings::autoPaste();
 717     Settings::setAutoPaste( autoPaste );
 718
 719     if (autoPaste)
 720         clipboardTimer->start(1000);
 721     else
 722         clipboardTimer->stop();
 723     m_autoPasteAction->setChecked(autoPaste);
 724 }
 725
 726 void MainWindow::slotCheckClipboard()
 727 {
 728     QString clipData = QApplication::clipboard()->text( QClipboard::Clipboard ).trimmed();
 729
 730     if (clipData != lastClipboard)
 731     {
 732         lastClipboard = clipData;
 733         if (lastClipboard.isEmpty())
 734             return;
 735
 736         KUrl url = KUrl(lastClipboard);
 737
 738         if (url.isValid() && !url.isLocalFile())
 739             KGet::addTransfer( url );
 740     }
 741 }
 742
 743 void MainWindow::slotTrayKonquerorIntegration(bool enable)
 744 {
 745     slotKonquerorIntegration(enable);
 746     if (!enable && Settings::konquerorIntegration() && !Settings::expertMode())
 747     {
 748         KGet::showNotification(this, KNotification::Notification,
 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                                      "dialog-info");
 753         /*KMessageBox::information(this,
 754             i18n("KGet has been temporarily disabled as download manager for Konqueror. "
 755             "If you want to disable it forever, go to Settings->Advanced and disable \"Use "
 756             "as download manager for Konqueror\"."),
 757             i18n("Konqueror Integration disabled"),
 758             "KonquerorIntegrationDisabled");*/
 759     }
 760 }
 761
 762 void MainWindow::slotKonquerorIntegration(bool konquerorIntegration)
 763 {
 764     KConfig cfgKonqueror("konquerorrc", KConfig::NoGlobals);
 765     cfgKonqueror.group("HTML Settings").writeEntry("DownloadManager",
 766                                                    QString(konquerorIntegration ? "kget" : QString()));
 767     cfgKonqueror.sync();
 768 }
 769
 770 void MainWindow::slotShowMenubar()
 771 {
 772     if (m_menubarAction->isChecked())
 773         menuBar()->show();
 774     else
 775         menuBar()->hide();
 776 }
 777
 778 void MainWindow::setSystemTrayDownloading(bool running)
 779 {
 780     kDebug(5001);
 781
 782     m_dock->setDownloading(running);
 783 }
 784
 785 void MainWindow::importLinks(const QList <QString> &links)
 786 {
 787     KGetLinkView *link_view = new KGetLinkView(this);
 788     link_view->setLinks(links);
 789     link_view->show();
 790 }
 791
 792 void MainWindow::slotTransferHistory()
 793 {
 794     TransferHistory *history = new TransferHistory();
 795     history->exec();
 796 }
 797
 798 void MainWindow::slotTransferGroupSettings()
 799 {
 800     kDebug(5001);
 801     QList<TransferGroupHandler*> list = KGet::selectedTransferGroups();
 802     foreach(TransferGroupHandler* group, list)
 803     {
 804         GroupSettingsDialog *settings = new GroupSettingsDialog(this, group);
 805         settings->exec();
 806     }
 807 }
 808
 809 void MainWindow::slotTransferSettings()
 810 {
 811     kDebug(5001);
 812     QList<TransferHandler*> list = KGet::selectedTransfers();
 813     foreach(TransferHandler* transfer, list)
 814     {
 815         TransferSettingsDialog *settings = new TransferSettingsDialog(this, transfer);
 816         settings->exec();
 817     }
 818 }
 819
 820 /** slots for link list **/
 821 void MainWindow::slotShowListLinks()
 822 {
 823     KGetLinkView *link_view = new KGetLinkView(this);
 824     link_view->importUrl();
 825     link_view->show();
 826 }
 827
 828 void MainWindow::slotImportUrl(const QString &url)
 829 {
 830     KGetLinkView *link_view = new KGetLinkView(this);
 831     link_view->importUrl(url);
 832     link_view->show();
 833 }
 834
 835 /** widget events */
 836 void MainWindow::closeEvent( QCloseEvent * e )
 837 {
 838     // if the event comes from out the application (close event) we decide between close or hide
 839     // if the event comes from the application (system shutdown) we say goodbye
 840     if(e->spontaneous()) {
 841         e->ignore();
 842         if(!Settings::enableSystemTray()) {
 843             slotQuit();
 844         }
 845         else {
 846             hide();
 847         }
 848     }
 849 }
 850
 851 void MainWindow::dragEnterEvent(QDragEnterEvent * event)
 852 {
 853     event->setAccepted(KUrl::List::canDecode(event->mimeData())
 854                   || event->mimeData()->hasText());
 855 }
 856
 857 void MainWindow::dropEvent(QDropEvent * event)
 858 {
 859     KUrl::List list = KUrl::List::fromMimeData(event->mimeData());
 860     QString str;
 861
 862     if (!list.isEmpty())
 863     {
 864         if (list.count() == 1 && list.first().url().endsWith(".kgt"))
 865         {
 866             int msgBoxResult = KMessageBox::questionYesNoCancel(this, i18n("The dropped file is a KGet-Transferlist"), "KGet",
 867                                    KGuiItem(i18n("&Download"), KIcon("document-save")),
 868                                        KGuiItem(i18n("&Load transferlist"), KIcon("list-add")), KStandardGuiItem::cancel());
 869
 870             if (msgBoxResult == 3) //Download
 871                 NewTransferDialog::instance(this)->showDialog(list.first().url());
 872             if (msgBoxResult == 4) //Load
 873                 KGet::load(list.first().url());
 874         }
 875         else
 876         {
 877             if (list.count() == 1)
 878             {
 879                 str = event->mimeData()->text();
 880                 NewTransferDialog::instance(this)->showDialog(str);
 881             }
 882             else
 883                 NewTransferDialog::instance(this)->showDialog(list);
 884         }
 885     }
 886     else
 887     {
 888         NewTransferDialog::instance(this)->showDialog();
 889     }
 890 }
 891
 892
 893 /** DBUS interface */
 894
 895 void MainWindow::addTransfer(const QString& src, const QString& dest, bool start)
 896 {
 897     // split src for the case it is a QStringList (e.g. from konqueror plugin)
 898     KGet::addTransfer(src.split(';'), dest, QString(), start);
 899 }
 900
 901 void MainWindow::showNewTransferDialog(const QStringList &urls)
 902 {
 903     NewTransferDialog::instance(this)->showDialog(urls);
 904 }
 905
 906 bool MainWindow::dropTargetVisible() const
 907 {
 908     return m_drop->isVisible();
 909 }
 910
 911 void MainWindow::setDropTargetVisible( bool setVisible )
 912 {
 913     if ( setVisible != Settings::showDropTarget() )
 914         m_drop->setDropTargetVisible( setVisible );
 915 }
 916
 917 void MainWindow::setOfflineMode( bool offline )
 918 {
 919     KGet::setSchedulerRunning(offline);
 920 }
 921
 922 bool MainWindow::offlineMode() const
 923 {
 924     return !KGet::schedulerRunning();
 925 }
 926
 927 QVariantMap MainWindow::transfers() const
 928 {
 929     return m_dbusModelObserver->transfers();
 930 }
 931
 932 int MainWindow::transfersSpeed() const
 933 {
 934     return m_dbusModelObserver->transfersSpeed();
 935 }
 936
 937 MainWindowModelObserver::MainWindowModelObserver(MainWindow *window)
 938     : QObject(window)
 939 {
 940     m_window = window;
 941     m_groupObserver = new MainWindowGroupObserver(window);
 942 }
 943
 944 void MainWindowModelObserver::addedTransferGroupEvent(TransferGroupHandler *group)
 945 {
 946     group->addObserver(m_groupObserver);
 947 }
 948
 949 void MainWindowModelObserver::removedTransferGroupEvent(TransferGroupHandler *group)
 950 {
 951     group->delObserver(m_groupObserver);
 952 }
 953
 954 MainWindowGroupObserver::MainWindowGroupObserver(MainWindow *window)
 955     : QObject(window)
 956 {
 957     m_window = window;
 958 }
 959
 960 void MainWindowGroupObserver::groupChangedEvent(TransferGroupHandler * group)
 961 {
 962     TransferGroupHandler::ChangesFlags transferFlags = group->changesFlags(this);
 963     if (transferFlags & TransferGroup::Gc_Percent) {
 964         m_window->slotUpdateTitlePercent();
 965     }
 966     group->resetChangesFlags(this);
 967 }
 968
 969 /**void MainWindowGroupObserver::addedTransferEvent(TransferHandler * transfer, TransferHandler * after)
 970 {
 971     Q_UNUSED(transfer);
 972     Q_UNUSED(after);
 973 }
 974
 975 void MainWindowGroupObserver::removedTransferEvent(TransferHandler * transfer)
 976 {
 977     Q_UNUSED(transfer);
 978 }
 979
 980 void MainWindowGroupObserver::movedTransferEvent(TransferHandler * transfer, TransferHandler * after)
 981 {
 982     Q_UNUSED(transfer);
 983     Q_UNUSED(after);
 984 }**/
 985
 986 #include "mainwindow.moc"