jobclasses.h

Go to the documentation of this file.

// -*- c++ -*-
/* This file is part of the KDE libraries
    Copyright (C) 2000 Stephan Kulow <coolo@kde.org>
                  2000-2009 David Faure <faure@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef KIO_JOBCLASSES_H
#define KIO_JOBCLASSES_H

#include <QtCore/QObject>
#include <QtCore/QLinkedList> // KDE5: remove
#include <QtCore/QStringList>

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

#include <kcompositejob.h>

namespace KIO {

    enum JobFlag {
      DefaultFlags = 0,

      HideProgressInfo = 1,

      Resume = 2,

      Overwrite = 4
    };
    Q_DECLARE_FLAGS(JobFlags, JobFlag)
    Q_DECLARE_OPERATORS_FOR_FLAGS(JobFlags)

    class JobUiDelegate;

    class JobPrivate;
    class KIO_EXPORT Job : public KCompositeJob {
        Q_OBJECT

    protected:
        Job();
        Job(JobPrivate &dd);

    public:
        virtual ~Job();
        void start() {} // Since KIO autostarts its jobs

        JobUiDelegate *ui() const;

    protected:
        virtual bool doKill();

        virtual bool doSuspend();

        virtual bool doResume();

    public:
        QString errorString() const;

        QStringList detailedErrorStrings(const KUrl *reqUrl = 0L,
                                         int method = -1) const;

#ifndef KDE_NO_DEPRECATED
        KDE_DEPRECATED void showErrorDialog( QWidget *parent = 0 );
#endif

        bool isInteractive() const;

        void setParentJob( Job* parentJob );

        Job* parentJob() const;

        void setMetaData( const KIO::MetaData &metaData);

        void addMetaData(const QString &key, const QString &value);

        void addMetaData(const QMap<QString,QString> &values);

        void mergeMetaData(const QMap<QString,QString> &values);

        MetaData outgoingMetaData() const;

        MetaData metaData() const;

        QString queryMetaData(const QString &key);

    protected:

    Q_SIGNALS:
        void canceled( KJob *job );

        void connected( KIO::Job *job );

    protected:
        virtual bool addSubjob( KJob *job );

        virtual bool removeSubjob( KJob *job );

    private:
        Q_PRIVATE_SLOT(d_func(), void slotSpeed( KJob *job, unsigned long speed ))
        Q_DECLARE_PRIVATE(Job)
    };

    class SimpleJobPrivate;
    class KIO_EXPORT SimpleJob : public KIO::Job {
    Q_OBJECT

    public:
        ~SimpleJob();

    protected:
        virtual bool doSuspend();

        virtual bool doResume();

        virtual bool doKill();

    public:
        const KUrl& url() const;

        virtual void putOnHold();

        static void removeOnHold();

        bool isRedirectionHandlingEnabled() const;

        void setRedirectionHandlingEnabled(bool handle);

    public Q_SLOTS:
        void slotError( int , const QString & );

    protected Q_SLOTS:
        virtual void slotFinished( );

        virtual void slotWarning( const QString & );

        virtual void slotMetaData( const KIO::MetaData &_metaData);

    protected:
        /*
         * Allow jobs that inherit SimpleJob and are aware
         * of redirections to store the SSL session used.
         * Retrieval is handled by SimpleJob::start
         * @param m_redirectionURL Reference to redirection URL,
         * used instead of m_url if not empty
         */
        void storeSSLSessionFromJob(const KUrl &m_redirectionURL);

        SimpleJob(SimpleJobPrivate &dd);
    private:
        Q_PRIVATE_SLOT(d_func(), void slotConnected())
        Q_PRIVATE_SLOT(d_func(), void slotProcessedSize( KIO::filesize_t data_size ))
        Q_PRIVATE_SLOT(d_func(), void slotSpeed( unsigned long speed ))
        Q_PRIVATE_SLOT(d_func(), void slotTotalSize( KIO::filesize_t data_size ))
        Q_PRIVATE_SLOT(d_func(), void _k_slotSlaveInfoMessage(const QString&))

        Q_DECLARE_PRIVATE(SimpleJob)
    };

    class StatJobPrivate;
    class KIO_EXPORT StatJob : public SimpleJob {

    Q_OBJECT

    public:
        enum StatSide {
            SourceSide,
            DestinationSide
        };

        ~StatJob();

        void setSide(StatSide side);

#ifndef KDE_NO_DEPRECATED
        KDE_DEPRECATED void setSide( bool source );
#endif

        void setDetails( short int details );

        const UDSEntry & statResult() const;

        KUrl mostLocalUrl() const;

    Q_SIGNALS:
        void redirection( KIO::Job *job, const KUrl &url );

        void permanentRedirection( KIO::Job *job, const KUrl &fromUrl, const KUrl &toUrl );

    protected Q_SLOTS:
        virtual void slotFinished();
        virtual void slotMetaData( const KIO::MetaData &_metaData);
    protected:
        StatJob(StatJobPrivate &dd);

    private:
        Q_PRIVATE_SLOT(d_func(), void slotStatEntry( const KIO::UDSEntry & entry ))
        Q_PRIVATE_SLOT(d_func(), void slotRedirection( const KUrl &url))
        Q_DECLARE_PRIVATE(StatJob)
    };

    class FileCopyJobPrivate;
    class TransferJobPrivate;
    class KIO_EXPORT TransferJob : public SimpleJob {
    Q_OBJECT

    public:
        ~TransferJob();

        void setModificationTime( const QDateTime& mtime );

        bool isErrorPage() const;

        void setAsyncDataEnabled(bool enabled);

        void sendAsyncData(const QByteArray &data);

#ifndef KDE_NO_DEPRECATED
        KDE_DEPRECATED void setReportDataSent(bool enabled);
#endif

#ifndef KDE_NO_DEPRECATED
        KDE_DEPRECATED bool reportDataSent() const;
#endif

        QString mimetype() const;

        void setTotalSize(KIO::filesize_t bytes);

    protected:
        virtual void slotResult( KJob *job );

        virtual bool doResume();

    Q_SIGNALS:
        void data( KIO::Job *job, const QByteArray &data );

        void dataReq( KIO::Job *job, QByteArray &data );

        void redirection( KIO::Job *job, const KUrl &url );

        void permanentRedirection( KIO::Job *job, const KUrl &fromUrl, const KUrl &toUrl );

        void mimetype( KIO::Job *job, const QString &type );

        void canResume( KIO::Job *job, KIO::filesize_t offset );


    protected Q_SLOTS:
        virtual void slotRedirection( const KUrl &url);
        virtual void slotFinished();
        virtual void slotData( const QByteArray &data);
        virtual void slotDataReq();
        virtual void slotMimetype( const QString &mimetype );
        virtual void slotMetaData( const KIO::MetaData &_metaData);

    protected:
        TransferJob(TransferJobPrivate &dd);
    private:
        Q_PRIVATE_SLOT(d_func(), void slotErrorPage())
        Q_PRIVATE_SLOT(d_func(), void slotCanResume( KIO::filesize_t offset ))
        Q_PRIVATE_SLOT(d_func(), void slotPostRedirection())
        Q_PRIVATE_SLOT(d_func(), void slotNeedSubUrlData())
        Q_PRIVATE_SLOT(d_func(), void slotSubUrlData(KIO::Job*, const QByteArray &))
        Q_PRIVATE_SLOT(d_func(), void slotDataReqFromDevice())
        Q_DECLARE_PRIVATE(TransferJob)

        // A FileCopyJob may control one or more TransferJobs
        friend class FileCopyJob;
        friend class FileCopyJobPrivate;
    };

    class StoredTransferJobPrivate;
    class KIO_EXPORT StoredTransferJob : public KIO::TransferJob {
        Q_OBJECT

    public:
        ~StoredTransferJob();

        void setData( const QByteArray& arr );

        QByteArray data() const;

    protected:
        StoredTransferJob(StoredTransferJobPrivate &dd);
    private:
        Q_PRIVATE_SLOT(d_func(), void slotStoredData( KIO::Job *job, const QByteArray &data ))
        Q_PRIVATE_SLOT(d_func(), void slotStoredDataReq( KIO::Job *job, QByteArray &data ))

        Q_DECLARE_PRIVATE(StoredTransferJob)
    };

    class MultiGetJobPrivate;
    class KIO_EXPORT MultiGetJob : public TransferJob {
    Q_OBJECT

    public:
        virtual ~MultiGetJob();

        void get(long id, const KUrl &url, const MetaData &metaData);

    Q_SIGNALS:
        void data( long id, const QByteArray &data);

        void mimetype( long id, const QString &type );

        void result( long id);

    protected Q_SLOTS:
        virtual void slotRedirection( const KUrl &url);
        virtual void slotFinished();
        virtual void slotData( const QByteArray &data);
        virtual void slotMimetype( const QString &mimetype );

    protected:
        MultiGetJob(MultiGetJobPrivate &dd);
    private:
        Q_DECLARE_PRIVATE(MultiGetJob)
    };

    class MimetypeJobPrivate;
    class KIO_EXPORT MimetypeJob : public TransferJob {
    Q_OBJECT

    public:
        ~MimetypeJob();

    protected Q_SLOTS:
        virtual void slotFinished( );
    protected:
        MimetypeJob(MimetypeJobPrivate &dd);
    private:
        Q_DECLARE_PRIVATE(MimetypeJob)
    };

    class KIO_EXPORT FileCopyJob : public Job {
    Q_OBJECT

    public:
        ~FileCopyJob();
        void setSourceSize(KIO::filesize_t size);

        void setModificationTime( const QDateTime& mtime );

        KUrl srcUrl() const;

        KUrl destUrl() const;

        bool doSuspend();
        bool doResume();

    Q_SIGNALS:
        void mimetype( KIO::Job *job, const QString &type );

    protected Q_SLOTS:
        virtual void slotResult( KJob *job );

    protected:
        FileCopyJob(FileCopyJobPrivate &dd);

    private:
        Q_PRIVATE_SLOT(d_func(), void slotStart())
        Q_PRIVATE_SLOT(d_func(), void slotData( KIO::Job *, const QByteArray &data))
        Q_PRIVATE_SLOT(d_func(), void slotDataReq( KIO::Job *, QByteArray &data))
        Q_PRIVATE_SLOT(d_func(), void slotMimetype( KIO::Job*, const QString& type ))
        Q_PRIVATE_SLOT(d_func(), void slotProcessedSize( KJob *job, qulonglong size ))
        Q_PRIVATE_SLOT(d_func(), void slotTotalSize( KJob *job, qulonglong size ))
        Q_PRIVATE_SLOT(d_func(), void slotPercent( KJob *job, unsigned long pct ))
        Q_PRIVATE_SLOT(d_func(), void slotCanResume( KIO::Job *job, KIO::filesize_t offset ))

        Q_DECLARE_PRIVATE(FileCopyJob)
    };

    class ListJobPrivate;
    class KIO_EXPORT ListJob : public SimpleJob {
    Q_OBJECT

    public:
        ~ListJob();

        const KUrl& redirectionUrl() const;

        void setUnrestricted(bool unrestricted);

    Q_SIGNALS:
        void entries( KIO::Job *job, const KIO::UDSEntryList& list); // TODO KDE5: use KIO::ListJob* argument to avoid casting

        void redirection( KIO::Job *job, const KUrl &url );

        void permanentRedirection( KIO::Job *job, const KUrl &fromUrl, const KUrl &toUrl );

    protected Q_SLOTS:
        virtual void slotFinished( );
        virtual void slotMetaData( const KIO::MetaData &_metaData);
        virtual void slotResult( KJob *job );

    protected:
        ListJob(ListJobPrivate &dd);

    private:
        Q_PRIVATE_SLOT(d_func(), void slotListEntries( const KIO::UDSEntryList& list ))
        Q_PRIVATE_SLOT(d_func(), void slotRedirection( const KUrl &url ))
        Q_PRIVATE_SLOT(d_func(), void gotEntries( KIO::Job * subjob, const KIO::UDSEntryList& list ))
        Q_DECLARE_PRIVATE(ListJob)
    };

    class SpecialJobPrivate;
    class KIO_EXPORT SpecialJob : public TransferJob
    {
        Q_OBJECT
    public:
        explicit SpecialJob(const KUrl &url, const QByteArray &data = QByteArray());

        void setArguments(const QByteArray &data);

        QByteArray arguments() const;

    public:
        ~SpecialJob();

    private:
        Q_DECLARE_PRIVATE(SpecialJob)
    };
}

#endif