File indexing completed on 2024-09-08 04:30:28

 /* This file is part of the KDE project
 
    Copyright (C) 2005 Dario Massarin <nekkar@libero.it>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 */
 
 #include "core/transferhandler.h"
 
 #include "core/job.h"
 #include "core/jobqueue.h"
 #include "core/plugin/transferfactory.h"
 #include "core/transfergroup.h"
 #include "core/transfergrouphandler.h"
 #include "core/transfertreemodel.h"
 #include "kgetkjobadapter.h"
 #include "mainwindow.h"
 #include "settings.h"
 
 #include "kget_debug.h"
 #include <KLocalizedString>
 #include <QAction>
 #include <QDebug>
 
 TransferHandler::TransferHandler(Transfer *parent, Scheduler *scheduler)
     : Handler(scheduler, parent)
     , m_transfer(parent)
     , m_changesFlags(Transfer::Tc_None)
 {
     static int dBusObjIdx = 0;
     m_dBusObjectPath = "/KGet/Transfers/" + QString::number(dBusObjIdx++);
 
     m_kjobAdapter = new KGetKJobAdapter(this, this);
 
     connect(m_transfer, &Transfer::capabilitiesChanged, this, &TransferHandler::capabilitiesChanged);
 }
 
 TransferHandler::~TransferHandler()
 {
 }
 
 Transfer::Capabilities TransferHandler::capabilities() const
 {
     return m_transfer->capabilities();
 }
 
 void TransferHandler::start()
 {
     if (m_transfer->group()->status() == JobQueue::Running) {
         m_transfer->setPolicy(Job::None);
         KGet::model()->moveTransfer(m_transfer, m_transfer->group());
     } else {
         m_transfer->setPolicy(Job::Start);
     }
 }
 
 void TransferHandler::stop()
 {
     if (m_transfer->group()->status() == JobQueue::Stopped) {
         m_transfer->setPolicy(Job::None);
     } else {
         m_transfer->setPolicy(Job::Stop);
     }
 }
 
 int TransferHandler::elapsedTime() const
 {
     return m_transfer->elapsedTime();
 }
 
 int TransferHandler::remainingTime() const
 {
     return m_transfer->remainingTime();
 }
 
 KIO::filesize_t TransferHandler::totalSize() const
 {
     return m_transfer->totalSize();
 }
 
 KIO::filesize_t TransferHandler::downloadedSize() const
 {
     return m_transfer->downloadedSize();
 }
 
 KIO::filesize_t TransferHandler::uploadedSize() const
 {
     return m_transfer->uploadedSize();
 }
 
 int TransferHandler::percent() const
 {
     return m_transfer->percent();
 }
 
 int TransferHandler::downloadSpeed() const
 {
     return m_transfer->downloadSpeed();
 }
 
 int TransferHandler::averageDownloadSped() const
 {
     return m_transfer->averageDownloadSpeed();
 }
 
 int TransferHandler::uploadSpeed() const
 {
     return m_transfer->uploadSpeed();
 }
 
 QVariant TransferHandler::data(int column)
 {
     //     qCDebug(KGET_DEBUG) << "TransferHandler::data(" << column << ")";
 
     switch (column) {
     case 0:
         return dest().fileName();
     case 1:
         if (status() == Job::Aborted && !error().text.isEmpty())
             return error().text;
         return statusText();
     case 2:
         if (totalSize() != 0)
             return KIO::convertSize(totalSize());
         else
             return i18nc("not available", "n/a");
     case 3:
         //             return QString::number(percent())+'%'; // display progressbar instead
         return QVariant();
     case 4:
         if (downloadSpeed() == 0) {
             if (m_transfer->isStalled())
                 return i18n("Stalled");
             else
                 return QString();
         } else
             return i18n("%1/s", KIO::convertSize(downloadSpeed()));
     case 5:
         if (status() == Job::Running && downloadSpeed() != 0)
             return KIO::convertSeconds(remainingTime());
         else
             return QString();
     default:
         return QVariant();
     }
 }
 
 void TransferHandler::setSelected(bool select)
 {
     if (select != isSelected()) {
         m_transfer->m_isSelected = select;
         setTransferChange(Transfer::Tc_Selection, true);
     }
 }
 
 bool TransferHandler::isSelected() const
 {
     return m_transfer->m_isSelected;
 }
 
 Transfer::ChangesFlags TransferHandler::changesFlags() const
 {
     return m_changesFlags;
 }
 
 void TransferHandler::resetChangesFlags()
 {
     m_changesFlags = 0;
 }
 
 void TransferHandler::destroy()
 {
     qCDebug(KGET_DEBUG) << "TransferHandler::destroy() ENTERING";
 
     qCDebug(KGET_DEBUG) << "TransferHandler::destroy() LEAVING";
 }
 
 void TransferHandler::setTransferChange(ChangesFlags change, bool notifyModel)
 {
     m_changesFlags |= change;
 
     if (notifyModel) {
         // Notify the TransferTreeModel
         m_transfer->model()->postDataChangedEvent(this);
 
         m_kjobAdapter->slotUpdateDescription();
     }
 }
 
 QList<QAction *> TransferHandler::contextActions()
 {
     QList<QAction *> actions;
     if (status() != Job::Finished) {
         actions << KGet::actionCollection()->action("start_selected_download") << KGet::actionCollection()->action("stop_selected_download");
     }
     actions << KGet::actionCollection()->action("delete_selected_download") << KGet::actionCollection()->action("redownload_selected_download")
             << KGet::actionCollection()->action("select_all");
 
     return actions;
 }
 
 QList<QAction *> TransferHandler::factoryActions()
 {
     QList<QAction *> actions;
     foreach (QAction *action, m_transfer->factory()->actions(this))
         actions.append(action);
     return actions;
 }
 
 #include "moc_transferhandler.cpp"