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
  21 #include <kdebug.h>
  22 #include <klocale.h>
  23
  24 #include <QVariant>
  25
  26 TransferHandler::TransferHandler(Transfer * transfer, Scheduler * scheduler)
  27     : m_transfer(transfer), m_scheduler(scheduler)
  28 {
  29
  30 }
  31
  32 TransferHandler::~TransferHandler()
  33 {
  34 }
  35
  36 void TransferHandler::addObserver(TransferObserver * observer)
  37 {
  38     m_observers.push_back(observer);
  39     m_changesFlags[observer]=0xFFFFFFFF;
  40     kDebug(5001) << "TransferHandler: OBSERVERS++ = " << m_observers.size();
  41 }
  42
  43 void TransferHandler::delObserver(TransferObserver * observer)
  44 {
  45     m_observers.removeAll(observer);
  46     m_changesFlags.remove(observer);
  47     kDebug(5001) << "TransferHandler: OBSERVERS-- = " << m_observers.size();
  48 }
  49
  50 void TransferHandler::start()
  51 {
  52     if(m_transfer->group()->status() == JobQueue::Running)
  53     {
  54         m_transfer->setPolicy(Job::None);
  55         m_transfer->group()->move(m_transfer, 0);
  56     }
  57     else
  58     {
  59         m_transfer->setPolicy(Job::Start);
  60     }
  61 }
  62
  63 void TransferHandler::stop()
  64 {
  65     if(m_transfer->group()->status() == JobQueue::Stopped)
  66     {
  67         m_transfer->setPolicy(Job::None);
  68     }
  69     else
  70     {
  71         m_transfer->setPolicy(Job::Stop);
  72     }
  73 }
  74
  75 int TransferHandler::elapsedTime() const
  76 {
  77     return m_transfer->elapsedTime();
  78 }
  79
  80 int TransferHandler::remainingTime() const
  81 {
  82     return m_transfer->remainingTime();
  83 }
  84
  85 bool TransferHandler::isResumable() const
  86 {
  87     return m_transfer->isResumable();
  88 }
  89
  90 KIO::filesize_t TransferHandler::totalSize() const
  91 {
  92     return m_transfer->totalSize();
  93 }
  94
  95 KIO::filesize_t TransferHandler::processedSize() const
  96 {
  97     return m_transfer->processedSize();
  98 }
  99
 100 int TransferHandler::percent() const
 101 {
 102     return m_transfer->percent();
 103 }
 104
 105 int TransferHandler::speed() const
 106 {
 107     return m_transfer->speed();
 108 }
 109
 110 QVariant TransferHandler::data(int column)
 111 {
 112 //     kDebug(5001) << "TransferHandler::data(" << column << ")";
 113
 114     switch(column)
 115     {
 116         case 0:
 117             return dest().fileName();
 118         case 1:
 119             return statusText();
 120         case 2:
 121             if (totalSize() != 0)
 122                 return KIO::convertSize(totalSize());
 123             else
 124                 return i18nc("not available", "n/a");
 125         case 3:
 126 //             return QString::number(percent())+'%'; // display progressbar instead
 127             return QVariant();
 128         case 4:
 129             if (speed()==0)
 130             {
 131                 if (status() == Job::Running)
 132                     return i18n("Stalled");
 133                 else
 134                     return QString();
 135             }
 136             else
 137                 return i18n("%1/s", KIO::convertSize(speed()));
 138         default:
 139             return QVariant();
 140     }
 141 }
 142
 143 KMenu * TransferHandler::popupMenu(QList<TransferHandler *> transfers)
 144 {
 145     return m_transfer->factory()->createPopupMenu(transfers);
 146 }
 147
 148 void TransferHandler::setSelected( bool select )
 149 {
 150     if( (select && !isSelected()) || (!select && isSelected()) )
 151     {
 152         m_transfer->m_isSelected = select;
 153         setTransferChange( Transfer::Tc_Selection, true );
 154     }
 155 }
 156
 157 bool TransferHandler::isSelected() const
 158 {
 159     return m_transfer->m_isSelected;
 160 }
 161
 162 Transfer::ChangesFlags TransferHandler::changesFlags(TransferObserver * observer) const
 163 {
 164     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 165         return m_changesFlags[observer];
 166     else
 167     {
 168         kDebug(5001) << " TransferHandler::changesFlags() doesn't see you as an observer! ";
 169
 170         return 0xFFFFFFFF;
 171     }
 172 }
 173
 174 void TransferHandler::resetChangesFlags(TransferObserver * observer)
 175 {
 176     if( m_changesFlags.find(observer) != m_changesFlags.end() )
 177         m_changesFlags[observer] = 0;
 178     else
 179         kDebug(5001) << " TransferHandler::resetchangesFlags() doesn't see you as an observer! ";
 180 }
 181
 182 void TransferHandler::setTransferChange(ChangesFlags change, bool postEvent)
 183 {
 184     QMap<TransferObserver *, ChangesFlags>::Iterator it = m_changesFlags.begin();
 185     QMap<TransferObserver *, ChangesFlags>::Iterator itEnd = m_changesFlags.end();
 186
 187     for( ; it!=itEnd; ++it )
 188         *it |= change;
 189
 190     if(postEvent)
 191         postTransferChangedEvent();
 192 }
 193
 194 void TransferHandler::postTransferChangedEvent()
 195 {
 196 //     kDebug(5001) << "TransferHandler::postTransferChangedEvent() ENTERING";
 197
 198     // Here we have to copy the list and iterate on the copy itself, because
 199     // a view can remove itself as a view while we are iterating over the
 200     // observers list and this leads to crashes.
 201     QList<TransferObserver *> observers = m_observers;
 202
 203     QList<TransferObserver *>::iterator it = observers.begin();
 204     QList<TransferObserver *>::iterator itEnd = observers.end();
 205
 206     // Notify the observers
 207     for(; it!=itEnd; ++it)
 208     {
 209         (*it)->transferChangedEvent(this);
 210     }
 211
 212     // Notify the group
 213     m_transfer->group()->transferChangedEvent(m_transfer);
 214
 215     // Notify the TransferTreeModel
 216     m_transfer->model()->postDataChangedEvent(this);
 217
 218     //kDebug(5001) << "TransferHandler::postTransferChangedEvent() LEAVING";
 219 }
 220
 221 void TransferHandler::postDeleteEvent()
 222 {
 223     kDebug(5001) << "TransferHandler::postDeleteEvent() ENTERING";
 224
 225     //Here we have to copy the list and iterate on the copy itself, because
 226     //a view can remove itself as a view while we are iterating over the
 227     //observers list and this leads to crashes.
 228     QList<TransferObserver *> observers = m_observers;
 229
 230     QList<TransferObserver *>::iterator it = observers.begin();
 231     QList<TransferObserver *>::iterator itEnd = observers.end();
 232
 233     for(; it!=itEnd; ++it)
 234     {
 235         (*it)->deleteEvent(this);
 236     }
 237     kDebug(5001) << "TransferHandler::postDeleteEvent() LEAVING";
 238 }