transfer.h

Go to the documentation of this file.

/* This file is part of the KDE project

   Copyright (C) 2004 Dario Massarin <nekkar@libero.it>
   Copyright (C) 2008 - 2011 Lukas Appelhans <l.appelhans@gmx.de>

   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.
*/

#ifndef TRANSFER_H
#define TRANSFER_H

#include "job.h"
#include "../kget_export.h"

#include <QPixmap>
#include <QTime>

#include <kurl.h>
#include <kio/global.h>

class QDomElement;

class Signature;
class TransferHandler;
class TransferFactory;
class TransferGroup;
class Scheduler;
class TransferTreeModel;
class NepomukHandler;
class FileModel;
class Verifier;

class KGET_EXPORT Transfer : public Job
{
    Q_OBJECT
    friend class TransferHandler;
    friend class TransferTreeModel;
    public:

        enum TransferChange
        {
            Tc_None           = 0x00000000,
            // These flags respect the Model columns order NOTE: The model only checks the last 8 bits, so all values which need to be updated by the model should look like: 0x000000xx
            Tc_Source         = 0x00000001,
            Tc_FileName       = 0x00000002,
            Tc_Status         = 0x00000004,
            Tc_TotalSize      = 0x00000008,
            Tc_Percent        = 0x00000010,
            Tc_DownloadSpeed  = 0x00000020,
            Tc_RemainingTime  = 0x00000040,
            // Misc
            Tc_UploadSpeed    = 0x00000100,
            Tc_UploadLimit    = 0x00000200,
            Tc_DownloadLimit  = 0x00000400,
            Tc_CanResume      = 0x00000800,
            Tc_DownloadedSize = 0x00001000,
            Tc_UploadedSize   = 0x00002000,
            Tc_Log            = 0x00004000,
            Tc_Group          = 0x00008000,
            Tc_Selection      = 0x00010000
        };

        enum Capability
        {
            Cap_SpeedLimit = 0x00000001,
            Cap_MultipleMirrors = 0x00000002,
            Cap_Resuming = 0x00000004,
            Cap_Renaming = 0x00000008,
            Cap_Moving = 0x00000010,
            Cap_FindFilesize = 0x00000020
        };
        Q_DECLARE_FLAGS(Capabilities, Capability)

        enum LogLevel
        {
            Log_Info,
            Log_Warning,
            Log_Error
        };

        enum SpeedLimit
        {
            VisibleSpeedLimit   = 0x01,
            InvisibleSpeedLimit = 0x02
        };
        
        enum DeleteOption
        {
            DeleteTemporaryFiles = 0x00000001,
            DeleteFiles = 0x00000002
        };
        Q_DECLARE_FLAGS(DeleteOptions, DeleteOption)
        typedef int ChangesFlags;

        Transfer(TransferGroup * parent, TransferFactory * factory,
                 Scheduler * scheduler, const KUrl & src, const KUrl & dest,
                 const QDomElement * e = 0);

        virtual ~Transfer();

        Capabilities capabilities() const {return m_capabilities;}

        void create();
        
        void destroy(DeleteOptions options);
        
        virtual void init();

        virtual void deinit(DeleteOptions options) {Q_UNUSED(options);}

        virtual bool repair(const KUrl &file = KUrl()) {Q_UNUSED(file) return false;}

        const KUrl & source() const            {return m_source;}
        const KUrl & dest() const              {return m_dest;}

        virtual QList<KUrl> files() const {return QList<KUrl>() << m_dest;}

        virtual KUrl directory() const {return m_dest.upUrl();}

        virtual bool setDirectory(const KUrl &newDirectory);

        //Transfer status
        KIO::filesize_t totalSize() const      {return m_totalSize;}
        KIO::filesize_t downloadedSize() const {return m_downloadedSize;}
        KIO::filesize_t uploadedSize() const   {return m_uploadedSize;}
        QString statusText() const             {return m_statusText;}
        QPixmap statusPixmap() const           {return (error().pixmap.isNull() ? m_statusPixmap : error().pixmap);}

        static QString statusText(Job::Status status);
        static QPixmap statusPixmap(Job::Status status);

        int percent() const                    {return m_percent;}
        int downloadSpeed() const              {return m_downloadSpeed;}
        int averageDownloadSpeed() const;
        int uploadSpeed() const                {return m_uploadSpeed;}
        virtual int remainingTime() const      {return KIO::calculateRemainingSeconds(totalSize(), downloadedSize(), downloadSpeed());}
        virtual int elapsedTime() const;
        virtual bool isStalled() const         {return (status() == Job::Running && downloadSpeed() == 0);}
        virtual bool isWorking() const         {return downloadSpeed() > 0;}

        virtual QHash<KUrl, QPair<bool, int> > availableMirrors(const KUrl &file) const;

        virtual void setAvailableMirrors(const KUrl &file, const QHash<KUrl, QPair<bool, int> > &mirrors) {Q_UNUSED(file) Q_UNUSED(mirrors)}

        void setUploadLimit(int ulLimit, SpeedLimit limit);

        void setDownloadLimit(int dlLimit, SpeedLimit limit);

        int uploadLimit(SpeedLimit limit) const;

        int downloadLimit(SpeedLimit limit) const;

        void setMaximumShareRatio(double ratio);

        double maximumShareRatio() {return m_ratio;}

        void checkShareRatio();

        bool isSelected() const             {return m_isSelected;}

        const QStringList log() const;

        bool operator<(const Transfer& t2) const;

        TransferGroup * group() const   {return (TransferGroup *) m_jobQueue;}

        TransferHandler * handler();

        TransferTreeModel * model();

        TransferFactory * factory() const   {return m_factory;}

        virtual FileModel * fileModel() {return 0;}

        virtual Verifier * verifier(const KUrl &file) {Q_UNUSED(file) return 0;}

        virtual Signature * signature(const KUrl &file) {Q_UNUSED(file) return 0;}

#ifdef HAVE_NEPOMUK

        void setNepomukHandler(NepomukHandler *handler);

        NepomukHandler * nepomukHandler() {return m_nepomukHandler;}
#endif

        virtual void save(const QDomElement &element);

        virtual void load(const QDomElement *element);

    signals:
        void capabilitiesChanged();

    public slots:
         void setLog(const QString& message, Transfer::LogLevel level = Log_Info);

    protected:
        void setStatus(Job::Status jobStatus, const QString &text = QString(), const QPixmap &pix = QPixmap());

        void setCapabilities(Capabilities capabilities);

        virtual void setTransferChange(ChangesFlags change, bool postEvent=false);

        virtual void setSpeedLimits(int uploadLimit, int downloadLimit) {Q_UNUSED(uploadLimit) Q_UNUSED(downloadLimit) }

        // --- Transfer information ---
        KUrl m_source;
        KUrl m_dest;

        QStringList   m_log;
        KIO::filesize_t m_totalSize;
        KIO::filesize_t m_downloadedSize;
        KIO::filesize_t m_uploadedSize;
        int           m_percent;
        int           m_downloadSpeed;
        int           m_uploadSpeed;

        int           m_uploadLimit;
        int           m_downloadLimit;

        bool m_isSelected;

    private:
        Capabilities m_capabilities;
        int m_visibleUploadLimit;
        int m_visibleDownloadLimit;
        int m_runningSeconds;
        double m_ratio;

        QString m_statusText;
        QPixmap m_statusPixmap;
        QTime m_runningTime;

        TransferHandler * m_handler;
        TransferFactory * m_factory;
#ifdef HAVE_NEPOMUK
        NepomukHandler * m_nepomukHandler;
#endif
};

Q_DECLARE_OPERATORS_FOR_FLAGS(Transfer::Capabilities)
Q_DECLARE_OPERATORS_FOR_FLAGS(Transfer::DeleteOptions)

#endif