kio Library API Documentation

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., 59 Temple Place - Suite 330,
00019     Boston, MA 02111-1307, 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 
00170         void setAutoErrorHandlingEnabled( bool enable, QWidget *parentWidget = 0 );
00171 
00178         bool isAutoErrorHandlingEnabled() const;
00179 
00185         void setWindow(QWidget *window);
00186 
00192         QWidget *window() const;
00193 
00204         void setParentJob( Job* parentJob );
00205 
00212         Job* parentJob() const;
00213 
00221         void setMetaData( const KIO::MetaData &metaData);
00222 
00230         void addMetaData(const QString &key, const QString &value);
00231 
00239         void addMetaData(const QMap<QString,QString> &values);
00240 
00248         void mergeMetaData(const QMap<QString,QString> &values);
00249 
00253         MetaData outgoingMetaData() const;
00254 
00260         MetaData metaData() const;
00261 
00269         QString queryMetaData(const QString &key);
00270 
00276         KIO::filesize_t getProcessedSize();
00277 
00278     signals:
00284         void result( KIO::Job *job );
00285 
00293         void canceled( KIO::Job *job );
00294 
00301         void infoMessage( KIO::Job *job, const QString & msg );
00302         // KDE 3.0: Separate rich-text string from plain-text string, for different widgets.
00303 
00310         void connected( KIO::Job *job );
00311 
00320         void percent( KIO::Job *job, unsigned long percent );
00321 
00328         void totalSize( KIO::Job *job, KIO::filesize_t size );
00329 
00336         void processedSize( KIO::Job *job, KIO::filesize_t size );
00337 
00343         void speed( KIO::Job *job, unsigned long bytes_per_second );
00344 
00345     protected slots:
00354         virtual void slotResult( KIO::Job *job );
00355 
00362         void slotSpeed( KIO::Job *job, unsigned long bytes_per_second );
00369         void slotInfoMessage( KIO::Job *job, const QString &msg );
00370 
00374         void slotSpeedTimeout();
00375 
00376     protected:
00386         virtual void addSubjob( Job *job, bool inheritMetaData=true );
00387 
00396         virtual void removeSubjob( Job *job );
00405         void removeSubjob( Job *job, bool mergeMetaData, bool emitResultIfLast ); // KDE4: merge with above, with =true to both
00406 
00415         void emitPercent( KIO::filesize_t processedSize, KIO::filesize_t totalSize );
00416 
00423         void emitSpeed( unsigned long bytes_per_second );
00424 
00429         void emitResult();
00430 
00435         void setProcessedSize(KIO::filesize_t size);
00436 
00442         enum { EF_TransferJobAsync    = (1 << 0),
00443                EF_TransferJobNeedData = (1 << 1),
00444                EF_TransferJobDataSent = (1 << 2),
00445                EF_ListJobUnrestricted = (1 << 3) };
00446         int &extraFlags();
00447 
00448         QPtrList<Job> subjobs;
00449         int m_error;
00450         QString m_errorText;
00451         unsigned long m_percent;
00452         int m_progressId; // for uiserver
00453         QTimer *m_speedTimer;
00454         QGuardedPtr<QWidget> m_window;
00455         MetaData m_outgoingMetaData;
00456         MetaData m_incomingMetaData;
00457     protected:
00458     virtual void virtual_hook( int id, void* data );
00459     private:
00460         class JobPrivate;
00461         JobPrivate *d;
00462     };
00463 
00470     class KIO_EXPORT SimpleJob : public KIO::Job {
00471     Q_OBJECT
00472 
00473     public:
00482         SimpleJob(const KURL& url, int command, const QByteArray &packedArgs,
00483                   bool showProgressInfo);
00484 
00485         ~SimpleJob();
00486 
00491         const KURL& url() const { return m_url; }
00492 
00500         virtual void kill( bool quietly = true );
00501 
00506         virtual void putOnHold();
00507 
00511         static void removeOnHold();
00512 
00518         virtual void start( Slave *slave );
00519 
00524         void slaveDone();
00525 
00530         Slave *slave() const { return m_slave; }
00531 
00535         int command() const { return m_command; }
00536 
00537     public slots:
00543         void slotTotalSize( KIO::filesize_t data_size );
00544 
00545     protected slots:
00550         virtual void slotFinished( );
00551 
00556         void slotWarning( const QString & ); // KDE4: make virtual
00557 
00563         void slotInfoMessage( const QString &s ); // KDE4: make virtual
00564 
00569         void slotConnected();
00570 
00576         void slotProcessedSize( KIO::filesize_t data_size );
00582         void slotSpeed( unsigned long bytes_per_second );
00583 
00589         virtual void slotMetaData( const KIO::MetaData &_metaData);
00590 
00591     public slots:
00597         virtual void slotError( int , const QString & );
00598 
00599     protected slots:
00603         void slotNeedProgressId();
00604 
00605     protected:
00606         Slave * m_slave;
00607         QByteArray m_packedArgs;
00608         KURL m_url;
00609         KURL m_subUrl;
00610         int m_command;
00611         KIO::filesize_t m_totalSize;
00612     protected:
00613     virtual void virtual_hook( int id, void* data );
00614     /*
00615      * Allow jobs that inherit SimpleJob and are aware
00616      * of redirections to store the SSL session used.
00617      * Retrieval is handled by SimpleJob::start
00618      * @param m_redirectionURL Reference to redirection URL,
00619      * used instead of m_url if not empty
00620      */
00621     void storeSSLSessionFromJob(const KURL &m_redirectionURL);
00622     private:
00623     class SimpleJobPrivate* d;
00624     };
00625 
00630     class KIO_EXPORT StatJob : public SimpleJob {
00631 
00632     Q_OBJECT
00633 
00634     public:
00642         StatJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00643 
00651         void setSide( bool source ) { m_bSource = source; }
00652 
00662         void setDetails( short int details ) { m_details = details; }
00663 
00669         const UDSEntry & statResult() const { return m_statResult; }
00670 
00677         virtual void start( Slave *slave );
00678 
00679     signals:
00687         void redirection( KIO::Job *job, const KURL &url );
00688 
00697         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00698 
00699     protected slots:
00700         void slotStatEntry( const KIO::UDSEntry & entry );
00701         void slotRedirection( const KURL &url);
00702         virtual void slotFinished();
00703         virtual void slotMetaData( const KIO::MetaData &_metaData);
00704 
00705     protected:
00706         UDSEntry m_statResult;
00707         KURL m_redirectionURL;
00708         bool m_bSource;
00709         short int m_details;
00710     protected:
00711     virtual void virtual_hook( int id, void* data );
00712     private:
00713         class StatJobPrivate;
00714         StatJobPrivate *d;
00715     };
00716 
00722     class KIO_EXPORT MkdirJob : public SimpleJob {
00723 
00724     Q_OBJECT
00725 
00726     public:
00734         MkdirJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00735 
00742         virtual void start( Slave *slave );
00743 
00744     signals:
00752         void redirection( KIO::Job *job, const KURL &url );
00753 
00761         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00762 
00763     protected slots:
00764         void slotRedirection( const KURL &url);
00765         virtual void slotFinished();
00766 
00767     protected:
00768         KURL m_redirectionURL;
00769 
00770     protected:
00771     virtual void virtual_hook( int id, void* data );
00772     private:
00773         class MkdirJobPrivate;
00774         MkdirJobPrivate *d;
00775     };
00776 
00781     class KIO_EXPORT DirectCopyJob : public SimpleJob {
00782     Q_OBJECT
00783 
00784     public:
00788         DirectCopyJob(const KURL& url, int command, const QByteArray &packedArgs,
00789                       bool showProgressInfo);
00796         virtual void start(Slave *slave);
00797 
00798     signals:
00804         void canResume( KIO::Job *job, KIO::filesize_t offset );
00805 
00806     private slots:
00807         void slotCanResume( KIO::filesize_t offset );
00808     };
00809 
00810 
00817     class KIO_EXPORT TransferJob : public SimpleJob {
00818     Q_OBJECT
00819 
00820     public:
00830         TransferJob(const KURL& url, int command,
00831                     const QByteArray &packedArgs,
00832                     const QByteArray &_staticData,
00833                     bool showProgressInfo);
00834 
00841         virtual void start(Slave *slave);
00842 
00847         virtual void slotResult( KIO::Job *job );
00848 
00852         void suspend();
00853 
00857         void resume();
00858 
00863     bool isSuspended() const { return m_suspended; }
00864 
00865 
00873         bool isErrorPage() const { return m_errorPage; }
00874 
00882         void setAsyncDataEnabled(bool enabled);
00883 
00890         void sendAsyncData(const QByteArray &data);
00891 
00899         void setReportDataSent(bool enabled);
00900 
00907         bool reportDataSent();
00908 
00909     signals:
00919         void data( KIO::Job *job, const QByteArray &data );
00920 
00932         void dataReq( KIO::Job *job, QByteArray &data );
00933 
00941         void redirection( KIO::Job *job, const KURL &url );
00942 
00951         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00952 
00958         void mimetype( KIO::Job *job, const QString &type );
00959 
00967         void canResume( KIO::Job *job, KIO::filesize_t offset );
00968 
00969 
00970     protected slots:
00971         virtual void slotRedirection( const KURL &url);
00972         virtual void slotFinished();
00973         virtual void slotData( const QByteArray &data);
00974         virtual void slotDataReq();
00975         virtual void slotMimetype( const QString &mimetype );
00976         virtual void slotNeedSubURLData();
00977         virtual void slotSubURLData(KIO::Job*, const QByteArray &);
00978         virtual void slotMetaData( const KIO::MetaData &_metaData);
00979         void slotErrorPage();
00980         void slotCanResume( KIO::filesize_t offset );
00981         void slotPostRedirection();
00982 
00983     protected:
00984         bool m_suspended;
00985         bool m_errorPage;
00986         QByteArray staticData;
00987         KURL m_redirectionURL;
00988         KURL::List m_redirectionList;
00989         QString m_mimetype;
00990         TransferJob *m_subJob;
00991     protected:
00992     virtual void virtual_hook( int id, void* data );
00993     private:
00994     class TransferJobPrivate *d;
00995     };
00996 
01017     class KIO_EXPORT StoredTransferJob : public KIO::TransferJob {
01018         Q_OBJECT
01019 
01020     public:
01030         StoredTransferJob(const KURL& url, int command,
01031                           const QByteArray &packedArgs,
01032                           const QByteArray &_staticData,
01033                           bool showProgressInfo);
01034 
01040         void setData( const QByteArray& arr );
01041 
01046         QByteArray data() const { return m_data; }
01047 
01048     private slots:
01049         void slotStoredData( KIO::Job *job, const QByteArray &data );
01050         void slotStoredDataReq( KIO::Job *job, QByteArray &data );
01051     private:
01052         QByteArray m_data;
01053         int m_uploadOffset;
01054     };
01055 
01062     class KIO_EXPORT MultiGetJob : public TransferJob {
01063     Q_OBJECT
01064 
01065     public:
01073         MultiGetJob(const KURL& url, bool showProgressInfo);
01074 
01081          virtual void start(Slave *slave);
01082 
01090         void get(long id, const KURL &url, const MetaData &metaData);
01091 
01092     signals:
01099         void data( long id, const QByteArray &data);
01100 
01106         void mimetype( long id, const QString &type );
01107 
01115         void result( long id);
01116 
01117     protected slots:
01118         virtual void slotRedirection( const KURL &url);
01119         virtual void slotFinished();
01120         virtual void slotData( const QByteArray &data);
01121         virtual void slotMimetype( const QString &mimetype );
01122     private:
01123         struct GetRequest {
01124         public:
01125            GetRequest(long _id, const KURL &_url, const MetaData &_metaData)
01126              : id(_id), url(_url), metaData(_metaData) { }
01127            long id;
01128            KURL url;
01129            MetaData metaData;
01130         };
01131         bool findCurrentEntry();
01132         void flushQueue(QPtrList<GetRequest> &queue);
01133 
01134         QPtrList<GetRequest> m_waitQueue;
01135         QPtrList<GetRequest> m_activeQueue;
01136         bool b_multiGetActive;
01137         GetRequest *m_currentEntry;
01138     protected:
01139     virtual void virtual_hook( int id, void* data );
01140     private:
01141     class MultiGetJobPrivate* d;
01142     };
01143 
01150     class KIO_EXPORT MimetypeJob : public TransferJob {
01151     Q_OBJECT
01152 
01153     public:
01162         MimetypeJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
01163 
01169          QString mimetype() const { return m_mimetype; }
01170 
01177         virtual void start( Slave *slave );
01178 
01179     protected slots:
01180         virtual void slotFinished( );
01181     protected:
01182     virtual void virtual_hook( int id, void* data );
01183     private:
01184     class MimetypeJobPrivate* d;
01185     };
01186 
01192     class KIO_EXPORT FileCopyJob : public Job {
01193     Q_OBJECT
01194 
01195     public:
01207         FileCopyJob( const KURL& src, const KURL& dest, int permissions,
01208                      bool move, bool overwrite, bool resume, bool showProgressInfo);
01209 
01210         ~FileCopyJob();
01217         void setSourceSize64(KIO::filesize_t size);
01218 
01222         void setSourceSize( off_t size ) KDE_DEPRECATED;
01223 
01228         KURL srcURL() const { return m_src; }
01229 
01234         KURL destURL() const { return m_dest; }
01235 
01236     public slots:
01237         void slotStart();
01238         void slotData( KIO::Job *, const QByteArray &data);
01239         void slotDataReq( KIO::Job *, QByteArray &data);
01240 
01241     protected slots:
01246         virtual void slotResult( KIO::Job *job );
01247 
01253         void slotProcessedSize( KIO::Job *job, KIO::filesize_t size );
01259         void slotTotalSize( KIO::Job *job, KIO::filesize_t size );
01265         void slotPercent( KIO::Job *job, unsigned long pct );
01271         void slotCanResume( KIO::Job *job, KIO::filesize_t offset );
01272 
01273     protected:
01274         void startCopyJob();
01275         void startCopyJob(const KURL &slave_url);
01276         void startRenameJob(const KURL &slave_url);
01277         void startDataPump();
01278         void connectSubjob( SimpleJob * job );
01279 
01280     private:
01281         void startBestCopyMethod();
01282 
01283     protected:
01284         KURL m_src;
01285         KURL m_dest;
01286         int m_permissions;
01287         bool m_move:1;
01288         bool m_overwrite:1;
01289         bool m_resume:1;
01290         bool m_canResume:1;
01291         bool m_resumeAnswerSent:1;
01292         QByteArray m_buffer;
01293         SimpleJob *m_moveJob;
01294         SimpleJob *m_copyJob;
01295         TransferJob *m_getJob;
01296         TransferJob *m_putJob;
01297         KIO::filesize_t m_totalSize;
01298     protected:
01299     virtual void virtual_hook( int id, void* data );
01300     private:
01301     class FileCopyJobPrivate;
01302     FileCopyJobPrivate* d;
01303     };
01304 
01312     class KIO_EXPORT ListJob : public SimpleJob {
01313     Q_OBJECT
01314 
01315     public:
01326         ListJob(const KURL& url, bool showProgressInfo,
01327                 bool recursive = false, QString prefix = QString::null,
01328                 bool includeHidden = true);
01329 
01336         virtual void start( Slave *slave );
01337 
01342         void setUnrestricted(bool unrestricted);
01343 
01344     signals:
01354         void entries( KIO::Job *job, const KIO::UDSEntryList& list);
01355 
01363         void redirection( KIO::Job *job, const KURL &url );
01364 
01373         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
01374 
01375     protected slots:
01376         virtual void slotFinished( );
01377         virtual void slotMetaData( const KIO::MetaData &_metaData);
01378         virtual void slotResult( KIO::Job *job );
01379         void slotListEntries( const KIO::UDSEntryList& list );
01380         void slotRedirection( const KURL &url );
01381         void gotEntries( KIO::Job * subjob, const KIO::UDSEntryList& list );
01382 
01383     private:
01384         bool recursive;
01385         bool includeHidden;
01386         QString prefix;
01387         unsigned long m_processedEntries;
01388         KURL m_redirectionURL;
01389     protected:
01390     virtual void virtual_hook( int id, void* data );
01391     private:
01392     class ListJobPrivate* d;
01393     };
01394 
01396     struct KIO_EXPORT CopyInfo
01397     {
01398         KURL uSource;
01399         KURL uDest;
01400         QString linkDest; // for symlinks only
01401         int permissions;
01402         //mode_t type;
01403         time_t ctime;
01404         time_t mtime;
01405         KIO::filesize_t size; // 0 for dirs
01406     };
01407 
01420     class KIO_EXPORT CopyJob : public Job {
01421     Q_OBJECT
01422 
01423     public:
01427         enum CopyMode{ Copy, Move, Link };
01428 
01446         CopyJob( const KURL::List& src, const KURL& dest, CopyMode mode, bool asMethod, bool showProgressInfo );
01447 
01448         virtual ~CopyJob();
01449 
01454         KURL::List srcURLs() const { return m_srcList; }
01455 
01460         KURL destURL() const { return m_dest; }
01461 
01472         void setDefaultPermissions( bool b );
01473 
01483         void setInteractive( bool b );
01484 
01485     signals:
01486 
01492         void totalFiles( KIO::Job *job, unsigned long files );
01498         void totalDirs( KIO::Job *job, unsigned long dirs );
01499 
01507         void aboutToCreate( KIO::Job *job, const QValueList<KIO::CopyInfo> &files);
01508 
01514         void processedFiles( KIO::Job *job, unsigned long files );
01520         void processedDirs( KIO::Job *job, unsigned long dirs );
01521 
01529         void copying( KIO::Job *job, const KURL& from, const KURL& to );
01537         void linking( KIO::Job *job, const QString& target, const KURL& to );
01545         void moving( KIO::Job *job, const KURL& from, const KURL& to );
01551         void creatingDir( KIO::Job *job, const KURL& dir );
01558         void renamed( KIO::Job *job, const KURL& from, const KURL& to );
01559 
01572         void copyingDone( KIO::Job *job, const KURL &from, const KURL &to, bool directory, bool renamed );
01582         void copyingLinkDone( KIO::Job *job, const KURL &from, const QString& target, const KURL& to );
01583 
01584     protected:
01585         void statCurrentSrc();
01586         void statNextSrc();
01587 
01588         // Those aren't slots but submethods for slotResult.
01589         void slotResultStating( KIO::Job * job );
01590         void startListing( const KURL & src );
01591         void slotResultCreatingDirs( KIO::Job * job );
01592         void slotResultConflictCreatingDirs( KIO::Job * job );
01593         void createNextDir();
01594         void slotResultCopyingFiles( KIO::Job * job );
01595         void slotResultConflictCopyingFiles( KIO::Job * job );
01596         void copyNextFile();
01597         void slotResultDeletingDirs( KIO::Job * job );
01598         void deleteNextDir();
01599         void skip( const KURL & sourceURL );
01600         void slotResultRenaming( KIO::Job * job );
01601     private:
01602         void startRenameJob(const KURL &slave_url);
01603         bool shouldOverwrite( const QString& path ) const;
01604         bool shouldSkip( const QString& path ) const;
01605         void skipSrc();
01606 
01607     protected slots:
01608         void slotStart();
01609         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01610         virtual void slotResult( KIO::Job *job );
01614         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01619         void slotTotalSize( KIO::Job*, KIO::filesize_t size );
01620 
01621         void slotReport();
01622     private:
01623         CopyMode m_mode;
01624         bool m_asMethod;
01625         enum DestinationState { DEST_NOT_STATED, DEST_IS_DIR, DEST_IS_FILE, DEST_DOESNT_EXIST };
01626         DestinationState destinationState;
01627         enum { STATE_STATING, STATE_RENAMING, STATE_LISTING, STATE_CREATING_DIRS,
01628                STATE_CONFLICT_CREATING_DIRS, STATE_COPYING_FILES, STATE_CONFLICT_COPYING_FILES,
01629                STATE_DELETING_DIRS } state;
01630         KIO::filesize_t m_totalSize;
01631         KIO::filesize_t m_processedSize;
01632         KIO::filesize_t m_fileProcessedSize;
01633         int m_processedFiles;
01634         int m_processedDirs;
01635         QValueList<CopyInfo> files;
01636         QValueList<CopyInfo> dirs;
01637         KURL::List dirsToRemove;
01638         KURL::List m_srcList;
01639         KURL::List::Iterator m_currentStatSrc;
01640         bool m_bCurrentSrcIsDir;
01641         bool m_bCurrentOperationIsLink;
01642         bool m_bSingleFileCopy;
01643         bool m_bOnlyRenames;
01644         KURL m_dest;
01645         KURL m_currentDest;
01646         //
01647         QStringList m_skipList;
01648         QStringList m_overwriteList;
01649         bool m_bAutoSkip;
01650         bool m_bOverwriteAll;
01651         int m_conflictError;
01652 
01653         QTimer *m_reportTimer;
01654         //these both are used for progress dialog reporting
01655         KURL m_currentSrcURL;
01656         KURL m_currentDestURL;
01657     protected:
01658     virtual void virtual_hook( int id, void* data );
01659     private:
01660     class CopyJobPrivate;
01661         CopyJobPrivate* d;
01662         friend class CopyJobPrivate; // for DestinationState
01663     };
01664 
01671     class KIO_EXPORT DeleteJob : public Job {
01672     Q_OBJECT
01673 
01674     public:
01684         DeleteJob( const KURL::List& src, bool shred, bool showProgressInfo );
01685 
01690         KURL::List urls() const { return m_srcList; }
01691 
01692     signals:
01693 
01699         void totalFiles( KIO::Job *job, unsigned long files );
01705         void totalDirs( KIO::Job *job, unsigned long dirs );
01706 
01712         void processedFiles( KIO::Job *job, unsigned long files );
01718         void processedDirs( KIO::Job *job, unsigned long dirs );
01719 
01726         void deleting( KIO::Job *job, const KURL& file );
01727 
01728     protected slots:
01729         void slotStart();
01730         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01731         virtual void slotResult( KIO::Job *job );
01732 
01736         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01737         void slotReport();
01738 
01739     private:
01740         void statNextSrc();
01741         void deleteNextFile();
01742         void deleteNextDir();
01743 
01744     private:
01745         enum { STATE_STATING, STATE_LISTING,
01746                STATE_DELETING_FILES, STATE_DELETING_DIRS } state;
01747         KIO::filesize_t m_totalSize;
01748         KIO::filesize_t m_processedSize;
01749         KIO::filesize_t m_fileProcessedSize;
01750         int m_processedFiles;
01751         int m_processedDirs;
01752         int m_totalFilesDirs;
01753         KURL m_currentURL;
01754         KURL::List files;
01755         KURL::List symlinks;
01756         KURL::List dirs;
01757         KURL::List m_srcList;
01758         KURL::List::Iterator m_currentStat;
01759     QStringList m_parentDirs;
01760         bool m_shred; // BIC: remove in KDE4
01761         QTimer *m_reportTimer;
01762     protected:
01764     virtual void virtual_hook( int id, void* data );
01765     private:
01766     class DeleteJobPrivate* d;
01767     };
01768 
01769 }
01770 
01771 #endif
KDE Logo
This file is part of the documentation for kio Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Fri Apr 22 16:03:44 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003