kget/core/transfergrouphandler.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2005 Dario Massarin <nekkar@libero.it>
   4    Copyright (C) 2008 Lukas Appelhans <l.appelhans@gmx.de>
   5
   6    This program is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU General Public
   8    License as published by the Free Software Foundation; either
   9    version 2 of the License, or (at your option) any later version.
  10 */
  11
  12 #include "core/transfergrouphandler.h"
  13
  14 #include "core/kgetkjobadapter.h"
  15 #include "core/transferhandler.h"
  16 #include "core/transfertreemodel.h"
  17 #include "core/transfer.h"
  18 #include "core/observer.h"
  19 #include "core/kget.h"
  20
  21 #include <kdebug.h>
  22 #include <kmenu.h>
  23 #include <kaction.h>
  24 #include <kactioncollection.h>
  25 #include <klocale.h>
  26 #include <kicon.h>
  27
  28 TransferGroupHandler::TransferGroupHandler(TransferGroup * group, Scheduler * scheduler)
  29   : Handler(scheduler),
  30     m_group(group),
  31     m_qobject(0)
  32 {
  33     addObserver(0);
  34 }
  35
  36 TransferGroupHandler::~TransferGroupHandler()
  37 {
  38 }
  39
  40 void TransferGroupHandler::addObserver(TransferGroupObserver * observer)
  41 {
  42     kDebug(5001) << "TransferGroupHandler::addObserver";
  43     m_observers.push_back(observer);
  44     m_changesFlags[observer]=0xFFFFFFFF;
  45     kDebug(5001) << "   Now we have " << m_observers.size() << " observers";
  46 }
  47
  48 void TransferGroupHandler::delObserver(TransferGroupObserver * observer)
  49 {
  50     m_observers.removeAll(observer);
  51     m_changesFlags.remove(observer);
  52 }
  53
  54 void TransferGroupHandler::start()
  55 {
  56     kDebug(5001) << "TransferGroupHandler::start()";
  57     m_group->setStatus( JobQueue::Running );
  58 }
  59
  60 void TransferGroupHandler::stop()
  61 {
  62     kDebug(5001) << "TransferGroupHandler::stop()";
  63     m_group->setStatus( JobQueue::Stopped );
  64 }
  65
  66 void TransferGroupHandler::move(QList<TransferHandler *> transfers, TransferHandler * after)
  67 {
  68     //Check that the given transfer (after) belongs to this group
  69     if( after && (after->group() != this) )
  70         return;
  71
  72     QList<TransferHandler *>::iterator it = transfers.begin();
  73     QList<TransferHandler *>::iterator itEnd = transfers.end();
  74
  75     for( ; it!=itEnd ; ++it )
  76     {
  77         //Move the transfers in the JobQueue
  78         if(after)
  79             m_group->move( (*it)->m_transfer, after->m_transfer );
  80         else
  81             m_group->move( (*it)->m_transfer, 0 );
  82
  83         after = *it;
  84     }
  85 }
  86
  87 TransferHandler * TransferGroupHandler::operator[] (int i)
  88 {
  89 //     kDebug(5001) << "TransferGroupHandler::operator[" << i << "]";
  90
  91     return (*m_group)[i]->handler();
  92 }
  93
  94 void TransferGroupHandler::setName(const QString &name)
  95 {
  96     m_group->setName(name);
  97     postGroupChangedEvent();
  98 }
  99
 100 QVariant TransferGroupHandler::data(int column)
 101 {
 102 //     kDebug(5001) << "TransferGroupHandler::data(" << column << ")";
 103
 104     switch(column)
 105     {
 106         case 0:
 107             if (!m_group->supportsSpeedLimits() &&
 108                              (m_group->downloadLimit(Transfer::VisibleSpeedLimit) != 0 || m_group->uploadLimit(Transfer::VisibleSpeedLimit) != 0))
 109                 return name() + " - Does not supports SpeedLimits";//FIXME: Do a better text here
 110             else
 111                 return name();
 112         case 2:
 113             if(m_group->size())
 114                 return i18np("1 Item", "%1 Items", m_group->size());
 115             else
 116                 return QString();
 117 /*            if (totalSize() != 0)
 118                 return KIO::convertSize(totalSize());
 119             else
 120                 return i18nc("not available", "n/a");*/
 121         case 3:
 122 //             return QString::number(percent())+'%'; // display progressbar instead
 123             return QVariant();
 124         case 4:
 125             if (downloadSpeed() == 0)
 126             {
 127                 return QString();
 128             }
 129             else
 130                 return i18n("%1/s", KIO::convertSize(downloadSpeed()));
 131         default:
 132             return QVariant();
 133     }
 134 }
 135
 136 TransferGroup::ChangesFlags TransferGroupHandler::changesFlags(TransferGroupObserver * observer)
 137 {
 138     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 139         return m_changesFlags[observer];
 140     else
 141     {
 142         kDebug(5001) << " TransferGroupHandler::changesFlags() doesn't see you as an observer! ";
 143
 144         return 0xFFFFFFFF;
 145     }
 146 }
 147
 148 void TransferGroupHandler::resetChangesFlags(TransferGroupObserver * observer)
 149 {
 150     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 151         m_changesFlags[observer] = 0;
 152     else
 153         kDebug(5001) << " TransferGroupHandler::resetchangesFlags() doesn't see you as an observer! ";
 154 }
 155
 156 int TransferGroupHandler::indexOf(TransferHandler * transfer)
 157 {
 158     return m_group->indexOf(transfer->m_transfer);
 159 }
 160
 161 const QList<TransferHandler *> TransferGroupHandler::transfers()
 162 {
 163     QList<TransferHandler *> transfers;
 164
 165     TransferGroup::iterator it = m_group->begin();
 166     TransferGroup::iterator itEnd = m_group->end();
 167
 168     for( ; it!=itEnd ; ++it )
 169     {
 170         transfers.append((static_cast<Transfer *>(*it))->handler());
 171     }
 172     return transfers;
 173 }
 174
 175 const QList<QAction *> & TransferGroupHandler::actions()
 176 {
 177     createActions();
 178
 179     return m_actions;
 180 }
 181
 182 QObjectInterface * TransferGroupHandler::qObject()
 183 {
 184     if( !m_qobject )
 185         m_qobject = new QObjectInterface(this);
 186
 187     return m_qobject;
 188 }
 189
 190 void TransferGroupHandler::setGroupChange(ChangesFlags change, bool postEvent)
 191 {
 192     QMap<TransferGroupObserver *, ChangesFlags>::Iterator it = m_changesFlags.begin();
 193     QMap<TransferGroupObserver *, ChangesFlags>::Iterator itEnd = m_changesFlags.end();
 194
 195     for( ; it!=itEnd; ++it )
 196         *it |= change;
 197
 198     if(postEvent)
 199         postGroupChangedEvent();
 200 }
 201
 202 void TransferGroupHandler::postGroupChangedEvent()
 203 {
 204     //Here we have to copy the list and iterate on the copy itself, because
 205     //a view can remove itself as a view while we are iterating over the
 206     //observers list and this leads to crashes.
 207     QList<TransferGroupObserver *> observers = m_observers;
 208
 209     QList<TransferGroupObserver *>::iterator it = observers.begin();
 210     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 211
 212     for(; it!=itEnd; ++it)
 213     {
 214         if(*it)
 215             (*it)->groupChangedEvent(this);
 216     }
 217
 218     m_group->model()->postDataChangedEvent(this);
 219 }
 220
 221 void TransferGroupHandler::postAddedTransferEvent(Transfer * transfer, Transfer * after)
 222 {
 223     kDebug(5001) << "TransferGroupHandler::postAddedTransferEvent";
 224     kDebug(5001) << "   number of observers = " << m_observers.size();
 225
 226     //Here we have to copy the list and iterate on the copy itself, because
 227     //a view can remove itself as a view while we are iterating over the
 228     //observers list and this leads to crashes.
 229     QList<TransferGroupObserver *> observers = m_observers;
 230
 231     QList<TransferGroupObserver *>::iterator it = observers.begin();
 232     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 233
 234     for(; it!=itEnd; ++it)
 235     {
 236         if(*it)
 237         {
 238             if(after)
 239                 (*it)->addedTransferEvent(transfer->handler(), after->handler());
 240             else
 241                 (*it)->addedTransferEvent(transfer->handler(), 0);
 242         }
 243     }
 244 }
 245
 246 void TransferGroupHandler::postRemovedTransferEvent(Transfer * transfer)
 247 {
 248     //Here we have to copy the list and iterate on the copy itself, because
 249     //a view can remove itself as a view while we are iterating over the
 250     //observers list and this leads to crashes.
 251     QList<TransferGroupObserver *> observers = m_observers;
 252
 253     QList<TransferGroupObserver *>::iterator it = observers.begin();
 254     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 255
 256     for(; it!=itEnd; ++it)
 257     {
 258         if(*it)
 259             (*it)->removedTransferEvent(transfer->handler());
 260     }
 261 }
 262
 263 void TransferGroupHandler::postMovedTransferEvent(Transfer * transfer, Transfer * after)
 264 {
 265     //Here we have to copy the list and iterate on the copy itself, because
 266     //a view can remove itself as a view while we are iterating over the
 267     //observers list and this leads to crashes.
 268     QList<TransferGroupObserver *> observers = m_observers;
 269
 270     QList<TransferGroupObserver *>::iterator it = observers.begin();
 271     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 272
 273     for(; it!=itEnd; ++it)
 274     {
 275         if(*it)
 276         {
 277             if(after)
 278                 (*it)->movedTransferEvent(transfer->handler(), after->handler());
 279             else
 280                 (*it)->movedTransferEvent(transfer->handler(), 0);
 281         }
 282     }
 283 }
 284
 285 void TransferGroupHandler::postDeleteEvent()
 286 {
 287     //Here we have to copy the list and iterate on the copy itself, because
 288     //a view can remove itself as a view while we are iterating over the
 289     //observers list and this leads to crashes.
 290     QList<TransferGroupObserver *> observers = m_observers;
 291
 292     QList<TransferGroupObserver *>::iterator it = observers.begin();
 293     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 294
 295     for(; it!=itEnd; ++it)
 296     {
 297         if(*it)
 298             (*it)->deleteEvent(this);
 299     }
 300 }
 301
 302 void TransferGroupHandler::createActions()
 303 {
 304     if( !m_actions.empty() )
 305         return;
 306
 307     //Calling this function we make sure the QObjectInterface object
 308     //has been created (if not it will create it)
 309     qObject();
 310
 311     QAction *startAction = KGet::actionCollection()->addAction("transfer_group_start");
 312     startAction->setText(i18nc("start transfergroup downloads", "Start"));
 313     startAction->setIcon(KIcon("media-playback-start"));
 314     QObject::connect(startAction, SIGNAL(triggered()), qObject(), SLOT(slotStart()));
 315     m_actions.append(startAction);
 316
 317     QAction *stopAction = KGet::actionCollection()->addAction("transfer_group_stop");
 318     stopAction->setText(i18nc("stop transfergroup downloads", "Stop"));
 319     stopAction->setIcon(KIcon("media-playback-pause"));
 320     QObject::connect(stopAction, SIGNAL(triggered()), qObject(), SLOT(slotStop()));
 321     m_actions.append(stopAction);
 322
 323 }
 324
 325
 326
 327 QObjectInterface::QObjectInterface(TransferGroupHandler * handler)
 328     : m_handler(handler)
 329 {
 330
 331 }
 332
 333 void QObjectInterface::slotStart()
 334 {
 335     m_handler->start();
 336 }
 337
 338 void QObjectInterface::slotStop()
 339 {
 340     m_handler->stop();
 341 }
 342
 343
 344
 345 GenericTransferGroupObserver::GenericTransferGroupObserver() : QObject(),
 346     m_adapters()
 347 {
 348     m_transferObserver = new GenericTransferObserver(this);
 349 }
 350
 351 GenericTransferGroupObserver::~GenericTransferGroupObserver()
 352 {
 353     delete m_transferObserver;
 354 }
 355
 356 void GenericTransferGroupObserver::groupChangedEvent(TransferGroupHandler * group)
 357 {
 358     TransferGroupHandler::ChangesFlags transferFlags = group->changesFlags(this);
 359     if (transferFlags & TransferGroup::Gc_Percent)
 360         KGet::calculateGlobalSpeedLimits();
 361     group->resetChangesFlags(this);
 362 }
 363
 364 void GenericTransferGroupObserver::addedTransferEvent(TransferHandler * transfer, TransferHandler * after)
 365 {
 366     Q_UNUSED(transfer);
 367     Q_UNUSED(after);
 368     KGet::calculateGlobalSpeedLimits();
 369
 370     if (transfer->percent() != 100) {
 371         transfer->addObserver(m_transferObserver);
 372
 373         KGet::save();
 374     }
 375
 376     registerTransferAsKJob(transfer);
 377 }
 378
 379 void GenericTransferGroupObserver::removedTransferEvent(TransferHandler * transfer)
 380 {
 381     Q_UNUSED(transfer);
 382     KGet::calculateGlobalSpeedLimits();
 383
 384     transfer->delObserver(m_transferObserver);
 385
 386     KGet::save();
 387     if(m_adapters.contains(transfer)) {
 388         KGet::unregisterKJob(m_adapters [transfer]);
 389         m_adapters.remove(transfer);
 390     }
 391 }
 392
 393 void GenericTransferGroupObserver::movedTransferEvent(TransferHandler * transfer, TransferHandler * after)
 394 {
 395     Q_UNUSED(transfer);
 396     Q_UNUSED(after);
 397     KGet::calculateGlobalSpeedLimits();
 398
 399     KGet::save();
 400 }
 401
 402 void GenericTransferGroupObserver::addTransferGroup(TransferGroupHandler *group)
 403 {
 404     foreach(TransferHandler *handler, group->transfers()) {
 405         handler->addObserver(m_transferObserver);
 406         registerTransferAsKJob(handler);
 407     }
 408 }
 409
 410 void GenericTransferGroupObserver::postTransferChanged(TransferHandler *transfer)
 411 {
 412     if(m_adapters.contains(transfer)) {
 413         m_adapters[transfer]->slotUpdateDescription();
 414
 415         if(transfer->status() == Job::Finished) {
 416             KGet::unregisterKJob(m_adapters [transfer]);
 417             m_adapters.remove(transfer);
 418         }
 419     }
 420 }
 421
 422 void GenericTransferGroupObserver::registerTransferAsKJob(TransferHandler *transfer)
 423 {
 424     KGetKJobAdapter *adapter = new KGetKJobAdapter(this, transfer);
 425     KGet::registerKJob(adapter);
 426
 427     m_adapters [transfer] = adapter;
 428 }
 429
 430 #include "transfergrouphandler.moc"