kget/core/kget.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2005 Dario Massarin <nekkar@libero.it>
   4    Copyright (C) 2007-2008 Lukas Appelhans <l.appelhans@gmx.de>
   5    Copyright (C) 2008 Urs Wolfer <uwolfer @ kde.org>
   6    Copyright (C) 2008 Dario Freddi <drf54321@gmail.com>
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public
  10    License as published by the Free Software Foundation; either
  11    version 2 of the License, or (at your option) any later version.
  12 */
  13
  14 #include "core/kget.h"
  15
  16 #include "mainwindow.h"
  17 #include "core/transfer.h"
  18 #include "core/transferdatasource.h"
  19 #include "core/transfergroup.h"
  20 #include "core/transfergrouphandler.h"
  21 #include "core/transfertreemodel.h"
  22 #include "core/transfertreeselectionmodel.h"
  23 #include "core/plugin/plugin.h"
  24 #include "core/plugin/transferfactory.h"
  25 #include "core/observer.h"
  26 #include "core/kuiserverjobs.h"
  27 #include "core/transfergroupscheduler.h"
  28 #include "settings.h"
  29
  30 #include <kio/netaccess.h>
  31 #include <kinputdialog.h>
  32 #include <kfiledialog.h>
  33 #include <kmessagebox.h>
  34 #include <klocale.h>
  35 #include <kstandarddirs.h>
  36 #include <kservicetypetrader.h>
  37 #include <kiconloader.h>
  38 #include <kactioncollection.h>
  39 #include <kio/renamedialog.h>
  40 #include <KSystemTrayIcon>
  41 #include <KSharedConfig>
  42 #include <KPluginInfo>
  43
  44 #include <QTextStream>
  45 #include <QDomElement>
  46 #include <QApplication>
  47 #include <QClipboard>
  48 #include <QAbstractItemView>
  49
  50 /**
  51  * This is our KGet class. This is where the user's transfers and searches are
  52  * stored and organized.
  53  * Use this class from the views to add or remove transfers or searches
  54  * In order to organize the transfers inside categories we have a TransferGroup
  55  * class. By definition, a transfer must always belong to a TransferGroup. If we
  56  * don't want it to be displayed by the gui inside a specific group, we will put
  57  * it in the group named "Not grouped" (better name?).
  58  **/
  59
  60 KGet& KGet::self( MainWindow * mainWindow )
  61 {
  62     if(mainWindow)
  63     {
  64         m_mainWindow = mainWindow;
  65         m_jobManager = new KUiServerJobs(m_mainWindow);
  66     }
  67
  68     static KGet m;
  69     return m;
  70 }
  71
  72 void KGet::addObserver(ModelObserver * observer)
  73 {
  74     kDebug(5001);
  75
  76     m_observers.append(observer);
  77
  78     //Update the new observer with the TransferGroups objects of the model
  79     QList<TransferGroup *>::const_iterator it = m_transferTreeModel->transferGroups().begin();
  80     QList<TransferGroup *>::const_iterator itEnd = m_transferTreeModel->transferGroups().end();
  81
  82     for( ; it!=itEnd ; ++it )
  83     {
  84         postAddedTransferGroupEvent(*it, observer);
  85     }
  86
  87     kDebug(5001) << " >>> EXITING";
  88 }
  89
  90 void KGet::delObserver(ModelObserver * observer)
  91 {
  92     m_observers.removeAll(observer);
  93 }
  94
  95 bool KGet::addGroup(const QString& groupName)
  96 {
  97     kDebug(5001);
  98
  99     // Check if a group with that name already exists
 100     if(m_transferTreeModel->findGroup(groupName))
 101         return false;
 102
 103     TransferGroup * group = new TransferGroup(m_transferTreeModel, m_scheduler, groupName);
 104     m_transferTreeModel->addGroup(group);
 105
 106     //post notifications
 107     postAddedTransferGroupEvent(group);
 108
 109     return true;
 110 }
 111
 112 void KGet::delGroup(const QString& groupName)
 113 {
 114     TransferGroup * group = m_transferTreeModel->findGroup(groupName);
 115
 116     if(group)
 117     {
 118         m_transferTreeModel->delGroup(group);
 119         postRemovedTransferGroupEvent(group);
 120         delete(group);
 121     }
 122 }
 123
 124 void KGet::renameGroup(const QString& oldName, const QString& newName)
 125 {
 126     TransferGroup *group = m_transferTreeModel->findGroup(oldName);
 127
 128     if(group)
 129     {
 130         group->handler()->setName(newName);
 131     }
 132 }
 133
 134 QStringList KGet::transferGroupNames()
 135 {
 136     QStringList names;
 137
 138     foreach(TransferGroup *group, m_transferTreeModel->transferGroups()) {
 139         names << group->name();
 140     }
 141
 142     return names;
 143 }
 144
 145 void KGet::addTransfer(KUrl srcUrl, QString destDir, // krazy:exclude=passbyvalue
 146                        const QString& groupName, bool start)
 147 {
 148     kDebug(5001) << "Source:" << srcUrl.url();
 149
 150     KUrl destUrl;
 151
 152     if ( srcUrl.isEmpty() )
 153     {
 154         //No src location: we let the user insert it manually
 155         srcUrl = urlInputDialog();
 156         if( srcUrl.isEmpty() )
 157             return;
 158     }
 159
 160     if ( !isValidSource( srcUrl ) )
 161         return;
 162
 163     if (destDir.isEmpty())
 164     {
 165         if (Settings::useDefaultDirectory())
 166             destDir = KUrl(Settings::defaultDirectory()).path();
 167
 168         QString checkExceptions = getSaveDirectoryFromExceptions(srcUrl);
 169         if (Settings::enableExceptions() && !checkExceptions.isEmpty())
 170             destDir = checkExceptions;
 171     }
 172
 173     if (!isValidDestDirectory(destDir))
 174         destDir = destInputDialog();
 175
 176     if( (destUrl = getValidDestUrl( destDir, srcUrl )).isEmpty() )
 177         return;
 178
 179     if(m_transferTreeModel->findTransferByDestination(destUrl) != 0 || (destUrl.isLocalFile() && QFile::exists(destUrl.path()))) {
 180         KIO::RenameDialog dlg( m_mainWindow, i18n("Rename transfer"), srcUrl,
 181                                destUrl, KIO::M_MULTI);
 182         if (dlg.exec() == KIO::R_RENAME)
 183             destUrl = dlg.newDestUrl();
 184         else
 185             return;
 186     }
 187     createTransfer(srcUrl, destUrl, groupName, start);
 188 }
 189
 190 void KGet::addTransfer(const QDomElement& e, const QString& groupName)
 191 {
 192     //We need to read these attributes now in order to know which transfer
 193     //plugin to use.
 194     KUrl srcUrl = KUrl( e.attribute("Source") );
 195     KUrl destUrl = KUrl( e.attribute("Dest") );
 196
 197     kDebug(5001) << " src= " << srcUrl.url()
 198               << " dest= " << destUrl.url()
 199               << " group= "<< groupName << endl;
 200
 201     if ( srcUrl.isEmpty() || !isValidSource(srcUrl)
 202          || !isValidDestDirectory(destUrl.directory()) )
 203         return;
 204
 205     createTransfer(srcUrl, destUrl, groupName, false, &e);
 206 }
 207
 208 void KGet::addTransfer(KUrl::List srcUrls, QString destDir, // krazy:exclude=passbyvalue
 209                        const QString& groupName, bool start)
 210 {
 211     KUrl::List urlsToDownload;
 212
 213     KUrl::List::Iterator it = srcUrls.begin();
 214     KUrl::List::Iterator itEnd = srcUrls.end();
 215
 216     for(; it!=itEnd ; ++it)
 217     {
 218         if ( isValidSource( *it ) )
 219             urlsToDownload.append( *it );
 220     }
 221
 222     if ( urlsToDownload.count() == 0 )
 223         return;
 224
 225     if ( urlsToDownload.count() == 1 )
 226     {
 227         // just one file -> ask for filename
 228         addTransfer(srcUrls.first(), destDir + srcUrls.first().fileName(), groupName, start);
 229         return;
 230     }
 231
 232     KUrl destUrl;
 233
 234     // multiple files -> ask for directory, not for every single filename
 235     if (!isValidDestDirectory(destDir) && !Settings::useDefaultDirectory())
 236         destDir = destInputDialog();
 237
 238     it = urlsToDownload.begin();
 239     itEnd = urlsToDownload.end();
 240
 241     for ( ; it != itEnd; ++it )
 242     {
 243         if (destDir.isEmpty())
 244         {
 245             if (Settings::useDefaultDirectory())
 246                 destDir = KUrl(Settings::defaultDirectory()).path();
 247
 248             QString checkExceptions = getSaveDirectoryFromExceptions(*it);
 249             if (Settings::enableExceptions() && !checkExceptions.isEmpty())
 250                 destDir = checkExceptions;
 251         }
 252         destUrl = getValidDestUrl(destDir, *it);
 253
 254         if(!isValidDestUrl(destUrl))
 255             continue;
 256
 257         createTransfer(*it, destUrl, groupName, start);
 258     }
 259 }
 260
 261
 262 bool KGet::delTransfer(TransferHandler * transfer)
 263 {
 264     Transfer * t = transfer->m_transfer;
 265     t->stop();
 266
 267     m_transferTreeModel->delTransfer(t);
 268
 269     //Here I delete the Transfer. The other possibility is to move it to a list
 270     //and to delete all these transfers when kget gets closed. Obviously, after
 271     //the notification to the views that the transfer has been removed, all the
 272     //pointers to it are invalid.
 273     transfer->postDeleteEvent();
 274     delete t;
 275     return true;
 276 }
 277
 278 void KGet::moveTransfer(TransferHandler * transfer, const QString& groupName)
 279 {
 280   Q_UNUSED(transfer);
 281   Q_UNUSED(groupName);
 282 }
 283
 284 void KGet::redownloadTransfer(TransferHandler * transfer)
 285 {
 286      QString group = transfer->group()->name();
 287      QString src = transfer->source().url();
 288      QString dest = transfer->dest().url();
 289      bool running = false;
 290      if (transfer->status() == Job::Running)
 291          running = true;
 292
 293      KGet::delTransfer(transfer);
 294      KGet::addTransfer(src, dest, group, running);
 295 }
 296
 297 QList<TransferHandler *> KGet::selectedTransfers()
 298 {
 299 //     kDebug(5001) << "KGet::selectedTransfers";
 300
 301     QList<TransferHandler *> selectedTransfers;
 302
 303     QModelIndexList selectedIndexes = m_selectionModel->selectedRows();
 304
 305     foreach(const QModelIndex &currentIndex, selectedIndexes)
 306     {
 307         if(!m_transferTreeModel->isTransferGroup(currentIndex))
 308             selectedTransfers.append(static_cast<TransferHandler *> (currentIndex.internalPointer()));
 309     }
 310
 311     return selectedTransfers;
 312
 313
 314 // This is the code that was used in the old selectedTransfers function
 315 /*    QList<TransferGroup *>::const_iterator it = m_transferTreeModel->transferGroups().begin();
 316     QList<TransferGroup *>::const_iterator itEnd = m_transferTreeModel->transferGroups().end();
 317
 318     for( ; it!=itEnd ; ++it )
 319     {
 320         TransferGroup::iterator it2 = (*it)->begin();
 321         TransferGroup::iterator it2End = (*it)->end();
 322
 323         for( ; it2!=it2End ; ++it2 )
 324         {
 325             Transfer * transfer = (Transfer*) *it2;
 326
 327             if( transfer->isSelected() )
 328                 selectedTransfers.append( transfer->handler() );
 329         }
 330     }
 331     return selectedTransfers;*/
 332 }
 333
 334 QList<TransferHandler *> KGet::finishedTransfers()
 335 {
 336     QList<TransferHandler *> finishedTransfers;
 337
 338     foreach(TransferHandler *transfer, allTransfers())
 339     {
 340         if (transfer->status() == Job::Finished) {
 341             finishedTransfers << transfer;
 342         }
 343     }
 344     return finishedTransfers;
 345 }
 346
 347 QList<TransferGroupHandler *> KGet::selectedTransferGroups()
 348 {
 349     QList<TransferGroupHandler *> selectedTransferGroups;
 350
 351     QModelIndexList selectedIndexes = m_selectionModel->selectedRows();
 352
 353     foreach(const QModelIndex &currentIndex, selectedIndexes)
 354     {
 355         if(m_transferTreeModel->isTransferGroup(currentIndex))
 356             selectedTransferGroups.append(static_cast<TransferGroupHandler *> (currentIndex.internalPointer()));
 357     }
 358
 359     return selectedTransferGroups;
 360 }
 361
 362 TransferTreeSelectionModel * KGet::selectionModel()
 363 {
 364     return m_selectionModel;
 365 }
 366
 367 void KGet::addTransferView(QAbstractItemView * view)
 368 {
 369     view->setModel(m_transferTreeModel);
 370 }
 371
 372 void KGet::load( QString filename ) // krazy:exclude=passbyvalue
 373 {
 374     kDebug(5001) << "(" << filename << ")";
 375
 376     if(filename.isEmpty())
 377         filename = KStandardDirs::locateLocal("appdata", "transfers.kgt");
 378
 379     QString tmpFile;
 380
 381     //Try to save the transferlist to a temporary location
 382     if(!KIO::NetAccess::download(KUrl(filename), tmpFile, 0))
 383         return;
 384
 385     QFile file(tmpFile);
 386     QDomDocument doc;
 387
 388     kDebug(5001) << "file:" << filename;
 389
 390     if(doc.setContent(&file))
 391     {
 392         QDomElement root = doc.documentElement();
 393
 394         QDomNodeList nodeList = root.elementsByTagName("TransferGroup");
 395         int nItems = nodeList.length();
 396
 397         for( int i = 0 ; i < nItems ; i++ )
 398         {
 399             TransferGroup * foundGroup = m_transferTreeModel->findGroup( nodeList.item(i).toElement().attribute("Name") );
 400
 401             kDebug(5001) << "KGet::load  -> group = " << nodeList.item(i).toElement().attribute("Name");
 402
 403             if( !foundGroup )
 404             {
 405                 kDebug(5001) << "KGet::load  -> group not found";
 406
 407                 TransferGroup * newGroup = new TransferGroup(m_transferTreeModel, m_scheduler);
 408
 409                 m_transferTreeModel->addGroup(newGroup);
 410
 411                 newGroup->load(nodeList.item(i).toElement());
 412
 413                 //Post notifications
 414                 postAddedTransferGroupEvent(newGroup);
 415             }
 416             else
 417             {
 418                 kDebug(5001) << "KGet::load  -> group found";
 419
 420                 //A group with this name already exists.
 421                 //Integrate the group's transfers with the ones read from file
 422                 foundGroup->load(nodeList.item(i).toElement());
 423             }
 424         }
 425     }
 426     else
 427     {
 428         kWarning(5001) << "Error reading the transfers file";
 429     }
 430
 431     addObserver(new GenericModelObserver());
 432 }
 433
 434 void KGet::save( QString filename, bool plain ) // krazy:exclude=passbyvalue
 435 {
 436     if ( !filename.isEmpty()
 437         && QFile::exists( filename )
 438         && (KMessageBox::questionYesNoCancel(0,
 439                 i18n("The file %1 already exists.\nOverwrite?", filename),
 440                 i18n("Overwrite existing file?"), KStandardGuiItem::yes(),
 441                 KStandardGuiItem::no(), KStandardGuiItem::cancel(), "QuestionFilenameExists" )
 442                 != KMessageBox::Yes) )
 443         return;
 444
 445     if(filename.isEmpty())
 446         filename = KStandardDirs::locateLocal("appdata", "transfers.kgt");
 447
 448     QFile file(filename);
 449     if ( !file.open( QIODevice::WriteOnly ) )
 450     {
 451         //kWarning(5001)<<"Unable to open output file when saving";
 452         KMessageBox::error(0,
 453                         i18n("Unable to save to: %1", filename),
 454                         i18n("Error"));
 455
 456         return;
 457     }
 458
 459     if (plain) {
 460         QTextStream out(&file);
 461         foreach(TransferHandler *handler, allTransfers()) {
 462             out << handler->source().prettyUrl() << endl;
 463         }
 464     }
 465     else {
 466         QDomDocument doc(QString("KGetTransfers"));
 467         QDomElement root = doc.createElement("Transfers");
 468         doc.appendChild(root);
 469
 470         QList<TransferGroup *>::const_iterator it = m_transferTreeModel->transferGroups().begin();
 471         QList<TransferGroup *>::const_iterator itEnd = m_transferTreeModel->transferGroups().end();
 472
 473         for ( ; it!=itEnd ; ++it )
 474         {
 475             QDomElement e = doc.createElement("TransferGroup");
 476             root.appendChild(e);
 477             (*it)->save(e);
 478         }
 479
 480         QTextStream stream( &file );
 481         doc.save( stream, 0 );
 482     }
 483     file.close();
 484 }
 485
 486 TransferFactory * KGet::factory(TransferHandler * transfer)
 487 {
 488     return transfer->m_transfer->factory();
 489 }
 490
 491 KActionCollection * KGet::actionCollection()
 492 {
 493     return m_mainWindow->actionCollection();
 494 }
 495
 496 void KGet::setSchedulerRunning(bool running)
 497 {
 498     if(running)
 499     {
 500         m_scheduler->stop(); //stopall first, to have a clean startingpoint
 501         m_scheduler->start();
 502     }
 503     else
 504         m_scheduler->stop();
 505 }
 506
 507 bool KGet::schedulerRunning()
 508 {
 509     return (m_scheduler->countRunningJobs() > 0);
 510 }
 511
 512 QList<TransferHandler*> KGet::allTransfers()
 513 {
 514     QList<TransferHandler*> transfers;
 515
 516     foreach (TransferGroup *group, KGet::m_transferTreeModel->transferGroups())
 517     {
 518         transfers << group->handler()->transfers();
 519     }
 520     return transfers;
 521 }
 522
 523 QList<TransferGroupHandler*> KGet::allTransferGroups()
 524 {
 525     QList<TransferGroupHandler*> transfergroups;
 526
 527     foreach (TransferGroup *group, KGet::m_transferTreeModel->transferGroups())
 528     {
 529         transfergroups << group->handler();
 530     }
 531     return transfergroups;
 532 }
 533
 534 TransferHandler * KGet::findTransfer(const KUrl &src)
 535 {
 536     return KGet::m_transferTreeModel->findTransfer(src)->handler();
 537 }
 538
 539 void KGet::checkSystemTray()
 540 {
 541     kDebug(5001);
 542     bool running = false;
 543
 544     foreach (TransferHandler *handler, KGet::allTransfers())
 545     {
 546         if (handler->status() == Job::Running)
 547             running = true;
 548
 549         if (running)
 550             continue;
 551     }
 552
 553     m_mainWindow->setSystemTrayDownloading(running);
 554 }
 555
 556 void KGet::settingsChanged()
 557 {
 558     kDebug(5001);
 559
 560     QList<TransferFactory*>::const_iterator it = m_transferFactories.constBegin();
 561     QList<TransferFactory*>::const_iterator itEnd = m_transferFactories.constEnd();
 562
 563     for( ; it!=itEnd ; ++it )
 564     {
 565         (*it)->settingsChanged();
 566     }
 567 }
 568
 569 void KGet::registerKJob(KJob *job)
 570 {
 571     m_jobManager->registerJob(job);
 572 }
 573
 574 void KGet::unregisterKJob(KJob *job)
 575 {
 576     m_jobManager->unregisterJob(job);
 577 }
 578
 579 void KGet::reloadKJobs()
 580 {
 581     m_jobManager->reload();
 582 }
 583
 584 QStringList KGet::defaultFolders(const KUrl &filename, const QString &groupname)
 585 {
 586     kDebug(5001) << filename << groupname;
 587
 588     QStringList list;
 589     const QString saveDirectoryFromExceptions = KGet::getSaveDirectoryFromExceptions(filename);
 590     if (Settings::enableExceptions() && !saveDirectoryFromExceptions.isEmpty())
 591         list.append(saveDirectoryFromExceptions);
 592
 593     TransferGroup * group = KGet::m_transferTreeModel->findGroup(groupname);
 594
 595     if (!group->defaultFolder().isEmpty())
 596         list.append(group->defaultFolder());
 597
 598     if (Settings::useDefaultDirectory())
 599         list.append(Settings::defaultDirectory());
 600
 601     if (!Settings::lastDirectory().isEmpty() &&
 602         QString::compare(Settings::lastDirectory(), Settings::defaultDirectory()) != 0)
 603         list.append(Settings::lastDirectory());
 604
 605     if (list.isEmpty())
 606         list.append(QDir::homePath());//If we have no defaultDir, we return the home-dir
 607
 608     for (int i = 0; i < list.size(); i++)
 609     {
 610         list[i] = KUrl(list[i]).path();
 611     }
 612     return list;
 613 }
 614
 615 void KGet::setGlobalDownloadLimit(int limit)
 616 {
 617     m_scheduler->setDownloadLimit(limit);
 618     if (!limit)
 619         m_scheduler->calculateDownloadLimit();
 620 }
 621
 622 void KGet::setGlobalUploadLimit(int limit)
 623 {
 624     m_scheduler->setUploadLimit(limit);
 625     if (!limit)
 626         m_scheduler->calculateUploadLimit();
 627 }
 628
 629 void KGet::calculateGlobalSpeedLimits()
 630 {
 631     if (m_scheduler->downloadLimit())//TODO: Remove this and the both other hacks in the 2 upper functions with a better replacement
 632         m_scheduler->calculateDownloadLimit();
 633     if (m_scheduler->uploadLimit())
 634         m_scheduler->calculateUploadLimit();
 635 }
 636
 637 void KGet::calculateGlobalDownloadLimit()
 638 {
 639     m_scheduler->calculateDownloadLimit();
 640 }
 641
 642 void KGet::calculateGlobalUploadLimit()
 643 {
 644     m_scheduler->calculateUploadLimit();
 645 }
 646
 647 // ------ STATIC MEMBERS INITIALIZATION ------
 648 QList<ModelObserver *> KGet::m_observers;
 649 TransferTreeModel * KGet::m_transferTreeModel;
 650 TransferTreeSelectionModel * KGet::m_selectionModel;
 651 QList<TransferFactory *> KGet::m_transferFactories;
 652 TransferGroupScheduler * KGet::m_scheduler = new TransferGroupScheduler();
 653 MainWindow * KGet::m_mainWindow = 0;
 654 KUiServerJobs * KGet::m_jobManager = 0;
 655
 656 // ------ PRIVATE FUNCTIONS ------
 657 KGet::KGet()
 658 {
 659     m_transferTreeModel = new TransferTreeModel(m_scheduler);
 660     m_selectionModel = new TransferTreeSelectionModel(m_transferTreeModel);
 661
 662     //Load all the available plugins
 663     loadPlugins();
 664
 665     //Create the default group
 666     addGroup(i18n("My Downloads"));
 667 }
 668
 669 KGet::~KGet()
 670 {
 671     delete m_scheduler;
 672 }
 673
 674 bool KGet::createTransfer(const KUrl &src, const KUrl &dest, const QString& groupName,
 675                           bool start, const QDomElement * e)
 676 {
 677     kDebug(5001) << "srcUrl= " << src.url() << "  "
 678                              << "destUrl= " << dest.url()
 679                              << "group= _" << groupName << "_" << endl;
 680
 681     TransferGroup * group = m_transferTreeModel->findGroup(groupName);
 682     if (group==0)
 683     {
 684         kDebug(5001) << "KGet::createTransfer  -> group not found";
 685         group = m_transferTreeModel->transferGroups().first();
 686     }
 687     Transfer * newTransfer;
 688
 689     QList<TransferFactory *>::iterator it = m_transferFactories.begin();
 690     QList<TransferFactory *>::iterator itEnd = m_transferFactories.end();
 691
 692     for( ; it!=itEnd ; ++it)
 693     {
 694         kDebug(5001) << "Trying plugin   n.plugins=" << m_transferFactories.size();
 695         if((newTransfer = (*it)->createTransfer(src, dest, group, m_scheduler, e)))
 696         {
 697 //             kDebug(5001) << "KGet::createTransfer   ->   CREATING NEW TRANSFER ON GROUP: _" << group->name() << "_";
 698             m_transferTreeModel->addTransfer(newTransfer, group);
 699
 700             if(start)
 701                 newTransfer->handler()->start();
 702 /*
 703             if (newTransfer->percent() != 100) //Don't add a finished observer if the Transfer has already been finished
 704                 newTransfer->handler()->addObserver(new GenericTransferObserver());
 705 */
 706             return true;
 707         }
 708     }
 709     kDebug(5001) << "Warning! No plugin found to handle the given url";
 710     return false;
 711 }
 712
 713 TransferDataSource * KGet::createTransferDataSource(const KUrl &src)
 714 {
 715     kDebug(5001);
 716     QList<TransferFactory *>::iterator it = m_transferFactories.begin();
 717     QList<TransferFactory *>::iterator itEnd = m_transferFactories.end();
 718
 719     TransferDataSource *dataSource;
 720     for( ; it!=itEnd ; ++it)
 721     {
 722         dataSource = (*it)->createTransferDataSource(src);
 723         if(dataSource)
 724             return dataSource;
 725     }
 726     return 0;
 727 }
 728
 729 void KGet::postAddedTransferGroupEvent(TransferGroup * group, ModelObserver * observer)
 730 {
 731     kDebug(5001);
 732     if(observer)
 733     {
 734         observer->addedTransferGroupEvent(group->handler());
 735         return;
 736     }
 737
 738     QList<ModelObserver *>::iterator it = m_observers.begin();
 739     QList<ModelObserver *>::iterator itEnd = m_observers.end();
 740
 741     for(; it!=itEnd; ++it)
 742     {
 743         kDebug(5001) << "message posted";
 744
 745         (*it)->addedTransferGroupEvent(group->handler());
 746     }
 747 }
 748
 749 void KGet::postRemovedTransferGroupEvent(TransferGroup * group, ModelObserver * observer)
 750 {
 751     if(observer)
 752     {
 753         observer->removedTransferGroupEvent(group->handler());
 754         return;
 755     }
 756
 757     QList<ModelObserver *>::iterator it = m_observers.begin();
 758     QList<ModelObserver *>::iterator itEnd = m_observers.end();
 759
 760     for(; it!=itEnd; ++it)
 761     {
 762         (*it)->removedTransferGroupEvent(group->handler());
 763     }
 764 }
 765
 766 KUrl KGet::urlInputDialog()
 767 {
 768     QString newtransfer;
 769     bool ok = false;
 770
 771     KUrl clipboardUrl = KUrl(QApplication::clipboard()->text(QClipboard::Clipboard).trimmed());
 772     if (clipboardUrl.isValid())
 773         newtransfer = clipboardUrl.url();
 774
 775     while (!ok)
 776     {
 777         newtransfer = KInputDialog::getText(i18n("New Download"), i18n("Enter URL:"), newtransfer, &ok, 0);
 778
 779         if (!ok)
 780         {
 781             //user pressed cancel
 782             return KUrl();
 783         }
 784
 785         KUrl src = KUrl(newtransfer);
 786         if(src.isValid())
 787             return src;
 788         else
 789             ok = false;
 790     }
 791     return KUrl();
 792 }
 793
 794 QString KGet::destInputDialog()
 795 {
 796     QString destDir = KFileDialog::getExistingDirectory(Settings::lastDirectory());
 797
 798     Settings::setLastDirectory( destDir );
 799     return destDir;
 800 }
 801
 802 QString KGet::getSaveDirectoryFromExceptions(const KUrl &filename)
 803 {
 804     QString destDir;
 805
 806     const QStringList list = Settings::extensionsFolderList();
 807     QStringList::ConstIterator it = list.begin();
 808     const QStringList::ConstIterator end = list.end();
 809     while (it != end) {
 810         // odd list items are regular expressions for extensions
 811         QString ext = *it;
 812         ++it;
 813         QString path = *it;
 814         ++it;
 815
 816         if (!ext.startsWith('*'))
 817             ext = '*' + ext;
 818
 819         QRegExp rexp(ext);
 820         rexp.setPatternSyntax(QRegExp::Wildcard);
 821
 822         if (rexp.exactMatch(filename.url())) {
 823             destDir = path;
 824             break;
 825         }
 826     }
 827
 828     return KUrl(destDir).path();
 829 }
 830
 831 bool KGet::isValidSource(const KUrl &source)
 832 {
 833     // Check if the URL is well formed
 834     if (!source.isValid())
 835     {
 836         KMessageBox::error(0,
 837                            i18n("Malformed URL:\n%1", source.prettyUrl()),
 838                            i18n("Error"));
 839
 840         return false;
 841     }
 842     // Check if the URL contains the protocol
 843     if ( source.protocol().isEmpty() ){
 844
 845         KMessageBox::error(0, i18n("Malformed URL, protocol missing:\n%1", source.prettyUrl()),
 846                            i18n("Error"));
 847
 848         return false;
 849     }
 850     // Check if a transfer with the same url already exists
 851     Transfer * transfer = m_transferTreeModel->findTransfer( source );
 852     if ( transfer )
 853     {
 854         if ( transfer->status() == Job::Finished )
 855         {
 856             // transfer is finished, ask if we want to download again
 857             if (KMessageBox::questionYesNoCancel(0,
 858                 i18n("URL already saved:\n%1\nDownload again?", source.prettyUrl()),
 859                 i18n("Download URL again?"), KStandardGuiItem::yes(),
 860                 KStandardGuiItem::no(), KStandardGuiItem::cancel(), "QuestionUrlAlreadySaved" )
 861                 == KMessageBox::Yes)
 862             {
 863                 transfer->stop();
 864                 TransferHandler * th = transfer->handler();
 865                 KGet::delTransfer(th);
 866                 return true;
 867             }
 868         }
 869         else
 870         {
 871             //Transfer is already in list and not finished, ...
 872             return false;
 873         }
 874         return false;
 875     }
 876     return true;
 877 }
 878
 879 bool KGet::isValidDestDirectory(const QString & destDir)
 880 {
 881     kDebug(5001) << destDir;
 882     if (!QFileInfo(destDir).isDir())
 883     {
 884         if (QFileInfo(KUrl(destDir).directory()).isWritable())
 885             return (!destDir.isEmpty());
 886         if (!QFileInfo(KUrl(destDir).directory()).isWritable() && !destDir.isEmpty())
 887             KMessageBox::error(0, i18n("Directory is not writable"));
 888     }
 889     else
 890     {
 891         if (QFileInfo(destDir).isWritable())
 892             return (!destDir.isEmpty());
 893         if (!QFileInfo(destDir).isWritable() && !destDir.isEmpty())
 894             KMessageBox::error(0, i18n("Directory is not writable"));
 895     }
 896     return false;
 897 }
 898
 899 bool KGet::isValidDestUrl(const KUrl &destUrl)
 900 {
 901     if(KIO::NetAccess::exists(destUrl, KIO::NetAccess::DestinationSide, 0))
 902     {
 903         if (KMessageBox::warningYesNoCancel(0,
 904             i18n("Destination file \n%1\nalready exists.\n"
 905                  "Do you want to overwrite it?", destUrl.prettyUrl()))
 906             == KMessageBox::Yes)
 907         {
 908             safeDeleteFile( destUrl );
 909             return true;
 910         }
 911         else
 912             return false;
 913     }
 914     if (m_transferTreeModel->findTransferByDestination(destUrl) || destUrl.isEmpty())
 915         return false;
 916
 917     return true;
 918    /*
 919     KIO::open_RenameDlg(i18n("File already exists"),
 920     (*it).url(), destUrl.url(),
 921     KIO::M_MULTI);
 922    */
 923 }
 924
 925 KUrl KGet::getValidDestUrl(const QString& destDir, const KUrl &srcUrl)
 926 {
 927     if ( !isValidDestDirectory(destDir) )
 928         return KUrl();
 929
 930     // create a proper destination file from destDir
 931     KUrl destUrl = KUrl( destDir );
 932     QString filename = srcUrl.fileName();
 933
 934     if ( filename.isEmpty() )
 935     {
 936         // simply use the full url as filename
 937         filename = KUrl::toPercentEncoding( srcUrl.prettyUrl(), "/" );
 938         kDebug(5001) << " Filename is empty. Setting to  " << filename;
 939         kDebug(5001) << "   srcUrl = " << srcUrl.url();
 940         kDebug(5001) << "   prettyUrl = " << srcUrl.prettyUrl();
 941     }
 942     if (QFileInfo(destUrl.path()).isDir())
 943     {
 944         kDebug(5001) << " Filename is not empty";
 945         destUrl.adjustPath( KUrl::AddTrailingSlash );
 946         destUrl.setFileName( filename );
 947     }
 948     if (!isValidDestUrl(destUrl))
 949     {
 950         kDebug(5001) << "   destUrl " << destUrl.path() << " is not valid";
 951         return KUrl();
 952     }
 953     return destUrl;
 954 }
 955
 956 void KGet::loadPlugins()
 957 {
 958     m_transferFactories.clear();
 959     // Add versioning constraint
 960     QString
 961     str  = "[X-KDE-KGet-framework-version] == ";
 962     str += QString::number( FrameworkVersion );
 963     str += " and ";
 964     str += "[X-KDE-KGet-rank] > 0";
 965     str += " and ";
 966     str += "[X-KDE-KGet-plugintype] == ";
 967
 968     KService::List offers;
 969
 970     //TransferFactory plugins
 971     offers = KServiceTypeTrader::self()->query( "KGet/Plugin", str + "'TransferFactory'" );
 972
 973     //Here we use a QMap only to easily sort the plugins by rank
 974     QMap<int, KService::Ptr> services;
 975     QMap<int, KService::Ptr>::iterator it;
 976
 977     for ( int i = 0; i < offers.count(); ++i )
 978     {
 979         services[ offers[i]->property( "X-KDE-KGet-rank" ).toInt() ] = offers[i];
 980         kDebug(5001) << " TransferFactory plugin found:" << endl <<
 981          "  rank = " << offers[i]->property( "X-KDE-KGet-rank" ).toInt() << endl <<
 982          "  plugintype = " << offers[i]->property( "X-KDE-KGet-plugintype" ) << endl;
 983     }
 984
 985     //I must fill this pluginList before and my m_transferFactories list after.
 986     //This because calling the KLibLoader::globalLibrary() erases the static
 987     //members of this class (why?), such as the m_transferFactories list.
 988     QList<KGetPlugin *> pluginList;
 989
 990     KConfigGroup plugins = KConfigGroup(KGlobal::config(), "Plugins");
 991
 992     for( it = services.begin(); it != services.end(); ++it )
 993     {
 994         KPluginInfo info(*it);
 995         info.load(plugins);
 996
 997         if( !info.isPluginEnabled() ) {
 998             kDebug(5001) << "TransferFactory plugin (" << (*it)->library()
 999                              << ") found, but not enabled";
1000             continue;
1001         }
1002
1003         KGetPlugin * plugin;
1004         if( (plugin = createPluginFromService(*it)) != 0 )
1005         {
1006             QString pluginName = info.name();
1007
1008             pluginList.prepend(plugin);
1009             kDebug(5001) << "TransferFactory plugin (" << (*it)->library()
1010                          << ") found and added to the list of available plugins";
1011
1012         }
1013         else
1014             kDebug(5001) << "Error loading TransferFactory plugin ("
1015                       << (*it)->library() << ")";
1016     }
1017
1018     QList<KGetPlugin *>::iterator it2 = pluginList.begin();
1019     QList<KGetPlugin *>::iterator it2End = pluginList.end();
1020
1021     for( ; it2!=it2End ; ++it2 )
1022         m_transferFactories.append( qobject_cast<TransferFactory *>(*it2) );
1023
1024     kDebug(5001) << "Number of factories = " << m_transferFactories.size();
1025 }
1026
1027 KGetPlugin * KGet::createPluginFromService( const KService::Ptr &service )
1028 {
1029     //try to load the specified library
1030     KPluginFactory *factory = KPluginLoader(service->library()).factory();
1031
1032     if (!factory)
1033     {
1034         KMessageBox::error(0, i18n("<html><p>Plugin loader could not load the plugin:<br/><i>%1</i></p></html>",
1035                                    service->library()));
1036         kError(5001) << "KPluginFactory could not load the plugin:" << service->library();
1037         return 0;
1038     }
1039     KGetPlugin * plugin = factory->create< TransferFactory >(KGet::m_mainWindow);
1040
1041     return plugin;
1042 }
1043
1044 bool KGet::safeDeleteFile( const KUrl& url )
1045 {
1046     if ( url.isLocalFile() )
1047     {
1048         QFileInfo info( url.path() );
1049         if ( info.isDir() )
1050         {
1051             KGet::showNotification(m_mainWindow, KNotification::Notification,
1052                                    i18n("Not deleting\n%1\nas it is a directory.", url.prettyUrl()),
1053                                    "dialog-info");
1054             return false;
1055         }
1056         KIO::NetAccess::del( url, 0L );
1057         return true;
1058     }
1059
1060     else
1061         KGet::showNotification(m_mainWindow, KNotification::Notification,
1062                                i18n("Not deleting\n%1\nas it is not a local file.", url.prettyUrl()),
1063                                "dialog-info");
1064     return false;
1065 }
1066
1067 void KGet::showNotification(QWidget *parent, KNotification::StandardEvent eventId,
1068                             const QString &text, const QString &icon)
1069 {
1070     KNotification::event(eventId, text, KIcon(icon).pixmap(KIconLoader::Small), parent);
1071 }
1072
1073 GenericModelObserver::GenericModelObserver(QObject *parent) : QObject(parent)
1074 {
1075     m_groupObserver = new GenericTransferGroupObserver();
1076 }
1077
1078 GenericModelObserver::~GenericModelObserver()
1079 {
1080     delete m_groupObserver;
1081 }
1082
1083 void GenericModelObserver::addedTransferGroupEvent(TransferGroupHandler * group)
1084 {
1085     Q_UNUSED(group)
1086     kDebug() << "OBSERVER :: Adding group " << group;
1087     group->addObserver(m_groupObserver);
1088
1089     // we need to do this to add the genericTransfer to all the transfers under the group
1090     m_groupObserver->addTransferGroup(group);
1091
1092     KGet::save();
1093 }
1094
1095 void GenericModelObserver::removedTransferGroupEvent(TransferGroupHandler * group)
1096 {
1097     Q_UNUSED(group)
1098     group->delObserver(m_groupObserver);
1099     KGet::save();
1100 }