← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/digikam/intrepid

« back to all changes in this revision

Viewing changes to digikam/utilities/cameragui/cameraiconview.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mark Purcell
  • Date: 2008-07-17 20:25:39 UTC
  • mfrom: (1.3.2 upstream) (37 hardy)
  • mto: This revision was merged to the branch mainline in revision 39.
  • Revision ID: james.westby@ubuntu.com-20080717202539-1bw3w3nrsso7yj4z
http://bugs.debian.org/490144
* New upstream release
  - digiKam 0.9.4 Release Plan (KDE3) ~ 13 July 08 (Closes: #490144)
* DEB_CONFIGURE_EXTRA_FLAGS := --without-included-sqlite3
* Debhelper compatibility level V7
* Install pixmaps in debian/*.install
* Add debian/digikam.lintian-overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
digikam/utilities/cameragui/cameraiconview.cpp
1
1
/* ============================================================
2
 
 * Author: Renchi Raju <renchi@pooh.tam.uiuc.edu>
3
 
 * Date  : 2004-09-18
4
 
 * Description : 
 
2
 *
 
3
 * This file is a part of digiKam project
 
4
 * http://www.digikam.org
 
5
 *
 
6
 * Date        : 2004-09-18
 
7
 * Description : camera icon view
5
8
 * 
6
 
 * Copyright 2004 by Renchi Raju
7
 
 
 
9
 * Copyright (C) 2004-2005 by Renchi Raju <renchi@pooh.tam.uiuc.edu>
 
10
 * Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
 
11
 *
8
12
 * This program is free software; you can redistribute it
9
13
 * and/or modify it under the terms of the GNU General
10
14
 * Public License as published by the Free Software Foundation;
18
22
 * 
19
23
 * ============================================================ */
20
24
 
 
25
// Qt includes.
 
26
 
21
27
#include <qfile.h>
 
28
#include <qfileinfo.h>
 
29
#include <qtimer.h>
 
30
#include <qpainter.h>
22
31
#include <qpixmap.h>
23
 
#include <qpopupmenu.h>
24
32
#include <qcursor.h>
25
33
#include <qfontmetrics.h>
26
34
#include <qfont.h>
27
 
 
 
35
#include <qdragobject.h>
 
36
#include <qclipboard.h>
 
37
 
 
38
// KDE includes.
 
39
 
 
40
#include <kurldrag.h>
28
41
#include <kmimetype.h>
29
42
#include <klocale.h>
30
43
#include <kiconloader.h>
31
 
 
32
 
extern "C"
33
 
{
34
 
#include <time.h>
35
 
}
36
 
 
 
44
#include <kaction.h>
 
45
#include <kapplication.h>
 
46
 
 
47
// Local includes.
 
48
 
 
49
#include "ddebug.h"
 
50
#include "themeengine.h"
 
51
#include "thumbnailsize.h"
 
52
#include "gpiteminfo.h"
 
53
#include "renamecustomizer.h"
 
54
#include "icongroupitem.h"
 
55
#include "dpopupmenu.h"
 
56
#include "dragobjects.h"
37
57
#include "cameraui.h"
38
 
#include "gpiteminfo.h"
39
58
#include "cameraiconitem.h"
40
59
#include "cameraiconview.h"
41
 
#include "renamecustomizer.h"
42
 
#include "icongroupitem.h"
 
60
#include "cameraiconview.moc"
 
61
 
 
62
namespace Digikam
 
63
{
 
64
 
 
65
class CameraIconViewPriv
 
66
{
 
67
public:
 
68
 
 
69
    CameraIconViewPriv()
 
70
    {
 
71
        renamer   = 0;
 
72
        groupItem = 0;
 
73
        cameraUI  = 0;
 
74
        thumbSize = ThumbnailSize::Large;
 
75
    }
 
76
 
 
77
    QDict<CameraIconViewItem>  itemDict;
 
78
 
 
79
    QRect                      itemRect;
 
80
 
 
81
    QPixmap                    itemRegPixmap;
 
82
    QPixmap                    itemSelPixmap;
 
83
 
 
84
    RenameCustomizer          *renamer;
 
85
 
 
86
    IconGroupItem             *groupItem;
 
87
 
 
88
    ThumbnailSize              thumbSize;
 
89
 
 
90
    CameraUI                  *cameraUI;
 
91
};
43
92
 
44
93
CameraIconView::CameraIconView(CameraUI* ui, QWidget* parent)
45
 
    : IconView(parent), m_renamer(0), m_ui(ui),
46
 
      m_groupItem(new IconGroupItem(this))
 
94
              : IconView(parent)
47
95
{
 
96
    d = new CameraIconViewPriv;
 
97
    d->cameraUI  = ui;
 
98
    d->groupItem = new IconGroupItem(this);
 
99
 
48
100
    setHScrollBarMode(QScrollView::AlwaysOff);
49
 
 
50
 
    CameraIconViewItem::m_newEmblem = new QPixmap(CameraIconViewItem::new_xpm);
51
 
    
 
101
    setMinimumSize(400, 300);
 
102
 
 
103
    setAcceptDrops(true);
 
104
    viewport()->setAcceptDrops(true);
 
105
 
 
106
    // ----------------------------------------------------------------
 
107
 
52
108
    connect(this, SIGNAL(signalSelectionChanged()),
53
 
            SLOT(slotSelectionChanged()));
 
109
            this, SLOT(slotSelectionChanged()));
 
110
 
 
111
    connect(this, SIGNAL(signalNewSelection(bool)),
 
112
            this, SLOT(slotUpdateDownloadNames(bool)));
 
113
 
54
114
    connect(this, SIGNAL(signalRightButtonClicked(IconItem*, const QPoint&)),
55
 
            SLOT(slotContextMenu(IconItem*, const QPoint&)));
 
115
            this, SLOT(slotContextMenu(IconItem*, const QPoint&)));
 
116
 
 
117
    connect(this, SIGNAL(signalRightButtonClicked(const QPoint &)),
 
118
            this, SLOT(slotRightButtonClicked(const QPoint &)));
 
119
 
56
120
    connect(this, SIGNAL(signalDoubleClicked(IconItem*)),
57
 
            SLOT(slotDoubleClicked(IconItem*)));
 
121
            this, SLOT(slotDoubleClicked(IconItem*)));
 
122
 
 
123
    connect(ThemeEngine::instance(), SIGNAL(signalThemeChanged()),
 
124
            this, SLOT(slotThemeChanged()));
 
125
 
 
126
    // ----------------------------------------------------------------
 
127
 
 
128
    updateItemRectsPixmap();
 
129
    slotThemeChanged();
58
130
}
59
131
 
60
132
CameraIconView::~CameraIconView()
61
133
{
62
134
    clear();
63
 
    delete CameraIconViewItem::m_newEmblem;
64
 
    CameraIconViewItem::m_newEmblem = 0;
 
135
    delete d;
 
136
}
 
137
 
 
138
QPixmap* CameraIconView::itemBaseRegPixmap() const
 
139
{
 
140
    return &d->itemRegPixmap;
 
141
}
 
142
 
 
143
QPixmap* CameraIconView::itemBaseSelPixmap() const
 
144
{
 
145
    return &d->itemSelPixmap;
65
146
}
66
147
 
67
148
void CameraIconView::setRenameCustomizer(RenameCustomizer* renamer)
68
149
{
69
 
    m_renamer = renamer;
70
 
    connect(m_renamer, SIGNAL(signalChanged()),
71
 
            SLOT(slotDownloadNameChanged()));
 
150
    d->renamer = renamer;
 
151
    
 
152
    connect(d->renamer, SIGNAL(signalChanged()),
 
153
            this, SLOT(slotDownloadNameChanged()));
72
154
}
73
155
 
74
156
void CameraIconView::addItem(const GPItemInfo& info)
75
157
{
76
 
    KMimeType::Ptr mime;
77
 
    mime = KMimeType::mimeType( info.mime );
78
 
    QPixmap pix = mime->pixmap( KIcon::Desktop, 100, KIcon::DefaultState);
 
158
    QImage thumb;
 
159
    // Just to have a generic image thumb from desktop with KDE < 3.5.0
 
160
    KMimeType::Ptr mime = KMimeType::mimeType(info.mime == QString("image/x-raw") ? 
 
161
                                              QString("image/tiff") : info.mime);
79
162
 
 
163
    if (mime)
 
164
    {
 
165
        thumb = QImage(mime->pixmap(KIcon::Desktop, ThumbnailSize::Huge, KIcon::DefaultState)
 
166
                       .convertToImage());
 
167
    }
 
168
    else
 
169
    {
 
170
        KIconLoader *iconLoader = KApplication::kApplication()->iconLoader();
 
171
        thumb = iconLoader->loadIcon("empty", KIcon::Desktop,
 
172
                                     ThumbnailSize::Huge, KIcon::DefaultState, 0, true)
 
173
                                     .convertToImage();
 
174
    }
 
175
    
80
176
    QString downloadName;
81
177
 
82
 
    if (m_renamer)
 
178
    if (d->renamer)
83
179
    {
84
 
        if (!m_renamer->useDefault())
 
180
        if (!d->renamer->useDefault())
85
181
        {
86
 
            downloadName = getTemplatedName( m_renamer->nameTemplate(), &info,
87
 
                                             m_itemDict.count() );
 
182
            downloadName = getTemplatedName( &info, d->itemDict.count() );
88
183
        }
89
184
        else
90
185
        {
91
 
            downloadName = getCasedName( m_renamer->changeCase(), &info);
 
186
            downloadName = getCasedName( d->renamer->changeCase(), &info);
92
187
        }
93
188
    }
94
189
 
95
 
    CameraIconViewItem* item = new CameraIconViewItem(m_groupItem, info,
96
 
                                                      pix, downloadName);
97
 
    m_itemDict.insert(info.folder+info.name, item);
 
190
    CameraIconViewItem* item = new CameraIconViewItem(d->groupItem, info, thumb, downloadName);
 
191
    d->itemDict.insert(info.folder+info.name, item);
98
192
}
99
193
 
100
194
void CameraIconView::removeItem(const QString& folder, const QString& file)
101
195
{
102
 
    CameraIconViewItem* item = m_itemDict.find(folder+file);
 
196
    CameraIconViewItem* item = d->itemDict.find(folder+file);
103
197
    if (!item)
104
198
        return;
 
199
    d->itemDict.remove(folder+file);
105
200
 
 
201
    setDelayedRearrangement(true);
106
202
    delete item;
107
 
    triggerUpdate();
 
203
    setDelayedRearrangement(false);
108
204
}
109
205
 
110
206
CameraIconViewItem* CameraIconView::findItem(const QString& folder, const QString& file)
111
207
{
112
 
    return m_itemDict.find(folder+file);
113
 
}
114
 
 
115
 
void CameraIconView::setThumbnail(const QString& folder, const QString& filename,
116
 
                                  const QPixmap& pixmap)
117
 
{
118
 
    CameraIconViewItem* item = m_itemDict.find(folder+filename);
 
208
    return d->itemDict.find(folder+file);
 
209
}
 
210
 
 
211
int CameraIconView::countItemsByFolder(QString folder)
 
212
{
 
213
    int count = 0;
 
214
    if (folder.endsWith("/")) folder.truncate(folder.length()-1);
 
215
 
 
216
    for (IconItem* item = firstItem(); item; item = item->nextItem())
 
217
    {
 
218
        CameraIconViewItem* iconItem = static_cast<CameraIconViewItem*>(item);
 
219
        QString itemFolder = iconItem->itemInfo()->folder;
 
220
        if (itemFolder.endsWith("/")) itemFolder.truncate(itemFolder.length()-1);
 
221
 
 
222
        if (folder == itemFolder)
 
223
            count++;
 
224
    }
 
225
    
 
226
    return count;
 
227
}
 
228
 
 
229
void CameraIconView::setThumbnail(const QString& folder, const QString& filename, const QImage& image)
 
230
{
 
231
    CameraIconViewItem* item = d->itemDict.find(folder+filename);
119
232
    if (!item)
120
233
        return;
121
234
 
122
 
    item->setPixmap(pixmap);
 
235
    item->setThumbnail(image);
123
236
    item->repaint();
124
237
}
125
238
 
 
239
void CameraIconView::ensureItemVisible(CameraIconViewItem *item)
 
240
{
 
241
    IconView::ensureItemVisible(item);
 
242
}
 
243
 
 
244
void CameraIconView::ensureItemVisible(const GPItemInfo& itemInfo)
 
245
{
 
246
    ensureItemVisible(itemInfo.folder, itemInfo.name);
 
247
}
 
248
 
 
249
void CameraIconView::ensureItemVisible(const QString& folder, const QString& file)
 
250
{
 
251
    CameraIconViewItem* item = d->itemDict.find(folder+file);
 
252
    if (!item)
 
253
        return;
 
254
 
 
255
    ensureItemVisible(item);
 
256
}
 
257
 
126
258
void CameraIconView::slotDownloadNameChanged()
127
259
{
128
 
    bool    useDefault   = true;
129
 
    QString nameTemplate;
130
 
 
131
 
    if (m_renamer)
132
 
    {
133
 
        useDefault   = m_renamer->useDefault();
134
 
        nameTemplate = m_renamer->nameTemplate();
 
260
    bool hasSelection = false;
 
261
    for (IconItem* item = firstItem(); item; item = item->nextItem())
 
262
    {
 
263
        if (item->isSelected())
 
264
        {
 
265
            hasSelection = true;
 
266
            break;
 
267
        }
 
268
    }
 
269
 
 
270
    // connected to slotUpdateDownloadNames, and used externally
 
271
    emit signalNewSelection(hasSelection);
 
272
}
 
273
 
 
274
void CameraIconView::slotUpdateDownloadNames(bool hasSelection)
 
275
{
 
276
    bool useDefault = true;
 
277
    int  startIndex = 0;
 
278
 
 
279
    if (d->renamer)
 
280
    {
 
281
        useDefault = d->renamer->useDefault();
 
282
        startIndex = d->renamer->startIndex() -1;
135
283
    }
136
284
    
 
285
    bool convertLossLessJpeg = d->cameraUI->convertLosslessJpegFiles();
 
286
    QString losslessFormat   = d->cameraUI->losslessFormat();
 
287
 
137
288
    viewport()->setUpdatesEnabled(false);
138
 
    for (IconItem* item = firstItem(); item;
139
 
         item = item->nextItem())
140
 
    {
141
 
        CameraIconViewItem* viewItem =
142
 
            static_cast<CameraIconViewItem*>(item);
143
 
 
144
 
        QString downloadName;
145
 
        if (!useDefault)
146
 
            downloadName = getTemplatedName( nameTemplate,
147
 
                                             viewItem->itemInfo(),
148
 
                                             m_groupItem->index(viewItem) );
149
 
        else
150
 
            downloadName = getCasedName( m_renamer->changeCase(),
151
 
                                         viewItem->itemInfo() );
152
 
 
153
 
        viewItem->setDownloadName( downloadName );
154
 
    }
155
 
    rearrangeItems();
 
289
 
 
290
    if (hasSelection)
 
291
    {
 
292
        // Camera items selection.
 
293
    
 
294
        for (IconItem* item = firstItem(); item; item = item->nextItem())
 
295
        {
 
296
            QString downloadName;
 
297
            CameraIconViewItem* viewItem = static_cast<CameraIconViewItem*>(item);
 
298
 
 
299
            if (item->isSelected())
 
300
            {
 
301
                if (!useDefault)
 
302
                    downloadName = getTemplatedName( viewItem->itemInfo(), startIndex );
 
303
                else
 
304
                    downloadName = getCasedName( d->renamer->changeCase(), viewItem->itemInfo() );
 
305
 
 
306
                startIndex++;
 
307
            }
 
308
    
 
309
            if (convertLossLessJpeg && !downloadName.isEmpty())
 
310
            {
 
311
                QFileInfo fi(downloadName);
 
312
                QString ext = fi.extension(false).upper();
 
313
                if (ext == QString("JPEG") || ext == QString("JPG") || ext == QString("JPE"))
 
314
                {
 
315
                    downloadName.truncate(downloadName.length() - ext.length());
 
316
                    downloadName.append(losslessFormat.lower());
 
317
                }
 
318
            }
 
319
 
 
320
            viewItem->setDownloadName( downloadName );
 
321
        }
 
322
    }
 
323
    else
 
324
    {
 
325
        // No camera item selection.
 
326
    
 
327
        for (IconItem* item = firstItem(); item; item = item->nextItem())
 
328
        {
 
329
            QString downloadName;
 
330
            CameraIconViewItem* viewItem = static_cast<CameraIconViewItem*>(item);
 
331
    
 
332
            if (!useDefault)
 
333
                downloadName = getTemplatedName( viewItem->itemInfo(), startIndex );
 
334
            else
 
335
                downloadName = getCasedName( d->renamer->changeCase(), viewItem->itemInfo() );
 
336
 
 
337
            if (convertLossLessJpeg)
 
338
            {
 
339
                QFileInfo fi(downloadName);
 
340
                QString ext = fi.extension(false).upper();
 
341
                if (ext == QString("JPEG") || ext == QString("JPG") || ext == QString("JPE"))
 
342
                {
 
343
                    downloadName.truncate(downloadName.length() - ext.length());
 
344
                    downloadName.append(losslessFormat.lower());
 
345
                }
 
346
            }
 
347
    
 
348
            viewItem->setDownloadName( downloadName );
 
349
            startIndex++;
 
350
        }
 
351
    }
 
352
 
156
353
    viewport()->setUpdatesEnabled(true);
157
354
    viewport()->update();
158
355
}
159
356
 
160
 
QString CameraIconView::getTemplatedName(const QString& templ,
161
 
                                         const GPItemInfo* itemInfo,
162
 
                                         int position)
163
 
{
164
 
    if (templ.isEmpty())
165
 
        return QString::null;
166
 
    
167
 
    QString dname(templ);
168
 
    
 
357
QString CameraIconView::defaultDownloadName(CameraIconViewItem *viewItem)
 
358
{
 
359
    RenameCustomizer::Case renamecase = RenameCustomizer::NONE;
 
360
    if (d->renamer)
 
361
        renamecase = d->renamer->changeCase();
 
362
 
 
363
    return getCasedName( renamecase, viewItem->itemInfo() );
 
364
}
 
365
 
 
366
QString CameraIconView::getTemplatedName(const GPItemInfo* itemInfo, int position)
 
367
{
169
368
    QString ext = itemInfo->name;
170
369
    int pos = ext.findRev('.');
171
370
    if (pos < 0)
172
371
        ext = "";
173
372
    else
174
 
        ext = ext.right( ext.length() - pos - 1);
175
 
 
176
 
    struct tm* time_tm = ::localtime(&itemInfo->mtime);
177
 
    char s[100];
178
 
    strftime(s, 100, QFile::encodeName(dname), time_tm);
179
 
 
180
 
    dname  = s;
181
 
    dname.replace("%s", "");
182
 
    
183
 
    dname.sprintf(QFile::encodeName(dname), position+1);
184
 
    dname.replace("/","");
185
 
 
186
 
    dname += '.';
187
 
    dname += ext;
188
 
    
189
 
    return dname;
 
373
        ext = ext.right( ext.length() - pos );
 
374
 
 
375
    QDateTime mtime;
 
376
    mtime.setTime_t(itemInfo->mtime);
 
377
 
 
378
    return d->renamer->newName(mtime, position+1, ext);
190
379
}
191
380
 
192
381
QString CameraIconView::getCasedName(const RenameCustomizer::Case ccase,
196
385
 
197
386
    switch (ccase)
198
387
    {
199
 
    case(RenameCustomizer::UPPER):
200
 
    {
201
 
        dname = itemInfo->name.upper();
202
 
        break;
203
 
    }
204
 
    case(RenameCustomizer::LOWER):
205
 
    {
206
 
        dname = itemInfo->name.lower();
207
 
        break;
208
 
    }
209
 
    default:
210
 
        break;
 
388
        case(RenameCustomizer::UPPER):
 
389
        {
 
390
            dname = itemInfo->name.upper();
 
391
            break;
 
392
        }
 
393
        case(RenameCustomizer::LOWER):
 
394
        {
 
395
            dname = itemInfo->name.lower();
 
396
            break;
 
397
        }
 
398
        default:
 
399
        {
 
400
            dname = itemInfo->name;
 
401
            break;
 
402
        }
211
403
    };
212
404
 
213
405
    return dname;
215
407
 
216
408
void CameraIconView::slotSelectionChanged()
217
409
{
218
 
    bool selected = false;
219
 
    
220
 
    for (IconItem* item = firstItem(); item;
221
 
         item = item->nextItem())
 
410
    bool selected               = false;
 
411
    CameraIconViewItem* camItem = 0;
 
412
 
 
413
    for (IconItem* item = firstItem(); item; item = item->nextItem())
222
414
    {
223
415
        if (item->isSelected())
224
416
        {
 
417
            camItem  = static_cast<CameraIconViewItem*>(item);
225
418
            selected = true;
226
419
            break;
227
420
        }
228
421
    }
229
422
 
230
 
    emit signalSelected(selected);
 
423
    emit signalNewSelection(selected);
 
424
    emit signalSelected(camItem, selected);
 
425
 
 
426
    viewport()->update();
231
427
}
232
428
 
233
429
void CameraIconView::slotContextMenu(IconItem * item, const QPoint&)
236
432
        return;
237
433
 
238
434
    // don't popup context menu if the camera is busy
239
 
    if (m_ui->isBusy())
 
435
    if (d->cameraUI->isBusy())
240
436
        return;
241
437
 
242
438
    CameraIconViewItem* camItem = static_cast<CameraIconViewItem*>(item);
243
439
    
244
 
    QPopupMenu menu;
 
440
    DPopupMenu menu(this);
245
441
    menu.insertItem(SmallIcon("editimage"), i18n("&View"), 0);
246
 
    menu.insertSeparator();
247
 
    menu.insertItem(i18n("Properties"), 1);
248
 
    menu.insertItem(SmallIcon("text_block"), i18n("EXIF Information"), 2);
249
 
    menu.insertSeparator();
250
 
    menu.insertItem(SmallIcon("down"),i18n("Download"), 3);
251
 
    menu.insertItem(SmallIcon("editdelete"), i18n("Delete"), 4);
 
442
    menu.insertSeparator(-1);
 
443
    menu.insertItem(SmallIcon("down"),i18n("Download"), 1);
 
444
    menu.insertItem(SmallIcon("down"),i18n("Download && Delete"), 4);
 
445
    menu.insertItem(SmallIcon("encrypted"), i18n("Toggle lock"), 3);
 
446
    menu.insertSeparator(-1);
 
447
    menu.insertItem(SmallIcon("editdelete"), i18n("Delete"), 2);
252
448
 
253
449
    int result = menu.exec(QCursor::pos());
254
450
 
255
451
    switch (result)
256
452
    {
257
 
    case(0):
258
 
    {
259
 
        emit signalFileView(camItem);
260
 
        break;
261
 
    }
262
 
    case(1):
263
 
    {
264
 
        emit signalFileProperties(camItem);
265
 
        break;
266
 
    }
267
 
    case(2):
268
 
    {
269
 
        emit signalFileExif(camItem);
270
 
        break;
271
 
    }
272
 
    case(3):
273
 
    {
274
 
        emit signalDownload();
275
 
        break;
276
 
    }
277
 
    case(4):
278
 
    {
279
 
        emit signalDelete();
280
 
        break;
281
 
    }
282
 
    default:
283
 
        break;
 
453
        case(0):
 
454
        {
 
455
            emit signalFileView(camItem);
 
456
            break;
 
457
        }
 
458
        case(1):
 
459
        {
 
460
            emit signalDownload();
 
461
            break;
 
462
        }
 
463
        case(2):
 
464
        {
 
465
            emit signalDelete();
 
466
            break;
 
467
        }
 
468
        case(3):
 
469
        {
 
470
            emit signalToggleLock();
 
471
            break;
 
472
        }
 
473
        case(4):
 
474
        {
 
475
            emit signalDownloadAndDelete();
 
476
            break;
 
477
        }
 
478
        default:
 
479
            break;
284
480
    }
285
481
}
286
482
 
289
485
    if (!item)
290
486
        return;
291
487
    
292
 
    if (m_ui->isBusy())
 
488
    if (d->cameraUI->isBusy())
293
489
        return;
294
490
 
295
491
    emit signalFileView(static_cast<CameraIconViewItem*>(item));
314
510
{
315
511
    blockSignals(true);
316
512
    clearSelection();
 
513
 
317
514
    for (IconItem* item = firstItem(); item;
318
515
         item = item->nextItem())
319
516
    {
320
 
        CameraIconViewItem* viewItem =
321
 
            static_cast<CameraIconViewItem*>(item);
322
 
        if (viewItem->itemInfo()->downloaded == 0)
 
517
        CameraIconViewItem* viewItem = static_cast<CameraIconViewItem*>(item);
 
518
        if (viewItem->itemInfo()->downloaded == GPItemInfo::NewPicture)
323
519
        {
324
520
            viewItem->setSelected(true, false);
325
521
        }
326
522
    }
 
523
 
327
524
    blockSignals(false);
328
525
    emit signalSelectionChanged();
329
526
}
330
527
 
331
528
void CameraIconView::startDrag()
332
529
{
333
 
    
 
530
    QStringList lst;
 
531
 
 
532
    for (IconItem* item = firstItem(); item; item = item->nextItem())
 
533
    {
 
534
        if (!item->isSelected())
 
535
            continue;
 
536
 
 
537
        CameraIconViewItem* iconItem = static_cast<CameraIconViewItem*>(item);
 
538
        QString itemPath = iconItem->itemInfo()->folder + iconItem->itemInfo()->name;
 
539
        lst.append(itemPath);
 
540
    }
 
541
 
 
542
    QDragObject * drag = new CameraItemListDrag(lst, d->cameraUI);
 
543
    if (drag)
 
544
    {
 
545
        QPixmap icon(DesktopIcon("image", 48));
 
546
        int w = icon.width();
 
547
        int h = icon.height();
 
548
    
 
549
        QPixmap pix(w+4,h+4);
 
550
        QString text(QString::number(lst.count()));
 
551
    
 
552
        QPainter p(&pix);
 
553
        p.fillRect(0, 0, w+4, h+4, QColor(Qt::white));
 
554
        p.setPen(QPen(Qt::black, 1));
 
555
        p.drawRect(0, 0, w+4, h+4);
 
556
        p.drawPixmap(2, 2, icon);
 
557
        QRect r = p.boundingRect(2,2,w,h,Qt::AlignLeft|Qt::AlignTop,text);
 
558
        r.setWidth(QMAX(r.width(),r.height()));
 
559
        r.setHeight(QMAX(r.width(),r.height()));
 
560
        p.fillRect(r, QColor(0,80,0));
 
561
        p.setPen(Qt::white);
 
562
        QFont f(font());
 
563
        f.setBold(true);
 
564
        p.setFont(f);
 
565
        p.drawText(r, Qt::AlignCenter, text);
 
566
        p.end();
 
567
        
 
568
        drag->setPixmap(pix);
 
569
        drag->drag();
 
570
    }
 
571
}
 
572
 
 
573
void CameraIconView::contentsDropEvent(QDropEvent *event)
 
574
{
 
575
    // don't popup context menu if the camera is busy
 
576
    if (d->cameraUI->isBusy())
 
577
        return;
 
578
 
 
579
    if ( (!QUriDrag::canDecode(event) && !CameraDragObject::canDecode(event) )
 
580
         || event->source() == this)
 
581
    {
 
582
        event->ignore();
 
583
        return;
 
584
    }
 
585
 
 
586
    KURL::List srcURLs;
 
587
    KURLDrag::decode(event, srcURLs);
 
588
    uploadItemPopupMenu(srcURLs);
 
589
}
 
590
 
 
591
void CameraIconView::slotRightButtonClicked(const QPoint&)
 
592
{
 
593
    // don't popup context menu if the camera is busy
 
594
    if (d->cameraUI->isBusy())
 
595
        return;
 
596
 
 
597
    QMimeSource *data = kapp->clipboard()->data(QClipboard::Clipboard);
 
598
    if(!data || !QUriDrag::canDecode(data))
 
599
        return;
 
600
 
 
601
    KURL::List srcURLs;
 
602
    KURLDrag::decode(data, srcURLs);
 
603
    uploadItemPopupMenu(srcURLs);
 
604
}
 
605
 
 
606
void CameraIconView::uploadItemPopupMenu(const KURL::List& srcURLs)
 
607
{
 
608
    KPopupMenu popMenu(this);
 
609
    popMenu.insertTitle(SmallIcon("digikam"), d->cameraUI->cameraTitle());
 
610
    popMenu.insertItem( SmallIcon("goto"), i18n("&Upload to camera"), 10 );
 
611
    popMenu.insertSeparator(-1);
 
612
    popMenu.insertItem( SmallIcon("cancel"), i18n("C&ancel") );
 
613
 
 
614
    popMenu.setMouseTracking(true);
 
615
    int id = popMenu.exec(QCursor::pos());
 
616
    switch(id) 
 
617
    {
 
618
        case 10: 
 
619
        {
 
620
            emit signalUpload(srcURLs);
 
621
            break;
 
622
        }
 
623
        default:
 
624
            break;
 
625
    }
334
626
}
335
627
 
336
628
QRect CameraIconView::itemRect() const
337
629
{
338
 
    if (!firstItem())
339
 
        return QRect();
340
 
 
341
 
    CameraIconViewItem* item = static_cast<CameraIconViewItem*>(firstItem());
342
 
 
343
 
    const int thumbSize = 128;
 
630
    return d->itemRect;
 
631
}
 
632
 
 
633
void CameraIconView::setThumbnailSize(const ThumbnailSize& thumbSize)
 
634
{
 
635
    if ( d->thumbSize != thumbSize)
 
636
    {
 
637
        d->thumbSize = thumbSize;
 
638
        updateItemRectsPixmap();
 
639
        triggerRearrangement();
 
640
    }
 
641
}
 
642
 
 
643
ThumbnailSize CameraIconView::thumbnailSize() const
 
644
{
 
645
    return d->thumbSize;
 
646
}
 
647
 
 
648
void CameraIconView::updateItemRectsPixmap()
 
649
{
 
650
    int thumbSize = d->thumbSize.size();
344
651
 
345
652
    QRect pixRect;
346
653
    QRect textRect;
348
655
 
349
656
    pixRect.setWidth(thumbSize);
350
657
    pixRect.setHeight(thumbSize);
351
 
    
 
658
 
352
659
    QFontMetrics fm(font());
353
660
    QRect r = QRect(fm.boundingRect(0, 0, thumbSize, 0xFFFFFFFF,
354
 
                                    Qt::AlignHCenter | Qt::AlignTop |
355
 
                                    Qt::WordBreak | Qt::BreakAnywhere,
356
 
                                    item->itemInfo()->name));
 
661
                                    Qt::AlignHCenter | Qt::AlignTop,
 
662
                                    "XXXXXXXXX"));
357
663
    textRect.setWidth(r.width());
358
664
    textRect.setHeight(r.height());
359
665
 
360
 
    if (!item->getDownloadName().isEmpty())
 
666
    QFont fn(font());
 
667
    if (fn.pointSize() > 0)
361
668
    {
362
 
        QFont fn(font());
363
 
        if (fn.pointSize() > 0)
364
 
        {
365
 
            fn.setPointSize(QMAX(fn.pointSize()-2, 6));
366
 
        }
367
 
 
368
 
        fm = QFontMetrics(fn);
369
 
        r = QRect(fm.boundingRect(0, 0, thumbSize, 0xFFFFFFFF,
370
 
                                  Qt::AlignHCenter | Qt::WordBreak |
371
 
                                  Qt::BreakAnywhere | Qt::AlignTop,
372
 
                                  item->getDownloadName()));
373
 
        extraRect.setWidth(r.width());
374
 
        extraRect.setHeight(r.height());
 
669
        fn.setPointSize(QMAX(fn.pointSize()-2, 6));
375
670
    }
376
671
 
 
672
    fm = QFontMetrics(fn);
 
673
    r = QRect(fm.boundingRect(0, 0, thumbSize, 0xFFFFFFFF,
 
674
                              Qt::AlignHCenter | Qt::AlignTop,
 
675
                              "XXXXXXXXX"));
 
676
    extraRect.setWidth(r.width());
 
677
    extraRect.setHeight(r.height());
 
678
 
377
679
    r = QRect();
378
 
    r.setWidth(QMAX(QMAX(pixRect.width(), textRect.width()),
379
 
                       extraRect.width()) + 4);
380
 
    r.setHeight(pixRect.height() +
381
 
                textRect.height() +
382
 
                extraRect.height() + 4);
383
 
 
384
 
    return r;
385
 
}
386
 
 
387
 
#include "cameraiconview.moc"
 
680
    r.setWidth(QMAX(QMAX(pixRect.width(), textRect.width()), extraRect.width()) + 4);
 
681
    r.setHeight(pixRect.height() + textRect.height() + extraRect.height() + 4);
 
682
 
 
683
    d->itemRect = r;
 
684
 
 
685
    d->itemRegPixmap = ThemeEngine::instance()->thumbRegPixmap(d->itemRect.width(),
 
686
                                                               d->itemRect.height());
 
687
 
 
688
    d->itemSelPixmap = ThemeEngine::instance()->thumbSelPixmap(d->itemRect.width(),
 
689
                                                               d->itemRect.height());
 
690
}
 
691
 
 
692
void CameraIconView::slotThemeChanged()
 
693
{
 
694
    updateItemRectsPixmap();
 
695
    viewport()->update();
 
696
}
 
697
 
 
698
int CameraIconView::itemsDownloaded()
 
699
{
 
700
    int downloaded = 0;
 
701
 
 
702
    for (IconItem* item = firstItem(); item; item = item->nextItem())
 
703
    {
 
704
        CameraIconViewItem* iconItem = static_cast<CameraIconViewItem*>(item);
 
705
 
 
706
        if (iconItem->itemInfo()->downloaded == GPItemInfo::DownloadedYes)
 
707
            downloaded++;
 
708
    }
 
709
 
 
710
    return downloaded;
 
711
}
 
712
 
 
713
void CameraIconView::itemsSelectionSizeInfo(unsigned long& fSize, unsigned long& dSize)
 
714
{
 
715
    fSize = 0;  // Files size
 
716
    dSize = 0;  // Estimated space requires to download and process files.
 
717
    for (IconItem* item = firstItem(); item; item = item->nextItem())
 
718
    {
 
719
        if (item->isSelected())
 
720
        {
 
721
            CameraIconViewItem* iconItem = static_cast<CameraIconViewItem*>(item);
 
722
            fSize += iconItem->itemInfo()->size;
 
723
            
 
724
            if (iconItem->itemInfo()->mime == QString("image/jpeg"))
 
725
            {
 
726
                if (d->cameraUI->convertLosslessJpegFiles())
 
727
                {
 
728
                    // Estimated size is aroud 5 x original size when JPEG=>PNG.
 
729
                    dSize += iconItem->itemInfo()->size*5;
 
730
                }
 
731
                else if (d->cameraUI->autoRotateJpegFiles())
 
732
                {
 
733
                    // We need a double size to perform rotation.
 
734
                    dSize += iconItem->itemInfo()->size*2;
 
735
                }
 
736
                else
 
737
                {
 
738
                    // Real file size is added.
 
739
                    dSize += iconItem->itemInfo()->size;
 
740
                }
 
741
            }
 
742
            else
 
743
                dSize += iconItem->itemInfo()->size;
 
744
 
 
745
        }
 
746
    }
 
747
    
 
748
    fSize /= 1024;
 
749
    dSize /= 1024;
 
750
}
 
751
 
 
752
}  // namespace Digikam