← Back to branch summary

~ubuntu-branches/ubuntu/natty/digikam/natty

« back to all changes in this revision

Viewing changes to digikam/metadatamanager.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2010-08-26 19:25:16 UTC
  • mfrom: (1.2.30 upstream)
  • Revision ID: james.westby@ubuntu.com-20100826192516-mkbdww0h5v2x4yoy
Tags: 2:1.4.0-0ubuntu1
https://launchpad.net/bugs/626751
* New upstream bugfix release (LP: #626751)
* Install the file NEWS as upstream changelog because "ChangeLog" is
  too verbose.
* Don't copy the desktop .pot file to imageplugins, not needed anymore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
digikam/metadatamanager.cpp
6
6
 * Date        : 2009-05-05
7
7
 * Description : Metadata operations on images
8
8
 *
9
 
 * Copyright (C) 2009 by Marcel Wiesweg <marcel.wiesweg@gmx.de>
 
9
 * Copyright (C) 2009-2010 by Marcel Wiesweg <marcel.wiesweg@gmx.de>
10
10
 *
11
11
 * This program is free software; you can redistribute it
12
12
 * and/or modify it under the terms of the GNU General
49
49
{
50
50
 
51
51
class MetadataManagerCreator { public: MetadataManager object; };
52
 
K_GLOBAL_STATIC(MetadataManagerCreator, creator)
 
52
K_GLOBAL_STATIC(MetadataManagerCreator, metadataManagercreator)
53
53
 
54
54
MetadataManager* MetadataManager::instance()
55
55
{
56
 
    return &creator->object;
 
56
    return &metadataManagercreator->object;
57
57
}
58
58
 
59
59
MetadataManager::MetadataManager()
175
175
 
176
176
// --------------------------------------------------------------------------------------
177
177
 
178
 
MetadataManagerPriv::MetadataManagerPriv(MetadataManager *q)
179
 
                   : q(q)
 
178
MetadataManager::MetadataManagerPriv::MetadataManagerPriv(MetadataManager* q)
 
179
                                    : q(q)
180
180
{
181
181
    dbWorker   = new MetadataManagerDatabaseWorker(this);
182
182
    fileWorker = new MetadataManagerFileWorker(this);
186
186
    writerTodo = 0;
187
187
    writerDone = 0;
188
188
 
189
 
    connect(this, SIGNAL(signalAddTags(const QList<ImageInfo> &, const QList<int> &)),
190
 
            dbWorker, SLOT(assignTags(const QList<ImageInfo> &, const QList<int> &)));
191
 
 
192
 
    connect(this, SIGNAL(signalRemoveTags(const QList<ImageInfo> &, const QList<int> &)),
193
 
            dbWorker, SLOT(removeTags(const QList<ImageInfo> &, const QList<int> &)));
194
 
 
195
 
    connect(this, SIGNAL(signalAssignRating(const QList<ImageInfo> &, int)),
196
 
            dbWorker, SLOT(assignRating(const QList<ImageInfo> &, int)));
197
 
 
198
 
    connect(this, SIGNAL(signalSetExifOrientation(const QList<ImageInfo> &, int)),
199
 
            dbWorker, SLOT(setExifOrientation(const QList<ImageInfo> &, int)));
 
189
    connect(this, SIGNAL(signalAddTags(const QList<ImageInfo>&, const QList<int>&)),
 
190
            dbWorker, SLOT(assignTags(const QList<ImageInfo>&, const QList<int>&)));
 
191
 
 
192
    connect(this, SIGNAL(signalRemoveTags(const QList<ImageInfo>&, const QList<int>&)),
 
193
            dbWorker, SLOT(removeTags(const QList<ImageInfo>&, const QList<int>&)));
 
194
 
 
195
    connect(this, SIGNAL(signalAssignRating(const QList<ImageInfo>&, int)),
 
196
            dbWorker, SLOT(assignRating(const QList<ImageInfo>&, int)));
 
197
 
 
198
    connect(this, SIGNAL(signalSetExifOrientation(const QList<ImageInfo>&, int)),
 
199
            dbWorker, SLOT(setExifOrientation(const QList<ImageInfo>&, int)));
200
200
 
201
201
    connect(this, SIGNAL(signalApplyMetadata(const QList<ImageInfo>&, MetadataHub*)),
202
202
            dbWorker, SLOT(applyMetadata(const QList<ImageInfo>&, MetadataHub*)));
203
203
 
204
 
 
205
 
    connect(dbWorker, SIGNAL(writeMetadataToFiles(const QList<ImageInfo> &)),
206
 
            fileWorker, SLOT(writeMetadataToFiles(const QList<ImageInfo> &)));
207
 
 
208
 
    connect(dbWorker, SIGNAL(writeOrientationToFiles(const QList<ImageInfo> &, int)),
209
 
            fileWorker, SLOT(writeOrientationToFiles(const QList<ImageInfo> &, int)));
 
204
    connect(dbWorker, SIGNAL(writeMetadataToFiles(const QList<ImageInfo>&)),
 
205
            fileWorker, SLOT(writeMetadataToFiles(const QList<ImageInfo>&)));
 
206
 
 
207
    connect(dbWorker, SIGNAL(writeOrientationToFiles(const QList<ImageInfo>&, int)),
 
208
            fileWorker, SLOT(writeOrientationToFiles(const QList<ImageInfo>&, int)));
210
209
 
211
210
    connect(dbWorker, SIGNAL(writeMetadata(const QList<ImageInfo>&, MetadataHub*)),
212
211
            fileWorker, SLOT(writeMetadata(const QList<ImageInfo>&, MetadataHub*)));
213
212
 
214
 
 
215
 
    connect(fileWorker, SIGNAL(imageDataChanged(const QString &, bool, bool)),
216
 
            this, SLOT(slotImageDataChanged(const QString &, bool, bool)));
 
213
    connect(fileWorker, SIGNAL(imageDataChanged(const QString&, bool, bool)),
 
214
            this, SLOT(slotImageDataChanged(const QString&, bool, bool)));
217
215
}
218
216
 
219
 
MetadataManagerPriv::~MetadataManagerPriv()
 
217
MetadataManager::MetadataManagerPriv::~MetadataManagerPriv()
220
218
{
221
219
    delete dbWorker;
222
220
    delete fileWorker;
223
221
}
224
222
 
225
 
void MetadataManagerPriv::schedulingForDB(int numberOfInfos)
 
223
void MetadataManager::MetadataManagerPriv::schedulingForDB(int numberOfInfos)
226
224
{
227
225
    dbTodo += numberOfInfos;
228
226
    updateProgress();
229
227
}
230
228
 
231
 
void MetadataManagerPriv::setDBAction(const QString& action)
 
229
void MetadataManager::MetadataManagerPriv::setDBAction(const QString& action)
232
230
{
233
231
    dbMessage = action;
234
232
    updateProgressMessage();
235
233
}
236
234
 
237
 
bool MetadataManagerPriv::shallSendForWriting(qlonglong id)
 
235
bool MetadataManager::MetadataManagerPriv::shallSendForWriting(qlonglong id)
238
236
{
239
237
    QMutexLocker lock(&mutex);
240
238
    if (scheduledToWrite.contains(id))
243
241
    return true;
244
242
}
245
243
 
246
 
void MetadataManagerPriv::dbProcessedOne()
 
244
void MetadataManager::MetadataManagerPriv::dbProcessedOne()
247
245
{
248
246
    if ( (dbDone++ % 10) == 0)
249
247
        updateProgress();
250
248
}
251
249
 
252
 
void MetadataManagerPriv::dbProcessed(int numberOfInfos)
 
250
void MetadataManager::MetadataManagerPriv::dbProcessed(int numberOfInfos)
253
251
{
254
252
    dbDone += numberOfInfos;
255
253
    updateProgress();
256
254
}
257
255
 
258
 
void MetadataManagerPriv::dbFinished(int numberOfInfos)
 
256
void MetadataManager::MetadataManagerPriv::dbFinished(int numberOfInfos)
259
257
{
260
258
    dbTodo -= numberOfInfos;
261
259
    updateProgress();
262
260
}
263
261
 
264
 
void MetadataManagerPriv::schedulingForWrite(int numberOfInfos)
 
262
void MetadataManager::MetadataManagerPriv::schedulingForWrite(int numberOfInfos)
265
263
{
266
264
    writerTodo += numberOfInfos;
267
265
    updateProgress();
268
266
}
269
267
 
270
 
void MetadataManagerPriv::schedulingForOrientationWrite(int numberOfInfos)
 
268
void MetadataManager::MetadataManagerPriv::schedulingForOrientationWrite(int numberOfInfos)
271
269
{
272
270
    schedulingForWrite(numberOfInfos);
273
271
}
274
272
 
275
 
void MetadataManagerPriv::setWriterAction(const QString& action)
 
273
void MetadataManager::MetadataManagerPriv::setWriterAction(const QString& action)
276
274
{
277
275
    writerMessage = action;
278
276
    updateProgressMessage();
279
277
}
280
278
 
281
 
void MetadataManagerPriv::startingToWrite(const QList<ImageInfo>& infos)
 
279
void MetadataManager::MetadataManagerPriv::startingToWrite(const QList<ImageInfo>& infos)
282
280
{
283
281
    QMutexLocker lock(&mutex);
284
282
    foreach (const ImageInfo& info, infos)
285
283
        scheduledToWrite.remove(info.id());
286
284
}
287
285
 
288
 
void MetadataManagerPriv::writtenToOne()
 
286
void MetadataManager::MetadataManagerPriv::writtenToOne()
289
287
{
290
288
    writerDone++;
291
289
    updateProgress();
292
290
}
293
291
 
294
 
void MetadataManagerPriv::orientationWrittenToOne()
 
292
void MetadataManager::MetadataManagerPriv::orientationWrittenToOne()
295
293
{
296
294
    writtenToOne();
297
295
}
298
296
 
299
 
void MetadataManagerPriv::finishedWriting(int numberOfInfos)
 
297
void MetadataManager::MetadataManagerPriv::finishedWriting(int numberOfInfos)
300
298
{
301
299
    writerTodo -= numberOfInfos;
302
300
    updateProgress();
303
301
}
304
302
 
305
 
void MetadataManagerPriv::updateProgressMessage()
 
303
void MetadataManager::MetadataManagerPriv::updateProgressMessage()
306
304
{
307
305
    QString message;
308
306
    if (dbTodo && writerTodo)
314
312
    emit progressMessageChanged(message);
315
313
}
316
314
 
317
 
void MetadataManagerPriv::updateProgress()
 
315
void MetadataManager::MetadataManagerPriv::updateProgress()
318
316
{
319
317
    if (dbTodo == 0 && writerTodo == 0)
320
318
    {
328
326
    emit progressValueChanged(percent);
329
327
}
330
328
 
331
 
void MetadataManagerPriv::slotImageDataChanged(const QString &path, bool removeThumbnails, bool notifyCache)
 
329
void MetadataManager::MetadataManagerPriv::slotImageDataChanged(const QString &path, bool removeThumbnails, bool notifyCache)
332
330
{
333
331
    // must be done from the UI thread, touches pixmaps
334
332
    if (removeThumbnails)
352
350
    changeTags(infos, tagIDs, false);
353
351
}
354
352
 
355
 
void MetadataManagerDatabaseWorker::changeTags(const QList<ImageInfo>& infos, const QList<int>& tagIDs, bool addOrRemove)
 
353
void MetadataManagerDatabaseWorker::changeTags(const QList<ImageInfo>& infos, 
 
354
                                                                const QList<int>& tagIDs, bool addOrRemove)
356
355
{
357
 
    MetadataHub hub;
358
 
 
 
356
    MetadataHub      hub;
359
357
    QList<ImageInfo> forWriting;
360
358
 
361
359
    {
396
394
    d->setDBAction(i18n("Assigning image ratings. Please wait..."));
397
395
 
398
396
    rating = qMin(RatingMax, qMax(RatingMin, rating));
399
 
    MetadataHub hub;
400
 
 
 
397
    MetadataHub      hub;
401
398
    QList<ImageInfo> forWriting;
402
399
 
403
400
    {