jobclasses.h

/* This file is part of the KDE libraries
    Copyright (C) 2000 Stephan Kulow <coolo@kde.org>
                       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 __tdeio_jobclasses_h__
#define __tdeio_jobclasses_h__
 
#include <tqobject.h>
#include <tqptrlist.h>
#include <tqstring.h>
#include <tqstringlist.h>
#include <tqguardedptr.h>
 
#include <sys/types.h>
#include <sys/stat.h>
 
#include <kurl.h>
#include <tdeio/global.h>
 
class Observer;
class TQTimer;
 
#define TDEIO_COPYJOB_HAS_SETINTERACTIVE // new in 3.4. Used by tdeio_trash.
 
namespace TDEIO {
 
    class Slave;
    class SlaveInterface;
 

    class TDEIO_EXPORT Job : public TQObject {
        TQ_OBJECT
 
    protected:
        Job( bool showProgressInfo );
 
    public:
        virtual ~Job();

        virtual void kill( bool quietly = true );

        int error() const { return m_error; }

        int progressId() const { return m_progressId; }

        const TQString & errorText() const { return m_errorText; }

        TQString errorString() const;

        TQStringList detailedErrorStrings(const KURL *reqUrl = 0L,
                                         int method = -1) const;

        void showErrorDialog( TQWidget * parent = 0L );

        void setAutoErrorHandlingEnabled( bool enable, TQWidget *parentWidget = 0 );

        bool isAutoErrorHandlingEnabled() const;

        void setAutoWarningHandlingEnabled( bool enable );

        bool isAutoWarningHandlingEnabled() const;

        void setInteractive(bool enable);

        bool isInteractive() const;
        void setWindow(TQWidget *window);

        TQWidget *window() const;

        void updateUserTimestamp( unsigned long time );

        void setParentJob( Job* parentJob );

        Job* parentJob() const;

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

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

        void addMetaData(const TQMap<TQString,TQString> &values);

        void mergeMetaData(const TQMap<TQString,TQString> &values);

        MetaData outgoingMetaData() const;

        MetaData metaData() const;

        TQString queryMetaData(const TQString &key);

        TDEIO::filesize_t getProcessedSize();
 
    signals:
        void result( TDEIO::Job *job );

        void canceled( TDEIO::Job *job );

        void infoMessage( TDEIO::Job *job, const TQString & msg );
        // KDE4: Separate rich-text string from plain-text string, for different widgets.

        void warning( TDEIO::Job *job, const TQString & msg );
        // KDE4: Separate rich-text string from plain-text string, for different widgets.

        void connected( TDEIO::Job *job );

        void percent( TDEIO::Job *job, unsigned long percent );

        void totalSize( TDEIO::Job *job, TDEIO::filesize_t size );

        void processedSize( TDEIO::Job *job, TDEIO::filesize_t size );

        void speed( TDEIO::Job *job, unsigned long speed );
 
    protected slots:
        virtual void slotResult( TDEIO::Job *job );

        void slotSpeed( TDEIO::Job *job, unsigned long speed );
        void slotInfoMessage( TDEIO::Job *job, const TQString &msg );

        void slotSpeedTimeout();
 
    protected:
        virtual void addSubjob( Job *job, bool inheritMetaData=true );

        virtual void removeSubjob( Job *job );
        void removeSubjob( Job *job, bool mergeMetaData, bool emitResultIfLast ); // KDE4: merge with above, with =true to both

        void emitPercent( TDEIO::filesize_t processedSize, TDEIO::filesize_t totalSize );

        void emitSpeed( unsigned long speed );

        void emitResult();

        void setProcessedSize(TDEIO::filesize_t size);

        unsigned long userTimestamp() const;

        enum { EF_TransferJobAsync    = (1 << 0),
               EF_TransferJobNeedData = (1 << 1),
               EF_TransferJobDataSent = (1 << 2),
               EF_ListJobUnrestricted = (1 << 3) };
        int &extraFlags();
 
        TQPtrList<Job> subjobs;
        int m_error;
        TQString m_errorText;
        unsigned long m_percent;
        int m_progressId; // for uiserver
        TQTimer *m_speedTimer;
        TQGuardedPtr<TQWidget> m_window;
        MetaData m_outgoingMetaData;
        MetaData m_incomingMetaData;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
        class JobPrivate;
        JobPrivate *d;
    };

    class TDEIO_EXPORT SimpleJob : public TDEIO::Job {
    TQ_OBJECT
 
    public:
        SimpleJob(const KURL& url, int command, const TQByteArray &packedArgs,
                  bool showProgressInfo);
 
        ~SimpleJob();

        const KURL& url() const { return m_url; }

        virtual void kill( bool quietly = true );

        virtual void putOnHold();

        static void removeOnHold();

        virtual void start( Slave *slave );

        void slaveDone();

        Slave *slave() const { return m_slave; }

        int command() const { return m_command; }
 
    public slots:
        void slotTotalSize( TDEIO::filesize_t data_size );
 
    protected slots:
        virtual void slotFinished( );

        void slotWarning( const TQString & ); // KDE4: make virtual

        void slotInfoMessage( const TQString &s ); // KDE4: make virtual

        void slotConnected();

        void slotProcessedSize( TDEIO::filesize_t data_size );
        void slotSpeed( unsigned long speed );

        virtual void slotMetaData( const TDEIO::MetaData &_metaData);
 
    public slots:
        virtual void slotError( int , const TQString & );
 
    protected slots:
        void slotNeedProgressId();
 
    protected:
        Slave * m_slave;
        TQByteArray m_packedArgs;
        KURL m_url;
        KURL m_subUrl;
        int m_command;
        TDEIO::filesize_t m_totalSize;
    protected:
    virtual void virtual_hook( int id, void* data );
    /*
     * 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);
    private:
    class SimpleJobPrivate* d;
    };

    class TDEIO_EXPORT StatJob : public SimpleJob {
 
    TQ_OBJECT
 
    public:
        StatJob(const KURL& url, int command, const TQByteArray &packedArgs, bool showProgressInfo);

        void setSide( bool source ) { m_bSource = source; }

        void setDetails( short int details ) { m_details = details; }

        const UDSEntry & statResult() const { return m_statResult; }

        virtual void start( Slave *slave );
 
    signals:
        void redirection( TDEIO::Job *job, const KURL &url );

        void permanentRedirection( TDEIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
 
    protected slots:
        void slotStatEntry( const TDEIO::UDSEntry & entry );
        void slotRedirection( const KURL &url);
        virtual void slotFinished();
        virtual void slotMetaData( const TDEIO::MetaData &_metaData);
 
    protected:
        UDSEntry m_statResult;
        KURL m_redirectionURL;
        bool m_bSource;
        short int m_details;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
        class StatJobPrivate;
        StatJobPrivate *d;
    };

    class TDEIO_EXPORT MkdirJob : public SimpleJob {
 
    TQ_OBJECT
 
    public:
        MkdirJob(const KURL& url, int command, const TQByteArray &packedArgs, bool showProgressInfo);

        virtual void start( Slave *slave );
 
    signals:
        void redirection( TDEIO::Job *job, const KURL &url );

        void permanentRedirection( TDEIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
 
    protected slots:
        void slotRedirection( const KURL &url);
        virtual void slotFinished();
 
    protected:
        KURL m_redirectionURL;
 
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
        class MkdirJobPrivate;
        MkdirJobPrivate *d;
    };

    class TDEIO_EXPORT DirectCopyJob : public SimpleJob {
    TQ_OBJECT
 
    public:
        DirectCopyJob(const KURL& url, int command, const TQByteArray &packedArgs,
                      bool showProgressInfo);
        virtual void start(Slave *slave);
 
    signals:
        void canResume( TDEIO::Job *job, TDEIO::filesize_t offset );
 
    private slots:
        void slotCanResume( TDEIO::filesize_t offset );
    };
 

    class TDEIO_EXPORT TransferJob : public SimpleJob {
    TQ_OBJECT
 
    public:
        TransferJob(const KURL& url, int command,
                    const TQByteArray &packedArgs,
                    const TQByteArray &_staticData,
                    bool showProgressInfo);

        virtual void start(Slave *slave);

        virtual void slotResult( TDEIO::Job *job );

        void suspend();

        void resume();

    bool isSuspended() const { return m_suspended; }
 

        bool isErrorPage() const { return m_errorPage; }

        void setAsyncDataEnabled(bool enabled);

        void sendAsyncData(const TQByteArray &data);

        void setReportDataSent(bool enabled);

        bool reportDataSent();
 
    signals:
        void data( TDEIO::Job *job, const TQByteArray &data );

        void dataReq( TDEIO::Job *job, TQByteArray &data );

        void redirection( TDEIO::Job *job, const KURL &url );

        void permanentRedirection( TDEIO::Job *job, const KURL &fromUrl, const KURL &toUrl );

        void mimetype( TDEIO::Job *job, const TQString &type );

        void canResume( TDEIO::Job *job, TDEIO::filesize_t offset );
 
 
    protected slots:
        virtual void slotRedirection( const KURL &url);
        virtual void slotFinished();
        virtual void slotData( const TQByteArray &data);
        virtual void slotDataReq();
        virtual void slotMimetype( const TQString &mimetype );
        virtual void slotNeedSubURLData();
        virtual void slotSubURLData(TDEIO::Job*, const TQByteArray &);
        virtual void slotMetaData( const TDEIO::MetaData &_metaData);
        void slotErrorPage();
        void slotCanResume( TDEIO::filesize_t offset );
        void slotPostRedirection();
 
    protected:
        bool m_suspended;
        bool m_errorPage;
        TQByteArray staticData;
        KURL m_redirectionURL;
        KURL::List m_redirectionList;
        TQString m_mimetype;
        TransferJob *m_subJob;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class TransferJobPrivate *d;
    };

    class TDEIO_EXPORT StoredTransferJob : public TDEIO::TransferJob {
        TQ_OBJECT
 
    public:
        StoredTransferJob(const KURL& url, int command,
                          const TQByteArray &packedArgs,
                          const TQByteArray &_staticData,
                          bool showProgressInfo);

        void setData( const TQByteArray& arr );

        TQByteArray data() const { return m_data; }
 
    private slots:
        void slotStoredData( TDEIO::Job *job, const TQByteArray &data );
        void slotStoredDataReq( TDEIO::Job *job, TQByteArray &data );
    private:
        TQByteArray m_data;
        int m_uploadOffset;
    };

    class TDEIO_EXPORT MultiGetJob : public TransferJob {
    TQ_OBJECT
 
    public:
        MultiGetJob(const KURL& url, bool showProgressInfo);

         virtual void start(Slave *slave);

        void get(long id, const KURL &url, const MetaData &metaData);
 
    signals:
        void data( long id, const TQByteArray &data);

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

        void result( long id);
 
    protected slots:
        virtual void slotRedirection( const KURL &url);
        virtual void slotFinished();
        virtual void slotData( const TQByteArray &data);
        virtual void slotMimetype( const TQString &mimetype );
    private:
        struct GetRequest {
        public:
           GetRequest(long _id, const KURL &_url, const MetaData &_metaData)
             : id(_id), url(_url), metaData(_metaData) { }
           long id;
           KURL url;
           MetaData metaData;
        };
        bool findCurrentEntry();
        void flushQueue(TQPtrList<GetRequest> &queue);
 
        TQPtrList<GetRequest> m_waitQueue;
        TQPtrList<GetRequest> m_activeQueue;
        bool b_multiGetActive;
        GetRequest *m_currentEntry;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class MultiGetJobPrivate* d;
    };

    class TDEIO_EXPORT MimetypeJob : public TransferJob {
    TQ_OBJECT
 
    public:
        MimetypeJob(const KURL& url, int command, const TQByteArray &packedArgs, bool showProgressInfo);

         TQString mimetype() const { return m_mimetype; }

        virtual void start( Slave *slave );
 
    protected slots:
        virtual void slotFinished( );
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class MimetypeJobPrivate* d;
    };

    class TDEIO_EXPORT FileCopyJob : public Job {
    TQ_OBJECT
 
    public:
        FileCopyJob( const KURL& src, const KURL& dest, int permissions,
                     bool move, bool overwrite, bool resume, bool showProgressInfo);
 
        ~FileCopyJob();
        void setSourceSize64(TDEIO::filesize_t size);

        void setModificationTime( time_t mtime );

        void setSourceSize( off_t size ) TDE_DEPRECATED;

        KURL srcURL() const { return m_src; }

        KURL destURL() const { return m_dest; }
 
    signals:
        void mimetype( TDEIO::Job *job, const TQString &type );
 
    public slots:
        void slotStart();
        void slotData( TDEIO::Job *, const TQByteArray &data);
        void slotDataReq( TDEIO::Job *, TQByteArray &data);
        void slotMimetype( TDEIO::Job *, const TQString& type );
 
    protected slots:
        virtual void slotResult( TDEIO::Job *job );

        void slotProcessedSize( TDEIO::Job *job, TDEIO::filesize_t size );
        void slotTotalSize( TDEIO::Job *job, TDEIO::filesize_t size );
        void slotPercent( TDEIO::Job *job, unsigned long pct );
        void slotCanResume( TDEIO::Job *job, TDEIO::filesize_t offset );
 
    protected:
        void startCopyJob();
        void startCopyJob(const KURL &slave_url);
        void startRenameJob(const KURL &slave_url);
        void startDataPump();
        void connectSubjob( SimpleJob * job );
 
    private:
        void startBestCopyMethod();
 
    protected:
        KURL m_src;
        KURL m_dest;
        int m_permissions;
        bool m_move:1;
        bool m_overwrite:1;
        bool m_resume:1;
        bool m_canResume:1;
        bool m_resumeAnswerSent:1;
        TQByteArray m_buffer;
        SimpleJob *m_moveJob;
        SimpleJob *m_copyJob;
        TransferJob *m_getJob;
        TransferJob *m_putJob;
        TDEIO::filesize_t m_totalSize;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class FileCopyJobPrivate;
    FileCopyJobPrivate* d;
    };

    class TDEIO_EXPORT ListJob : public SimpleJob {
    TQ_OBJECT
 
    public:
        ListJob(const KURL& url, bool showProgressInfo,
                bool recursive = false, TQString prefix = TQString::null,
                bool includeHidden = true);

        virtual void start( Slave *slave );

        const KURL& redirectionURL() const { return m_redirectionURL; }

        void setUnrestricted(bool unrestricted);
 
    signals:
        void entries( TDEIO::Job *job, const TDEIO::UDSEntryList& list);

        void redirection( TDEIO::Job *job, const KURL &url );

        void permanentRedirection( TDEIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
 
    protected slots:
        virtual void slotFinished( );
        virtual void slotMetaData( const TDEIO::MetaData &_metaData);
        virtual void slotResult( TDEIO::Job *job );
        void slotListEntries( const TDEIO::UDSEntryList& list );
        void slotRedirection( const KURL &url );
        void gotEntries( TDEIO::Job * subjob, const TDEIO::UDSEntryList& list );
 
    private:
        bool recursive;
        bool includeHidden;
        TQString prefix;
        unsigned long m_processedEntries;
        KURL m_redirectionURL;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class ListJobPrivate* d;
    };

    struct TDEIO_EXPORT CopyInfo
    {
        KURL uSource;
        KURL uDest;
        TQString linkDest; // for symlinks only
        int permissions;
        //mode_t type;
        time_t ctime;
        time_t mtime;
        TDEIO::filesize_t size; // 0 for dirs
    };

    class TDEIO_EXPORT CopyJob : public Job {
    TQ_OBJECT
 
    public:
        enum CopyMode{ Copy, Move, Link };

        CopyJob( const KURL::List& src, const KURL& dest, CopyMode mode, bool asMethod, bool showProgressInfo );
 
        virtual ~CopyJob();

        KURL::List srcURLs() const { return m_srcList; }

        KURL destURL() const { return m_dest; }

        void setDefaultPermissions( bool b );

        void setInteractive( bool b );
 
    signals:

        void totalFiles( TDEIO::Job *job, unsigned long files );
        void totalDirs( TDEIO::Job *job, unsigned long dirs );

        void aboutToCreate( TDEIO::Job *job, const TQValueList<TDEIO::CopyInfo> &files);

        void processedFiles( TDEIO::Job *job, unsigned long files );
        void processedDirs( TDEIO::Job *job, unsigned long dirs );

        void copying( TDEIO::Job *job, const KURL& from, const KURL& to );
        void linking( TDEIO::Job *job, const TQString& target, const KURL& to );
        void moving( TDEIO::Job *job, const KURL& from, const KURL& to );
        void creatingDir( TDEIO::Job *job, const KURL& dir );
        void renamed( TDEIO::Job *job, const KURL& from, const KURL& to );

        void copyingDone( TDEIO::Job *job, const KURL &from, const KURL &to, bool directory, bool renamed );
        void copyingLinkDone( TDEIO::Job *job, const KURL &from, const TQString& target, const KURL& to );
 
    protected:
        void statCurrentSrc();
        void statNextSrc();
 
        // Those aren't slots but submethods for slotResult.
        void slotResultStating( TDEIO::Job * job );
        void startListing( const KURL & src );
        void slotResultCreatingDirs( TDEIO::Job * job );
        void slotResultConflictCreatingDirs( TDEIO::Job * job );
        void createNextDir();
        void slotResultCopyingFiles( TDEIO::Job * job );
        void slotResultConflictCopyingFiles( TDEIO::Job * job );
        void copyNextFile();
        void slotResultDeletingDirs( TDEIO::Job * job );
        void deleteNextDir();
        void skip( const KURL & sourceURL );
        void slotResultRenaming( TDEIO::Job * job );
        //void slotResultSettingDirAttributes( TDEIO::Job * job );
        void setNextDirAttribute();
    private:
        void startRenameJob(const KURL &slave_url);
        bool shouldOverwrite( const TQString& path ) const;
        bool shouldSkip( const TQString& path ) const;
        void skipSrc();
 
    protected slots:
        void slotStart();
        void slotEntries( TDEIO::Job*, const TDEIO::UDSEntryList& list );
        virtual void slotResult( TDEIO::Job *job );
        void slotProcessedSize( TDEIO::Job*, TDEIO::filesize_t data_size );
        void slotTotalSize( TDEIO::Job*, TDEIO::filesize_t size );
 
        void slotReport();
    private:
        CopyMode m_mode;
        bool m_asMethod;
        enum DestinationState { DEST_NOT_STATED, DEST_IS_DIR, DEST_IS_FILE, DEST_DOESNT_EXIST };
        DestinationState destinationState;
        enum { STATE_STATING, STATE_RENAMING, STATE_LISTING, STATE_CREATING_DIRS,
               STATE_CONFLICT_CREATING_DIRS, STATE_COPYING_FILES, STATE_CONFLICT_COPYING_FILES,
               STATE_DELETING_DIRS, STATE_SETTING_DIR_ATTRIBUTES } state;
        TDEIO::filesize_t m_totalSize;
        TDEIO::filesize_t m_processedSize;
        TDEIO::filesize_t m_fileProcessedSize;
        int m_processedFiles;
        int m_processedDirs;
        TQValueList<CopyInfo> files;
        TQValueList<CopyInfo> dirs;
        KURL::List dirsToRemove;
        KURL::List m_srcList;
        KURL::List::Iterator m_currentStatSrc;
        bool m_bCurrentSrcIsDir;
        bool m_bCurrentOperationIsLink;
        bool m_bSingleFileCopy;
        bool m_bOnlyRenames;
        KURL m_dest;
        KURL m_currentDest;
        //
        TQStringList m_skipList;
        TQStringList m_overwriteList;
        bool m_bAutoSkip;
        bool m_bOverwriteAll;
        int m_conflictError;
 
        TQTimer *m_reportTimer;
        //these both are used for progress dialog reporting
        KURL m_currentSrcURL;
        KURL m_currentDestURL;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class CopyJobPrivate;
        CopyJobPrivate* d;
        friend class CopyJobPrivate; // for DestinationState
    };

    class TDEIO_EXPORT DeleteJob : public Job {
    TQ_OBJECT
 
    public:
        DeleteJob( const KURL::List& src, bool shred, bool showProgressInfo );

        KURL::List urls() const { return m_srcList; }
 
    signals:

        void totalFiles( TDEIO::Job *job, unsigned long files );
        void totalDirs( TDEIO::Job *job, unsigned long dirs );

        void processedFiles( TDEIO::Job *job, unsigned long files );
        void processedDirs( TDEIO::Job *job, unsigned long dirs );

        void deleting( TDEIO::Job *job, const KURL& file );
 
    protected slots:
        void slotStart();
        void slotEntries( TDEIO::Job*, const TDEIO::UDSEntryList& list );
        virtual void slotResult( TDEIO::Job *job );

        void slotProcessedSize( TDEIO::Job*, TDEIO::filesize_t data_size );
        void slotReport();
 
    private:
        void statNextSrc();
        void deleteNextFile();
        void deleteNextDir();
 
    private:
        enum { STATE_STATING, STATE_LISTING,
               STATE_DELETING_FILES, STATE_DELETING_DIRS } state;
        TDEIO::filesize_t m_totalSize;
        TDEIO::filesize_t m_processedSize;
        TDEIO::filesize_t m_fileProcessedSize;
        int m_processedFiles;
        int m_processedDirs;
        int m_totalFilesDirs;
        KURL m_currentURL;
        KURL::List files;
        KURL::List symlinks;
        KURL::List dirs;
        KURL::List m_srcList;
        KURL::List::Iterator m_currentStat;
    TQStringList m_parentDirs;
        bool m_shred; // BIC: remove in KDE4
        TQTimer *m_reportTimer;
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
    class DeleteJobPrivate* d;
    };

    class TDEIO_EXPORT LocalURLJob : public SimpleJob {
 
    TQ_OBJECT
 
    public:
        LocalURLJob(const KURL& url, int command, const TQByteArray &packedArgs, bool showProgressInfo);

        virtual void start( Slave *slave );
 
    signals:
        void localURL( TDEIO::LocalURLJob *job, const KURL &url, bool isLocal );
 
    protected slots:
        void slotLocalURL( const KURL &url, bool isLocal );
        virtual void slotFinished();
 
    protected:
    virtual void virtual_hook( int id, void* data );
    private:
        class LocalURLJobPrivate;
        LocalURLJobPrivate *d;
    };
 
}
 
#endif