← Back to branch summary

~ubuntu-branches/ubuntu/vivid/krusader/vivid-proposed

« back to all changes in this revision

Viewing changes to krusader/VFS/kiojobwrapper.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-05-05 22:26:37 UTC
  • mfrom: (3.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100505222637-ydv3cwjwy365on2r
Tags: 1:2.1.0~beta1-1ubuntu1
* Merge from Debian Unstable.  Remaining changes:
  - Retain Kubuntu doc path

Show diffs side-by-side

added added

removed removed

Lines of Context:
krusader/VFS/kiojobwrapper.cpp
29
29
 ***************************************************************************/
30
30
 
31
31
#include "kiojobwrapper.h"
32
 
#include <qevent.h>
 
32
 
 
33
#include <cstdio>
 
34
#include <iostream>
 
35
 
 
36
#include <QtCore/QEvent>
 
37
#include <QtGui/QApplication>
 
38
#include <QtGui/QTextDocument>
 
39
 
33
40
#include <kurl.h>
34
41
#include <kio/global.h>
35
42
#include <kio/jobclasses.h>
36
43
#include <kio/directorysizejob.h>
37
44
#include <kio/jobuidelegate.h>
38
45
#include <kio/job.h>
39
 
#include <qapplication.h>
40
 
#include <iostream>
41
46
#include <klocale.h>
 
47
 
42
48
#include "virtualcopyjob.h"
43
 
#include <QTextDocument>
 
49
#include "packjob.h"
44
50
 
45
 
class JobStartEvent : public QEvent {
 
51
class JobStartEvent : public QEvent
 
52
{
46
53
public:
47
 
        JobStartEvent( KIOJobWrapper * wrapperIn ) : QEvent( QEvent::User ),
48
 
                m_wrapper( wrapperIn ) {}
49
 
        virtual ~JobStartEvent() { if( m_wrapper->m_delete ) delete m_wrapper; }
50
 
        
51
 
        KIOJobWrapper * wrapper() { return m_wrapper; }
 
54
    JobStartEvent(KIOJobWrapper * wrapperIn) : QEvent(QEvent::User),
 
55
            m_wrapper(wrapperIn) {}
 
56
    virtual ~JobStartEvent() {
 
57
        if (m_wrapper->m_delete) delete m_wrapper;
 
58
    }
 
59
 
 
60
    KIOJobWrapper * wrapper() {
 
61
        return m_wrapper;
 
62
    }
52
63
private:
53
 
        KIOJobWrapper * m_wrapper;
 
64
    KIOJobWrapper * m_wrapper;
54
65
};
55
66
 
56
67
KrJobStarter * KrJobStarter::m_self = 0;
57
68
 
58
 
bool KrJobStarter::event( QEvent * e ) {
59
 
        if( e->type() == QEvent::User ) {
60
 
                JobStartEvent *je = (JobStartEvent *)e;
61
 
                je->wrapper()->createJob();
62
 
                return true;
63
 
        }
64
 
        return QObject::event( e );
65
 
}
66
 
 
67
 
KIOJobWrapper::KIOJobWrapper( KIOJobWrapperType type, KUrl &url ) : QObject( 0 ),
68
 
                              m_autoErrorHandling( false ), m_delete( true ), m_started( false ),
69
 
                              m_suspended( false ) {
70
 
        moveToThread(QApplication::instance()->thread());
71
 
        m_type = type;
72
 
        m_url = url;
73
 
}
74
 
 
75
 
KIOJobWrapper::KIOJobWrapper( KIOJobWrapperType type, KUrl &url, void * userData ) : QObject( 0 ),
76
 
                              m_autoErrorHandling( false ), m_delete( true ), m_started( false ),
77
 
                              m_suspended( false ) {
78
 
        moveToThread(QApplication::instance()->thread());
79
 
        m_type = type;
80
 
        m_url = url;
81
 
        m_userData = userData;
82
 
}
83
 
 
84
 
KIOJobWrapper::KIOJobWrapper( KIOJobWrapperType type, KUrl &url, KUrl::List &list,
85
 
                              int pmode, bool showp  ) : QObject( 0 ),
86
 
                              m_autoErrorHandling( false ), m_delete( true ), m_started( false ),
87
 
                              m_suspended( false ) {
88
 
        moveToThread(QApplication::instance()->thread());
89
 
        m_type = type;
90
 
        m_url = url;
91
 
        m_urlList = list;
92
 
        m_pmode = pmode;
93
 
        m_showProgress = showp;
94
 
}
95
 
 
96
 
KIOJobWrapper::~KIOJobWrapper() {
97
 
}
98
 
 
99
 
void KIOJobWrapper::createJob() {
100
 
        KIO::Job * job = 0;
101
 
        switch( m_type ) {
102
 
        case Stat:
103
 
                job = KIO::stat( m_url );
104
 
                break;
105
 
        case DirectorySize:
106
 
                job = KIO::directorySize( m_url );
107
 
                break;
108
 
        case VirtualMove:
109
 
        case VirtualCopy:
110
 
                {
111
 
                        VirtualCopyJob * vcj = (VirtualCopyJob *)m_userData;
112
 
                        vcj->slotStart();
113
 
                        job = vcj;
114
 
                }
115
 
                break;
116
 
        case Copy:
117
 
                job = PreservingCopyJob::createCopyJob( (PreserveMode)m_pmode, m_urlList, m_url, KIO::CopyJob::Copy, false, m_showProgress );
118
 
                break;
119
 
        case Move:
120
 
                job = PreservingCopyJob::createCopyJob( (PreserveMode)m_pmode, m_urlList, m_url, KIO::CopyJob::Move, false, m_showProgress );
121
 
                break;
122
 
        default:
123
 
                fprintf( stderr, "Internal error: invalid job!\n" );
124
 
                break;
125
 
        }
126
 
        if( job ) {
127
 
                m_job = job;
128
 
                m_delete = false;
129
 
                connect( job, SIGNAL( destroyed() ), this, SLOT( deleteLater() ) );
130
 
                for( int i=0; i != m_signals.count(); i++ )
131
 
                        if( !m_receivers[ i ].isNull() )
132
 
                                connect( job, m_signals[ i ], m_receivers[ i ], m_methods[ i ] );
133
 
                
134
 
                if( m_autoErrorHandling && job->ui() )
135
 
                        job->ui()->setAutoErrorHandlingEnabled( true );
136
 
                if( m_suspended )
137
 
                        job->suspend();
138
 
        }
139
 
}
140
 
 
141
 
KIOJobWrapper * KIOJobWrapper::stat( KUrl &url ) {
142
 
        return new KIOJobWrapper( Stat, url );
143
 
}
144
 
 
145
 
KIOJobWrapper * KIOJobWrapper::directorySize( KUrl &url ) {
146
 
        return new KIOJobWrapper( DirectorySize, url );
147
 
}
148
 
 
149
 
KIOJobWrapper * KIOJobWrapper::copy( int pmode, KUrl::List &list, KUrl &url, bool showProgress ) {
150
 
        return new KIOJobWrapper( Copy, url, list, pmode, showProgress );
151
 
}
152
 
 
153
 
KIOJobWrapper * KIOJobWrapper::move( int pmode, KUrl::List &list, KUrl &url, bool showProgress ) {
154
 
        return new KIOJobWrapper( Move, url, list, pmode, showProgress );
155
 
}
156
 
 
157
 
KIOJobWrapper * KIOJobWrapper::virtualCopy( const QStringList *names, vfs * vfs, KUrl& dest,
158
 
                                            const KUrl& baseURL, int pmode, bool showProgressInfo ) {
159
 
        return new KIOJobWrapper( VirtualCopy, dest, 
160
 
           new VirtualCopyJob( names, vfs, dest, baseURL, (PreserveMode)pmode, KIO::CopyJob::Copy, showProgressInfo, false ) );
161
 
}
162
 
 
163
 
KIOJobWrapper * KIOJobWrapper::virtualMove( const QStringList *names, vfs * vfs, KUrl& dest,
164
 
                                            const KUrl& baseURL, int pmode, bool showProgressInfo ) {
165
 
        return new KIOJobWrapper( VirtualMove, dest, 
166
 
           new VirtualCopyJob( names, vfs, dest, baseURL, (PreserveMode)pmode, KIO::CopyJob::Move, showProgressInfo, false ) );
167
 
}
168
 
 
169
 
void KIOJobWrapper::start() {
170
 
        m_started = true;
171
 
        KrJobStarter *self = KrJobStarter::self();
172
 
        QApplication::postEvent( self, new JobStartEvent( this ) );
173
 
}
174
 
 
175
 
void KIOJobWrapper::connectTo( const char * signal, const QObject * receiver, const char * method ) {
176
 
        m_signals.append( signal );
177
 
        m_receivers.append( (QObject *)receiver );
178
 
        m_methods.append( method );
179
 
}
180
 
 
181
 
QString KIOJobWrapper::typeStr() {
182
 
        switch( m_type )
183
 
        {
184
 
        case Stat:
185
 
                return i18n( "Status" );
186
 
        case DirectorySize:
187
 
                return i18n( "Directory Size" );
188
 
        case Copy:
189
 
        case VirtualCopy:
190
 
                return i18n( "Copy" );
191
 
        case Move:
192
 
        case VirtualMove:
193
 
                return i18n( "Move" );
194
 
        default:
195
 
                return i18n( "Unknown" );
196
 
        }
197
 
}
198
 
 
199
 
void KIOJobWrapper::suspend() {
200
 
        m_suspended = true;
201
 
        if( m_job )
202
 
                m_job->suspend();
203
 
}
204
 
 
205
 
void KIOJobWrapper::resume() {
206
 
        m_suspended = false;
207
 
        if( m_job )
208
 
                m_job->resume();
209
 
}
210
 
 
211
 
void KIOJobWrapper::abort() {
212
 
        if( m_job )
213
 
                m_job->kill();
214
 
}
215
 
 
216
 
QString KIOJobWrapper::toolTip() {
217
 
        QString tip = "<qt><div align=\"center\">";
218
 
        tip += "<h3>" + Qt::escape( typeStr() ) + "</h3>";
219
 
        tip += "<table frame=\"box\" border=\"1\"><tbody>";
220
 
        tip += "<tr><td>" + Qt::escape( i18n( "Target" ) ) + "</td><td>" + Qt::escape( url().prettyUrl() ) + "</td></tr>";
221
 
        tip += "<tr><td>" + Qt::escape( i18n( "Source" ) ) + "</td><td>";
222
 
        foreach( KUrl urlIn, urlList() ) {
223
 
                tip += "<li>" + Qt::escape( urlIn.prettyUrl() ) + "</li>";
224
 
        }
225
 
        tip += "</td></tr>";
226
 
        tip += "</tbody></table>";
227
 
        tip += "</div></qt>";
228
 
        return tip;
 
69
bool KrJobStarter::event(QEvent * e)
 
70
{
 
71
    if (e->type() == QEvent::User) {
 
72
        JobStartEvent *je = (JobStartEvent *)e;
 
73
        je->wrapper()->createJob();
 
74
        return true;
 
75
    }
 
76
    return QObject::event(e);
 
77
}
 
78
 
 
79
KIOJobWrapper::KIOJobWrapper(KIOJobWrapperType type, const KUrl &url) : QObject(0),
 
80
        m_autoErrorHandling(false), m_delete(true), m_started(false),
 
81
        m_suspended(false)
 
82
{
 
83
    moveToThread(QApplication::instance()->thread());
 
84
    m_type = type;
 
85
    m_url = url;
 
86
}
 
87
 
 
88
KIOJobWrapper::KIOJobWrapper(KIOJobWrapperType type, const KUrl &url, void * userData) : QObject(0),
 
89
        m_autoErrorHandling(false), m_delete(true), m_started(false),
 
90
        m_suspended(false)
 
91
{
 
92
    moveToThread(QApplication::instance()->thread());
 
93
    m_type = type;
 
94
    m_url = url;
 
95
    m_userData = userData;
 
96
}
 
97
 
 
98
KIOJobWrapper::KIOJobWrapper(KIOJobWrapperType type, const KUrl &url, const KUrl::List &list,
 
99
                             int pmode, bool showp) : QObject(0),
 
100
        m_autoErrorHandling(false), m_delete(true), m_started(false),
 
101
        m_suspended(false)
 
102
{
 
103
    moveToThread(QApplication::instance()->thread());
 
104
    m_type = type;
 
105
    m_url = url;
 
106
    m_urlList = list;
 
107
    m_pmode = pmode;
 
108
    m_showProgress = showp;
 
109
}
 
110
 
 
111
KIOJobWrapper::KIOJobWrapper(KIOJobWrapperType type, const KUrl &url, const KUrl &dest, const QStringList &names,
 
112
                             bool showp, const QString &atype, const QMap<QString, QString> &packProps) : QObject(0),
 
113
        m_urlList(), m_autoErrorHandling(false), m_delete(true), m_started(false),
 
114
        m_suspended(false)
 
115
{
 
116
    m_type = type;
 
117
    m_url = dest;
 
118
    m_archiveSourceBase = url;
 
119
    foreach(const QString &name , names) {
 
120
        KUrl srcUrl = url;
 
121
        srcUrl.addPath(name);
 
122
        m_urlList << srcUrl;
 
123
    }
 
124
    m_archiveFileNames = names;
 
125
    m_showProgress = showp;
 
126
    m_archiveType = atype;
 
127
    m_archiveProperties = packProps;
 
128
}
 
129
 
 
130
KIOJobWrapper::~KIOJobWrapper()
 
131
{
 
132
}
 
133
 
 
134
void KIOJobWrapper::createJob()
 
135
{
 
136
    KIO::Job * job = 0;
 
137
    switch (m_type) {
 
138
    case Stat:
 
139
        job = KIO::stat(m_url);
 
140
        break;
 
141
    case DirectorySize:
 
142
        job = KIO::directorySize(m_url);
 
143
        break;
 
144
    case VirtualMove:
 
145
    case VirtualCopy: {
 
146
        VirtualCopyJob * vcj = (VirtualCopyJob *)m_userData;
 
147
        vcj->slotStart();
 
148
        job = vcj;
 
149
    }
 
150
    break;
 
151
    case Copy:
 
152
        job = PreservingCopyJob::createCopyJob((PreserveMode)m_pmode, m_urlList, m_url, KIO::CopyJob::Copy, false, m_showProgress);
 
153
        break;
 
154
    case Move:
 
155
        job = PreservingCopyJob::createCopyJob((PreserveMode)m_pmode, m_urlList, m_url, KIO::CopyJob::Move, false, m_showProgress);
 
156
        break;
 
157
    case Pack:
 
158
        job = PackJob::createPacker(m_archiveSourceBase, m_url, m_archiveFileNames, m_archiveType, m_archiveProperties);
 
159
        break;
 
160
    case Unpack:
 
161
        job = UnpackJob::createUnpacker(m_archiveSourceBase, m_url, m_archiveFileNames);
 
162
        break;
 
163
    default:
 
164
        fprintf(stderr, "Internal error: invalid job!\n");
 
165
        break;
 
166
    }
 
167
    if (job) {
 
168
        m_job = job;
 
169
        m_delete = false;
 
170
        connect(job, SIGNAL(destroyed()), this, SLOT(deleteLater()));
 
171
        for (int i = 0; i != m_signals.count(); i++)
 
172
            if (!m_receivers[ i ].isNull())
 
173
                connect(job, m_signals[ i ], m_receivers[ i ], m_methods[ i ]);
 
174
 
 
175
        if (m_autoErrorHandling && job->ui())
 
176
            job->ui()->setAutoErrorHandlingEnabled(true);
 
177
        if (m_suspended)
 
178
            job->suspend();
 
179
    }
 
180
}
 
181
 
 
182
KIOJobWrapper * KIOJobWrapper::stat(KUrl &url)
 
183
{
 
184
    return new KIOJobWrapper(Stat, url);
 
185
}
 
186
 
 
187
KIOJobWrapper * KIOJobWrapper::directorySize(KUrl &url)
 
188
{
 
189
    return new KIOJobWrapper(DirectorySize, url);
 
190
}
 
191
 
 
192
KIOJobWrapper * KIOJobWrapper::copy(int pmode, KUrl::List &list, KUrl &url, bool showProgress)
 
193
{
 
194
    return new KIOJobWrapper(Copy, url, list, pmode, showProgress);
 
195
}
 
196
 
 
197
KIOJobWrapper * KIOJobWrapper::move(int pmode, KUrl::List &list, KUrl &url, bool showProgress)
 
198
{
 
199
    return new KIOJobWrapper(Move, url, list, pmode, showProgress);
 
200
}
 
201
 
 
202
KIOJobWrapper * KIOJobWrapper::virtualCopy(const QStringList *names, vfs * vfs, KUrl& dest,
 
203
        const KUrl& baseURL, int pmode, bool showProgressInfo)
 
204
{
 
205
    return new KIOJobWrapper(VirtualCopy, dest,
 
206
                             new VirtualCopyJob(names, vfs, dest, baseURL, (PreserveMode)pmode, KIO::CopyJob::Copy, showProgressInfo, false));
 
207
}
 
208
 
 
209
KIOJobWrapper * KIOJobWrapper::virtualMove(const QStringList *names, vfs * vfs, KUrl& dest,
 
210
        const KUrl& baseURL, int pmode, bool showProgressInfo)
 
211
{
 
212
    return new KIOJobWrapper(VirtualMove, dest,
 
213
                             new VirtualCopyJob(names, vfs, dest, baseURL, (PreserveMode)pmode, KIO::CopyJob::Move, showProgressInfo, false));
 
214
}
 
215
 
 
216
KIOJobWrapper * KIOJobWrapper::pack(const KUrl &srcUrl, const KUrl &destUrl, const QStringList & fileNames,
 
217
                                    const QString &type, const QMap<QString, QString> &packProps, bool showProgressInfo)
 
218
{
 
219
    return new KIOJobWrapper(Pack, srcUrl, destUrl, fileNames, showProgressInfo, type, packProps);
 
220
}
 
221
 
 
222
KIOJobWrapper * KIOJobWrapper::unpack(const KUrl &srcUrl, const KUrl &destUrl, const QStringList & fileNames,
 
223
                                      bool showProgressInfo)
 
224
{
 
225
    return new KIOJobWrapper(Unpack, srcUrl, destUrl, fileNames, showProgressInfo, QString(), QMap<QString, QString> ());
 
226
}
 
227
 
 
228
void KIOJobWrapper::start()
 
229
{
 
230
    m_started = true;
 
231
    KrJobStarter *self = KrJobStarter::self();
 
232
    QApplication::postEvent(self, new JobStartEvent(this));
 
233
}
 
234
 
 
235
void KIOJobWrapper::connectTo(const char * signal, const QObject * receiver, const char * method)
 
236
{
 
237
    m_signals.append(signal);
 
238
    m_receivers.append((QObject *)receiver);
 
239
    m_methods.append(method);
 
240
}
 
241
 
 
242
QString KIOJobWrapper::typeStr()
 
243
{
 
244
    switch (m_type) {
 
245
    case Stat:
 
246
        return i18n("Status");
 
247
    case DirectorySize:
 
248
        return i18n("Directory Size");
 
249
    case Copy:
 
250
    case VirtualCopy:
 
251
        return i18n("Copy");
 
252
    case Move:
 
253
    case VirtualMove:
 
254
        return i18n("Move");
 
255
    case Pack:
 
256
        return i18n("Pack");
 
257
    case Unpack:
 
258
        return i18n("Unpack");
 
259
    default:
 
260
        return i18n("Unknown");
 
261
    }
 
262
}
 
263
 
 
264
void KIOJobWrapper::suspend()
 
265
{
 
266
    m_suspended = true;
 
267
    if (m_job)
 
268
        m_job->suspend();
 
269
}
 
270
 
 
271
void KIOJobWrapper::resume()
 
272
{
 
273
    m_suspended = false;
 
274
    if (m_job)
 
275
        m_job->resume();
 
276
}
 
277
 
 
278
void KIOJobWrapper::abort()
 
279
{
 
280
    if (m_job)
 
281
        m_job->kill();
 
282
}
 
283
 
 
284
QString KIOJobWrapper::toolTip()
 
285
{
 
286
    QString tip = "<qt><div align=\"center\">";
 
287
    tip += "<h3>" + Qt::escape(typeStr()) + "</h3>";
 
288
    tip += "<table frame=\"box\" border=\"1\"><tbody>";
 
289
    tip += "<tr><td>" + Qt::escape(i18n("Target")) + "</td><td>" + Qt::escape(url().prettyUrl()) + "</td></tr>";
 
290
    tip += "<tr><td>" + Qt::escape(i18n("Source")) + "</td><td>";
 
291
    foreach(const KUrl &urlIn, urlList()) {
 
292
        tip += "<li>" + Qt::escape(urlIn.prettyUrl()) + "</li>";
 
293
    }
 
294
    tip += "</td></tr>";
 
295
    tip += "</tbody></table>";
 
296
    tip += "</div></qt>";
 
297
    return tip;
229
298
}