← Back to branch summary

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

« back to all changes in this revision

Viewing changes to digikam/digikam/albumfolderview.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mark Purcell
  • Date: 2008-07-17 20:25:39 UTC
  • mfrom: (1.3.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 39.
  • Revision ID: james.westby@ubuntu.com-20080717202539-ttj4and3ds1ldgn1
Tags: upstream-0.9.4
Import upstream version 0.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
digikam/digikam/albumfolderview.cpp
7
7
 * Description : Albums folder view.
8
8
 *
9
9
 * Copyright (C) 2005-2006 by Joern Ahrens <joern.ahrens@kdemail.net>
 
10
 * Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
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
62
63
#include "albumsettings.h"
63
64
#include "thumbnailjob.h"
64
65
#include "thumbnailsize.h"
65
 
#include "albumpropsedit.h"
66
66
#include "folderitem.h"
67
67
#include "cameraui.h"
68
68
#include "dio.h"
82
82
namespace Digikam
83
83
{
84
84
 
85
 
//-----------------------------------------------------------------------------
86
 
// AlbumFolderViewItem
87
 
//-----------------------------------------------------------------------------
88
 
 
89
85
class AlbumFolderViewItem : public FolderItem
90
86
{
 
87
 
91
88
public:
92
89
 
93
90
    AlbumFolderViewItem(QListView *parent, PAlbum *album);
97
94
    AlbumFolderViewItem(QListViewItem* parent, const QString& name,
98
95
                        int year, int month);
99
96
 
100
 
    PAlbum* getAlbum() const;
101
 
    int id() const;
102
 
    bool isGroupItem() const;
103
 
 
104
 
    int compare(QListViewItem *i, int col, bool ascending) const;
105
 
 
 
97
    PAlbum* album() const;
 
98
    int     id() const;
 
99
    bool    isGroupItem() const;
 
100
    int     compare(QListViewItem *i, int col, bool ascending) const;
 
101
    void    refresh();
 
102
    void    setOpen(bool o);
 
103
    void    setCount(int count);
 
104
    int     count();
 
105
    
106
106
private:
107
107
 
108
 
    PAlbum *m_album;
 
108
    bool    m_groupItem;
 
109
 
 
110
    int     m_count;
109
111
    int     m_year;
110
112
    int     m_month;
111
 
    bool    m_groupItem;
 
113
    
 
114
    PAlbum *m_album;
112
115
};
113
116
 
114
117
AlbumFolderViewItem::AlbumFolderViewItem(QListView *parent, PAlbum *album)
117
120
    setDragEnabled(true);
118
121
    m_album     = album;
119
122
    m_groupItem = false;
 
123
    m_count     = 0;
120
124
}
121
125
 
122
126
AlbumFolderViewItem::AlbumFolderViewItem(QListViewItem *parent, PAlbum *album)
125
129
    setDragEnabled(true);
126
130
    m_album     = album;
127
131
    m_groupItem = false;
128
 
/*    setText(0, album->title() + QString(" (%1)")
129
 
            .arg(AlbumManager::instance()->albumDB()->getItemNamesInAlbum(album->id()).count()));*/
 
132
    m_count     = 0;
130
133
}
131
134
 
132
135
// special group item (collection/dates)
133
136
AlbumFolderViewItem::AlbumFolderViewItem(QListViewItem* parent, const QString& name,
134
137
                                         int year, int month)
135
 
                   : FolderItem(parent, name, true),
136
 
                     m_album(0), m_year(year), m_month(month), m_groupItem(true)
137
 
{
138
 
    setDragEnabled(false);
139
 
}
140
 
 
141
 
PAlbum* AlbumFolderViewItem::getAlbum() const
 
138
                   : FolderItem(parent, name, true)
 
139
{
 
140
    m_album     = 0;
 
141
    m_year      = year;
 
142
    m_month     = month;
 
143
    m_groupItem = true;
 
144
    m_count     = 0;
 
145
}
 
146
 
 
147
void AlbumFolderViewItem::refresh()
 
148
{
 
149
    if (!m_album) return;
 
150
    
 
151
    if (AlbumSettings::instance()->getShowFolderTreeViewItemsCount() &&
 
152
        dynamic_cast<AlbumFolderViewItem*>(parent()))
 
153
    {
 
154
        if (isOpen())
 
155
            setText(0, QString("%1 (%2)").arg(m_album->title()).arg(m_count));
 
156
        else
 
157
        {
 
158
            int countRecursive = m_count;
 
159
            AlbumIterator it(m_album);
 
160
            while ( it.current() )
 
161
            {
 
162
                AlbumFolderViewItem *item = (AlbumFolderViewItem*)it.current()->extraData(listView());
 
163
                if (item)
 
164
                    countRecursive += item->count();
 
165
                ++it;
 
166
            }
 
167
            setText(0, QString("%1 (%2)").arg(m_album->title()).arg(countRecursive));
 
168
        }
 
169
    }
 
170
    else
 
171
    {
 
172
        setText(0, m_album->title());
 
173
    }
 
174
}
 
175
 
 
176
void AlbumFolderViewItem::setOpen(bool o)
 
177
{
 
178
    QListViewItem::setOpen(o);
 
179
    refresh();
 
180
}
 
181
 
 
182
PAlbum* AlbumFolderViewItem::album() const
142
183
{
143
184
    return m_album;
144
185
}
188
229
        return -1;
189
230
}
190
231
 
191
 
 
192
 
//-----------------------------------------------------------------------------
193
 
// AlbumFolderViewPriv
194
 
//-----------------------------------------------------------------------------
 
232
void AlbumFolderViewItem::setCount(int count)
 
233
{
 
234
    m_count = count;
 
235
    refresh();
 
236
}
 
237
 
 
238
int AlbumFolderViewItem::count()
 
239
{
 
240
    return m_count;
 
241
}
 
242
 
 
243
// -----------------------------------------------------------------------------
195
244
 
196
245
class AlbumFolderViewPriv
197
246
{
208
257
    QValueList<AlbumFolderViewItem*>  groupItems;
209
258
};
210
259
 
211
 
//-----------------------------------------------------------------------------
212
 
// AlbumFolderView
213
 
//-----------------------------------------------------------------------------
214
 
 
215
260
AlbumFolderView::AlbumFolderView(QWidget *parent)
216
261
               : FolderView(parent, "AlbumFolderView")
217
262
{
242
287
    connect(d->albumMan, SIGNAL(signalAlbumRenamed(Album*)),
243
288
            this, SLOT(slotAlbumRenamed(Album*)));
244
289
 
 
290
    connect(d->albumMan, SIGNAL(signalPAlbumsDirty(const QMap<int, int>&)),
 
291
            this, SLOT(slotRefresh(const QMap<int, int>&)));
 
292
 
245
293
    AlbumThumbnailLoader *loader = AlbumThumbnailLoader::instance();
246
294
 
247
295
    connect(loader, SIGNAL(signalThumbnail(Album *, const QPixmap&)),
268
316
    delete d;
269
317
}
270
318
 
271
 
void AlbumFolderView::slotFolderFilterChanged(const QString& filter)
 
319
void AlbumFolderView::slotTextFolderFilterChanged(const QString& filter)
272
320
{
273
321
    QString search = filter.lower();
274
322
 
333
381
        }
334
382
    }
335
383
 
336
 
    emit signalFolderFilterMatch(atleastOneMatch);
 
384
    emit signalTextFolderFilterMatch(atleastOneMatch);
337
385
}
338
386
 
339
387
void AlbumFolderView::slotAlbumAdded(Album *album)
406
454
 
407
455
    AlbumFolderViewItem* item = (AlbumFolderViewItem*) palbum->extraData(this);
408
456
    if(item)
409
 
    {
410
 
        item->setText(0, palbum->title());
411
 
    }
 
457
        item->refresh();
412
458
}
413
459
 
414
460
void AlbumFolderView::slotAlbumsCleared()
513
559
        return;
514
560
    }
515
561
 
516
 
    d->albumMan->setCurrentAlbum(albumitem->getAlbum());
 
562
    d->albumMan->setCurrentAlbum(albumitem->album());
517
563
}
518
564
 
519
565
void AlbumFolderView::slotContextMenu(QListViewItem *listitem, const QPoint &, int)
527
573
    popmenu.insertItem(SmallIcon("albumfolder-new"), i18n("New Album..."), 10);
528
574
 
529
575
    AlbumFolderViewItem *item = dynamic_cast<AlbumFolderViewItem*>(listitem);
530
 
    if (item && !item->getAlbum())
 
576
    if (item && !item->album())
531
577
    {
532
578
        // if collection/date return
533
579
        return;
631
677
        case 13:
632
678
        {
633
679
            QString err;
634
 
            d->albumMan->updatePAlbumIcon(item->getAlbum(), 0, err);
 
680
            d->albumMan->updatePAlbumIcon(item->album(), 0, err);
635
681
            break;
636
682
        }
637
683
        case 14:
683
729
    if(!item)
684
730
        parent = d->albumMan->findPAlbum(0);
685
731
    else
686
 
        parent = item->getAlbum();
 
732
        parent = item->album();
687
733
 
688
734
    if (!parent)
689
735
        return;
738
784
 
739
785
void AlbumFolderView::albumDelete(AlbumFolderViewItem *item)
740
786
{
741
 
    PAlbum *album = item->getAlbum();
 
787
    PAlbum *album = item->album();
742
788
 
743
789
    if(!album || album->isRoot())
744
790
        return;
800
846
 
801
847
void AlbumFolderView::albumRename(AlbumFolderViewItem* item)
802
848
{
803
 
    PAlbum *album = item->getAlbum();
 
849
    PAlbum *album = item->album();
804
850
 
805
851
    if (!album)
806
852
        return;
842
888
 
843
889
void AlbumFolderView::albumEdit(AlbumFolderViewItem* item)
844
890
{
845
 
    PAlbum *album = item->getAlbum();
 
891
    PAlbum *album = item->album();
846
892
 
847
893
    if (!album)
848
894
        return;
892
938
    if(!item)
893
939
        return 0;
894
940
 
895
 
    PAlbum *album = item->getAlbum();
 
941
    PAlbum *album = item->album();
896
942
    if(album->isRoot())
897
943
        return 0;
898
944
 
925
971
                    return false;
926
972
    
927
973
                // Dragging a parent on its child makes no sense
928
 
                if(itemDrag && itemDrag->getAlbum()->isAncestorOf(itemDrop->getAlbum()))
 
974
                if(itemDrag && itemDrag->album()->isAncestorOf(itemDrop->album()))
929
975
                    return false;
930
976
    
931
977
                return true;
1008
1054
 
1009
1055
            if(id == 10)
1010
1056
            {
1011
 
                PAlbum *album = itemDrag->getAlbum();
 
1057
                PAlbum *album = itemDrag->album();
1012
1058
                PAlbum *destAlbum;
1013
1059
                if(!itemDrop)
1014
1060
                {
1018
1064
                else
1019
1065
                {
1020
1066
                    // move dragItem below dropItem
1021
 
                    destAlbum = itemDrop->getAlbum();
 
1067
                    destAlbum = itemDrop->album();
1022
1068
                }
1023
1069
                KIO::Job* job = DIO::move(album->kurl(), destAlbum->kurl());
1024
1070
                connect(job, SIGNAL(result(KIO::Job*)),
1033
1079
 
1034
1080
            if (itemDrop->isGroupItem())
1035
1081
            {
1036
 
                PAlbum *album = itemDrag->getAlbum();
 
1082
                PAlbum *album = itemDrag->album();
1037
1083
                if (!album)
1038
1084
                    return;
1039
1085
 
1050
1096
        if (!itemDrop)
1051
1097
            return;
1052
1098
 
1053
 
        PAlbum *destAlbum = itemDrop->getAlbum();
 
1099
        PAlbum *destAlbum = itemDrop->album();
1054
1100
 
1055
1101
        KURL::List      urls;
1056
1102
        KURL::List      kioURLs;
1182
1228
 
1183
1229
    if(CameraItemListDrag::canDecode(e))
1184
1230
    {
1185
 
        Album *album = dynamic_cast<Album*>(itemDrop->getAlbum());
 
1231
        Album *album = dynamic_cast<Album*>(itemDrop->album());
1186
1232
        if (!album) return;
1187
1233
        
1188
1234
        CameraUI *ui = dynamic_cast<CameraUI*>(e->source());
1221
1267
        PAlbum* destAlbum = 0;
1222
1268
 
1223
1269
        if (itemDrop)
1224
 
            destAlbum = itemDrop->getAlbum();
 
1270
            destAlbum = itemDrop->album();
1225
1271
        else
1226
1272
            destAlbum = d->albumMan->findPAlbum(0);
1227
1273
 
1310
1356
    if(selectedItem())
1311
1357
    {
1312
1358
        AlbumFolderViewItem *folderItem = dynamic_cast<AlbumFolderViewItem*>(selectedItem());
1313
 
        Album *album = folderItem->getAlbum();
 
1359
        Album *album = folderItem->album();
1314
1360
        if (album && album->type() == Album::PHYSICAL)
1315
1361
        {
1316
1362
            parent = dynamic_cast<PAlbum*>(album);
1487
1533
    if (!folderItem)
1488
1534
        return;
1489
1535
 
1490
 
    PAlbum* album = folderItem->getAlbum();
 
1536
    PAlbum* album = folderItem->album();
1491
1537
    if (!album || album->isRoot())
1492
1538
        return;
1493
1539
 
1536
1582
    }
1537
1583
}
1538
1584
 
 
1585
void AlbumFolderView::refresh()
 
1586
{
 
1587
    QListViewItemIterator it(this);
 
1588
    
 
1589
    while (it.current())
 
1590
    {
 
1591
        AlbumFolderViewItem* item = dynamic_cast<AlbumFolderViewItem*>(*it);
 
1592
        if (item)
 
1593
            item->refresh();
 
1594
        ++it;
 
1595
    }
 
1596
}
 
1597
 
 
1598
void AlbumFolderView::slotRefresh(const QMap<int, int>& albumsStatMap)
 
1599
{
 
1600
    QListViewItemIterator it(this);
 
1601
    
 
1602
    while (it.current())
 
1603
    {
 
1604
        AlbumFolderViewItem* item = dynamic_cast<AlbumFolderViewItem*>(*it);
 
1605
        if (item)
 
1606
        {
 
1607
            if (item->album())
 
1608
            {
 
1609
                int id = item->id();
 
1610
                QMap<int, int>::const_iterator it2 = albumsStatMap.find(id);
 
1611
                if ( it2 != albumsStatMap.end() )
 
1612
                    item->setCount(it2.data());
 
1613
            }
 
1614
        }
 
1615
        ++it;
 
1616
    }
 
1617
 
 
1618
    refresh();
 
1619
}
 
1620
 
1539
1621
}  // namespace Digikam