kget/core/transfergrouphandler.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/transfergrouphandler.h"
  12
  13 #include "core/transferhandler.h"
  14 #include "core/transfertreemodel.h"
  15 #include "core/transfer.h"
  16 #include "core/observer.h"
  17 #include "core/kget.h"
  18
  19 #include <kdebug.h>
  20 #include <kmenu.h>
  21 #include <kaction.h>
  22 #include <kactioncollection.h>
  23 #include <klocale.h>
  24 #include <kicon.h>
  25
  26 TransferGroupHandler::TransferGroupHandler(TransferGroup * group, Scheduler * scheduler)
  27     : m_group(group),
  28       m_scheduler(scheduler),
  29       m_qobject(0)
  30 {
  31 }
  32
  33 TransferGroupHandler::~TransferGroupHandler()
  34 {
  35 }
  36
  37 void TransferGroupHandler::addObserver(TransferGroupObserver * observer)
  38 {
  39     kDebug(5001) << "TransferGroupHandler::addObserver";
  40     m_observers.push_back(observer);
  41     m_changesFlags[observer]=0xFFFFFFFF;
  42     kDebug(5001) << "   Now we have " << m_observers.size() << " observers";
  43 }
  44
  45 void TransferGroupHandler::delObserver(TransferGroupObserver * observer)
  46 {
  47     m_observers.removeAll(observer);
  48     m_changesFlags.remove(observer);
  49 }
  50
  51 void TransferGroupHandler::start()
  52 {
  53     kDebug(5001) << "TransferGroupHandler::start()";
  54     m_group->setStatus( JobQueue::Running );
  55 }
  56
  57 void TransferGroupHandler::stop()
  58 {
  59     kDebug(5001) << "TransferGroupHandler::stop()";
  60     m_group->setStatus( JobQueue::Stopped );
  61 }
  62
  63 void TransferGroupHandler::move(QList<TransferHandler *> transfers, TransferHandler * after)
  64 {
  65     //Check that the given transfer (after) belongs to this group
  66     if( after && (after->group() != this) )
  67         return;
  68
  69     QList<TransferHandler *>::iterator it = transfers.begin();
  70     QList<TransferHandler *>::iterator itEnd = transfers.end();
  71
  72     for( ; it!=itEnd ; ++it )
  73     {
  74         //Move the transfers in the JobQueue
  75         if(after)
  76             m_group->move( (*it)->m_transfer, after->m_transfer );
  77         else
  78             m_group->move( (*it)->m_transfer, 0 );
  79
  80         after = *it;
  81     }
  82 }
  83
  84 TransferHandler * TransferGroupHandler::operator[] (int i)
  85 {
  86 //     kDebug(5001) << "TransferGroupHandler::operator[" << i << "]";
  87
  88     return (*m_group)[i]->handler();
  89 }
  90
  91 void TransferGroupHandler::setName(const QString &name)
  92 {
  93     m_group->setName(name);
  94     postGroupChangedEvent();
  95 }
  96
  97 QVariant TransferGroupHandler::data(int column)
  98 {
  99 //     kDebug(5001) << "TransferGroupHandler::data(" << column << ")";
 100
 101     switch(column)
 102     {
 103         case 0:
 104             return name();
 105         case 2:
 106             if(m_group->size())
 107                 return i18np("1 Item", "%1 Items", m_group->size());
 108             else
 109                 return QString();
 110 /*            if (totalSize() != 0)
 111                 return KIO::convertSize(totalSize());
 112             else
 113                 return i18nc("not available", "n/a");*/
 114         case 3:
 115 //             return QString::number(percent())+'%'; // display progressbar instead
 116             return QVariant();
 117         case 4:
 118             if (speed()==0)
 119             {
 120                 if (status() == JobQueue::Running)
 121                     return i18n("Stalled");
 122                 else
 123                     return QString();
 124             }
 125             else
 126                 return i18n("%1/s", KIO::convertSize(speed()));
 127         default:
 128             return QVariant();
 129     }
 130 }
 131
 132 TransferGroup::ChangesFlags TransferGroupHandler::changesFlags(TransferGroupObserver * observer)
 133 {
 134     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 135         return m_changesFlags[observer];
 136     else
 137     {
 138         kDebug(5001) << " TransferGroupHandler::changesFlags() doesn't see you as an observer! ";
 139
 140         return 0xFFFFFFFF;
 141     }
 142 }
 143
 144 void TransferGroupHandler::resetChangesFlags(TransferGroupObserver * observer)
 145 {
 146     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 147         m_changesFlags[observer] = 0;
 148     else
 149         kDebug(5001) << " TransferGroupHandler::resetchangesFlags() doesn't see you as an observer! ";
 150 }
 151
 152 int TransferGroupHandler::indexOf(TransferHandler * transfer)
 153 {
 154     return m_group->indexOf(transfer->m_transfer);
 155 }
 156
 157 const QList<TransferHandler *> TransferGroupHandler::transfers()
 158 {
 159     QList<TransferHandler *> transfers;
 160
 161     TransferGroup::iterator it = m_group->begin();
 162     TransferGroup::iterator itEnd = m_group->end();
 163
 164     for( ; it!=itEnd ; ++it )
 165     {
 166         transfers.append((static_cast<Transfer *>(*it))->handler());
 167     }
 168     return transfers;
 169 }
 170
 171 const QList<QAction *> & TransferGroupHandler::actions()
 172 {
 173     createActions();
 174
 175     return m_actions;
 176 }
 177
 178 KMenu * TransferGroupHandler::popupMenu()
 179 {
 180     KMenu * popup = new KMenu( 0 );
 181 //     popup->addTitle( i18nc( "%1 is the name of the group", "%1 Group", name() ) );
 182
 183     createActions();
 184
 185     popup->addAction( KGet::actionCollection()->action("transfer_group_start") );
 186     popup->addAction( KGet::actionCollection()->action("transfer_group_stop") );
 187     if(m_group->name() != i18n("My Downloads")) {
 188         popup->addSeparator();
 189         popup->addAction( KGet::actionCollection()->action("delete_groups") );
 190         popup->addAction( KGet::actionCollection()->action("rename_groups") );
 191     }
 192     return popup;
 193 }
 194
 195 QObjectInterface * TransferGroupHandler::qObject()
 196 {
 197     if( !m_qobject )
 198         m_qobject = new QObjectInterface(this);
 199
 200     return m_qobject;
 201 }
 202
 203 void TransferGroupHandler::setGroupChange(ChangesFlags change, bool postEvent)
 204 {
 205     QMap<TransferGroupObserver *, ChangesFlags>::Iterator it = m_changesFlags.begin();
 206     QMap<TransferGroupObserver *, ChangesFlags>::Iterator itEnd = m_changesFlags.end();
 207
 208     for( ; it!=itEnd; ++it )
 209         *it |= change;
 210
 211     if(postEvent)
 212         postGroupChangedEvent();
 213 }
 214
 215 void TransferGroupHandler::postGroupChangedEvent()
 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<TransferGroupObserver *> observers = m_observers;
 221
 222     QList<TransferGroupObserver *>::iterator it = observers.begin();
 223     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 224
 225     for(; it!=itEnd; ++it)
 226     {
 227         (*it)->groupChangedEvent(this);
 228     }
 229
 230     m_group->model()->postDataChangedEvent(this);
 231 }
 232
 233 void TransferGroupHandler::postAddedTransferEvent(Transfer * transfer, Transfer * after)
 234 {
 235     kDebug(5001) << "TransferGroupHandler::postAddedTransferEvent";
 236     kDebug(5001) << "   number of observers = " << m_observers.size();
 237
 238     //Here we have to copy the list and iterate on the copy itself, because
 239     //a view can remove itself as a view while we are iterating over the
 240     //observers list and this leads to crashes.
 241     QList<TransferGroupObserver *> observers = m_observers;
 242
 243     QList<TransferGroupObserver *>::iterator it = observers.begin();
 244     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 245
 246     for(; it!=itEnd; ++it)
 247     {
 248         if(after)
 249             (*it)->addedTransferEvent(transfer->handler(), after->handler());
 250         else
 251             (*it)->addedTransferEvent(transfer->handler(), 0);
 252     }
 253 }
 254
 255 void TransferGroupHandler::postRemovedTransferEvent(Transfer * transfer)
 256 {
 257     //Here we have to copy the list and iterate on the copy itself, because
 258     //a view can remove itself as a view while we are iterating over the
 259     //observers list and this leads to crashes.
 260     QList<TransferGroupObserver *> observers = m_observers;
 261
 262     QList<TransferGroupObserver *>::iterator it = observers.begin();
 263     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 264
 265     for(; it!=itEnd; ++it)
 266     {
 267         (*it)->removedTransferEvent(transfer->handler());
 268     }
 269 }
 270
 271 void TransferGroupHandler::postMovedTransferEvent(Transfer * transfer, Transfer * after)
 272 {
 273     //Here we have to copy the list and iterate on the copy itself, because
 274     //a view can remove itself as a view while we are iterating over the
 275     //observers list and this leads to crashes.
 276     QList<TransferGroupObserver *> observers = m_observers;
 277
 278     QList<TransferGroupObserver *>::iterator it = observers.begin();
 279     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 280
 281     for(; it!=itEnd; ++it)
 282     {
 283         if(after)
 284             (*it)->movedTransferEvent(transfer->handler(), after->handler());
 285         else
 286             (*it)->movedTransferEvent(transfer->handler(), 0);
 287     }
 288 }
 289
 290 void TransferGroupHandler::postDeleteEvent()
 291 {
 292     //Here we have to copy the list and iterate on the copy itself, because
 293     //a view can remove itself as a view while we are iterating over the
 294     //observers list and this leads to crashes.
 295     QList<TransferGroupObserver *> observers = m_observers;
 296
 297     QList<TransferGroupObserver *>::iterator it = observers.begin();
 298     QList<TransferGroupObserver *>::iterator itEnd = observers.end();
 299
 300     for(; it!=itEnd; ++it)
 301     {
 302         (*it)->deleteEvent(this);
 303     }
 304 }
 305
 306 void TransferGroupHandler::createActions()
 307 {
 308     if( !m_actions.empty() )
 309         return;
 310
 311     //Calling this function we make sure the QObjectInterface object
 312     //has been created (if not it will create it)
 313     qObject();
 314
 315     QAction *startAction = KGet::actionCollection()->addAction("transfer_group_start");
 316     startAction->setText(i18n("Start"));
 317     startAction->setIcon(KIcon("media-playback-start"));
 318     QObject::connect(startAction, SIGNAL(triggered()), qObject(), SLOT(slotStart()));
 319     m_actions.append(startAction);
 320
 321     QAction *stopAction = KGet::actionCollection()->addAction("transfer_group_stop");
 322     stopAction->setText(i18n("Stop"));
 323     stopAction->setIcon(KIcon("media-playback-pause"));
 324     QObject::connect(stopAction, SIGNAL(triggered()), qObject(), SLOT(slotStop()));
 325     m_actions.append(stopAction);
 326
 327 }
 328
 329
 330
 331 QObjectInterface::QObjectInterface(TransferGroupHandler * handler)
 332     : m_handler(handler)
 333 {
 334
 335 }
 336
 337 void QObjectInterface::slotStart()
 338 {
 339     m_handler->start();
 340 }
 341
 342 void QObjectInterface::slotStop()
 343 {
 344     m_handler->stop();
 345 }
 346
 347 #include "transfergrouphandler.moc"