kget/core/transferhandler.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; either
   8    version 2 of the License, or (at your option) any later version.
   9 */
  10
  11 #include "core/transferhandler.h"
  12
  13 #include "core/job.h"
  14 #include "core/jobqueue.h"
  15 #include "core/transfergroup.h"
  16 #include "core/transfergrouphandler.h"
  17 #include "core/transfertreemodel.h"
  18 #include "core/plugin/transferfactory.h"
  19 #include "core/observer.h"
  20 #include "settings.h"
  21 #include "mainwindow.h"
  22
  23 #include <kdebug.h>
  24 #include <klocale.h>
  25 #include <KPassivePopup>
  26 #include <QAction>
  27 #include <QVariant>
  28
  29 #ifdef HAVE_KWORKSPACE
  30     #include <kworkspace/kworkspace.h>
  31 #endif
  32
  33 TransferHandler::TransferHandler(Transfer * transfer, Scheduler * scheduler)
  34   : Handler(scheduler),
  35     m_transfer(transfer)
  36 {
  37     addObserver(0);
  38 }
  39
  40 TransferHandler::~TransferHandler()
  41 {
  42 //    qDeleteAll(m_observers);
  43 }
  44
  45 void TransferHandler::addObserver(TransferObserver * observer)
  46 {
  47     m_observers.push_back(observer);
  48     m_changesFlags[observer]=0xFFFFFFFF;
  49     kDebug(5001) << "TransferHandler: OBSERVERS++ = " << m_observers.size();
  50 }
  51
  52 void TransferHandler::delObserver(TransferObserver * observer)
  53 {
  54     m_observers.removeAll(observer);
  55     m_changesFlags.remove(observer);
  56     kDebug(5001) << "TransferHandler: OBSERVERS-- = " << m_observers.size();
  57 }
  58
  59 void TransferHandler::start()
  60 {
  61     if(m_transfer->group()->status() == JobQueue::Running)
  62     {
  63         m_transfer->setPolicy(Job::None);
  64         m_transfer->group()->move(m_transfer, 0);
  65     }
  66     else
  67     {
  68         m_transfer->setPolicy(Job::Start);
  69     }
  70 }
  71
  72 void TransferHandler::stop()
  73 {
  74     if (m_transfer->group()->status() == JobQueue::Stopped)
  75     {
  76         m_transfer->setPolicy(Job::None);
  77     }
  78     else
  79     {
  80         m_transfer->setPolicy(Job::Stop);
  81     }
  82 }
  83
  84 int TransferHandler::elapsedTime() const
  85 {
  86     return m_transfer->elapsedTime();
  87 }
  88
  89 int TransferHandler::remainingTime() const
  90 {
  91     return m_transfer->remainingTime();
  92 }
  93
  94 bool TransferHandler::isResumable() const
  95 {
  96     return m_transfer->isResumable();
  97 }
  98
  99 KIO::filesize_t TransferHandler::totalSize() const
 100 {
 101     return m_transfer->totalSize();
 102 }
 103
 104 KIO::filesize_t TransferHandler::downloadedSize() const
 105 {
 106     return m_transfer->downloadedSize();
 107 }
 108
 109 KIO::filesize_t TransferHandler::uploadedSize() const
 110 {
 111     return m_transfer->uploadedSize();
 112 }
 113
 114 int TransferHandler::percent() const
 115 {
 116     return m_transfer->percent();
 117 }
 118
 119 int TransferHandler::downloadSpeed() const
 120 {
 121     return m_transfer->downloadSpeed();
 122 }
 123
 124 int TransferHandler::uploadSpeed() const
 125 {
 126     return m_transfer->uploadSpeed();
 127 }
 128
 129 QVariant TransferHandler::data(int column)
 130 {
 131 //     kDebug(5001) << "TransferHandler::data(" << column << ")";
 132
 133     switch(column)
 134     {
 135         case 0:
 136             return dest().fileName();
 137         case 1:
 138             return statusText();
 139         case 2:
 140             if (totalSize() != 0)
 141                 return KIO::convertSize(totalSize());
 142             else
 143                 return i18nc("not available", "n/a");
 144         case 3:
 145 //             return QString::number(percent())+'%'; // display progressbar instead
 146             return QVariant();
 147         case 4:
 148             if (downloadSpeed()==0)
 149             {
 150                 if (status() == Job::Running)
 151                     return i18n("Stalled");
 152                 else
 153                     return QString();
 154             }
 155             else
 156                 return i18n("%1/s", KIO::convertSize(downloadSpeed()));
 157         case 5:
 158             if (status() == Job::Running)
 159                 return KIO::convertSeconds(remainingTime());
 160             else
 161                 return QString();
 162         default:
 163             return QVariant();
 164     }
 165 }
 166
 167 void TransferHandler::setSelected( bool select )
 168 {
 169     if( (select && !isSelected()) || (!select && isSelected()) )
 170     {
 171         m_transfer->m_isSelected = select;
 172         setTransferChange( Transfer::Tc_Selection, true );
 173     }
 174 }
 175
 176 bool TransferHandler::isSelected() const
 177 {
 178     return m_transfer->m_isSelected;
 179 }
 180
 181 Transfer::ChangesFlags TransferHandler::changesFlags(TransferObserver * observer) const
 182 {
 183     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 184         return m_changesFlags[observer];
 185     else
 186     {
 187         kDebug(5001) << " TransferHandler::changesFlags() doesn't see you as an observer! ";
 188
 189         return 0xFFFFFFFF;
 190     }
 191 }
 192
 193 void TransferHandler::resetChangesFlags(TransferObserver * observer)
 194 {
 195     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 196         m_changesFlags[observer] = 0;
 197     else
 198         kDebug(5001) << " TransferHandler::resetChangesFlags() doesn't see you as an observer! ";
 199 }
 200
 201 void TransferHandler::setTransferChange(ChangesFlags change, bool postEvent)
 202 {
 203     QMap<TransferObserver *, ChangesFlags>::Iterator it = m_changesFlags.begin();
 204     QMap<TransferObserver *, ChangesFlags>::Iterator itEnd = m_changesFlags.end();
 205
 206     for( ; it!=itEnd; ++it )
 207         *it |= change;
 208
 209     if(postEvent)
 210         postTransferChangedEvent();
 211 }
 212
 213 void TransferHandler::postTransferChangedEvent()
 214 {
 215 //     kDebug(5001) << "TransferHandler::postTransferChangedEvent() ENTERING";
 216
 217     // Here we have to copy the list and iterate on the copy itself, because
 218     // a view can remove itself as a view while we are iterating over the
 219     // observers list and this leads to crashes.
 220     QList<TransferObserver *> observers = m_observers;
 221
 222     QList<TransferObserver *>::iterator it = observers.begin();
 223     QList<TransferObserver *>::iterator itEnd = observers.end();
 224
 225     // Notify the observers
 226     for(; it!=itEnd; ++it)
 227     {
 228         if(*it)
 229             (*it)->transferChangedEvent(this);
 230     }
 231
 232     // Notify the group
 233     m_transfer->group()->transferChangedEvent(m_transfer);
 234
 235     // Notify the TransferTreeModel
 236     m_transfer->model()->postDataChangedEvent(this);
 237
 238     //kDebug(5001) << "TransferHandler::postTransferChangedEvent() LEAVING";
 239 }
 240
 241 void TransferHandler::postDeleteEvent()
 242 {
 243     kDebug(5001) << "TransferHandler::postDeleteEvent() ENTERING";
 244
 245     m_transfer->postDeleteEvent();//First inform the transfer itself
 246
 247     //Here we have to copy the list and iterate on the copy itself, because
 248     //a view can remove itself as a view while we are iterating over the
 249     //observers list and this leads to crashes.
 250     QList<TransferObserver *> observers = m_observers;
 251
 252     QList<TransferObserver *>::iterator it = observers.begin();
 253     QList<TransferObserver *>::iterator itEnd = observers.end();
 254
 255     for(; it!=itEnd; ++it)
 256     {
 257         if(*it && *it != dynamic_cast<TransferObserver*>(m_transfer))
 258             (*it)->deleteEvent(this);
 259     }
 260     kDebug(5001) << "TransferHandler::postDeleteEvent() LEAVING";
 261 }
 262
 263 QList<QAction*> TransferHandler::contextActions()
 264 {
 265     QList<QAction*> actions;
 266     if (status() != Job::Finished)
 267     {
 268         actions << KGet::actionCollection()->action("start_selected_download")
 269                 << KGet::actionCollection()->action("stop_selected_download");
 270     }
 271     actions << KGet::actionCollection()->action("delete_selected_download")
 272             << KGet::actionCollection()->action("redownload_selected_download");
 273
 274     return actions;
 275 }
 276
 277 QList<QAction*> TransferHandler::factoryActions()
 278 {
 279     QList<QAction*> actions;
 280     foreach(QAction *action, m_transfer->factory()->actions(this))
 281         actions.append(action);
 282     return actions;
 283 }
 284
 285
 286 GenericTransferObserver::GenericTransferObserver(GenericTransferGroupObserver *groupObserver)
 287   : QObject(groupObserver),
 288     TransferObserver()
 289 {
 290     m_groupObserver = groupObserver;
 291 }
 292
 293 void GenericTransferObserver::transferChangedEvent(TransferHandler * transfer)
 294 {
 295     //kDebug(5001);
 296     TransferHandler::ChangesFlags transferFlags = transfer->changesFlags(this);
 297
 298     if (transfer->status() == Job::Finished && Settings::afterFinishActionEnabled()
 299                                             && Settings::afterFinishAction() == KGet::Quit)
 300     {
 301         checkAndFinish();
 302     }
 303
 304 #ifdef HAVE_KWORKSPACE
 305     if (transfer->status() == Job::Finished && Settings::afterFinishActionEnabled()
 306                                             && Settings::afterFinishAction() == KGet::Shutdown) {
 307         checkAndShutdown();
 308     }
 309 #endif
 310
 311     if (prevStatus != transfer->statusText())//FIXME: HACK: better: check statusFlags if it
 312     {                                                                 //contains Tc_Status (flags & Transfer::Tc_Status <-doesn't work)
 313         prevStatus = transfer->statusText();
 314         KGet::checkSystemTray();
 315     }
 316
 317     if (transferFlags & Transfer::Tc_Percent) {
 318         transfer->group()->setGroupChange(TransferGroup::Gc_Percent, true);
 319     }
 320
 321     if (transferFlags & Transfer::Tc_DownloadSpeed) {
 322         transfer->group()->setGroupChange(TransferGroup::Gc_DownloadSpeed, true);
 323     }
 324
 325     if (transferFlags & Transfer::Tc_UploadSpeed) {
 326         transfer->group()->setGroupChange(TransferGroup::Gc_UploadSpeed, true);
 327     }
 328
 329     transfer->resetChangesFlags(this);
 330     transfer->checkShareRatio();
 331
 332     m_groupObserver->postTransferChanged(transfer);
 333 }
 334
 335 bool GenericTransferObserver::allTransfersFinished()
 336 {
 337     bool quitFlag = true;
 338     foreach(TransferGroup *transferGroup, KGet::m_transferTreeModel->transferGroups()) {
 339         foreach(TransferHandler *transfer, transferGroup->handler()->transfers()) {
 340             if(transfer->status() != Job::Finished) {
 341                 quitFlag = false;
 342             }
 343         }
 344     }
 345
 346     return quitFlag;
 347 }
 348
 349 KPassivePopup* GenericTransferObserver::popupMessage(const QString &title, const QString &message)
 350 {
 351     KPassivePopup *popup;
 352     // we have to call diferent message from kpassivePopup
 353     // one with parent as QWidget for the mainWindow
 354     // and another with parent as QSystemTrayIcon if the parent is a systemTray
 355     // so passing the QSystemTrayIcon as QWidget don't work
 356     if(Settings::enableSystemTray())
 357     {
 358         popup = KPassivePopup::message(5000, title, message, KGet::m_mainWindow->systemTray());
 359     }
 360     else
 361     {
 362         popup = KPassivePopup::message(5000, title, message, KGet::m_mainWindow);
 363     }
 364
 365     return popup;
 366 }
 367
 368 void GenericTransferObserver::checkAndFinish()
 369 {
 370     // check if there is some unfinished transfer in scheduler queues
 371     if(allTransfersFinished()) {
 372         KPassivePopup *message = popupMessage(i18n("Quit KGet"),
 373                                             i18n("KGet is now closing, as all downloads have completed."));
 374         QObject::connect(message, SIGNAL(destroyed()), KGet::m_mainWindow, SLOT(slotQuit()));
 375     }
 376 }
 377
 378 #ifdef HAVE_KWORKSPACE
 379 void GenericTransferObserver::checkAndShutdown()
 380 {
 381     if(allTransfersFinished()) {
 382         KPassivePopup *message = popupMessage(i18n("Quit KGet"),
 383                                             i18n("The computer will now turn off, as all downloads have completed."));
 384         QObject::connect(message, SIGNAL(destroyed()), SLOT(slotShutdown()));
 385         QObject::connect(message, SIGNAL(destroyed()),  KGet::m_mainWindow, SLOT(slotQuit()));
 386     }
 387 }
 388
 389 void GenericTransferObserver::slotShutdown()
 390 {
 391     KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmNo,
 392                                 KWorkSpace::ShutdownTypeHalt,
 393                                 KWorkSpace::ShutdownModeForceNow);
 394 }
 395 #endif