kget/core/kget.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2005 Dario Massarin <nekkar@libero.it>
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public
   7    License as published by the Free Software Foundation; version 2
   8    of the License.
   9 */
  10
  11 #include "core/kget.h"
  12
  13 #include "mainwindow.h"
  14 #include "core/transfer.h"
  15 #include "core/transfergroup.h"
  16 #include "core/transfertreemodel.h"
  17 #include "core/transfertreeselectionmodel.h"
  18 #include "core/plugin/plugin.h"
  19 #include "core/plugin/transferfactory.h"
  20 #include "core/observer.h"
  21 #include "settings.h"
  22
  23 #include <kio/netaccess.h>
  24 #include <kinputdialog.h>
  25 #include <kfiledialog.h>
  26 #include <kmessagebox.h>
  27 #include <klocale.h>
  28 #include <kstandarddirs.h>
  29 #include <kservicetypetrader.h>
  30 #include <klibloader.h>
  31 #include <kiconloader.h>
  32 #include <kactioncollection.h>
  33
  34 #include <QDirModel>
  35 #include <QTextStream>
  36 #include <QDomElement>
  37 #include <QApplication>
  38 #include <QClipboard>
  39 #include <QItemSelectionModel>
  40 #include <QAbstractItemView>
  41
  42 /**
  43  * This is our KGet class. This is where the user's transfers and searches are
  44  * stored and organized.
  45  * Use this class from the views to add or remove transfers or searches
  46  * In order to organize the transfers inside categories we have a TransferGroup
  47  * class. By definition, a transfer must always belong to a TransferGroup. If we
  48  * don't want it to be displayed by the gui inside a specific group, we will put
  49  * it in the group named "Not grouped" (better name?).
  50  **/
  51
  52 KGet& KGet::self( MainWindow * mainWindow )
  53 {
  54     if(mainWindow)
  55     {
  56         m_mainWindow = mainWindow;
  57     }
  58
  59     static KGet m;
  60     return m;
  61 }
  62
  63 void KGet::addObserver(ModelObserver * observer)
  64 {
  65     kDebug(5001) << "KGet::addObserver" << endl;
  66
  67     m_observers.append(observer);
  68
  69     //Update the new observer with the TransferGroups objects of the model
  70     QList<TransferGroup *>::const_iterator it = m_transferTreeModel->transferGroups().begin();
  71     QList<TransferGroup *>::const_iterator itEnd = m_transferTreeModel->transferGroups().end();
  72
  73     for( ; it!=itEnd ; ++it )
  74     {
  75         postAddedTransferGroupEvent(*it, observer);
  76     }
  77
  78     kDebug(5001) << "KGet::addObserver   >>> EXITING" << endl;
  79 }
  80
  81 void KGet::delObserver(ModelObserver * observer)
  82 {
  83     m_observers.removeAll(observer);
  84 }
  85
  86 bool KGet::addGroup(const QString& groupName)
  87 {
  88     kDebug(5001) << "KGet::addGroup" << endl;
  89
  90     // Check if a group with that name already exists
  91     if(m_transferTreeModel->findGroup(groupName))
  92         return false;
  93
  94     TransferGroup * group = new TransferGroup(m_transferTreeModel, m_scheduler, groupName);
  95
  96     m_transferTreeModel->addGroup(group);
  97
  98     //post notifications
  99     postAddedTransferGroupEvent(group);
 100
 101     return true;
 102 }
 103
 104 void KGet::delGroup(const QString& groupName)
 105 {
 106     TransferGroup * group = m_transferTreeModel->findGroup(groupName);
 107
 108     if(group)
 109     {
 110         m_transferTreeModel->delGroup(group);
 111         postRemovedTransferGroupEvent(group);
 112         delete(group);
 113     }
 114 }
 115
 116 void KGet::addMetaLink(const KUrl &srcUrl)
 117 {
 118     kDebug(5001) << " addMetaLink:  " << srcUrl.url() << endl;
 119
 120     if ( !isValidSource( srcUrl ) )
 121         return;
 122
 123     QString destDir = destInputDialog();
 124     KUrl destUrl(destDir);
 125
 126     createTransfer(srcUrl, destUrl, QString("MetaLinks"));
 127 }
 128
 129 void KGet::addTransfer( KUrl srcUrl, QString destDir, // krazy:exclude=passbyvalue
 130                          const QString& groupName )
 131 {
 132     kDebug(5001) << " addTransfer:  " << srcUrl.url() << endl;
 133
 134     KUrl destUrl;
 135
 136     if ( srcUrl.isEmpty() )
 137     {
 138         //No src location: we let the user insert it manually
 139         srcUrl = urlInputDialog();
 140         if( srcUrl.isEmpty() )
 141             return;
 142     }
 143
 144     if ( !isValidSource( srcUrl ) )
 145         return;
 146
 147     if (!isValidDestDirectory(destDir) && !Settings::useDefaultDirectory())
 148         destDir = destInputDialog();
 149
 150     if (Settings::useDefaultDirectory())
 151         destDir = getSaveDirectoryFromDefault(srcUrl);
 152
 153     if( (destUrl = getValidDestUrl( destDir, srcUrl )).isEmpty() )
 154         return;
 155
 156     createTransfer(srcUrl, destUrl, groupName);
 157 }
 158
 159 void KGet::addTransfer(const QDomElement& e, const QString& groupName)
 160 {
 161     //We need to read these attributes now in order to know which transfer
 162     //plugin to use.
 163     KUrl srcUrl = KUrl( e.attribute("Source") );
 164     KUrl destUrl = KUrl( e.attribute("Dest") );
 165
 166     kDebug(5001) << "KGet::addTransfer  src= " << srcUrl.url()
 167               << " dest= " << destUrl.url()
 168               << " group= "<< groupName << endl;
 169
 170     if ( srcUrl.isEmpty() || !isValidSource(srcUrl)
 171          || !isValidDestDirectory(destUrl.directory()) )
 172         return;
 173
 174     createTransfer(srcUrl, destUrl, groupName, &e);
 175 }
 176
 177 void KGet::addTransfer(KUrl::List srcUrls, QString destDir, // krazy:exclude=passbyvalue
 178                         const QString& groupName)
 179 {
 180     KUrl::List urlsToDownload;
 181
 182     KUrl::List::ConstIterator it = srcUrls.begin();
 183     KUrl::List::ConstIterator itEnd = srcUrls.end();
 184
 185     for(; it!=itEnd ; ++it)
 186     {
 187         if ( isValidSource( *it ) )
 188             urlsToDownload.append( *it );
 189     }
 190
 191     if ( urlsToDownload.count() == 0 )
 192         return;
 193
 194     if ( urlsToDownload.count() == 1 )
 195     {
 196         // just one file -> ask for filename
 197         addTransfer(srcUrls.first(), destDir, groupName);
 198         return;
 199     }
 200
 201     KUrl destUrl;
 202
 203     // multiple files -> ask for directory, not for every single filename
 204     if (!isValidDestDirectory(destDir) && !Settings::useDefaultDirectory())
 205         destDir = destInputDialog();
 206
 207     it = urlsToDownload.begin();
 208     itEnd = urlsToDownload.end();
 209
 210     for ( ; it != itEnd; ++it )
 211     {
 212         destUrl = getValidDestUrl(destDir.isEmpty() ? getSaveDirectoryFromDefault(*it) : destDir, *it);
 213
 214         if(!isValidDestUrl(destUrl))
 215             continue;
 216
 217         createTransfer(*it, destUrl, groupName);
 218     }
 219 }
 220
 221
 222 void KGet::delTransfer(TransferHandler * transfer)
 223 {
 224     Transfer * t = transfer->m_transfer;
 225
 226     m_transferTreeModel->delTransfer(t);
 227
 228     //Here I delete the Transfer. The other possibility is to move it to a list
 229     //and to delete all these transfers when kget gets closed. Obviously, after
 230     //the notification to the views that the transfer has been removed, all the
 231     //pointers to it are invalid.
 232     transfer->postDeleteEvent();
 233 // TODO: why does it crash if a download is going to be deleted which is not the last in the list?
 234 // there are always no problems with the last download.
 235 //     delete( t );
 236 }
 237
 238 void KGet::moveTransfer(TransferHandler * transfer, const QString& groupName)
 239 {
 240   Q_UNUSED(transfer);
 241   Q_UNUSED(groupName);
 242 }
 243
 244 QList<TransferHandler *> KGet::selectedTransfers()
 245 {
 246 //     kDebug(5001) << "KGet::selectedTransfers" << endl;
 247
 248     QList<TransferHandler *> selectedTransfers;
 249
 250     QModelIndexList selectedIndexes = m_selectionModel->selectedRows();
 251
 252     foreach(QModelIndex currentIndex, selectedIndexes)
 253     {
 254         if(!m_transferTreeModel->isTransferGroup(currentIndex))
 255             selectedTransfers.append(static_cast<TransferHandler *> (currentIndex.internalPointer()));
 256     }
 257
 258     return selectedTransfers;
 259
 260
 261 // This is the code that was used in the old selectedTransfers function
 262 /*    QList<TransferGroup *>::const_iterator it = m_transferTreeModel->transferGroups().begin();
 263     QList<TransferGroup *>::const_iterator itEnd = m_transferTreeModel->transferGroups().end();
 264
 265     for( ; it!=itEnd ; ++it )
 266     {
 267         TransferGroup::iterator it2 = (*it)->begin();
 268         TransferGroup::iterator it2End = (*it)->end();
 269
 270         for( ; it2!=it2End ; ++it2 )
 271         {
 272             Transfer * transfer = (Transfer*) *it2;
 273
 274             if( transfer->isSelected() )
 275                 selectedTransfers.append( transfer->handler() );
 276         }
 277     }
 278     return selectedTransfers;*/
 279 }
 280
 281 TransferTreeSelectionModel * KGet::selectionModel()
 282 {
 283     return m_selectionModel;
 284 }
 285
 286 void KGet::addTransferView(QAbstractItemView * view)
 287 {
 288     view->setModel(m_transferTreeModel);
 289 }
 290
 291 void KGet::load( QString filename ) // krazy:exclude=passbyvalue
 292 {
 293     kDebug(5001) << "KGet::load(" << filename << ")" << endl;
 294
 295     if(filename.isEmpty())
 296         filename = KStandardDirs::locateLocal("appdata", "transfers.kgt");
 297
 298     QString tmpFile;
 299
 300     //Try to save the transferlist to a temporary location
 301     if(!KIO::NetAccess::download(KUrl(filename), tmpFile, 0))
 302         return;
 303
 304     QFile file(tmpFile);
 305     QDomDocument doc;
 306
 307     kDebug(5001) << "KGet::load file" << filename << endl;
 308
 309     if(doc.setContent(&file))
 310     {
 311         QDomElement root = doc.documentElement();
 312
 313         QDomNodeList nodeList = root.elementsByTagName("TransferGroup");
 314         int nItems = nodeList.length();
 315
 316         for( int i = 0 ; i < nItems ; i++ )
 317         {
 318             TransferGroup * foundGroup = m_transferTreeModel->findGroup( nodeList.item(i).toElement().attribute("Name") );
 319
 320             kDebug(5001) << "KGet::load  -> group = " << nodeList.item(i).toElement().attribute("Name") << endl;
 321
 322             if( !foundGroup )
 323             {
 324                 kDebug(5001) << "KGet::load  -> group not found" << endl;
 325
 326                 TransferGroup * newGroup = new TransferGroup(m_transferTreeModel, m_scheduler);
 327
 328                 m_transferTreeModel->addGroup(newGroup);
 329
 330                 newGroup->load(nodeList.item(i).toElement());
 331
 332                 //Post notifications
 333                 postAddedTransferGroupEvent(newGroup);
 334             }
 335             else
 336             {
 337                 kDebug(5001) << "KGet::load  -> group found" << endl;
 338
 339                 //A group with this name already exists.
 340                 //Integrate the group's transfers with the ones read from file
 341                 foundGroup->load(nodeList.item(i).toElement());
 342             }
 343         }
 344     }
 345     else
 346     {
 347         kWarning(5001) << "Error reading the transfers file" << endl;
 348     }
 349 }
 350
 351 void KGet::save( QString filename ) // krazy:exclude=passbyvalue
 352 {
 353     if ( !filename.isEmpty()
 354         && QFile::exists( filename )
 355         && (KMessageBox::questionYesNoCancel(0,
 356                 i18n("The file %1 already exists.\nOverwrite?", filename),
 357                 i18n("Overwrite existing file?"), KStandardGuiItem::yes(),
 358                 KStandardGuiItem::no(), KStandardGuiItem::cancel(), "QuestionFilenameExists" )
 359                 != KMessageBox::Yes) )
 360         return;
 361
 362     if(filename.isEmpty())
 363         filename = KStandardDirs::locateLocal("appdata", "transfers.kgt");
 364
 365     QDomDocument doc(QString("KGetTransfers"));
 366     QDomElement root = doc.createElement("Transfers");
 367     doc.appendChild(root);
 368
 369     QList<TransferGroup *>::const_iterator it = m_transferTreeModel->transferGroups().begin();
 370     QList<TransferGroup *>::const_iterator itEnd = m_transferTreeModel->transferGroups().end();
 371
 372     for ( ; it!=itEnd ; ++it )
 373     {
 374         QDomElement e = doc.createElement("TransferGroup");
 375         root.appendChild(e);
 376         (*it)->save(e);
 377     }
 378     QFile file(filename);
 379     if ( !file.open( QIODevice::WriteOnly ) )
 380     {
 381         //kWarning(5001)<<"Unable to open output file when saving"<< endl;
 382         KMessageBox::error(0,
 383                            i18n("Unable to save to: %1", filename),
 384                            i18n("Error"));
 385         return;
 386     }
 387
 388     QTextStream stream( &file );
 389     doc.save( stream, 0 );
 390     file.close();
 391 }
 392
 393 TransferFactory * KGet::factory(TransferHandler * transfer)
 394 {
 395     return transfer->m_transfer->factory();
 396 }
 397
 398 KActionCollection * KGet::actionCollection()
 399 {
 400     return m_mainWindow->actionCollection();
 401 }
 402
 403 void KGet::setSchedulerRunning(bool running)
 404 {
 405     if(running)
 406         m_scheduler->start();
 407     else
 408         m_scheduler->stop();
 409 }
 410
 411 bool KGet::schedulerRunning()
 412 {
 413     return (m_scheduler->countRunningJobs() > 0);
 414 }
 415
 416 void KGet::setPluginsSettingsWidget(KTabWidget * widget)
 417 {
 418     QList<TransferFactory *>::iterator it = m_transferFactories.begin();
 419     QList<TransferFactory *>::iterator itEnd = m_transferFactories.end();
 420
 421     QWidget * settingsWidget;
 422     for( ; it!=itEnd ; ++it)
 423     {
 424         settingsWidget = (*it)->createSettingsWidget();
 425         if(settingsWidget)
 426             widget->addTab( settingsWidget, (*it)->displayName() );
 427     }
 428 }
 429
 430 // ------ STATIC MEMBERS INITIALIZATION ------
 431 QList<ModelObserver *> KGet::m_observers;
 432 TransferTreeModel * KGet::m_transferTreeModel;
 433 TransferTreeSelectionModel * KGet::m_selectionModel;
 434 QList<TransferFactory *> KGet::m_transferFactories;
 435 QList<KLibrary *> KGet::m_pluginKLibraries;
 436 Scheduler * KGet::m_scheduler = new Scheduler();
 437 MainWindow * KGet::m_mainWindow = 0;
 438
 439 // ------ PRIVATE FUNCTIONS ------
 440 KGet::KGet()
 441 {
 442     m_transferTreeModel = new TransferTreeModel(m_scheduler);
 443     m_selectionModel = new TransferTreeSelectionModel(m_transferTreeModel);
 444
 445     //Load all the available plugins
 446     loadPlugins();
 447
 448     //Create the default group
 449     addGroup(i18n("Default Group"));
 450 }
 451
 452 KGet::~KGet()
 453 {
 454     unloadPlugins();
 455     delete(m_scheduler);
 456 }
 457
 458 void KGet::createTransfer(const KUrl &src, const KUrl &dest, const QString& groupName, const QDomElement * e)
 459 {
 460     kDebug(5001) << "createTransfer: srcUrl= " << src.url() << "  "
 461                              << "destUrl= " << dest.url()
 462                              << "group= _" << groupName << "_" << endl;
 463
 464     TransferGroup * group = m_transferTreeModel->findGroup(groupName);
 465     if (group==0)
 466     {
 467         kDebug(5001) << "KGet::createTransfer  -> group not found" << endl;
 468         group = m_transferTreeModel->transferGroups().first();
 469     }
 470     Transfer * newTransfer;
 471
 472     QList<TransferFactory *>::iterator it = m_transferFactories.begin();
 473     QList<TransferFactory *>::iterator itEnd = m_transferFactories.end();
 474
 475     for( ; it!=itEnd ; ++it)
 476     {
 477         kDebug(5001) << "Trying plugin   n.plugins=" << m_transferFactories.size() << endl;
 478         if((newTransfer = (*it)->createTransfer(src, dest, group, m_scheduler, e)))
 479         {
 480 //             kDebug(5001) << "KGet::createTransfer   ->   CREATING NEW TRANSFER ON GROUP: _" << group->name() << "_" << endl;
 481             m_transferTreeModel->addTransfer(newTransfer, group);
 482             return;
 483         }
 484     }
 485     kDebug(5001) << "createTransfer: Warning! No plugin found to handle the given url" << endl;
 486 }
 487
 488 void KGet::postAddedTransferGroupEvent(TransferGroup * group, ModelObserver * observer)
 489 {
 490     kDebug(5001) << "KGet::postAddedTransferGroupEvent" << endl;
 491     if(observer)
 492     {
 493         observer->addedTransferGroupEvent(group->handler());
 494         return;
 495     }
 496
 497     QList<ModelObserver *>::iterator it = m_observers.begin();
 498     QList<ModelObserver *>::iterator itEnd = m_observers.end();
 499
 500     for(; it!=itEnd; ++it)
 501     {
 502         kDebug(5001) << "message posted" << endl;
 503
 504         (*it)->addedTransferGroupEvent(group->handler());
 505     }
 506 }
 507
 508 void KGet::postRemovedTransferGroupEvent(TransferGroup * group, ModelObserver * observer)
 509 {
 510     if(observer)
 511     {
 512         observer->removedTransferGroupEvent(group->handler());
 513         return;
 514     }
 515
 516     QList<ModelObserver *>::iterator it = m_observers.begin();
 517     QList<ModelObserver *>::iterator itEnd = m_observers.end();
 518
 519     for(; it!=itEnd; ++it)
 520     {
 521         (*it)->removedTransferGroupEvent(group->handler());
 522     }
 523 }
 524
 525 KUrl KGet::urlInputDialog()
 526 {
 527     QString newtransfer;
 528     bool ok = false;
 529
 530     KUrl clipboardUrl = KUrl(QApplication::clipboard()->text(QClipboard::Clipboard).trimmed());
 531     if (clipboardUrl.isValid())
 532         newtransfer = clipboardUrl.url();
 533
 534     while (!ok)
 535     {
 536         newtransfer = KInputDialog::getText(i18n("New Download"), i18n("Enter URL:"), newtransfer, &ok, 0);
 537
 538         if (!ok)
 539         {
 540             //user pressed cancel
 541             return KUrl();
 542         }
 543
 544         KUrl src = KUrl(newtransfer);
 545         if(src.isValid())
 546             return src;
 547         else
 548             ok = false;
 549     }
 550     return KUrl();
 551 }
 552
 553 QString KGet::destInputDialog()
 554 {
 555     QString destDir = KFileDialog::getExistingDirectory(Settings::lastDirectory());
 556
 557     Settings::setLastDirectory( destDir );
 558     return destDir;
 559 }
 560
 561 QString KGet::getSaveDirectoryFromDefault(const KUrl &filename)
 562 {
 563 // use global default folder as default.
 564 // if extension is matching with one in the list, overwrite it below.
 565     QString destDir = Settings::defaultDirectory();
 566
 567     QStringList list = Settings::extensionsFolderList();
 568     QStringList::Iterator it = list.begin();
 569     QStringList::Iterator end = list.end();
 570     while (it != end) {
 571         // odd list items are regular expressions for extensions
 572         QString ext = *it;
 573         ++it;
 574         QString path = *it;
 575         ++it;
 576
 577         if (!ext.startsWith('*'))
 578             ext = '*' + ext;
 579
 580         QRegExp rexp(ext);
 581         rexp.setPatternSyntax(QRegExp::Wildcard);
 582
 583         if (rexp.exactMatch(filename.url())) {
 584             destDir = path;
 585             break;
 586         }
 587     }
 588
 589     return destDir.replace("file://", "");
 590 }
 591
 592 bool KGet::isValidSource(KUrl source)
 593 {
 594     if (!source.isValid())
 595     {
 596         KMessageBox::error(0,
 597                            i18n("Malformed URL:\n%1", source.prettyUrl()),
 598                            i18n("Error"));
 599         return false;
 600     }
 601     // Check if a transfer with the same url already exists
 602     Transfer * transfer = m_transferTreeModel->findTransfer( source );
 603     if ( transfer )
 604     {
 605         if ( transfer->status() == Job::Finished )
 606         {
 607             // transfer is finished, ask if we want to download again
 608             if (KMessageBox::questionYesNoCancel(0,
 609                 i18n("URL already saved:\n%1\nDownload again?", source.prettyUrl()),
 610                 i18n("Download URL again?"), KStandardGuiItem::yes(),
 611                 KStandardGuiItem::no(), KStandardGuiItem::cancel(), "QuestionUrlAlreadySaved" )
 612                 == KMessageBox::Yes)
 613             {
 614                 //TODO reimplement this
 615                 //transfer->slotRemove();
 616                 //checkQueue();
 617                 return true;
 618             }
 619         }
 620         else
 621         {
 622             //transfer is not finished. Give an error message.
 623             KMessageBox::error(0,
 624                                i18n("Already saving URL\n%1", source.prettyUrl()),
 625                                i18n("Error"));
 626             return false;
 627         }
 628         return false;
 629     }
 630     return true;
 631 }
 632
 633 bool KGet::isValidDestDirectory(const QString & destDir)
 634 {
 635     return (!destDir.isEmpty() && QFileInfo( destDir ).isDir());
 636 }
 637
 638 bool KGet::isValidDestUrl(KUrl destUrl)
 639 {
 640     if(KIO::NetAccess::exists(destUrl, false, 0))
 641     {
 642         if (KMessageBox::warningYesNoCancel(0,
 643             i18n("Destination file \n%1\nalready exists.\n"
 644                  "Do you want to overwrite it?", destUrl.prettyUrl()))
 645             == KMessageBox::Yes)
 646         {
 647             safeDeleteFile( destUrl );
 648             return true;
 649         }
 650         else
 651             return false;
 652     }
 653     return true;
 654    /*
 655     KIO::open_RenameDlg(i18n("File already exists"),
 656     (*it).url(), destUrl.url(),
 657     KIO::M_MULTI);
 658    */
 659 }
 660
 661 KUrl KGet::getValidDestUrl(const QString& destDir, const KUrl &srcUrl)
 662 {
 663     if ( !isValidDestDirectory(destDir) )
 664         return KUrl();
 665
 666     // create a proper destination file from destDir
 667     KUrl destUrl = KUrl( destDir );
 668     QString filename = srcUrl.fileName();
 669
 670     if ( filename.isEmpty() )
 671     {
 672         // simply use the full url as filename
 673         filename = QUrl::toPercentEncoding( srcUrl.prettyUrl(), "/" );
 674         kDebug(5001) << " Filename is empty. Setting to  " << filename << endl;
 675         kDebug(5001) << "   srcUrl = " << srcUrl.url() << endl;
 676         kDebug(5001) << "   prettyUrl = " << srcUrl.prettyUrl() << endl;
 677     }
 678     else
 679     {
 680         kDebug(5001) << " Filename is not empty" << endl;
 681         destUrl.adjustPath( KUrl::AddTrailingSlash );
 682         destUrl.setFileName( filename );
 683         if (!isValidDestUrl(destUrl))
 684         {
 685             kDebug(5001) << "   destUrl " << destUrl.path() << " is not valid" << endl;
 686             return KUrl();
 687         }
 688     }
 689     return destUrl;
 690 }
 691
 692 void KGet::loadPlugins()
 693 {
 694     // Add versioning constraint
 695     QString
 696     str  = "[X-KDE-KGet-framework-version] == ";
 697     str += QString::number( FrameworkVersion );
 698     str += " and ";
 699     str += "[X-KDE-KGet-rank] > 0";
 700     str += " and ";
 701     str += "[X-KDE-KGet-plugintype] == ";
 702
 703     KService::List offers;
 704
 705     //TransferFactory plugins
 706     offers = KServiceTypeTrader::self()->query( "KGet/Plugin", str + "'TransferFactory'" );
 707
 708     //Here we use a QMap only to easily sort the plugins by rank
 709     QMap<int, KService::Ptr> services;
 710     QMap<int, KService::Ptr>::iterator it;
 711
 712     for ( int i = 0; i < offers.count(); ++i )
 713     {
 714         services[ offers[i]->property( "X-KDE-KGet-rank" ).toInt() ] = offers[i];
 715         kDebug(5001) << " TransferFactory plugin found:" << endl <<
 716          "  rank = " << offers[i]->property( "X-KDE-KGet-rank" ).toInt() << endl <<
 717          "  plugintype = " << offers[i]->property( "X-KDE-KGet-plugintype" ) << endl;
 718     }
 719
 720     //I must fill this pluginList before and my m_transferFactories list after.
 721     //This because calling the KLibLoader::globalLibrary() erases the static
 722     //members of this class (why?), such as the m_transferFactories list.
 723     QList<KGetPlugin *> pluginList;
 724
 725     for( it = services.begin(); it != services.end(); ++it )
 726     {
 727         KGetPlugin * plugin;
 728         if( (plugin = createPluginFromService(*it)) != 0 )
 729         {
 730             pluginList.prepend(plugin);
 731             kDebug(5001) << "TransferFactory plugin (" << (*it)->library()
 732                       << ") found and added to the list of available plugins" << endl;
 733         }
 734         else
 735             kDebug(5001) << "Error loading TransferFactory plugin ("
 736                       << (*it)->library() << ")" << endl;
 737     }
 738
 739     QList<KGetPlugin *>::iterator it2 = pluginList.begin();
 740     QList<KGetPlugin *>::iterator it2End = pluginList.end();
 741
 742     for( ; it2!=it2End ; ++it2 )
 743         m_transferFactories.append( static_cast<TransferFactory *>(*it2) );
 744
 745     kDebug(5001) << "Number of factories = " << m_transferFactories.size() << endl;
 746 }
 747
 748 void KGet::unloadPlugins()
 749 {
 750     QList<KLibrary *>::iterator it = m_pluginKLibraries.begin();
 751     QList<KLibrary *>::iterator itEnd = m_pluginKLibraries.end();
 752
 753     for(;it!=itEnd;++it)
 754     {
 755         (*it)->unload();
 756     }
 757     m_transferFactories.clear();
 758 }
 759
 760 KGetPlugin * KGet::createPluginFromService( const KService::Ptr service )
 761 {
 762     //get the library loader instance
 763     KLibLoader *loader = KLibLoader::self();
 764
 765     //try to load the specified library
 766     //Warning! This line seems to erase my m_transferFactories list!!
 767     KLibrary *lib = loader->library( QFile::encodeName( service->library() ) );
 768
 769     if ( !lib )
 770     {
 771         KMessageBox::error( 0, i18n( "<p>KLibLoader could not load the plugin:<br/><i>%1</i></p>"
 772                 "<p>Error message:<br/><i>%2</i></p>", service->library(), loader->lastErrorMessage() ) );
 773         return 0;
 774     }
 775
 776     KGetPlugin* (*create_plugin)() = ( KGetPlugin* (*)() ) lib->resolveSymbol( "create_plugin" );
 777
 778     if ( !create_plugin )
 779     {
 780         kDebug(5001) << "create_plugin == NULL" << endl;
 781         return 0;
 782     }
 783
 784     m_pluginKLibraries.append(lib);
 785
 786     return create_plugin();
 787 }
 788
 789 bool KGet::safeDeleteFile( const KUrl& url )
 790 {
 791     if ( url.isLocalFile() )
 792     {
 793         QFileInfo info( url.path() );
 794         if ( info.isDir() )
 795         {
 796             KMessageBox::information(0L,i18n("Not deleting\n%1\nas it is a "
 797                                      "directory.", url.prettyUrl()),
 798                                      i18n("Not Deleted"));
 799             return false;
 800         }
 801         KIO::NetAccess::del( url, 0L );
 802         return true;
 803     }
 804
 805     else
 806         KMessageBox::information( 0L,
 807                                   i18n("Not deleting\n%1\nas it is not a local"
 808                                           " file.", url.prettyUrl()),
 809                                   i18n("Not Deleted") );
 810     return false;
 811 }