jobclasses.h

00001 // -*- c++ -*-
00002 /* This file is part of the KDE libraries
00003     Copyright (C) 2000 Stephan Kulow <coolo@kde.org>
00004                        David Faure <faure@kde.org>
00005 
00006     This library is free software; you can redistribute it and/or
00007     modify it under the terms of the GNU Library General Public
00008     License as published by the Free Software Foundation; either
00009     version 2 of the License, or (at your option) any later version.
00010 
00011     This library is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014     Library General Public License for more details.
00015 
00016     You should have received a copy of the GNU Library General Public License
00017     along with this library; see the file COPYING.LIB.  If not, write to
00018     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019     Boston, MA 02110-1301, USA.
00020 */
00021 
00022 #ifndef __kio_jobclasses_h__
00023 #define __kio_jobclasses_h__
00024 
00025 #include <qobject.h>
00026 #include <qptrlist.h>
00027 #include <qstring.h>
00028 #include <qstringlist.h>
00029 #include <qguardedptr.h>
00030 
00031 #include <sys/types.h>
00032 #include <sys/stat.h>
00033 
00034 #include <kurl.h>
00035 #include <kio/global.h>
00036 
00037 class Observer;
00038 class QTimer;
00039 
00040 #define KIO_COPYJOB_HAS_SETINTERACTIVE // new in 3.4. Used by kio_trash.
00041 
00042 namespace KIO {
00043 
00044     class Slave;
00045     class SlaveInterface;
00046 
00047 
00068     class KIO_EXPORT Job : public QObject {
00069         Q_OBJECT
00070 
00071     protected:
00072         Job( bool showProgressInfo );
00073 
00074     public:
00075         virtual ~Job();
00076 
00087         virtual void kill( bool quietly = true );
00088 
00095         int error() const { return m_error; }
00096 
00101         int progressId() const { return m_progressId; }
00102 
00111         const QString & errorText() const { return m_errorText; }
00112 
00130         QString errorString() const;
00131 
00142         QStringList detailedErrorStrings(const KURL *reqUrl = 0L,
00143                                          int method = -1) const;
00144 
00153         void showErrorDialog( QWidget * parent = 0L );
00154 
00168         void setAutoErrorHandlingEnabled( bool enable, QWidget *parentWidget = 0 );
00169 
00175         bool isAutoErrorHandlingEnabled() const;
00176 
00190         void setAutoWarningHandlingEnabled( bool enable );
00191 
00199         bool isAutoWarningHandlingEnabled() const;
00200 
00208         void setInteractive(bool enable);
00209 
00216         bool isInteractive() const;
00222         void setWindow(QWidget *window);
00223 
00229         QWidget *window() const;
00230 
00241         void setParentJob( Job* parentJob );
00242 
00249         Job* parentJob() const;
00250 
00258         void setMetaData( const KIO::MetaData &metaData);
00259 
00267         void addMetaData(const QString &key, const QString &value);
00268 
00276         void addMetaData(const QMap<QString,QString> &values);
00277 
00285         void mergeMetaData(const QMap<QString,QString> &values);
00286 
00290         MetaData outgoingMetaData() const;
00291 
00297         MetaData metaData() const;
00298 
00306         QString queryMetaData(const QString &key);
00307 
00313         KIO::filesize_t getProcessedSize();
00314 
00315     signals:
00321         void result( KIO::Job *job );
00322 
00330         void canceled( KIO::Job *job );
00331 
00338         void infoMessage( KIO::Job *job, const QString & msg );
00339         // KDE4: Separate rich-text string from plain-text string, for different widgets.
00340 
00347         void warning( KIO::Job *job, const QString & msg );
00348         // KDE4: Separate rich-text string from plain-text string, for different widgets.
00349 
00356         void connected( KIO::Job *job );
00357 
00366         void percent( KIO::Job *job, unsigned long percent );
00367 
00374         void totalSize( KIO::Job *job, KIO::filesize_t size );
00375 
00382         void processedSize( KIO::Job *job, KIO::filesize_t size );
00383 
00389         void speed( KIO::Job *job, unsigned long speed );
00390 
00391     protected slots:
00400         virtual void slotResult( KIO::Job *job );
00401 
00408         void slotSpeed( KIO::Job *job, unsigned long speed );
00415         void slotInfoMessage( KIO::Job *job, const QString &msg );
00416 
00420         void slotSpeedTimeout();
00421 
00422     protected:
00432         virtual void addSubjob( Job *job, bool inheritMetaData=true );
00433 
00442         virtual void removeSubjob( Job *job );
00451         void removeSubjob( Job *job, bool mergeMetaData, bool emitResultIfLast ); // KDE4: merge with above, with =true to both
00452 
00461         void emitPercent( KIO::filesize_t processedSize, KIO::filesize_t totalSize );
00462 
00469         void emitSpeed( unsigned long speed );
00470 
00475         void emitResult();
00476 
00481         void setProcessedSize(KIO::filesize_t size);
00482 
00488         enum { EF_TransferJobAsync    = (1 << 0),
00489                EF_TransferJobNeedData = (1 << 1),
00490                EF_TransferJobDataSent = (1 << 2),
00491                EF_ListJobUnrestricted = (1 << 3) };
00492         int &extraFlags();
00493 
00494         QPtrList<Job> subjobs;
00495         int m_error;
00496         QString m_errorText;
00497         unsigned long m_percent;
00498         int m_progressId; // for uiserver
00499         QTimer *m_speedTimer;
00500         QGuardedPtr<QWidget> m_window;
00501         MetaData m_outgoingMetaData;
00502         MetaData m_incomingMetaData;
00503     protected:
00504     virtual void virtual_hook( int id, void* data );
00505     private:
00506         class JobPrivate;
00507         JobPrivate *d;
00508     };
00509 
00516     class KIO_EXPORT SimpleJob : public KIO::Job {
00517     Q_OBJECT
00518 
00519     public:
00528         SimpleJob(const KURL& url, int command, const QByteArray &packedArgs,
00529                   bool showProgressInfo);
00530 
00531         ~SimpleJob();
00532 
00537         const KURL& url() const { return m_url; }
00538 
00546         virtual void kill( bool quietly = true );
00547 
00552         virtual void putOnHold();
00553 
00557         static void removeOnHold();
00558 
00564         virtual void start( Slave *slave );
00565 
00570         void slaveDone();
00571 
00576         Slave *slave() const { return m_slave; }
00577 
00581         int command() const { return m_command; }
00582 
00583     public slots:
00589         void slotTotalSize( KIO::filesize_t data_size );
00590 
00591     protected slots:
00596         virtual void slotFinished( );
00597 
00602         void slotWarning( const QString & ); // KDE4: make virtual
00603 
00609         void slotInfoMessage( const QString &s ); // KDE4: make virtual
00610 
00615         void slotConnected();
00616 
00622         void slotProcessedSize( KIO::filesize_t data_size );
00628         void slotSpeed( unsigned long speed );
00629 
00635         virtual void slotMetaData( const KIO::MetaData &_metaData);
00636 
00637     public slots:
00643         virtual void slotError( int , const QString & );
00644 
00645     protected slots:
00649         void slotNeedProgressId();
00650 
00651     protected:
00652         Slave * m_slave;
00653         QByteArray m_packedArgs;
00654         KURL m_url;
00655         KURL m_subUrl;
00656         int m_command;
00657         KIO::filesize_t m_totalSize;
00658     protected:
00659     virtual void virtual_hook( int id, void* data );
00660     /*
00661      * Allow jobs that inherit SimpleJob and are aware
00662      * of redirections to store the SSL session used.
00663      * Retrieval is handled by SimpleJob::start
00664      * @param m_redirectionURL Reference to redirection URL,
00665      * used instead of m_url if not empty
00666      */
00667     void storeSSLSessionFromJob(const KURL &m_redirectionURL);
00668     private:
00669     class SimpleJobPrivate* d;
00670     };
00671 
00676     class KIO_EXPORT StatJob : public SimpleJob {
00677 
00678     Q_OBJECT
00679 
00680     public:
00688         StatJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00689 
00697         void setSide( bool source ) { m_bSource = source; }
00698 
00708         void setDetails( short int details ) { m_details = details; }
00709 
00715         const UDSEntry & statResult() const { return m_statResult; }
00716 
00723         virtual void start( Slave *slave );
00724 
00725     signals:
00733         void redirection( KIO::Job *job, const KURL &url );
00734 
00743         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00744 
00745     protected slots:
00746         void slotStatEntry( const KIO::UDSEntry & entry );
00747         void slotRedirection( const KURL &url);
00748         virtual void slotFinished();
00749         virtual void slotMetaData( const KIO::MetaData &_metaData);
00750 
00751     protected:
00752         UDSEntry m_statResult;
00753         KURL m_redirectionURL;
00754         bool m_bSource;
00755         short int m_details;
00756     protected:
00757     virtual void virtual_hook( int id, void* data );
00758     private:
00759         class StatJobPrivate;
00760         StatJobPrivate *d;
00761     };
00762 
00768     class KIO_EXPORT MkdirJob : public SimpleJob {
00769 
00770     Q_OBJECT
00771 
00772     public:
00780         MkdirJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00781 
00788         virtual void start( Slave *slave );
00789 
00790     signals:
00798         void redirection( KIO::Job *job, const KURL &url );
00799 
00807         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00808 
00809     protected slots:
00810         void slotRedirection( const KURL &url);
00811         virtual void slotFinished();
00812 
00813     protected:
00814         KURL m_redirectionURL;
00815 
00816     protected:
00817     virtual void virtual_hook( int id, void* data );
00818     private:
00819         class MkdirJobPrivate;
00820         MkdirJobPrivate *d;
00821     };
00822 
00827     class KIO_EXPORT DirectCopyJob : public SimpleJob {
00828     Q_OBJECT
00829 
00830     public:
00834         DirectCopyJob(const KURL& url, int command, const QByteArray &packedArgs,
00835                       bool showProgressInfo);
00842         virtual void start(Slave *slave);
00843 
00844     signals:
00850         void canResume( KIO::Job *job, KIO::filesize_t offset );
00851 
00852     private slots:
00853         void slotCanResume( KIO::filesize_t offset );
00854     };
00855 
00856 
00863     class KIO_EXPORT TransferJob : public SimpleJob {
00864     Q_OBJECT
00865 
00866     public:
00876         TransferJob(const KURL& url, int command,
00877                     const QByteArray &packedArgs,
00878                     const QByteArray &_staticData,
00879                     bool showProgressInfo);
00880 
00887         virtual void start(Slave *slave);
00888 
00893         virtual void slotResult( KIO::Job *job );
00894 
00898         void suspend();
00899 
00903         void resume();
00904 
00909     bool isSuspended() const { return m_suspended; }
00910 
00911 
00919         bool isErrorPage() const { return m_errorPage; }
00920 
00928         void setAsyncDataEnabled(bool enabled);
00929 
00936         void sendAsyncData(const QByteArray &data);
00937 
00945         void setReportDataSent(bool enabled);
00946 
00953         bool reportDataSent();
00954 
00955     signals:
00965         void data( KIO::Job *job, const QByteArray &data );
00966 
00978         void dataReq( KIO::Job *job, QByteArray &data );
00979 
00987         void redirection( KIO::Job *job, const KURL &url );
00988 
00997         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00998 
01004         void mimetype( KIO::Job *job, const QString &type );
01005 
01013         void canResume( KIO::Job *job, KIO::filesize_t offset );
01014 
01015 
01016     protected slots:
01017         virtual void slotRedirection( const KURL &url);
01018         virtual void slotFinished();
01019         virtual void slotData( const QByteArray &data);
01020         virtual void slotDataReq();
01021         virtual void slotMimetype( const QString &mimetype );
01022         virtual void slotNeedSubURLData();
01023         virtual void slotSubURLData(KIO::Job*, const QByteArray &);
01024         virtual void slotMetaData( const KIO::MetaData &_metaData);
01025         void slotErrorPage();
01026         void slotCanResume( KIO::filesize_t offset );
01027         void slotPostRedirection();
01028 
01029     protected:
01030         bool m_suspended;
01031         bool m_errorPage;
01032         QByteArray staticData;
01033         KURL m_redirectionURL;
01034         KURL::List m_redirectionList;
01035         QString m_mimetype;
01036         TransferJob *m_subJob;
01037     protected:
01038     virtual void virtual_hook( int id, void* data );
01039     private:
01040     class TransferJobPrivate *d;
01041     };
01042 
01063     class KIO_EXPORT StoredTransferJob : public KIO::TransferJob {
01064         Q_OBJECT
01065 
01066     public:
01076         StoredTransferJob(const KURL& url, int command,
01077                           const QByteArray &packedArgs,
01078                           const QByteArray &_staticData,
01079                           bool showProgressInfo);
01080 
01086         void setData( const QByteArray& arr );
01087 
01092         QByteArray data() const { return m_data; }
01093 
01094     private slots:
01095         void slotStoredData( KIO::Job *job, const QByteArray &data );
01096         void slotStoredDataReq( KIO::Job *job, QByteArray &data );
01097     private:
01098         QByteArray m_data;
01099         int m_uploadOffset;
01100     };
01101 
01108     class KIO_EXPORT MultiGetJob : public TransferJob {
01109     Q_OBJECT
01110 
01111     public:
01119         MultiGetJob(const KURL& url, bool showProgressInfo);
01120 
01127          virtual void start(Slave *slave);
01128 
01136         void get(long id, const KURL &url, const MetaData &metaData);
01137 
01138     signals:
01145         void data( long id, const QByteArray &data);
01146 
01152         void mimetype( long id, const QString &type );
01153 
01161         void result( long id);
01162 
01163     protected slots:
01164         virtual void slotRedirection( const KURL &url);
01165         virtual void slotFinished();
01166         virtual void slotData( const QByteArray &data);
01167         virtual void slotMimetype( const QString &mimetype );
01168     private:
01169         struct GetRequest {
01170         public:
01171            GetRequest(long _id, const KURL &_url, const MetaData &_metaData)
01172              : id(_id), url(_url), metaData(_metaData) { }
01173            long id;
01174            KURL url;
01175            MetaData metaData;
01176         };
01177         bool findCurrentEntry();
01178         void flushQueue(QPtrList<GetRequest> &queue);
01179 
01180         QPtrList<GetRequest> m_waitQueue;
01181         QPtrList<GetRequest> m_activeQueue;
01182         bool b_multiGetActive;
01183         GetRequest *m_currentEntry;
01184     protected:
01185     virtual void virtual_hook( int id, void* data );
01186     private:
01187     class MultiGetJobPrivate* d;
01188     };
01189 
01196     class KIO_EXPORT MimetypeJob : public TransferJob {
01197     Q_OBJECT
01198 
01199     public:
01208         MimetypeJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
01209 
01215          QString mimetype() const { return m_mimetype; }
01216 
01223         virtual void start( Slave *slave );
01224 
01225     protected slots:
01226         virtual void slotFinished( );
01227     protected:
01228     virtual void virtual_hook( int id, void* data );
01229     private:
01230     class MimetypeJobPrivate* d;
01231     };
01232 
01238     class KIO_EXPORT FileCopyJob : public Job {
01239     Q_OBJECT
01240 
01241     public:
01253         FileCopyJob( const KURL& src, const KURL& dest, int permissions,
01254                      bool move, bool overwrite, bool resume, bool showProgressInfo);
01255 
01256         ~FileCopyJob();
01263         void setSourceSize64(KIO::filesize_t size);
01264 
01272         void setModificationTime( time_t mtime );
01273 
01277         void setSourceSize( off_t size ) KDE_DEPRECATED;
01278 
01283         KURL srcURL() const { return m_src; }
01284 
01289         KURL destURL() const { return m_dest; }
01290 
01291     public slots:
01292         void slotStart();
01293         void slotData( KIO::Job *, const QByteArray &data);
01294         void slotDataReq( KIO::Job *, QByteArray &data);
01295 
01296     protected slots:
01301         virtual void slotResult( KIO::Job *job );
01302 
01308         void slotProcessedSize( KIO::Job *job, KIO::filesize_t size );
01314         void slotTotalSize( KIO::Job *job, KIO::filesize_t size );
01320         void slotPercent( KIO::Job *job, unsigned long pct );
01326         void slotCanResume( KIO::Job *job, KIO::filesize_t offset );
01327 
01328     protected:
01329         void startCopyJob();
01330         void startCopyJob(const KURL &slave_url);
01331         void startRenameJob(const KURL &slave_url);
01332         void startDataPump();
01333         void connectSubjob( SimpleJob * job );
01334 
01335     private:
01336         void startBestCopyMethod();
01337 
01338     protected:
01339         KURL m_src;
01340         KURL m_dest;
01341         int m_permissions;
01342         bool m_move:1;
01343         bool m_overwrite:1;
01344         bool m_resume:1;
01345         bool m_canResume:1;
01346         bool m_resumeAnswerSent:1;
01347         QByteArray m_buffer;
01348         SimpleJob *m_moveJob;
01349         SimpleJob *m_copyJob;
01350         TransferJob *m_getJob;
01351         TransferJob *m_putJob;
01352         KIO::filesize_t m_totalSize;
01353     protected:
01354     virtual void virtual_hook( int id, void* data );
01355     private:
01356     class FileCopyJobPrivate;
01357     FileCopyJobPrivate* d;
01358     };
01359 
01367     class KIO_EXPORT ListJob : public SimpleJob {
01368     Q_OBJECT
01369 
01370     public:
01381         ListJob(const KURL& url, bool showProgressInfo,
01382                 bool recursive = false, QString prefix = QString::null,
01383                 bool includeHidden = true);
01384 
01391         virtual void start( Slave *slave );
01392 
01399         const KURL& redirectionURL() const { return m_redirectionURL; }
01400 
01405         void setUnrestricted(bool unrestricted);
01406 
01407     signals:
01417         void entries( KIO::Job *job, const KIO::UDSEntryList& list);
01418 
01426         void redirection( KIO::Job *job, const KURL &url );
01427 
01436         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
01437 
01438     protected slots:
01439         virtual void slotFinished( );
01440         virtual void slotMetaData( const KIO::MetaData &_metaData);
01441         virtual void slotResult( KIO::Job *job );
01442         void slotListEntries( const KIO::UDSEntryList& list );
01443         void slotRedirection( const KURL &url );
01444         void gotEntries( KIO::Job * subjob, const KIO::UDSEntryList& list );
01445 
01446     private:
01447         bool recursive;
01448         bool includeHidden;
01449         QString prefix;
01450         unsigned long m_processedEntries;
01451         KURL m_redirectionURL;
01452     protected:
01453     virtual void virtual_hook( int id, void* data );
01454     private:
01455     class ListJobPrivate* d;
01456     };
01457 
01459     struct KIO_EXPORT CopyInfo
01460     {
01461         KURL uSource;
01462         KURL uDest;
01463         QString linkDest; // for symlinks only
01464         int permissions;
01465         //mode_t type;
01466         time_t ctime;
01467         time_t mtime;
01468         KIO::filesize_t size; // 0 for dirs
01469     };
01470 
01483     class KIO_EXPORT CopyJob : public Job {
01484     Q_OBJECT
01485 
01486     public:
01490         enum CopyMode{ Copy, Move, Link };
01491 
01509         CopyJob( const KURL::List& src, const KURL& dest, CopyMode mode, bool asMethod, bool showProgressInfo );
01510 
01511         virtual ~CopyJob();
01512 
01517         KURL::List srcURLs() const { return m_srcList; }
01518 
01523         KURL destURL() const { return m_dest; }
01524 
01535         void setDefaultPermissions( bool b );
01536 
01548         void setInteractive( bool b );
01549 
01550     signals:
01551 
01557         void totalFiles( KIO::Job *job, unsigned long files );
01563         void totalDirs( KIO::Job *job, unsigned long dirs );
01564 
01572         void aboutToCreate( KIO::Job *job, const QValueList<KIO::CopyInfo> &files);
01573 
01579         void processedFiles( KIO::Job *job, unsigned long files );
01585         void processedDirs( KIO::Job *job, unsigned long dirs );
01586 
01594         void copying( KIO::Job *job, const KURL& from, const KURL& to );
01602         void linking( KIO::Job *job, const QString& target, const KURL& to );
01610         void moving( KIO::Job *job, const KURL& from, const KURL& to );
01616         void creatingDir( KIO::Job *job, const KURL& dir );
01623         void renamed( KIO::Job *job, const KURL& from, const KURL& to );
01624 
01637         void copyingDone( KIO::Job *job, const KURL &from, const KURL &to, bool directory, bool renamed );
01647         void copyingLinkDone( KIO::Job *job, const KURL &from, const QString& target, const KURL& to );
01648 
01649     protected:
01650         void statCurrentSrc();
01651         void statNextSrc();
01652 
01653         // Those aren't slots but submethods for slotResult.
01654         void slotResultStating( KIO::Job * job );
01655         void startListing( const KURL & src );
01656         void slotResultCreatingDirs( KIO::Job * job );
01657         void slotResultConflictCreatingDirs( KIO::Job * job );
01658         void createNextDir();
01659         void slotResultCopyingFiles( KIO::Job * job );
01660         void slotResultConflictCopyingFiles( KIO::Job * job );
01661         void copyNextFile();
01662         void slotResultDeletingDirs( KIO::Job * job );
01663         void deleteNextDir();
01664         void skip( const KURL & sourceURL );
01665         void slotResultRenaming( KIO::Job * job );
01666         //void slotResultSettingDirAttributes( KIO::Job * job );
01667         void setNextDirAttribute();
01668     private:
01669         void startRenameJob(const KURL &slave_url);
01670         bool shouldOverwrite( const QString& path ) const;
01671         bool shouldSkip( const QString& path ) const;
01672         void skipSrc();
01673 
01674     protected slots:
01675         void slotStart();
01676         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01677         virtual void slotResult( KIO::Job *job );
01681         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01686         void slotTotalSize( KIO::Job*, KIO::filesize_t size );
01687 
01688         void slotReport();
01689     private:
01690         CopyMode m_mode;
01691         bool m_asMethod;
01692         enum DestinationState { DEST_NOT_STATED, DEST_IS_DIR, DEST_IS_FILE, DEST_DOESNT_EXIST };
01693         DestinationState destinationState;
01694         enum { STATE_STATING, STATE_RENAMING, STATE_LISTING, STATE_CREATING_DIRS,
01695                STATE_CONFLICT_CREATING_DIRS, STATE_COPYING_FILES, STATE_CONFLICT_COPYING_FILES,
01696                STATE_DELETING_DIRS, STATE_SETTING_DIR_ATTRIBUTES } state;
01697         KIO::filesize_t m_totalSize;
01698         KIO::filesize_t m_processedSize;
01699         KIO::filesize_t m_fileProcessedSize;
01700         int m_processedFiles;
01701         int m_processedDirs;
01702         QValueList<CopyInfo> files;
01703         QValueList<CopyInfo> dirs;
01704         KURL::List dirsToRemove;
01705         KURL::List m_srcList;
01706         KURL::List::Iterator m_currentStatSrc;
01707         bool m_bCurrentSrcIsDir;
01708         bool m_bCurrentOperationIsLink;
01709         bool m_bSingleFileCopy;
01710         bool m_bOnlyRenames;
01711         KURL m_dest;
01712         KURL m_currentDest;
01713         //
01714         QStringList m_skipList;
01715         QStringList m_overwriteList;
01716         bool m_bAutoSkip;
01717         bool m_bOverwriteAll;
01718         int m_conflictError;
01719 
01720         QTimer *m_reportTimer;
01721         //these both are used for progress dialog reporting
01722         KURL m_currentSrcURL;
01723         KURL m_currentDestURL;
01724     protected:
01725     virtual void virtual_hook( int id, void* data );
01726     private:
01727     class CopyJobPrivate;
01728         CopyJobPrivate* d;
01729         friend class CopyJobPrivate; // for DestinationState
01730     };
01731 
01738     class KIO_EXPORT DeleteJob : public Job {
01739     Q_OBJECT
01740 
01741     public:
01751         DeleteJob( const KURL::List& src, bool shred, bool showProgressInfo );
01752 
01757         KURL::List urls() const { return m_srcList; }
01758 
01759     signals:
01760 
01766         void totalFiles( KIO::Job *job, unsigned long files );
01772         void totalDirs( KIO::Job *job, unsigned long dirs );
01773 
01779         void processedFiles( KIO::Job *job, unsigned long files );
01785         void processedDirs( KIO::Job *job, unsigned long dirs );
01786 
01793         void deleting( KIO::Job *job, const KURL& file );
01794 
01795     protected slots:
01796         void slotStart();
01797         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01798         virtual void slotResult( KIO::Job *job );
01799 
01803         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01804         void slotReport();
01805 
01806     private:
01807         void statNextSrc();
01808         void deleteNextFile();
01809         void deleteNextDir();
01810 
01811     private:
01812         enum { STATE_STATING, STATE_LISTING,
01813                STATE_DELETING_FILES, STATE_DELETING_DIRS } state;
01814         KIO::filesize_t m_totalSize;
01815         KIO::filesize_t m_processedSize;
01816         KIO::filesize_t m_fileProcessedSize;
01817         int m_processedFiles;
01818         int m_processedDirs;
01819         int m_totalFilesDirs;
01820         KURL m_currentURL;
01821         KURL::List files;
01822         KURL::List symlinks;
01823         KURL::List dirs;
01824         KURL::List m_srcList;
01825         KURL::List::Iterator m_currentStat;
01826     QStringList m_parentDirs;
01827         bool m_shred; // BIC: remove in KDE4
01828         QTimer *m_reportTimer;
01829     protected:
01831     virtual void virtual_hook( int id, void* data );
01832     private:
01833     class DeleteJobPrivate* d;
01834     };
01835 
01836 }
01837 
01838 #endif
KDE Home | KDE Accessibility Home | Description of Access Keys