kget.h

Go to the documentation of this file.

/* This file is part of the KDE project

   Copyright (C) 2005 Dario Massarin <nekkar@libero.it>
   Copyright (C) 2009 Lukas Appelhans <l.appelhans@gmx.de>
   Copyright (C) 2009 Matthias Fuchs <mat69@gmx.net>

   Based on:
       kmainwidget.{h,cpp}
       Copyright (C) 2002 by Patrick Charbonnier <pch@freeshell.org>
       that was based On Caitoo v.0.7.3 (c) 1998 - 2000, Matej Koss

   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 KGET_H
#define KGET_H

#include <kservice.h>
#include <kurl.h>
#include <kactioncollection.h>
#include <KNotification>
#include <ktabwidget.h>

#include <Solid/Networking>
#include <QtXml/QDomElement>

#include "kuiserverjobs.h"
#include "scheduler.h"
#include "../kget_export.h"
#include "transfer.h"
#include "transfergrouphandler.h"

class QDomElement;
class QAbstractItemView;

class KComboBox;

class TransferDataSource;
class TransferGroup;
class TransferHandler;
class TransferFactory;
class TransferTreeModel;
class TransferTreeSelectionModel;
class KGetPlugin;
class MainWindow;
class NewTransferDialog;
class TransferGroupScheduler;
class TransferHistoryStore;

#ifdef HAVE_NEPOMUK
class NepomukController;
#endif

class KGET_EXPORT KGet
{
    friend class NewTransferDialog;
    friend class NewTransferDialogHandler;
    friend class GenericObserver;
    friend class TransferTreeModel;
    friend class UrlChecker;
    public:
        enum AfterFinishAction {
            Quit = 0,
            Shutdown = 1,
            Hibernate = 2,
            Suspend = 3
        };
        enum DeleteMode {
            AutoDelete,
            DeleteFiles
        };
        ~KGet();

        static KGet* self( MainWindow * mainWindow=0 );

        static bool addGroup(const QString& groupName);

        static void delGroup(TransferGroupHandler * group, bool askUser = true);
        
        static void delGroups(QList<TransferGroupHandler*> groups, bool askUser = true);

        static void renameGroup(const QString& oldName, const QString& newName);

        static QStringList transferGroupNames();

        static TransferHandler * addTransfer(KUrl srcUrl, QString destDir = QString(), QString suggestedFileName = QString(),
                                             QString groupName = QString(), bool start = false);

        static QList<TransferHandler*> addTransfers(const QList<QDomElement> &elements, const QString &groupName = QString());

        static const QList<TransferHandler *> addTransfer(KUrl::List srcUrls, QString destDir = QString(),
                                                          QString groupName = QString(), bool start=false);

        static bool delTransfer(TransferHandler * transfer, DeleteMode mode = AutoDelete);

        static bool delTransfers(const QList<TransferHandler*> &transfers, DeleteMode mode = AutoDelete);

        static void moveTransfer(TransferHandler * transfer, const QString& groupName);

        static void redownloadTransfer(TransferHandler * transfer);

        static QList<TransferHandler *> selectedTransfers();

        static QList<TransferHandler *> finishedTransfers();

        static QList<TransferGroupHandler *>
        selectedTransferGroups();

        static TransferTreeModel * model();
        
        static TransferTreeSelectionModel * selectionModel();

        static void load( QString filename=QString() );

        static void save( QString filename=QString(), bool plain=false );
        
        static QList<TransferFactory*> factories();

        static TransferFactory * factory(TransferHandler * transfer);

        static KActionCollection * actionCollection();

        static void setSchedulerRunning(bool running=true);

        static bool schedulerRunning();

        static void setSuspendScheduler(bool isSuspended);

        static QList<TransferHandler*> allTransfers();

        static QList<TransferGroupHandler*> allTransferGroups();

        static TransferHandler * findTransfer(const KUrl &src);
        
        static TransferGroupHandler * findGroup(const QString &name);

        static void checkSystemTray();

        static void settingsChanged();

        static QList<TransferGroupHandler*> groupsFromExceptions(const KUrl &filename);

        static bool matchesExceptions(const KUrl &sourceUrl, const QStringList &patterns);

        static TransferDataSource * createTransferDataSource(const KUrl &src, const QDomElement &type = QDomElement(), QObject *parent = 0);

        static void setGlobalDownloadLimit(int limit);

        static void setGlobalUploadLimit(int limit);

        static void calculateGlobalSpeedLimits();

        static void calculateGlobalDownloadLimit();

        static void calculateGlobalUploadLimit();


        static KNotification *showNotification(QWidget *parent, const QString &eventType,
                                               const QString &text,
                                               const QString &icon = QString("dialog-error"),
                                               const QString &title = i18n("KGet"),
                                               const KNotification::NotificationFlags &flags = KNotification::CloseOnTimeout);

        static void loadPlugins();

        static QString generalDestDir(bool preferXDGDownloadDir = false);

#ifdef HAVE_NEPOMUK
        static NepomukController *nepomukController();
#endif

    private:
        KGet();

        class TransferData;

        static TransferHandler * createTransfer(const KUrl &src, const KUrl &dest, const QString& groupName = QString(), bool start = false, const QDomElement * e = 0);

        static QList<TransferHandler*> createTransfers(const QList<TransferData> &transferData);

        static KUrl urlInputDialog();
        static QString destDirInputDialog();
        static KUrl destFileInputDialog(QString destDir = QString(), const QString& suggestedFileName = QString());

        static bool isValidSource(const KUrl &source);
        static bool isValidDestDirectory(const QString& destDir);

        static KUrl getValidDestUrl(const KUrl& destDir, const KUrl &srcUrl);

        //Plugin-related functions
        static KGetPlugin * createPluginFromService( const KService::Ptr &service );

        static void setHasNetworkConnection(bool hasConnection);

        static bool safeDeleteFile( const KUrl& url );

        //Interview models
        static TransferTreeModel * m_transferTreeModel;
        static TransferTreeSelectionModel * m_selectionModel;

        //Lists of available plugins
        static QList<TransferFactory *> m_transferFactories;

        //pointer to the Main window
        static MainWindow * m_mainWindow;

        //Scheduler object
        static TransferGroupScheduler * m_scheduler;

        //pointer to the kget uiserver jobs manager
        static KUiServerJobs *m_jobManager;

        //pointer to the used TransferHistoryStore
        static TransferHistoryStore *m_store;

        static bool m_hasConnection;

#ifdef HAVE_NEPOMUK
        static NepomukController *m_nepomukController;
#endif
};

class KGET_EXPORT KGet::TransferData
{
    public:
        TransferData(const KUrl &src, const KUrl &dest, const QString &groupName = QString(), bool start = false, const QDomElement *e = 0);

        KUrl src;
        KUrl dest;
        QString groupName;
        bool start;
        const QDomElement *e;
};

class GenericObserver : public QObject
{
    Q_OBJECT
    public:
        GenericObserver(QObject *parent = 0);
        virtual ~GenericObserver ();

    public slots:
        void groupAddedEvent(TransferGroupHandler *handler);
        void groupRemovedEvent(TransferGroupHandler *handler);
        void transfersAddedEvent(const QList<TransferHandler*> &handlers);
        void transfersRemovedEvent(const QList<TransferHandler*> &handlers);
        void transfersChangedEvent(QMap<TransferHandler*, Transfer::ChangesFlags> transfers);
        void groupsChangedEvent(QMap<TransferGroupHandler*, TransferGroup::ChangesFlags> groups);
        void transferMovedEvent(TransferHandler *, TransferGroupHandler *);

    private slots:
        void slotSave();
        void slotAfterFinishAction();
        void slotAbortAfterFinishAction();
        void slotResolveTransferError();
        void slotNotificationClosed();
        void slotNetworkStatusChanged(const Solid::Networking::Status &status);

    private:
        bool allTransfersFinished();

        void requestSave();

    private:
        QTimer *m_save;
        QTimer *m_finishAction;
        QHash<KNotification*, TransferHandler*> m_notifications;
};
#endif