← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to digikam/albumselectwidget.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christian Mangold
  • Date: 2010-04-09 21:30:01 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100409213001-4bfyibrd359rn7o3
Tags: 2:1.2.0-0ubuntu1
https://launchpad.net/bugs/560576
* New upstream release (LP: #560576)
* Remove all patches, fixed upstream
  - Remove quilt build-depend

Show diffs side-by-side

added added

removed removed

Lines of Context:
digikam/albumselectwidget.cpp
7
7
 * Description : a widget to select a physical album
8
8
 *
9
9
 * Copyright (C) 2009 by Gilles Caulier <caulier dot gilles at gmail dot com>
 
10
 * Copyright (C) 2009-2010 by Johannes Wienke <languitar at semipol dot de>
10
11
 *
11
12
 * This program is free software; you can redistribute it
12
13
 * and/or modify it under the terms of the GNU General
43
44
// Local includes
44
45
 
45
46
#include "album.h"
46
 
#include "albummanager.h"
 
47
#include "albummodificationhelper.h"
 
48
#include "albumtreeview.h"
47
49
#include "albumthumbnailloader.h"
48
 
#include "treefolderitem.h"
49
50
#include "collectionmanager.h"
 
51
#include "contextmenuhelper.h"
50
52
#include "kipiinterface.h"
51
53
#include "kipiimagecollection.h"
52
54
 
53
55
namespace Digikam
54
56
{
55
57
 
 
58
class AlbumSelectTreeViewPriv
 
59
{
 
60
public:
 
61
    AlbumSelectTreeViewPriv() :
 
62
        albumModificationHelper(0)
 
63
    {
 
64
    }
 
65
 
 
66
    AlbumModificationHelper *albumModificationHelper;
 
67
 
 
68
    KAction *newAlbumAction;
 
69
 
 
70
};
 
71
 
 
72
AlbumSelectTreeView::AlbumSelectTreeView(AlbumModel *model,
 
73
                                         AlbumModificationHelper *albumModificationHelper,
 
74
                                         QWidget *parent) :
 
75
                                         AlbumTreeView(model, parent),
 
76
                                         d(new AlbumSelectTreeViewPriv)
 
77
{
 
78
 
 
79
    d->albumModificationHelper = albumModificationHelper;
 
80
 
 
81
    d->newAlbumAction = new KAction(KIcon("albumfolder-new"), i18n("Create New Album"), this);
 
82
 
 
83
}
 
84
 
 
85
AlbumSelectTreeView::~AlbumSelectTreeView()
 
86
{
 
87
    delete d;
 
88
}
 
89
 
 
90
void AlbumSelectTreeView::addCustomContextMenuActions(ContextMenuHelper &cmh,
 
91
                                                      Album *album)
 
92
{
 
93
    cmh.addAction(d->newAlbumAction);
 
94
    d->newAlbumAction->setEnabled(album);
 
95
}
 
96
 
 
97
void AlbumSelectTreeView::handleCustomContextMenuAction(QAction *action,
 
98
                                                        AlbumPointer<Album> album)
 
99
{
 
100
 
 
101
    Album *a = album;
 
102
    PAlbum *palbum = dynamic_cast<PAlbum*> (a);
 
103
    if (palbum && action == d->newAlbumAction)
 
104
    {
 
105
        d->albumModificationHelper->slotAlbumNew(palbum);
 
106
    }
 
107
 
 
108
}
 
109
 
 
110
void AlbumSelectTreeView::slotNewAlbum()
 
111
{
 
112
    PAlbum *palbum = currentAlbum();
 
113
    if (palbum)
 
114
    {
 
115
        PAlbum *createdAlbum = d->albumModificationHelper->slotAlbumNew(palbum);
 
116
        if (createdAlbum)
 
117
        {
 
118
            slotSelectAlbum(createdAlbum, false);
 
119
        }
 
120
    }
 
121
}
 
122
 
56
123
class AlbumSelectWidgetPriv
57
124
{
58
125
public:
59
126
 
60
 
    AlbumSelectWidgetPriv()
 
127
    AlbumSelectWidgetPriv() :
 
128
        albumModel(0),
 
129
        albumTreeView(0),
 
130
        albumModificationHelper(0),
 
131
        searchBar(0),
 
132
        newAlbumBtn(0)
61
133
    {
62
 
        albumsView = 0;
63
 
        searchBar  = 0;
64
 
        newAlbumBtn= 0;
65
134
    }
66
135
 
67
 
    QTreeWidget   *albumsView;
 
136
    AlbumModel          *albumModel;
 
137
    AlbumSelectTreeView *albumTreeView;
 
138
 
 
139
    AlbumModificationHelper *albumModificationHelper;
68
140
 
69
141
    SearchTextBar *searchBar;
70
142
 
75
147
                 : QWidget(parent),
76
148
                   d(new AlbumSelectWidgetPriv)
77
149
{
 
150
 
 
151
    setObjectName("AlbumSelectWidget");
 
152
 
 
153
    d->albumModificationHelper = new AlbumModificationHelper(this, this);
 
154
 
 
155
    // TODO let this class implement StateSavingObject
 
156
    KConfigGroup group = KGlobal::config()->group(objectName());
 
157
 
78
158
    QGridLayout *grid = new QGridLayout(this);
79
 
    d->albumsView     = new QTreeWidget(this);
80
 
    d->albumsView->setDragEnabled(false);
81
 
    d->albumsView->setDropIndicatorShown(false);
82
 
    d->albumsView->setAcceptDrops(false);
83
 
    d->albumsView->header()->hide();
84
 
    d->albumsView->setContextMenuPolicy(Qt::CustomContextMenu);
85
 
    d->albumsView->setSelectionMode(QAbstractItemView::SingleSelection);
 
159
    d->albumModel     = new AlbumModel(AbstractAlbumModel::IgnoreRootAlbum, this);
 
160
    d->albumTreeView  = new AlbumSelectTreeView(d->albumModel, d->albumModificationHelper, this);
 
161
    d->albumTreeView->setDragEnabled(false);
 
162
    d->albumTreeView->setDropIndicatorShown(false);
 
163
    d->albumTreeView->setAcceptDrops(false);
 
164
    d->albumTreeView->setSelectAlbumOnClick(false);
 
165
    d->albumTreeView->setSelectOnContextMenu(false);
 
166
    d->albumTreeView->setEnableContextMenu(true);
 
167
    d->albumTreeView->setSortingEnabled(true);
 
168
    d->albumTreeView->setConfigGroup(group);
 
169
    d->albumTreeView->setEntryPrefix("AlbumTreeView");
86
170
 
87
171
    d->searchBar      = new SearchTextBar(this, "AlbumSelectWidgetSearchBar");
 
172
    d->searchBar->setModel(d->albumModel,
 
173
                           AbstractAlbumModel::AlbumIdRole, AbstractAlbumModel::AlbumTitleRole);
 
174
    d->searchBar->setFilterModel(d->albumTreeView->albumFilterModel());
 
175
    d->searchBar->setConfigGroup(group);
 
176
    d->albumTreeView->setEntryPrefix("AlbumTreeView");
 
177
 
88
178
    d->newAlbumBtn    = new KPushButton(KGuiItem(i18n("&New Album"), "albumfolder-new",
89
179
                                                 i18n("Create new album")), this);
90
180
 
91
 
    grid->addWidget(d->albumsView,  0, 0, 1, 2);
 
181
    grid->addWidget(d->albumTreeView,  0, 0, 1, 2);
92
182
    grid->addWidget(d->searchBar,   1, 0, 1, 1);
93
183
    grid->addWidget(d->newAlbumBtn, 1, 1, 1, 1);
94
184
    grid->setRowStretch(0, 10);
97
187
 
98
188
    // ------------------------------------------------------------------------------------
99
189
 
100
 
    if (!albumToSelect) albumToSelect = dynamic_cast<PAlbum*>(AlbumManager::instance()->currentAlbum());
101
 
    populateTreeView(AlbumManager::instance()->allPAlbums(), d->albumsView, albumToSelect);
 
190
    PAlbum *select = albumToSelect;
 
191
    if (!select)
 
192
    {
 
193
        select = AlbumManager::instance()->currentPAlbum();
 
194
    }
 
195
    d->albumTreeView->slotSelectAlbum(select, false);
102
196
 
103
197
    // ------------------------------------------------------------------------------------
104
198
 
105
 
    connect(AlbumManager::instance(), SIGNAL(signalAlbumAdded(Album*)),
106
 
            this, SLOT(slotAlbumAdded(Album*)));
107
 
 
108
 
    connect(AlbumManager::instance(), SIGNAL(signalAlbumDeleted(Album*)),
109
 
            this, SLOT(slotAlbumDeleted(Album*)));
110
 
 
111
 
    connect(AlbumManager::instance(), SIGNAL(signalAlbumsCleared()),
112
 
            this, SLOT(slotAlbumsCleared()));
 
199
    connect(d->albumTreeView, SIGNAL(currentAlbumChanged(Album*)),
 
200
            this, SIGNAL(itemSelectionChanged()));
113
201
 
114
202
    connect(AlbumManager::instance(), SIGNAL(signalAlbumRenamed(Album*)),
115
203
            this, SLOT(slotAlbumRenamed(Album*)));
116
204
 
117
 
    connect(d->albumsView, SIGNAL(customContextMenuRequested(const QPoint&)),
118
 
            this, SLOT(slotContextMenu()));
119
 
 
120
 
    connect(d->searchBar, SIGNAL(signalSearchTextSettings(const SearchTextSettings&)),
121
 
            this, SLOT(slotSearchTextChanged(const SearchTextSettings&)));
122
 
 
123
205
    connect(d->newAlbumBtn, SIGNAL(clicked()),
124
 
            this, SLOT(slotNewAlbum()));
 
206
            d->albumTreeView, SLOT(slotNewAlbum()));
 
207
 
 
208
    d->albumTreeView->loadState();
 
209
    d->searchBar->loadState();
 
210
 
125
211
}
126
212
 
127
213
AlbumSelectWidget::~AlbumSelectWidget()
128
214
{
 
215
    d->albumTreeView->saveState();
 
216
    d->searchBar->saveState();
129
217
    delete d;
130
218
}
131
219
 
132
 
QTreeWidget* AlbumSelectWidget::albumView() const
133
 
{
134
 
    return d->albumsView;
135
 
}
136
 
 
137
 
void AlbumSelectWidget::populateTreeView(const AlbumList& aList, QTreeWidget *view, PAlbum* albumToSelect)
138
 
{
139
 
    for (AlbumList::const_iterator it = aList.constBegin(); it != aList.constEnd(); ++it)
140
 
    {
141
 
        Album *album        = *it;
142
 
        TreeAlbumItem *item = 0;
143
 
 
144
 
        if (album->isRoot())
145
 
        {
146
 
            item = new TreeAlbumItem(view, album);
147
 
            item->setExpanded(true);
148
 
        }
149
 
        else
150
 
        {
151
 
            TreeAlbumItem* pitem = 0;
152
 
            if (album->parent())
153
 
                pitem = static_cast<TreeAlbumItem*>(album->parent()->extraData(view));
154
 
            if (!pitem)
155
 
            {
156
 
                kWarning() << "Failed to find parent for Album " << album->title();
157
 
                continue;
158
 
            }
159
 
 
160
 
            item = new TreeAlbumItem(pitem, album);
161
 
        }
162
 
 
163
 
        if (item)
164
 
        {
165
 
            PAlbum* palbum = dynamic_cast<PAlbum*>(album);
166
 
            if (palbum)
167
 
                item->setIcon(0, AlbumThumbnailLoader::instance()->getStandardAlbumIcon(palbum));
168
 
            else
169
 
            {
170
 
                TAlbum* talbum = dynamic_cast<TAlbum*>(album);
171
 
                if (talbum)
172
 
                    item->setIcon(0, AlbumThumbnailLoader::instance()->getStandardTagIcon(talbum));
173
 
            }
174
 
 
175
 
            if (album == albumToSelect)
176
 
            {
177
 
                item->setExpanded(true);
178
 
                view->setCurrentItem(item);
179
 
                view->scrollToItem(item);
180
 
            }
181
 
        }
182
 
    }
183
 
}
184
 
 
185
220
PAlbum* AlbumSelectWidget::currentAlbum() const
186
221
{
187
 
    TreeAlbumItem* item = dynamic_cast<TreeAlbumItem*>(d->albumsView->currentItem());
188
 
    if (item)
189
 
    {
190
 
        PAlbum* palbum = (PAlbum*)(item->album());
191
 
        return palbum;
192
 
    }
193
 
    return 0;
 
222
    return d->albumTreeView->currentAlbum();
194
223
}
195
224
 
196
225
void AlbumSelectWidget::setCurrentAlbum(PAlbum *albumToSelect)
197
226
{
198
 
    QTreeWidgetItemIterator it(d->albumsView);
199
 
    while (*it)
200
 
    {
201
 
        TreeAlbumItem* item = dynamic_cast<TreeAlbumItem*>(*it);
202
 
        if (item)
203
 
        {
204
 
            PAlbum* palbum = (PAlbum*)(item->album());
205
 
            if (palbum == albumToSelect)
206
 
            {
207
 
                d->albumsView->setCurrentItem(item);
208
 
                d->albumsView->scrollToItem(item);
209
 
                item->setSelected(true);
210
 
                return;
211
 
            }
212
 
        }
213
 
        ++it;
214
 
    }
 
227
    d->albumTreeView->slotSelectAlbum(albumToSelect);
215
228
}
216
229
 
217
230
KUrl AlbumSelectWidget::currentAlbumUrl() const
218
231
{
219
 
    PAlbum* palbum = currentAlbum();
 
232
    PAlbum* palbum = d->albumTreeView->currentAlbum();
220
233
    if (palbum) return palbum->fileUrl();
221
234
 
222
235
    return KUrl();
224
237
 
225
238
void AlbumSelectWidget::setCurrentAlbumUrl(const KUrl& albumUrl)
226
239
{
227
 
    QTreeWidgetItemIterator it(d->albumsView);
228
 
    while (*it)
229
 
    {
230
 
        TreeAlbumItem* item = dynamic_cast<TreeAlbumItem*>(*it);
231
 
        if (item)
232
 
        {
233
 
            PAlbum* palbum = (PAlbum*)(item->album());
234
 
            if (palbum->fileUrl() == albumUrl)
235
 
            {
236
 
                d->albumsView->setCurrentItem(item);
237
 
                d->albumsView->scrollToItem(item);
238
 
                item->setSelected(true);
239
 
                return;
240
 
            }
241
 
        }
242
 
        ++it;
243
 
    }
244
 
}
245
 
 
246
 
void AlbumSelectWidget::slotSearchTextChanged(const SearchTextSettings& settings)
247
 
{
248
 
    QString search       = settings.text;
249
 
    bool atleastOneMatch = false;
250
 
 
251
 
    AlbumList pList = AlbumManager::instance()->allPAlbums();
252
 
    for (AlbumList::const_iterator it = pList.constBegin(); it != pList.constEnd(); ++it)
253
 
    {
254
 
        PAlbum* palbum = (PAlbum*)(*it);
255
 
 
256
 
        // don't touch the root Album
257
 
        if (palbum->isRoot())
258
 
            continue;
259
 
 
260
 
        bool match = palbum->title().contains(search, settings.caseSensitive);
261
 
        if (!match)
262
 
        {
263
 
            // check if any of the parents match the search
264
 
            Album* parent = palbum->parent();
265
 
            while (parent && !parent->isRoot())
266
 
            {
267
 
                if (parent->title().contains(search, settings.caseSensitive))
268
 
                {
269
 
                    match = true;
270
 
                    break;
271
 
                }
272
 
 
273
 
                parent = parent->parent();
274
 
            }
275
 
        }
276
 
 
277
 
        if (!match)
278
 
        {
279
 
            // check if any of the children match the search
280
 
            AlbumIterator it(palbum);
281
 
            while (it.current())
282
 
            {
283
 
                if ((*it)->title().contains(search, settings.caseSensitive))
284
 
                {
285
 
                    match = true;
286
 
                    break;
287
 
                }
288
 
                ++it;
289
 
            }
290
 
        }
291
 
 
292
 
        TreeAlbumCheckListItem* viewItem = (TreeAlbumCheckListItem*) palbum->extraData(d->albumsView);
293
 
 
294
 
        if (match)
295
 
        {
296
 
            atleastOneMatch = true;
297
 
 
298
 
            if (viewItem)
299
 
                viewItem->setHidden(false);
300
 
        }
301
 
        else
302
 
        {
303
 
            if (viewItem)
304
 
            {
305
 
                viewItem->setHidden(true);
306
 
            }
307
 
        }
308
 
    }
309
 
 
310
 
    d->searchBar->slotSearchResult(atleastOneMatch);
311
 
}
312
 
 
313
 
void AlbumSelectWidget::slotNewAlbum()
314
 
{
315
 
    QTreeWidgetItem* item = d->albumsView->currentItem();
316
 
    if (!item)
317
 
        item = d->albumsView->topLevelItem(0);
318
 
 
319
 
    if (!item)
320
 
        return;
321
 
 
322
 
    TreeAlbumItem* viewItem = dynamic_cast<TreeAlbumItem*>(item);
323
 
    if (!viewItem)
324
 
        return;
325
 
 
326
 
    PAlbum* album = dynamic_cast<PAlbum*>(viewItem->album());
327
 
    if (!album)
328
 
        return;
329
 
 
330
 
    bool ok;
331
 
    QString newAlbumName = KInputDialog::getText(i18n("New Album Name"),
332
 
                                                 i18n("Creating new album in '%1'\n"
333
 
                                                      "Enter album name:",
334
 
                                                      album->prettyUrl()),
335
 
                                                 QString(), &ok, this);
336
 
    if (!ok)
337
 
        return;
338
 
 
339
 
    PAlbum *newAlbum;
340
 
    QString errMsg;
341
 
    if (album->isRoot())
342
 
    {
343
 
        // if we create an album under root, need to supply the album root path.
344
 
        // TODO: Let user choose an album root
345
 
        newAlbum = AlbumManager::instance()->createPAlbum(CollectionManager::instance()->oneAlbumRootPath(),
346
 
                                                          newAlbumName, QString(), QDate::currentDate(), QString(), errMsg);
 
240
    PAlbum *urlAlbum = AlbumManager::instance()->findPAlbum(albumUrl);
 
241
    if (urlAlbum)
 
242
    {
 
243
        d->albumTreeView->slotSelectAlbum(urlAlbum);
347
244
    }
348
245
    else
349
246
    {
350
 
        newAlbum = AlbumManager::instance()->createPAlbum(album, newAlbumName, QString(),
351
 
                                                          QDate::currentDate(), QString(), errMsg);
352
 
    }
353
 
 
354
 
    if (!newAlbum)
355
 
    {
356
 
        KMessageBox::error(this, errMsg);
357
 
        return;
358
 
    }
359
 
 
360
 
    TreeAlbumItem* newItem = (TreeAlbumItem*)newAlbum->extraData(d->albumsView);
361
 
    if (newItem)
362
 
    {
363
 
        d->albumsView->scrollToItem(newItem);
364
 
        d->albumsView->setCurrentItem(newItem);
365
 
        newItem->setSelected(true);
366
 
    }
367
 
}
368
 
 
369
 
void AlbumSelectWidget::slotAlbumAdded(Album* album)
370
 
{
371
 
    if (!album || album->type() != Album::PHYSICAL)
372
 
        return;
373
 
 
374
 
    TreeAlbumItem* parentItem = 0;
375
 
 
376
 
    if (album->parent())
377
 
        parentItem = static_cast<TreeAlbumItem*>(album->parent()->extraData(d->albumsView));
378
 
 
379
 
    if (!parentItem)
380
 
    {
381
 
        kWarning() << "Failed to find parent for Album "
382
 
                        << album->title();
383
 
        return;
384
 
    }
385
 
 
386
 
    TreeAlbumItem* item = new TreeAlbumItem(parentItem, album);
387
 
    PAlbum* palbum      = dynamic_cast<PAlbum*>(album);
388
 
    if (palbum)
389
 
        item->setIcon(0, AlbumThumbnailLoader::instance()->getStandardAlbumIcon(palbum));
390
 
}
391
 
 
392
 
void AlbumSelectWidget::slotAlbumDeleted(Album* album)
393
 
{
394
 
    if (!album || album->type() != Album::PHYSICAL)
395
 
        return;
396
 
 
397
 
    TreeAlbumItem *item = (TreeAlbumItem*)(album->extraData(d->albumsView));
398
 
    if (item)
399
 
        delete item;
 
247
        kError() << "Cannot find an album for " << albumUrl;
 
248
    }
400
249
}
401
250
 
402
251
void AlbumSelectWidget::slotAlbumRenamed(Album* album)
403
252
{
404
253
    if (!album || album->type() != Album::PHYSICAL)
 
254
    {
405
255
        return;
406
 
 
407
 
    TreeAlbumItem *item = (TreeAlbumItem*)(album->extraData(d->albumsView));
408
 
    if (item)
409
 
    {
410
 
        item->setText(0, album->title());
411
 
        emit signalAlbumRenamed();
412
 
    }
413
 
}
414
 
 
415
 
void AlbumSelectWidget::slotAlbumsCleared()
416
 
{
417
 
    for(QTreeWidgetItemIterator it(d->albumsView); *it; ++it)
418
 
    {
419
 
        Album *album = static_cast<TreeAlbumItem*>(*it)->album();
420
 
        if (album)
421
 
            album->removeExtraData(d->albumsView);
422
 
    }
423
 
    d->albumsView->clear();
424
 
}
425
 
 
426
 
void AlbumSelectWidget::slotContextMenu()
427
 
{
428
 
    KMenu popmenu(d->albumsView);
429
 
 
430
 
    KAction *action = new KAction(KIcon("albumfolder-new"), i18n("Create New Album"), this);
431
 
    connect(action, SIGNAL(triggered(bool) ),
432
 
            this, SLOT(slotNewAlbum()));
433
 
 
434
 
    popmenu.addAction(action);
435
 
    popmenu.exec(QCursor::pos());
 
256
    }
 
257
 
 
258
    QModelIndex index = d->albumModel->indexForAlbum(album);
 
259
    if (index.isValid())
 
260
    {
 
261
        emit itemSelectionChanged();
 
262
    }
436
263
}
437
264
 
438
265
}  // namespace Digikam