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 & );
00548 
00554         void slotInfoMessage( const QString &s );
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 
00714     class TransferJob : public SimpleJob {
00715     Q_OBJECT
00716 
00717     public:
00727         TransferJob(const KURL& url, int command,
00728                     const QByteArray &packedArgs,
00729                     const QByteArray &_staticData,
00730                     bool showProgressInfo);
00731 
00738         virtual void start(Slave *slave);
00739 
00744         virtual void slotResult( KIO::Job *job );
00745 
00749         void suspend();
00750 
00754         void resume();
00755 
00760     bool isSuspended() const { return m_suspended; }
00761 
00762 
00770         bool isErrorPage() const { return m_errorPage; }
00771 
00779         void setAsyncDataEnabled(bool enabled);
00780 
00787         void sendAsyncData(const QByteArray &data);
00788 
00796         void setReportDataSent(bool enabled);
00797 
00804         bool reportDataSent();
00805 
00806     signals:
00816         void data( KIO::Job *job, const QByteArray &data );
00817 
00829         void dataReq( KIO::Job *job, QByteArray &data );
00830 
00838         void redirection( KIO::Job *job, const KURL &url );
00839 
00848         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
00849 
00855         void mimetype( KIO::Job *job, const QString &type );
00856 
00864         void canResume( KIO::Job *job, KIO::filesize_t offset );
00865 
00866 
00867     protected slots:
00868         virtual void slotRedirection( const KURL &url);
00869         virtual void slotFinished();
00870         virtual void slotData( const QByteArray &data);
00871         virtual void slotDataReq();
00872         virtual void slotMimetype( const QString &mimetype );
00873         virtual void slotNeedSubURLData();
00874         virtual void slotSubURLData(KIO::Job*, const QByteArray &);
00875         virtual void slotMetaData( const KIO::MetaData &_metaData);
00876         void slotErrorPage();
00877         void slotCanResume( KIO::filesize_t offset );
00878         void slotPostRedirection();
00879 
00880     protected:
00881         bool m_suspended;
00882         bool m_errorPage;
00883         QByteArray staticData;
00884         KURL m_redirectionURL;
00885         KURL::List m_redirectionList;
00886         QString m_mimetype;
00887         TransferJob *m_subJob;
00888     protected:
00889     virtual void virtual_hook( int id, void* data );
00890     private:
00891     class TransferJobPrivate *d;
00892     };
00893 
00900     class MultiGetJob : public TransferJob {
00901     Q_OBJECT
00902 
00903     public:
00911         MultiGetJob(const KURL& url, bool showProgressInfo);
00912 
00919          virtual void start(Slave *slave);
00920 
00928         void get(long id, const KURL &url, const MetaData &metaData);
00929 
00930     signals:
00937         void data( long id, const QByteArray &data);
00938 
00944         void mimetype( long id, const QString &type );
00945 
00953         void result( long id);
00954 
00955     protected slots:
00956         virtual void slotRedirection( const KURL &url);
00957         virtual void slotFinished();
00958         virtual void slotData( const QByteArray &data);
00959         virtual void slotMimetype( const QString &mimetype );
00960     private:
00961         struct GetRequest {
00962         public:
00963            GetRequest(long _id, const KURL &_url, const MetaData &_metaData)
00964              : id(_id), url(_url), metaData(_metaData) { }
00965            long id;
00966            KURL url;
00967            MetaData metaData;
00968         };
00969         bool findCurrentEntry();
00970         void flushQueue(QPtrList<GetRequest> &queue);
00971 
00972         QPtrList<GetRequest> m_waitQueue;
00973         QPtrList<GetRequest> m_activeQueue;
00974         bool b_multiGetActive;
00975         GetRequest *m_currentEntry;
00976     protected:
00977     virtual void virtual_hook( int id, void* data );
00978     private:
00979     class MultiGetJobPrivate* d;
00980     };
00981 
00988     class MimetypeJob : public TransferJob {
00989     Q_OBJECT
00990 
00991     public:
01000         MimetypeJob(const KURL& url, int command, const QByteArray &packedArgs, bool showProgressInfo);
01001 
01007          QString mimetype() const { return m_mimetype; }
01008 
01015         virtual void start( Slave *slave );
01016 
01017     protected slots:
01018         virtual void slotFinished( );
01019     protected:
01020     virtual void virtual_hook( int id, void* data );
01021     private:
01022     class MimetypeJobPrivate* d;
01023     };
01024 
01030     class FileCopyJob : public Job {
01031     Q_OBJECT
01032 
01033     public:
01045         FileCopyJob( const KURL& src, const KURL& dest, int permissions,
01046                      bool move, bool overwrite, bool resume, bool showProgressInfo);
01047 
01048         ~FileCopyJob();
01055         void setSourceSize64(KIO::filesize_t size);
01056 
01060         void setSourceSize( off_t size ) KDE_DEPRECATED;
01061 
01066         KURL srcURL() const { return m_src; }
01067 
01072         KURL destURL() const { return m_dest; }
01073 
01074     public slots:
01075         void slotStart();
01076         void slotData( KIO::Job *, const QByteArray &data);
01077         void slotDataReq( KIO::Job *, QByteArray &data);
01078 
01079     protected slots:
01084         virtual void slotResult( KIO::Job *job );
01085 
01091         void slotProcessedSize( KIO::Job *job, KIO::filesize_t size );
01097         void slotTotalSize( KIO::Job *job, KIO::filesize_t size );
01103         void slotPercent( KIO::Job *job, unsigned long pct );
01109         void slotCanResume( KIO::Job *job, KIO::filesize_t offset );
01110 
01111     protected:
01112         void startCopyJob();
01113         void startCopyJob(const KURL &slave_url);
01114         void startDataPump();
01115         void connectSubjob( SimpleJob * job );
01116 
01117         KURL m_src;
01118         KURL m_dest;
01119         int m_permissions;
01120         bool m_move:1;
01121         bool m_overwrite:1;
01122         bool m_resume:1;
01123         bool m_canResume:1;
01124         bool m_resumeAnswerSent:1;
01125         QByteArray m_buffer;
01126         SimpleJob *m_moveJob;
01127         SimpleJob *m_copyJob;
01128         TransferJob *m_getJob;
01129         TransferJob *m_putJob;
01130         KIO::filesize_t m_totalSize;
01131     protected:
01132     virtual void virtual_hook( int id, void* data );
01133     private:
01134     class FileCopyJobPrivate;
01135     FileCopyJobPrivate* d;
01136     };
01137 
01145     class ListJob : public SimpleJob {
01146     Q_OBJECT
01147 
01148     public:
01159         ListJob(const KURL& url, bool showProgressInfo,
01160                 bool recursive = false, QString prefix = QString::null,
01161                 bool includeHidden = true);
01162 
01169         virtual void start( Slave *slave );
01170 
01175         void setUnrestricted(bool unrestricted);
01176 
01177     signals:
01187         void entries( KIO::Job *job, const KIO::UDSEntryList& list);
01188 
01196         void redirection( KIO::Job *job, const KURL &url );
01197 
01206         void permanentRedirection( KIO::Job *job, const KURL &fromUrl, const KURL &toUrl );
01207         
01208     protected slots:
01209         virtual void slotFinished( );
01210         virtual void slotMetaData( const KIO::MetaData &_metaData);
01211         virtual void slotResult( KIO::Job *job );
01212         void slotListEntries( const KIO::UDSEntryList& list );
01213         void slotRedirection( const KURL &url );
01214         void gotEntries( KIO::Job * subjob, const KIO::UDSEntryList& list );
01215 
01216     private:
01217         bool recursive;
01218         bool includeHidden;
01219         QString prefix;
01220         unsigned long m_processedEntries;
01221         KURL m_redirectionURL;
01222     protected:
01223     virtual void virtual_hook( int id, void* data );
01224     private:
01225     class ListJobPrivate* d;
01226     };
01227 
01228     struct CopyInfo
01229     {
01230         KURL uSource;
01231         KURL uDest;
01232         QString linkDest; // for symlinks only
01233         int permissions;
01234         //mode_t type;
01235         time_t ctime;
01236         time_t mtime;
01237         KIO::filesize_t size; // 0 for dirs
01238     };
01239 
01252     class CopyJob : public Job {
01253     Q_OBJECT
01254 
01255     public:
01259         enum CopyMode{ Copy, Move, Link };
01260 
01278         CopyJob( const KURL::List& src, const KURL& dest, CopyMode mode, bool asMethod, bool showProgressInfo );
01279 
01284         KURL::List srcURLs() const { return m_srcList; }
01285 
01290         KURL destURL() const { return m_dest; }
01291 
01292     signals:
01293 
01299         void totalFiles( KIO::Job *job, unsigned long files );
01305         void totalDirs( KIO::Job *job, unsigned long dirs );
01306 
01314         void aboutToCreate( KIO::Job *job, const QValueList<KIO::CopyInfo> &files);
01315 
01321         void processedFiles( KIO::Job *job, unsigned long files );
01327         void processedDirs( KIO::Job *job, unsigned long dirs );
01328 
01336         void copying( KIO::Job *job, const KURL& from, const KURL& to );
01344         void linking( KIO::Job *job, const QString& target, const KURL& to );
01352         void moving( KIO::Job *job, const KURL& from, const KURL& to );
01358         void creatingDir( KIO::Job *job, const KURL& dir );
01365         void renamed( KIO::Job *job, const KURL& from, const KURL& to );
01366 
01379         void copyingDone( KIO::Job *job, const KURL &from, const KURL &to, bool directory, bool renamed );
01389         void copyingLinkDone( KIO::Job *job, const KURL &from, const QString& target, const KURL& to );
01390 
01391     protected:
01392         void statNextSrc();
01393 
01394         // Those aren't slots but submethods for slotResult.
01395         void slotResultStating( KIO::Job * job );
01396         void startListing( const KURL & src );
01397         void slotResultCreatingDirs( KIO::Job * job );
01398         void slotResultConflictCreatingDirs( KIO::Job * job );
01399         void createNextDir();
01400         void slotResultCopyingFiles( KIO::Job * job );
01401         void slotResultConflictCopyingFiles( KIO::Job * job );
01402         void copyNextFile();
01403         void slotResultDeletingDirs( KIO::Job * job );
01404         void deleteNextDir();
01405         void skip( const KURL & sourceURL );
01406 
01407     protected slots:
01408         void slotStart();
01409         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01410         virtual void slotResult( KIO::Job *job );
01414         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01419         void slotTotalSize( KIO::Job*, KIO::filesize_t size );
01420 
01421         void slotReport();
01422     private:
01423         CopyMode m_mode;
01424         bool m_asMethod;
01425         enum { DEST_NOT_STATED, DEST_IS_DIR, DEST_IS_FILE, DEST_DOESNT_EXIST } destinationState;
01426         enum { STATE_STATING, STATE_RENAMING, STATE_LISTING, STATE_CREATING_DIRS,
01427                STATE_CONFLICT_CREATING_DIRS, STATE_COPYING_FILES, STATE_CONFLICT_COPYING_FILES,
01428                STATE_DELETING_DIRS } state;
01429         KIO::filesize_t m_totalSize;
01430         KIO::filesize_t m_processedSize;
01431         KIO::filesize_t m_fileProcessedSize;
01432         int m_processedFiles;
01433         int m_processedDirs;
01434         QValueList<CopyInfo> files;
01435         QValueList<CopyInfo> dirs;
01436         KURL::List dirsToRemove;
01437         KURL::List m_srcList;
01438         KURL::List::Iterator m_currentStatSrc;
01439         bool m_bCurrentSrcIsDir;
01440         bool m_bCurrentOperationIsLink;
01441         bool m_bSingleFileCopy;
01442         bool m_bOnlyRenames;
01443         KURL m_dest;
01444         KURL m_currentDest;
01445         //
01446         QStringList m_skipList;
01447         QStringList m_overwriteList;
01448         bool m_bAutoSkip;
01449         bool m_bOverwriteAll;
01450         int m_conflictError;
01451 
01452         QTimer *m_reportTimer;
01453         //these both are used for progress dialog reporting
01454         KURL m_currentSrcURL;
01455         KURL m_currentDestURL;
01456     protected:
01457     virtual void virtual_hook( int id, void* data );
01458     private:
01459     class CopyJobPrivate* d;
01460     };
01461 
01468     class DeleteJob : public Job {
01469     Q_OBJECT
01470 
01471     public:
01481         DeleteJob( const KURL::List& src, bool shred, bool showProgressInfo );
01482 
01487         KURL::List urls() const { return m_srcList; }
01488 
01489     signals:
01490 
01496         void totalFiles( KIO::Job *job, unsigned long files );
01502         void totalDirs( KIO::Job *job, unsigned long dirs );
01503 
01509         void processedFiles( KIO::Job *job, unsigned long files );
01515         void processedDirs( KIO::Job *job, unsigned long dirs );
01516 
01523         void deleting( KIO::Job *job, const KURL& file );
01524 
01525     protected slots:
01526         void slotStart();
01527         void slotEntries( KIO::Job*, const KIO::UDSEntryList& list );
01528         virtual void slotResult( KIO::Job *job );
01529 
01533         void slotProcessedSize( KIO::Job*, KIO::filesize_t data_size );
01534         void slotReport();
01535 
01536     private:
01537         void statNextSrc();
01538         void deleteNextFile();
01539         void deleteNextDir();
01540 
01541     private:
01542         enum { STATE_STATING, STATE_LISTING,
01543                STATE_DELETING_FILES, STATE_DELETING_DIRS } state;
01544         KIO::filesize_t m_totalSize;
01545         KIO::filesize_t m_processedSize;
01546         KIO::filesize_t m_fileProcessedSize;
01547         int m_processedFiles;
01548         int m_processedDirs;
01549         int m_totalFilesDirs;
01550         KURL m_currentURL;
01551         KURL::List files;
01552         KURL::List symlinks;
01553         KURL::List dirs;
01554         KURL::List m_srcList;
01555         KURL::List::Iterator m_currentStat;
01556     QStringList m_parentDirs;
01557         bool m_shred;
01558         QTimer *m_reportTimer;
01559     protected:
01561     virtual void virtual_hook( int id, void* data );
01562     private:
01563     class DeleteJobPrivate* d;
01564     };
01565 
01566 }
01567 
01568 #endif
KDE Logo
This file is part of the documentation for kio Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Mar 3 19:23:38 2005 by doxygen 1.3.6 written by Dimitri van Heesch, © 1997-2003