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 <kurl.h>
00026 #include <kdemacros.h>
00027 
00028 #include <qobject.h>
00029 #include <qptrlist.h>
00030 #include <qstring.h>
00031 #include <qstringlist.h>
00032 #include <qguardedptr.h>
00033 
00034 #include <sys/types.h>
00035 #include <sys/stat.h>
00036 
00037 #include <kio/global.h>
00038 
00039 class Observer;
00040 class QTimer;
00041 
00042 namespace KIO {
00043 
00044     class Slave;
00045     class SlaveInterface;
00046 
00047 
00068     class 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 );
00397 
00406         void emitPercent( KIO::filesize_t processedSize, KIO::filesize_t totalSize );
00407 
00414         void emitSpeed( unsigned long bytes_per_second );
00415 
00420         void emitResult();
00421 
00426         void setProcessedSize(KIO::filesize_t size);
00427 
00433         enum { EF_TransferJobAsync    = (1 << 0),
00434                EF_TransferJobNeedData = (1 << 1),
00435                EF_TransferJobDataSent = (1 << 2),
00436                EF_ListJobUnrestricted = (1 << 3) };
00437         int &extraFlags();
00438 
00439         QPtrList<Job> subjobs;
00440         int m_error;
00441         QString m_errorText;
00442         unsigned long m_percent;
00443         int m_progressId; // for uiserver
00444         QTimer *m_speedTimer;
00445         QGuardedPtr<QWidget> m_window;
00446         MetaData m_outgoingMetaData;
00447         MetaData m_incomingMetaData;
00448     protected:
00449     virtual void virtual_hook( int id, void* data );
00450     private:
00451         class JobPrivate;
00452         JobPrivate *d;
00453     };
00454 
00461     class SimpleJob : public KIO::Job {
00462     Q_OBJECT
00463 
00464     public:
00473         SimpleJob(const KURL& url, int command, const QByteArray &packedArgs,
00474                   bool showProgressInfo);
00475 
00476         ~SimpleJob();
00477 
00482         const KURL& url() const { return m_url; }
00483 
00491         virtual void kill( bool quietly = true );
00492 
00497         virtual void putOnHold();
00498 
00502         static void removeOnHold();
00503 
00509         virtual void start( Slave *slave );
00510 
00515         void slaveDone();
00516 
00521         Slave *slave() const { return m_slave; }
00522 
00526         int command() const { return m_command; }
00527 
00528     public slots:
00534         void slotTotalSize( KIO::filesize_t data_size );
00535 
00536     protected slots:
00541         virtual void slotFinished( );
00542 
00547         void slotWarning( const QString & ); // KDE4: make virtual
00548 
00554         void slotInfoMessage( const QString &s ); // KDE4: make virtual
00555 
00560         void slotConnected();
00561 
00567         void slotProcessedSize( KIO::filesize_t data_size );
00573         void slotSpeed( unsigned long bytes_per_second );
00574 
00580         virtual void slotMetaData( const KIO::MetaData &_metaData);
00581 
00582     public slots:
00588         virtual void slotError( int , const QString & );
00589 
00590     protected slots:
00594         void slotNeedProgressId();
00595 
00596     protected:
00597         Slave * m_slave;
00598         QByteArray m_packedArgs;
00599         KURL m_url;
00600         KURL m_subUrl;
00601         int m_command;
00602         KIO::filesize_t m_totalSize;
00603     protected:
00604     virtual void virtual_hook( int id, void* data );
00605     /*
00606      * Allow jobs that inherit SimpleJob and are aware
00607      * of redirections to store the SSL session used.
00608      * Retrieval is handled by SimpleJob::start
00609      * @param m_redirectionURL Reference to redirection URL,
00610      * used instead of m_url if not empty
00611      */
00612     void storeSSLSessionFromJob(const KURL &m_redirectionURL);
00613     private:
00614     class SimpleJobPrivate* d;
00615     };
00616 
00621     class StatJob : public SimpleJob {
00622 
00623     Q_OBJECT
00624 
00625     public:
00633         StatJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00634 
00642         void setSide( bool source ) { m_bSource = source; }
00643 
00653         void setDetails( short int details ) { m_details = details; }
00654 
00660         const UDSEntry & statResult() const { return m_statResult; }
00661 
00668         virtual void start( Slave *slave );
00669 
00670     signals:
00678         void redirection( KIO::Job *job, const KURL &url );
00679 
00688         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00689 
00690     protected slots:
00691         void slotStatEntry( const KIO::UDSEntry & entry );
00692         void slotRedirection( const KURL &url);
00693         virtual void slotFinished();
00694         virtual void slotMetaData( const KIO::MetaData &_metaData);
00695 
00696     protected:
00697         UDSEntry m_statResult;
00698         KURL m_redirectionURL;
00699         bool m_bSource;
00700         short int m_details;
00701     protected:
00702     virtual void virtual_hook( int id, void* data );
00703     private:
00704         class StatJobPrivate;
00705         StatJobPrivate *d;
00706     };
00707 
00713     class MkdirJob : public SimpleJob {
00714 
00715     Q_OBJECT
00716 
00717     public:
00725         MkdirJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00726 
00733         virtual void start( Slave *slave );
00734 
00735     signals:
00743         void redirection( KIO::Job *job, const KURL &url );
00744 
00752         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00753 
00754     protected slots:
00755         void slotRedirection( const KURL &url);
00756         virtual void slotFinished();
00757 
00758     protected:
00759         KURL m_redirectionURL;
00760                     
00761     protected:
00762     virtual void virtual_hook( int id, void* data );
00763     private:
00764         class MkdirJobPrivate;
00765         MkdirJobPrivate *d;
00766     };
00767 
00772     class DirectCopyJob : public SimpleJob {
00773     Q_OBJECT
00774 
00775     public:
00779         DirectCopyJob(const KURL& url, int command, const QByteArray &packedArgs,
00780                       bool showProgressInfo);
00787         virtual void start(Slave *slave);
00788 
00789     signals:
00795         void canResume( KIO::Job *job, KIO::filesize_t offset );
00796 
00797     private slots:
00798         void slotCanResume( KIO::filesize_t offset );
00799     };
00800 
00801 
00808     class TransferJob : public SimpleJob {
00809     Q_OBJECT
00810 
00811     public:
00821         TransferJob(const KURL& url, int command,
00822                     const QByteArray &packedArgs,
00823                     const QByteArray &_staticData,
00824                     bool showProgressInfo);
00825 
00832         virtual void start(Slave *slave);
00833 
00838         virtual void slotResult( KIO::Job *job );
00839 
00843         void suspend();
00844 
00848         void resume();
00849 
00854     bool isSuspended() const { return m_suspended; }
00855 
00856 
00864         bool isErrorPage() const { return m_errorPage; }
00865 
00873         void setAsyncDataEnabled(bool enabled);
00874 
00881         void sendAsyncData(const QByteArray &data);
00882 
00890         void setReportDataSent(bool enabled);
00891 
00898         bool reportDataSent();
00899 
00900     signals:
00910         void data( KIO::Job *job, const QByteArray &data );
00911 
00923         void dataReq( KIO::Job *job, QByteArray &data );
00924 
00932         void redirection( KIO::Job *job, const KURL &url );
00933 
00942         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00943 
00949         void mimetype( KIO::Job *job, const QString &type );
00950 
00958         void canResume( KIO::Job *job, KIO::filesize_t offset );
00959 
00960 
00961     protected slots:
00962         virtual void slotRedirection( const KURL &url);
00963         virtual void slotFinished();
00964         virtual void slotData( const QByteArray &data);
00965         virtual void slotDataReq();
00966         virtual void slotMimetype( const QString &mimetype );
00967         virtual void slotNeedSubURLData();
00968         virtual void slotSubURLData(KIO::Job*, const QByteArray &);
00969         virtual void slotMetaData( const KIO::MetaData &_metaData);
00970         void slotErrorPage();
00971         void slotCanResume( KIO::filesize_t offset );
00972         void slotPostRedirection();
00973 
00974     protected:
00975         bool m_suspended;
00976         bool m_errorPage;
00977         QByteArray staticData;
00978         KURL m_redirectionURL;
00979         KURL::List m_redirectionList;
00980         QString m_mimetype;
00981         TransferJob *m_subJob;
00982     protected:
00983     virtual void virtual_hook( int id, void* data );
00984     private:
00985     class TransferJobPrivate *d;
00986     };
00987 
01008     class StoredTransferJob : public KIO::TransferJob {
01009         Q_OBJECT
01010 
01011     public:
01021         StoredTransferJob(const KURL& url, int command,
01022                           const QByteArray &packedArgs,
01023                           const QByteArray &_staticData,
01024                           bool showProgressInfo);
01025 
01031         void setData( const QByteArray& arr );
01032 
01037         QByteArray data() const { return m_data; }
01038 
01039     private slots:
01040         void slotStoredData( KIO::Job *job, const QByteArray &data );
01041         void slotStoredDataReq( KIO::Job *job, QByteArray &data );
01042     private:
01043         QByteArray m_data;
01044         int m_uploadOffset;
01045     };
01046 
01053     class MultiGetJob : public TransferJob {
01054     Q_OBJECT
01055 
01056     public:
01064         MultiGetJob(const KURL& url, bool showProgressInfo);
01065 
01072          virtual void start(Slave *slave);
01073 
01081         void get(long id, const KURL &url, const MetaData &metaData);
01082 
01083     signals:
01090         void data( long id, const QByteArray &data);
01091 
01097         void mimetype( long id, const QString &type );
01098 
01106         void result( long id);
01107 
01108     protected slots:
01109         virtual void slotRedirection( const KURL &url);
01110         virtual void slotFinished();
01111         virtual void slotData( const QByteArray &data);
01112         virtual void slotMimetype( const QString &mimetype );
01113     private:
01114         struct GetRequest {
01115         public:
01116            GetRequest(long _id, const KURL &_url, const MetaData &_metaData)
01117              : id(_id), url(_url), metaData(_metaData) { }
01118            long id;
01119            KURL url;
01120            MetaData metaData;
01121         };
01122         bool findCurrentEntry();
01123         void flushQueue(QPtrList<GetRequest> &queue);
01124 
01125         QPtrList<GetRequest> m_waitQueue;
01126         QPtrList<GetRequest> m_activeQueue;
01127         bool b_multiGetActive;
01128         GetRequest *m_currentEntry;
01129     protected:
01130     virtual void virtual_hook( int id, void* data );
01131     private:
01132     class MultiGetJobPrivate* d;
01133     };
01134 
01141     class MimetypeJob : public TransferJob {
01142     Q_OBJECT
01143 
01144     public:
01153         MimetypeJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
01154 
01160          QString mimetype() const { return m_mimetype; }
01161 
01168         virtual void start( Slave *slave );
01169 
01170     protected slots:
01171         virtual void slotFinished( );
01172     protected:
01173     virtual void virtual_hook( int id, void* data );
01174     private:
01175     class MimetypeJobPrivate* d;
01176     };
01177 
01183     class FileCopyJob : public Job {
01184     Q_OBJECT
01185 
01186     public:
01198         FileCopyJob( const KURL& src, const KURL& dest, int permissions,
01199                      bool move, bool overwrite, bool resume, bool showProgressInfo);
01200 
01201         ~FileCopyJob();
01208         void setSourceSize64(KIO::filesize_t size);
01209 
01213         void setSourceSize( off_t size ) KDE_DEPRECATED;
01214 
01219         KURL srcURL() const { return m_src; }
01220 
01225         KURL destURL() const { return m_dest; }
01226 
01227     public slots:
01228         void slotStart();
01229         void slotData( KIO::Job *, const QByteArray &data);
01230         void slotDataReq( KIO::Job *, QByteArray &data);
01231 
01232     protected slots:
01237         virtual void slotResult( KIO::Job *job );
01238 
01244         void slotProcessedSize( KIO::Job *job, KIO::filesize_t size );
01250         void slotTotalSize( KIO::Job *job, KIO::filesize_t size );
01256         void slotPercent( KIO::Job *job, unsigned long pct );
01262         void slotCanResume( KIO::Job *job, KIO::filesize_t offset );
01263 
01264     protected:
01265         void startCopyJob();
01266         void startCopyJob(const KURL &slave_url);
01267         void startDataPump();
01268         void connectSubjob( SimpleJob * job );
01269 
01270         KURL m_src;
01271         KURL m_dest;
01272         int m_permissions;
01273         bool m_move:1;
01274         bool m_overwrite:1;
01275         bool m_resume:1;
01276         bool m_canResume:1;
01277         bool m_resumeAnswerSent:1;
01278         QByteArray m_buffer;
01279         SimpleJob *m_moveJob;
01280         SimpleJob *m_copyJob;
01281         TransferJob *m_getJob;
01282         TransferJob *m_putJob;
01283         KIO::filesize_t m_totalSize;
01284     protected:
01285     virtual void virtual_hook( int id, void* data );
01286     private:
01287     class FileCopyJobPrivate;
01288     FileCopyJobPrivate* d;
01289     };
01290 
01298     class ListJob : public SimpleJob {
01299     Q_OBJECT
01300 
01301     public:
01312         ListJob(const KURL& url, bool showProgressInfo,
01313                 bool recursive = false, QString prefix = QString::null,
01314                 bool includeHidden = true);
01315 
01322         virtual void start( Slave *slave );
01323 
01328         void setUnrestricted(bool unrestricted);
01329 
01330     signals:
01340         void entries( KIO::Job *job, const KIO::UDSEntryList& list);
01341 
01349         void redirection( KIO::Job *job, const KURL &url );
01350 
01359         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
01360 
01361     protected slots:
01362         virtual void slotFinished( );
01363         virtual void slotMetaData( const KIO::MetaData &_metaData);
01364         virtual void slotResult( KIO::Job *job );
01365         void slotListEntries( const KIO::UDSEntryList& list );
01366         void slotRedirection( const KURL &url );
01367         void gotEntries( KIO::Job * subjob, const KIO::UDSEntryList& list );
01368 
01369     private:
01370         bool recursive;
01371         bool includeHidden;
01372         QString prefix;
01373         unsigned long m_processedEntries;
01374         KURL m_redirectionURL;
01375     protected:
01376     virtual void virtual_hook( int id, void* data );
01377     private:
01378     class ListJobPrivate* d;
01379     };
01380 
01381     struct CopyInfo
01382     {
01383         KURL uSource;
01384         KURL uDest;
01385         QString linkDest; // for symlinks only
01386         int permissions;
01387         //mode_t type;
01388         time_t ctime;
01389         time_t mtime;
01390         KIO::filesize_t size; // 0 for dirs
01391     };
01392 
01405     class CopyJob : public Job {
01406     Q_OBJECT
01407 
01408     public:
01412         enum CopyMode{ Copy, Move, Link };
01413 
01431         CopyJob( const KURL::List& src, const KURL& dest, CopyMode mode, bool asMethod, bool showProgressInfo );
01432 
01433         virtual ~CopyJob();
01434 
01439         KURL::List srcURLs() const { return m_srcList; }
01440 
01445         KURL destURL() const { return m_dest; }
01446 
01457         void setDefaultPermissions( bool b );
01458 
01459     signals:
01460 
01466         void totalFiles( KIO::Job *job, unsigned long files );
01472         void totalDirs( KIO::Job *job, unsigned long dirs );
01473 
01481         void aboutToCreate( KIO::Job *job, const QValueList<KIO::CopyInfo> &files);
01482 
01488         void processedFiles( KIO::Job *job, unsigned long files );
01494         void processedDirs( KIO::Job *job, unsigned long dirs );
01495 
01503         void copying( KIO::Job *job, const KURL& from, const KURL& to );
01511         void linking( KIO::Job *job, const QString& target, const KURL& to );
01519         void moving( KIO::Job *job, const KURL& from, const KURL& to );
01525         void creatingDir( KIO::Job *job, const KURL& dir );
01532         void renamed( KIO::Job *job, const KURL& from, const KURL& to );
01533 
01546         void copyingDone( KIO::Job *job, const KURL &from, const KURL &to, bool directory, bool renamed );
01556         void copyingLinkDone( KIO::Job *job, const KURL &from, const QString& target, const KURL& to );
01557 
01558     protected:
01559         void statCurrentSrc();
01560         void statNextSrc();
01561 
01562         // Those aren't slots but submethods for slotResult.
01563         void slotResultStating( KIO::Job * job );
01564         void startListing( const KURL & src );
01565         void slotResultCreatingDirs( KIO::Job * job );
01566         void slotResultConflictCreatingDirs( KIO::Job * job );
01567         void createNextDir();
01568         void slotResultCopyingFiles( KIO::Job * job );
01569         void slotResultConflictCopyingFiles( KIO::Job * job );
01570         void copyNextFile();
01571         void slotResultDeletingDirs( KIO::Job * job );
01572         void deleteNextDir();
01573         void skip( const KURL & sourceURL );
01574         void slotResultRenaming(  KIO::Job * job );
01575     private:
01576         void startRenameJob( const KURL &slave_url );
01577         bool shouldOverwrite(  const QString& path ) const;
01578         bool shouldSkip(  const QString& path ) const;
01579         void skipSrc();
01580 
01581     protected slots:
01582         void slotStart();
01583         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01584         virtual void slotResult( KIO::Job *job );
01588         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01593         void slotTotalSize( KIO::Job*, KIO::filesize_t size );
01594 
01595         void slotReport();
01596     private:
01597         CopyMode m_mode;
01598         bool m_asMethod;
01599         enum DestinationState { DEST_NOT_STATED, DEST_IS_DIR, DEST_IS_FILE, DEST_DOESNT_EXIST };
01600         DestinationState destinationState;
01601         enum { STATE_STATING, STATE_RENAMING, STATE_LISTING, STATE_CREATING_DIRS,
01602                STATE_CONFLICT_CREATING_DIRS, STATE_COPYING_FILES, STATE_CONFLICT_COPYING_FILES,
01603                STATE_DELETING_DIRS } state;
01604         KIO::filesize_t m_totalSize;
01605         KIO::filesize_t m_processedSize;
01606         KIO::filesize_t m_fileProcessedSize;
01607         int m_processedFiles;
01608         int m_processedDirs;
01609         QValueList<CopyInfo> files;
01610         QValueList<CopyInfo> dirs;
01611         KURL::List dirsToRemove;
01612         KURL::List m_srcList;
01613         KURL::List::Iterator m_currentStatSrc;
01614         bool m_bCurrentSrcIsDir;
01615         bool m_bCurrentOperationIsLink;
01616         bool m_bSingleFileCopy;
01617         bool m_bOnlyRenames;
01618         KURL m_dest;
01619         KURL m_currentDest;
01620         //
01621         QStringList m_skipList;
01622         QStringList m_overwriteList;
01623         bool m_bAutoSkip;
01624         bool m_bOverwriteAll;
01625         int m_conflictError;
01626 
01627         QTimer *m_reportTimer;
01628         //these both are used for progress dialog reporting
01629         KURL m_currentSrcURL;
01630         KURL m_currentDestURL;
01631     protected:
01632     virtual void virtual_hook( int id, void* data );
01633     private:
01634     class CopyJobPrivate;
01635         CopyJobPrivate* d;
01636         friend class CopyJobPrivate; // for DestinationState
01637     };
01638 
01645     class DeleteJob : public Job {
01646     Q_OBJECT
01647 
01648     public:
01658         DeleteJob( const KURL::List& src, bool shred, bool showProgressInfo );
01659 
01664         KURL::List urls() const { return m_srcList; }
01665 
01666     signals:
01667 
01673         void totalFiles( KIO::Job *job, unsigned long files );
01679         void totalDirs( KIO::Job *job, unsigned long dirs );
01680 
01686         void processedFiles( KIO::Job *job, unsigned long files );
01692         void processedDirs( KIO::Job *job, unsigned long dirs );
01693 
01700         void deleting( KIO::Job *job, const KURL& file );
01701 
01702     protected slots:
01703         void slotStart();
01704         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01705         virtual void slotResult( KIO::Job *job );
01706 
01710         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01711         void slotReport();
01712 
01713     private:
01714         void statNextSrc();
01715         void deleteNextFile();
01716         void deleteNextDir();
01717 
01718     private:
01719         enum { STATE_STATING, STATE_LISTING,
01720                STATE_DELETING_FILES, STATE_DELETING_DIRS } state;
01721         KIO::filesize_t m_totalSize;
01722         KIO::filesize_t m_processedSize;
01723         KIO::filesize_t m_fileProcessedSize;
01724         int m_processedFiles;
01725         int m_processedDirs;
01726         int m_totalFilesDirs;
01727         KURL m_currentURL;
01728         KURL::List files;
01729         KURL::List symlinks;
01730         KURL::List dirs;
01731         KURL::List m_srcList;
01732         KURL::List::Iterator m_currentStat;
01733     QStringList m_parentDirs;
01734         bool m_shred;
01735         QTimer *m_reportTimer;
01736     protected:
01738     virtual void virtual_hook( int id, void* data );
01739     private:
01740     class DeleteJobPrivate* d;
01741     };
01742 
01743 }
01744 
01745 #endif
KDE Logo
This file is part of the documentation for kio Library Version 3.3.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sun Jan 15 13:33:22 2006 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003