• Skip to content
  • Skip to link menu
KDE 3.5 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

kio

jobclasses.h

Go to the documentation of this file.
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 
00236         void updateUserTimestamp( unsigned long time );
00237 
00248         void setParentJob( Job* parentJob );
00249 
00256         Job* parentJob() const;
00257 
00265         void setMetaData( const KIO::MetaData &metaData);
00266 
00274         void addMetaData(const QString &key, const QString &value);
00275 
00283         void addMetaData(const QMap<QString,QString> &values);
00284 
00292         void mergeMetaData(const QMap<QString,QString> &values);
00293 
00297         MetaData outgoingMetaData() const;
00298 
00304         MetaData metaData() const;
00305 
00313         QString queryMetaData(const QString &key);
00314 
00320         KIO::filesize_t getProcessedSize();
00321 
00322     signals:
00328         void result( KIO::Job *job );
00329 
00337         void canceled( KIO::Job *job );
00338 
00345         void infoMessage( KIO::Job *job, const QString & msg );
00346         // KDE4: Separate rich-text string from plain-text string, for different widgets.
00347 
00354         void warning( KIO::Job *job, const QString & msg );
00355         // KDE4: Separate rich-text string from plain-text string, for different widgets.
00356 
00363         void connected( KIO::Job *job );
00364 
00373         void percent( KIO::Job *job, unsigned long percent );
00374 
00381         void totalSize( KIO::Job *job, KIO::filesize_t size );
00382 
00389         void processedSize( KIO::Job *job, KIO::filesize_t size );
00390 
00396         void speed( KIO::Job *job, unsigned long speed );
00397 
00398     protected slots:
00407         virtual void slotResult( KIO::Job *job );
00408 
00415         void slotSpeed( KIO::Job *job, unsigned long speed );
00422         void slotInfoMessage( KIO::Job *job, const QString &msg );
00423 
00427         void slotSpeedTimeout();
00428 
00429     protected:
00439         virtual void addSubjob( Job *job, bool inheritMetaData=true );
00440 
00449         virtual void removeSubjob( Job *job );
00458         void removeSubjob( Job *job, bool mergeMetaData, bool emitResultIfLast ); // KDE4: merge with above, with =true to both
00459 
00468         void emitPercent( KIO::filesize_t processedSize, KIO::filesize_t totalSize );
00469 
00476         void emitSpeed( unsigned long speed );
00477 
00482         void emitResult();
00483 
00488         void setProcessedSize(KIO::filesize_t size);
00489 
00493         unsigned long userTimestamp() const;
00494 
00500         enum { EF_TransferJobAsync    = (1 << 0),
00501                EF_TransferJobNeedData = (1 << 1),
00502                EF_TransferJobDataSent = (1 << 2),
00503                EF_ListJobUnrestricted = (1 << 3) };
00504         int &extraFlags();
00505 
00506         QPtrList<Job> subjobs;
00507         int m_error;
00508         QString m_errorText;
00509         unsigned long m_percent;
00510         int m_progressId; // for uiserver
00511         QTimer *m_speedTimer;
00512         QGuardedPtr<QWidget> m_window;
00513         MetaData m_outgoingMetaData;
00514         MetaData m_incomingMetaData;
00515     protected:
00516     virtual void virtual_hook( int id, void* data );
00517     private:
00518         class JobPrivate;
00519         JobPrivate *d;
00520     };
00521 
00528     class KIO_EXPORT SimpleJob : public KIO::Job {
00529     Q_OBJECT
00530 
00531     public:
00540         SimpleJob(const KURL& url, int command, const QByteArray &packedArgs,
00541                   bool showProgressInfo);
00542 
00543         ~SimpleJob();
00544 
00549         const KURL& url() const { return m_url; }
00550 
00558         virtual void kill( bool quietly = true );
00559 
00564         virtual void putOnHold();
00565 
00569         static void removeOnHold();
00570 
00576         virtual void start( Slave *slave );
00577 
00582         void slaveDone();
00583 
00588         Slave *slave() const { return m_slave; }
00589 
00593         int command() const { return m_command; }
00594 
00595     public slots:
00601         void slotTotalSize( KIO::filesize_t data_size );
00602 
00603     protected slots:
00608         virtual void slotFinished( );
00609 
00614         void slotWarning( const QString & ); // KDE4: make virtual
00615 
00621         void slotInfoMessage( const QString &s ); // KDE4: make virtual
00622 
00627         void slotConnected();
00628 
00634         void slotProcessedSize( KIO::filesize_t data_size );
00640         void slotSpeed( unsigned long speed );
00641 
00647         virtual void slotMetaData( const KIO::MetaData &_metaData);
00648 
00649     public slots:
00655         virtual void slotError( int , const QString & );
00656 
00657     protected slots:
00661         void slotNeedProgressId();
00662 
00663     protected:
00664         Slave * m_slave;
00665         QByteArray m_packedArgs;
00666         KURL m_url;
00667         KURL m_subUrl;
00668         int m_command;
00669         KIO::filesize_t m_totalSize;
00670     protected:
00671     virtual void virtual_hook( int id, void* data );
00672     /*
00673      * Allow jobs that inherit SimpleJob and are aware
00674      * of redirections to store the SSL session used.
00675      * Retrieval is handled by SimpleJob::start
00676      * @param m_redirectionURL Reference to redirection URL,
00677      * used instead of m_url if not empty
00678      */
00679     void storeSSLSessionFromJob(const KURL &m_redirectionURL);
00680     private:
00681     class SimpleJobPrivate* d;
00682     };
00683 
00688     class KIO_EXPORT StatJob : public SimpleJob {
00689 
00690     Q_OBJECT
00691 
00692     public:
00700         StatJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00701 
00709         void setSide( bool source ) { m_bSource = source; }
00710 
00720         void setDetails( short int details ) { m_details = details; }
00721 
00727         const UDSEntry & statResult() const { return m_statResult; }
00728 
00735         virtual void start( Slave *slave );
00736 
00737     signals:
00745         void redirection( KIO::Job *job, const KURL &url );
00746 
00755         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00756 
00757     protected slots:
00758         void slotStatEntry( const KIO::UDSEntry & entry );
00759         void slotRedirection( const KURL &url);
00760         virtual void slotFinished();
00761         virtual void slotMetaData( const KIO::MetaData &_metaData);
00762 
00763     protected:
00764         UDSEntry m_statResult;
00765         KURL m_redirectionURL;
00766         bool m_bSource;
00767         short int m_details;
00768     protected:
00769     virtual void virtual_hook( int id, void* data );
00770     private:
00771         class StatJobPrivate;
00772         StatJobPrivate *d;
00773     };
00774 
00780     class KIO_EXPORT MkdirJob : public SimpleJob {
00781 
00782     Q_OBJECT
00783 
00784     public:
00792         MkdirJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
00793 
00800         virtual void start( Slave *slave );
00801 
00802     signals:
00810         void redirection( KIO::Job *job, const KURL &url );
00811 
00819         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00820 
00821     protected slots:
00822         void slotRedirection( const KURL &url);
00823         virtual void slotFinished();
00824 
00825     protected:
00826         KURL m_redirectionURL;
00827 
00828     protected:
00829     virtual void virtual_hook( int id, void* data );
00830     private:
00831         class MkdirJobPrivate;
00832         MkdirJobPrivate *d;
00833     };
00834 
00839     class KIO_EXPORT DirectCopyJob : public SimpleJob {
00840     Q_OBJECT
00841 
00842     public:
00846         DirectCopyJob(const KURL& url, int command, const QByteArray &packedArgs,
00847                       bool showProgressInfo);
00854         virtual void start(Slave *slave);
00855 
00856     signals:
00862         void canResume( KIO::Job *job, KIO::filesize_t offset );
00863 
00864     private slots:
00865         void slotCanResume( KIO::filesize_t offset );
00866     };
00867 
00868 
00875     class KIO_EXPORT TransferJob : public SimpleJob {
00876     Q_OBJECT
00877 
00878     public:
00888         TransferJob(const KURL& url, int command,
00889                     const QByteArray &packedArgs,
00890                     const QByteArray &_staticData,
00891                     bool showProgressInfo);
00892 
00899         virtual void start(Slave *slave);
00900 
00905         virtual void slotResult( KIO::Job *job );
00906 
00910         void suspend();
00911 
00915         void resume();
00916 
00921     bool isSuspended() const { return m_suspended; }
00922 
00923 
00931         bool isErrorPage() const { return m_errorPage; }
00932 
00940         void setAsyncDataEnabled(bool enabled);
00941 
00948         void sendAsyncData(const QByteArray &data);
00949 
00957         void setReportDataSent(bool enabled);
00958 
00965         bool reportDataSent();
00966 
00967     signals:
00977         void data( KIO::Job *job, const QByteArray &data );
00978 
00990         void dataReq( KIO::Job *job, QByteArray &data );
00991 
00999         void redirection( KIO::Job *job, const KURL &url );
01000 
01009         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
01010 
01016         void mimetype( KIO::Job *job, const QString &type );
01017 
01025         void canResume( KIO::Job *job, KIO::filesize_t offset );
01026 
01027 
01028     protected slots:
01029         virtual void slotRedirection( const KURL &url);
01030         virtual void slotFinished();
01031         virtual void slotData( const QByteArray &data);
01032         virtual void slotDataReq();
01033         virtual void slotMimetype( const QString &mimetype );
01034         virtual void slotNeedSubURLData();
01035         virtual void slotSubURLData(KIO::Job*, const QByteArray &);
01036         virtual void slotMetaData( const KIO::MetaData &_metaData);
01037         void slotErrorPage();
01038         void slotCanResume( KIO::filesize_t offset );
01039         void slotPostRedirection();
01040 
01041     protected:
01042         bool m_suspended;
01043         bool m_errorPage;
01044         QByteArray staticData;
01045         KURL m_redirectionURL;
01046         KURL::List m_redirectionList;
01047         QString m_mimetype;
01048         TransferJob *m_subJob;
01049     protected:
01050     virtual void virtual_hook( int id, void* data );
01051     private:
01052     class TransferJobPrivate *d;
01053     };
01054 
01075     class KIO_EXPORT StoredTransferJob : public KIO::TransferJob {
01076         Q_OBJECT
01077 
01078     public:
01088         StoredTransferJob(const KURL& url, int command,
01089                           const QByteArray &packedArgs,
01090                           const QByteArray &_staticData,
01091                           bool showProgressInfo);
01092 
01098         void setData( const QByteArray& arr );
01099 
01104         QByteArray data() const { return m_data; }
01105 
01106     private slots:
01107         void slotStoredData( KIO::Job *job, const QByteArray &data );
01108         void slotStoredDataReq( KIO::Job *job, QByteArray &data );
01109     private:
01110         QByteArray m_data;
01111         int m_uploadOffset;
01112     };
01113 
01120     class KIO_EXPORT MultiGetJob : public TransferJob {
01121     Q_OBJECT
01122 
01123     public:
01131         MultiGetJob(const KURL& url, bool showProgressInfo);
01132 
01139          virtual void start(Slave *slave);
01140 
01148         void get(long id, const KURL &url, const MetaData &metaData);
01149 
01150     signals:
01157         void data( long id, const QByteArray &data);
01158 
01164         void mimetype( long id, const QString &type );
01165 
01173         void result( long id);
01174 
01175     protected slots:
01176         virtual void slotRedirection( const KURL &url);
01177         virtual void slotFinished();
01178         virtual void slotData( const QByteArray &data);
01179         virtual void slotMimetype( const QString &mimetype );
01180     private:
01181         struct GetRequest {
01182         public:
01183            GetRequest(long _id, const KURL &_url, const MetaData &_metaData)
01184              : id(_id), url(_url), metaData(_metaData) { }
01185            long id;
01186            KURL url;
01187            MetaData metaData;
01188         };
01189         bool findCurrentEntry();
01190         void flushQueue(QPtrList<GetRequest> &queue);
01191 
01192         QPtrList<GetRequest> m_waitQueue;
01193         QPtrList<GetRequest> m_activeQueue;
01194         bool b_multiGetActive;
01195         GetRequest *m_currentEntry;
01196     protected:
01197     virtual void virtual_hook( int id, void* data );
01198     private:
01199     class MultiGetJobPrivate* d;
01200     };
01201 
01208     class KIO_EXPORT MimetypeJob : public TransferJob {
01209     Q_OBJECT
01210 
01211     public:
01220         MimetypeJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
01221 
01227          QString mimetype() const { return m_mimetype; }
01228 
01235         virtual void start( Slave *slave );
01236 
01237     protected slots:
01238         virtual void slotFinished( );
01239     protected:
01240     virtual void virtual_hook( int id, void* data );
01241     private:
01242     class MimetypeJobPrivate* d;
01243     };
01244 
01250     class KIO_EXPORT FileCopyJob : public Job {
01251     Q_OBJECT
01252 
01253     public:
01265         FileCopyJob( const KURL& src, const KURL& dest, int permissions,
01266                      bool move, bool overwrite, bool resume, bool showProgressInfo);
01267 
01268         ~FileCopyJob();
01275         void setSourceSize64(KIO::filesize_t size);
01276 
01284         void setModificationTime( time_t mtime );
01285 
01289         void setSourceSize( off_t size ) KDE_DEPRECATED;
01290 
01295         KURL srcURL() const { return m_src; }
01296 
01301         KURL destURL() const { return m_dest; }
01302 
01303     signals:
01313         void mimetype( KIO::Job *job, const QString &type );
01314 
01315     public slots:
01316         void slotStart();
01317         void slotData( KIO::Job *, const QByteArray &data);
01318         void slotDataReq( KIO::Job *, QByteArray &data);
01319         void slotMimetype( KIO::Job *, const QString& type );
01320 
01321     protected slots:
01326         virtual void slotResult( KIO::Job *job );
01327 
01333         void slotProcessedSize( KIO::Job *job, KIO::filesize_t size );
01339         void slotTotalSize( KIO::Job *job, KIO::filesize_t size );
01345         void slotPercent( KIO::Job *job, unsigned long pct );
01351         void slotCanResume( KIO::Job *job, KIO::filesize_t offset );
01352 
01353     protected:
01354         void startCopyJob();
01355         void startCopyJob(const KURL &slave_url);
01356         void startRenameJob(const KURL &slave_url);
01357         void startDataPump();
01358         void connectSubjob( SimpleJob * job );
01359 
01360     private:
01361         void startBestCopyMethod();
01362 
01363     protected:
01364         KURL m_src;
01365         KURL m_dest;
01366         int m_permissions;
01367         bool m_move:1;
01368         bool m_overwrite:1;
01369         bool m_resume:1;
01370         bool m_canResume:1;
01371         bool m_resumeAnswerSent:1;
01372         QByteArray m_buffer;
01373         SimpleJob *m_moveJob;
01374         SimpleJob *m_copyJob;
01375         TransferJob *m_getJob;
01376         TransferJob *m_putJob;
01377         KIO::filesize_t m_totalSize;
01378     protected:
01379     virtual void virtual_hook( int id, void* data );
01380     private:
01381     class FileCopyJobPrivate;
01382     FileCopyJobPrivate* d;
01383     };
01384 
01392     class KIO_EXPORT ListJob : public SimpleJob {
01393     Q_OBJECT
01394 
01395     public:
01406         ListJob(const KURL& url, bool showProgressInfo,
01407                 bool recursive = false, QString prefix = QString::null,
01408                 bool includeHidden = true);
01409 
01416         virtual void start( Slave *slave );
01417 
01424         const KURL& redirectionURL() const { return m_redirectionURL; }
01425 
01430         void setUnrestricted(bool unrestricted);
01431 
01432     signals:
01442         void entries( KIO::Job *job, const KIO::UDSEntryList& list);
01443 
01451         void redirection( KIO::Job *job, const KURL &url );
01452 
01461         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
01462 
01463     protected slots:
01464         virtual void slotFinished( );
01465         virtual void slotMetaData( const KIO::MetaData &_metaData);
01466         virtual void slotResult( KIO::Job *job );
01467         void slotListEntries( const KIO::UDSEntryList& list );
01468         void slotRedirection( const KURL &url );
01469         void gotEntries( KIO::Job * subjob, const KIO::UDSEntryList& list );
01470 
01471     private:
01472         bool recursive;
01473         bool includeHidden;
01474         QString prefix;
01475         unsigned long m_processedEntries;
01476         KURL m_redirectionURL;
01477     protected:
01478     virtual void virtual_hook( int id, void* data );
01479     private:
01480     class ListJobPrivate* d;
01481     };
01482 
01484     struct KIO_EXPORT CopyInfo
01485     {
01486         KURL uSource;
01487         KURL uDest;
01488         QString linkDest; // for symlinks only
01489         int permissions;
01490         //mode_t type;
01491         time_t ctime;
01492         time_t mtime;
01493         KIO::filesize_t size; // 0 for dirs
01494     };
01495 
01508     class KIO_EXPORT CopyJob : public Job {
01509     Q_OBJECT
01510 
01511     public:
01515         enum CopyMode{ Copy, Move, Link };
01516 
01534         CopyJob( const KURL::List& src, const KURL& dest, CopyMode mode, bool asMethod, bool showProgressInfo );
01535 
01536         virtual ~CopyJob();
01537 
01542         KURL::List srcURLs() const { return m_srcList; }
01543 
01548         KURL destURL() const { return m_dest; }
01549 
01560         void setDefaultPermissions( bool b );
01561 
01573         void setInteractive( bool b );
01574 
01575     signals:
01576 
01582         void totalFiles( KIO::Job *job, unsigned long files );
01588         void totalDirs( KIO::Job *job, unsigned long dirs );
01589 
01597         void aboutToCreate( KIO::Job *job, const QValueList<KIO::CopyInfo> &files);
01598 
01604         void processedFiles( KIO::Job *job, unsigned long files );
01610         void processedDirs( KIO::Job *job, unsigned long dirs );
01611 
01619         void copying( KIO::Job *job, const KURL& from, const KURL& to );
01627         void linking( KIO::Job *job, const QString& target, const KURL& to );
01635         void moving( KIO::Job *job, const KURL& from, const KURL& to );
01641         void creatingDir( KIO::Job *job, const KURL& dir );
01648         void renamed( KIO::Job *job, const KURL& from, const KURL& to );
01649 
01662         void copyingDone( KIO::Job *job, const KURL &from, const KURL &to, bool directory, bool renamed );
01672         void copyingLinkDone( KIO::Job *job, const KURL &from, const QString& target, const KURL& to );
01673 
01674     protected:
01675         void statCurrentSrc();
01676         void statNextSrc();
01677 
01678         // Those aren't slots but submethods for slotResult.
01679         void slotResultStating( KIO::Job * job );
01680         void startListing( const KURL & src );
01681         void slotResultCreatingDirs( KIO::Job * job );
01682         void slotResultConflictCreatingDirs( KIO::Job * job );
01683         void createNextDir();
01684         void slotResultCopyingFiles( KIO::Job * job );
01685         void slotResultConflictCopyingFiles( KIO::Job * job );
01686         void copyNextFile();
01687         void slotResultDeletingDirs( KIO::Job * job );
01688         void deleteNextDir();
01689         void skip( const KURL & sourceURL );
01690         void slotResultRenaming( KIO::Job * job );
01691         //void slotResultSettingDirAttributes( KIO::Job * job );
01692         void setNextDirAttribute();
01693     private:
01694         void startRenameJob(const KURL &slave_url);
01695         bool shouldOverwrite( const QString& path ) const;
01696         bool shouldSkip( const QString& path ) const;
01697         void skipSrc();
01698 
01699     protected slots:
01700         void slotStart();
01701         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01702         virtual void slotResult( KIO::Job *job );
01706         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01711         void slotTotalSize( KIO::Job*, KIO::filesize_t size );
01712 
01713         void slotReport();
01714     private:
01715         CopyMode m_mode;
01716         bool m_asMethod;
01717         enum DestinationState { DEST_NOT_STATED, DEST_IS_DIR, DEST_IS_FILE, DEST_DOESNT_EXIST };
01718         DestinationState destinationState;
01719         enum { STATE_STATING, STATE_RENAMING, STATE_LISTING, STATE_CREATING_DIRS,
01720                STATE_CONFLICT_CREATING_DIRS, STATE_COPYING_FILES, STATE_CONFLICT_COPYING_FILES,
01721                STATE_DELETING_DIRS, STATE_SETTING_DIR_ATTRIBUTES } state;
01722         KIO::filesize_t m_totalSize;
01723         KIO::filesize_t m_processedSize;
01724         KIO::filesize_t m_fileProcessedSize;
01725         int m_processedFiles;
01726         int m_processedDirs;
01727         QValueList<CopyInfo> files;
01728         QValueList<CopyInfo> dirs;
01729         KURL::List dirsToRemove;
01730         KURL::List m_srcList;
01731         KURL::List::Iterator m_currentStatSrc;
01732         bool m_bCurrentSrcIsDir;
01733         bool m_bCurrentOperationIsLink;
01734         bool m_bSingleFileCopy;
01735         bool m_bOnlyRenames;
01736         KURL m_dest;
01737         KURL m_currentDest;
01738         //
01739         QStringList m_skipList;
01740         QStringList m_overwriteList;
01741         bool m_bAutoSkip;
01742         bool m_bOverwriteAll;
01743         int m_conflictError;
01744 
01745         QTimer *m_reportTimer;
01746         //these both are used for progress dialog reporting
01747         KURL m_currentSrcURL;
01748         KURL m_currentDestURL;
01749     protected:
01750     virtual void virtual_hook( int id, void* data );
01751     private:
01752     class CopyJobPrivate;
01753         CopyJobPrivate* d;
01754         friend class CopyJobPrivate; // for DestinationState
01755     };
01756 
01763     class KIO_EXPORT DeleteJob : public Job {
01764     Q_OBJECT
01765 
01766     public:
01776         DeleteJob( const KURL::List& src, bool shred, bool showProgressInfo );
01777 
01782         KURL::List urls() const { return m_srcList; }
01783 
01784     signals:
01785 
01791         void totalFiles( KIO::Job *job, unsigned long files );
01797         void totalDirs( KIO::Job *job, unsigned long dirs );
01798 
01804         void processedFiles( KIO::Job *job, unsigned long files );
01810         void processedDirs( KIO::Job *job, unsigned long dirs );
01811 
01818         void deleting( KIO::Job *job, const KURL& file );
01819 
01820     protected slots:
01821         void slotStart();
01822         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01823         virtual void slotResult( KIO::Job *job );
01824 
01828         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01829         void slotReport();
01830 
01831     private:
01832         void statNextSrc();
01833         void deleteNextFile();
01834         void deleteNextDir();
01835 
01836     private:
01837         enum { STATE_STATING, STATE_LISTING,
01838                STATE_DELETING_FILES, STATE_DELETING_DIRS } state;
01839         KIO::filesize_t m_totalSize;
01840         KIO::filesize_t m_processedSize;
01841         KIO::filesize_t m_fileProcessedSize;
01842         int m_processedFiles;
01843         int m_processedDirs;
01844         int m_totalFilesDirs;
01845         KURL m_currentURL;
01846         KURL::List files;
01847         KURL::List symlinks;
01848         KURL::List dirs;
01849         KURL::List m_srcList;
01850         KURL::List::Iterator m_currentStat;
01851     QStringList m_parentDirs;
01852         bool m_shred; // BIC: remove in KDE4
01853         QTimer *m_reportTimer;
01854     protected:
01856     virtual void virtual_hook( int id, void* data );
01857     private:
01858     class DeleteJobPrivate* d;
01859     };
01860 
01861 }
01862 
01863 #endif

kio

Skip menu "kio"
  • Main Page
  • Modules
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

API Reference

Skip menu "API Reference"
  • dcop
  • DNSSD
  • interfaces
  • Kate
  • kconf_update
  • KDECore
  • KDED
  • kdefx
  • KDEsu
  • kdeui
  • KDocTools
  • KHTML
  • KImgIO
  • KInit
  • kio
  • kioslave
  • KJS
  • KNewStuff
  • KParts
  • KUtils
Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal