← Back to branch summary

~ubuntu-branches/ubuntu/precise/gwenview/precise-proposed

« back to all changes in this revision

Viewing changes to importer/importer.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2011-12-15 14:17:54 UTC
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: package-import@ubuntu.com-20111215141754-z043hyx69dulbggf
Tags: upstream-4.7.90
Import upstream version 4.7.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
importer/importer.cpp
1
 
// vim: set tabstop=4 shiftwidth=4 noexpandtab:
 
1
// vim: set tabstop=4 shiftwidth=4 expandtab:
2
2
/*
3
3
Gwenview: an image viewer
4
4
Copyright 2009 Aurélien Gâteau <agateau@kde.org>
44
44
#include <filenameformater.h>
45
45
#include <lib/timeutils.h>
46
46
 
47
 
namespace Gwenview {
 
47
namespace Gwenview
 
48
{
48
49
 
49
50
struct ImporterPrivate {
50
 
        Importer* q;
51
 
        QWidget* mAuthWindow;
52
 
        std::auto_ptr<FileNameFormater> mFileNameFormater;
53
 
        std::auto_ptr<KTempDir> mDestImportDir;
54
 
 
55
 
        /* @defgroup reset Should be reset in start()
56
 
         * @{ */
57
 
        KUrl::List mUrlList;
58
 
        KUrl::List mImportedUrlList;
59
 
        KUrl::List mSkippedUrlList;
60
 
        int mRenamedCount;
61
 
        int mProgress;
62
 
        int mJobProgress;
63
 
        /* @} */
64
 
 
65
 
        KUrl mCurrentUrl;
66
 
 
67
 
        void emitError(const QString& message) {
68
 
                QMetaObject::invokeMethod(q, "error", Q_ARG(QString, message));
69
 
        }
70
 
 
71
 
        bool createImportDir(const KUrl url) {
72
 
                Q_ASSERT(url.isLocalFile());
73
 
                // FIXME: Support remote urls
74
 
 
75
 
                if (!KStandardDirs::makeDir(url.toLocalFile())) {
76
 
                        emitError(i18n("Could not create destination folder."));
77
 
                        return false;
78
 
                }
79
 
                mDestImportDir.reset(new KTempDir(url.toLocalFile() + "/.gwenview_importer-"));
80
 
                mDestImportDir->setAutoRemove(false);
81
 
                if (mDestImportDir->status() != 0) {
82
 
                        const QString message = QString::fromLocal8Bit(::strerror(mDestImportDir->status()));
83
 
                        emitError(i18n("Could not create temporary upload folder:\n%1", message));
84
 
                        return false;
85
 
                }
86
 
                return true;
87
 
        }
88
 
 
89
 
        void importNext() {
90
 
                if (mUrlList.empty()) {
91
 
                        q->finalizeImport();
92
 
                        return;
93
 
                }
94
 
                mCurrentUrl = mUrlList.takeFirst();
95
 
                KUrl dst = KUrl(mDestImportDir->name());
96
 
                dst.addPath(mCurrentUrl.fileName());
97
 
                KIO::Job* job = KIO::copy(mCurrentUrl, dst, KIO::HideProgressInfo);
98
 
                if (job->ui()) {
99
 
                        job->ui()->setWindow(mAuthWindow);
100
 
                }
101
 
                QObject::connect(job, SIGNAL(result(KJob*)),
102
 
                        q, SLOT(slotCopyDone(KJob*)));
103
 
                QObject::connect(job, SIGNAL(percent(KJob*, unsigned long)),
104
 
                        q, SLOT(slotPercent(KJob*, unsigned long)));
105
 
        }
106
 
 
107
 
        void renameImportedUrl(const KUrl& src) {
108
 
                KUrl dst = src;
109
 
                dst.cd("..");
110
 
                QString fileName;
111
 
                if (mFileNameFormater.get()) {
112
 
                        KFileItem item(KFileItem::Unknown, KFileItem::Unknown, src, true /* delayedMimeTypes */);
113
 
                        KDateTime dateTime = TimeUtils::dateTimeForFileItem(item);
114
 
                        fileName = mFileNameFormater->format(src, dateTime);
115
 
                } else {
116
 
                        fileName = src.fileName();
117
 
                }
118
 
                dst.setFileName(fileName);
119
 
 
120
 
                FileUtils::RenameResult result = FileUtils::rename(src, dst, mAuthWindow);
121
 
                switch (result) {
122
 
                case FileUtils::RenamedOK:
123
 
                        mImportedUrlList << mCurrentUrl;
124
 
                        break;
125
 
                case FileUtils::RenamedUnderNewName:
126
 
                        mRenamedCount++;
127
 
                        mImportedUrlList << mCurrentUrl;
128
 
                        break;
129
 
                case FileUtils::Skipped:
130
 
                        mSkippedUrlList << mCurrentUrl;
131
 
                        break;
132
 
                case FileUtils::RenameFailed:
133
 
                        kWarning() << "Rename failed for" << mCurrentUrl;
134
 
                }
135
 
                q->advance();
136
 
                importNext();
137
 
        }
 
51
    Importer* q;
 
52
    QWidget* mAuthWindow;
 
53
    std::auto_ptr<FileNameFormater> mFileNameFormater;
 
54
    std::auto_ptr<KTempDir> mDestImportDir;
 
55
 
 
56
    /* @defgroup reset Should be reset in start()
 
57
     * @{ */
 
58
    KUrl::List mUrlList;
 
59
    KUrl::List mImportedUrlList;
 
60
    KUrl::List mSkippedUrlList;
 
61
    int mRenamedCount;
 
62
    int mProgress;
 
63
    int mJobProgress;
 
64
    /* @} */
 
65
 
 
66
    KUrl mCurrentUrl;
 
67
 
 
68
    void emitError(const QString& message)
 
69
    {
 
70
        QMetaObject::invokeMethod(q, "error", Q_ARG(QString, message));
 
71
    }
 
72
 
 
73
    bool createImportDir(const KUrl url)
 
74
    {
 
75
        Q_ASSERT(url.isLocalFile());
 
76
        // FIXME: Support remote urls
 
77
 
 
78
        if (!KStandardDirs::makeDir(url.toLocalFile())) {
 
79
            emitError(i18n("Could not create destination folder."));
 
80
            return false;
 
81
        }
 
82
        mDestImportDir.reset(new KTempDir(url.toLocalFile() + "/.gwenview_importer-"));
 
83
        mDestImportDir->setAutoRemove(false);
 
84
        if (mDestImportDir->status() != 0) {
 
85
            const QString message = QString::fromLocal8Bit(::strerror(mDestImportDir->status()));
 
86
            emitError(i18n("Could not create temporary upload folder:\n%1", message));
 
87
            return false;
 
88
        }
 
89
        return true;
 
90
    }
 
91
 
 
92
    void importNext()
 
93
    {
 
94
        if (mUrlList.empty()) {
 
95
            q->finalizeImport();
 
96
            return;
 
97
        }
 
98
        mCurrentUrl = mUrlList.takeFirst();
 
99
        KUrl dst = KUrl(mDestImportDir->name());
 
100
        dst.addPath(mCurrentUrl.fileName());
 
101
        KIO::Job* job = KIO::copy(mCurrentUrl, dst, KIO::HideProgressInfo);
 
102
        if (job->ui()) {
 
103
            job->ui()->setWindow(mAuthWindow);
 
104
        }
 
105
        QObject::connect(job, SIGNAL(result(KJob*)),
 
106
                         q, SLOT(slotCopyDone(KJob*)));
 
107
        QObject::connect(job, SIGNAL(percent(KJob*, ulong)),
 
108
                         q, SLOT(slotPercent(KJob*, ulong)));
 
109
    }
 
110
 
 
111
    void renameImportedUrl(const KUrl& src)
 
112
    {
 
113
        KUrl dst = src;
 
114
        dst.cd("..");
 
115
        QString fileName;
 
116
        if (mFileNameFormater.get()) {
 
117
            KFileItem item(KFileItem::Unknown, KFileItem::Unknown, src, true /* delayedMimeTypes */);
 
118
            KDateTime dateTime = TimeUtils::dateTimeForFileItem(item);
 
119
            fileName = mFileNameFormater->format(src, dateTime);
 
120
        } else {
 
121
            fileName = src.fileName();
 
122
        }
 
123
        dst.setFileName(fileName);
 
124
 
 
125
        FileUtils::RenameResult result = FileUtils::rename(src, dst, mAuthWindow);
 
126
        switch (result) {
 
127
        case FileUtils::RenamedOK:
 
128
            mImportedUrlList << mCurrentUrl;
 
129
            break;
 
130
        case FileUtils::RenamedUnderNewName:
 
131
            mRenamedCount++;
 
132
            mImportedUrlList << mCurrentUrl;
 
133
            break;
 
134
        case FileUtils::Skipped:
 
135
            mSkippedUrlList << mCurrentUrl;
 
136
            break;
 
137
        case FileUtils::RenameFailed:
 
138
            kWarning() << "Rename failed for" << mCurrentUrl;
 
139
        }
 
140
        q->advance();
 
141
        importNext();
 
142
    }
138
143
};
139
144
 
140
 
 
141
145
Importer::Importer(QWidget* parent)
142
146
: QObject(parent)
143
 
, d(new ImporterPrivate) {
144
 
        d->q = this;
145
 
        d->mAuthWindow = parent;
146
 
}
147
 
 
148
 
Importer::~Importer() {
149
 
        delete d;
150
 
}
151
 
 
152
 
void Importer::setAutoRenameFormat(const QString& format) {
153
 
        if (format.isEmpty()) {
154
 
                d->mFileNameFormater.reset(0);
155
 
        } else {
156
 
                d->mFileNameFormater.reset(new FileNameFormater(format));
157
 
        }
158
 
}
159
 
 
160
 
void Importer::start(const KUrl::List& list, const KUrl& destination) {
161
 
        d->mUrlList = list;
162
 
        d->mImportedUrlList.clear();
163
 
        d->mSkippedUrlList.clear();
164
 
        d->mRenamedCount = 0;
165
 
        d->mProgress = 0;
166
 
        d->mJobProgress = 0;
167
 
 
168
 
        emitProgressChanged();
169
 
        maximumChanged(d->mUrlList.count() * 100);
170
 
 
171
 
        if (!d->createImportDir(destination)) {
172
 
                kWarning() << "Could not create import dir";
173
 
                return;
174
 
        }
175
 
        d->importNext();
176
 
}
177
 
 
178
 
void Importer::slotCopyDone(KJob* _job) {
179
 
        KIO::CopyJob* job = static_cast<KIO::CopyJob*>(_job);
180
 
        KUrl url = job->destUrl();
181
 
        if (job->error()) {
182
 
                kWarning() << "FIXME: What do we do with failed urls?";
183
 
                advance();
184
 
                d->importNext();
185
 
                return;
186
 
        }
187
 
 
188
 
        d->renameImportedUrl(url);
189
 
}
190
 
 
191
 
void Importer::finalizeImport() {
192
 
        d->mDestImportDir->unlink();
193
 
        importFinished();
194
 
}
195
 
 
196
 
void Importer::advance() {
197
 
        ++d->mProgress;
198
 
        d->mJobProgress = 0;
199
 
        emitProgressChanged();
200
 
}
201
 
 
202
 
void Importer::slotPercent(KJob*, unsigned long percent) {
203
 
        d->mJobProgress = percent;
204
 
        emitProgressChanged();
205
 
}
206
 
 
207
 
void Importer::emitProgressChanged() {
208
 
        progressChanged(d->mProgress * 100 + d->mJobProgress);
209
 
}
210
 
 
211
 
KUrl::List Importer::importedUrlList() const {
212
 
        return d->mImportedUrlList;
213
 
}
214
 
 
215
 
KUrl::List Importer::skippedUrlList() const {
216
 
        return d->mSkippedUrlList;
217
 
}
218
 
 
219
 
int Importer::renamedCount() const {
220
 
        return d->mRenamedCount;
 
147
, d(new ImporterPrivate)
 
148
{
 
149
    d->q = this;
 
150
    d->mAuthWindow = parent;
 
151
}
 
152
 
 
153
Importer::~Importer()
 
154
{
 
155
    delete d;
 
156
}
 
157
 
 
158
void Importer::setAutoRenameFormat(const QString& format)
 
159
{
 
160
    if (format.isEmpty()) {
 
161
        d->mFileNameFormater.reset(0);
 
162
    } else {
 
163
        d->mFileNameFormater.reset(new FileNameFormater(format));
 
164
    }
 
165
}
 
166
 
 
167
void Importer::start(const KUrl::List& list, const KUrl& destination)
 
168
{
 
169
    d->mUrlList = list;
 
170
    d->mImportedUrlList.clear();
 
171
    d->mSkippedUrlList.clear();
 
172
    d->mRenamedCount = 0;
 
173
    d->mProgress = 0;
 
174
    d->mJobProgress = 0;
 
175
 
 
176
    emitProgressChanged();
 
177
    maximumChanged(d->mUrlList.count() * 100);
 
178
 
 
179
    if (!d->createImportDir(destination)) {
 
180
        kWarning() << "Could not create import dir";
 
181
        return;
 
182
    }
 
183
    d->importNext();
 
184
}
 
185
 
 
186
void Importer::slotCopyDone(KJob* _job)
 
187
{
 
188
    KIO::CopyJob* job = static_cast<KIO::CopyJob*>(_job);
 
189
    KUrl url = job->destUrl();
 
190
    if (job->error()) {
 
191
        kWarning() << "FIXME: What do we do with failed urls?";
 
192
        advance();
 
193
        d->importNext();
 
194
        return;
 
195
    }
 
196
 
 
197
    d->renameImportedUrl(url);
 
198
}
 
199
 
 
200
void Importer::finalizeImport()
 
201
{
 
202
    d->mDestImportDir->unlink();
 
203
    importFinished();
 
204
}
 
205
 
 
206
void Importer::advance()
 
207
{
 
208
    ++d->mProgress;
 
209
    d->mJobProgress = 0;
 
210
    emitProgressChanged();
 
211
}
 
212
 
 
213
void Importer::slotPercent(KJob*, unsigned long percent)
 
214
{
 
215
    d->mJobProgress = percent;
 
216
    emitProgressChanged();
 
217
}
 
218
 
 
219
void Importer::emitProgressChanged()
 
220
{
 
221
    progressChanged(d->mProgress * 100 + d->mJobProgress);
 
222
}
 
223
 
 
224
KUrl::List Importer::importedUrlList() const
 
225
{
 
226
    return d->mImportedUrlList;
 
227
}
 
228
 
 
229
KUrl::List Importer::skippedUrlList() const
 
230
{
 
231
    return d->mSkippedUrlList;
 
232
}
 
233
 
 
234
int Importer::renamedCount() const
 
235
{
 
236
    return d->mRenamedCount;
221
237
}
222
238
 
223
239
} // namespace