1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/***************************************************************************
begin : Fri Sep 13 2002
copyright : (C) 2002 - 2004 by Scott Wheeler
email : wheeler@kde.org
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef COLLECTIONLIST_H
#define COLLECTIONLIST_H
#include <kapplication.h>
#include <kdirwatch.h>
#include <kfileitem.h>
#include <qdict.h>
#include <qclipboard.h>
#include <qvaluevector.h>
#include "playlist.h"
#include "playlistitem.h"
#include "sortedstringlist.h"
class CollectionListItem;
class ViewMode;
/**
* This type is for mapping QString track attributes like the album, artist
* and track to an integer count representing the number of outstanding items
* that hold the string.
*/
typedef QDict<int> TagCountDict;
typedef QDictIterator<int> TagCountDictIterator;
/**
* We then have an array of dicts, one for each column in the list view. We
* use pointers to TagCountDicts because QDict has a broken copy ctor, which
* doesn't copy the case sensitivity setting.
*/
typedef QValueVector<TagCountDict*> TagCountDicts;
/**
* This is the "collection", or all of the music files that have been opened
* in any playlist and not explicitly removed from the collection.
*
* It is being implemented as a "semi-singleton" because I need universal access
* to just one instance. However, because the collection needs initialization
* parameters (that will not always be available when an instance is needed).
* Hence there will be the familiar singleton "instance()" method allong with an
* "initialize()" method.
*/
class CollectionList : public Playlist
{
friend class CollectionListItem;
Q_OBJECT
public:
/**
* A variety of unique value lists will be kept in the collection. This
* enum can be used as an index into those structures.
*/
enum UniqueSetType { Artists = 0, Albums = 1, Genres = 2 };
static CollectionList *instance();
static void initialize(PlaylistCollection *collection);
/**
* Returns a unique set of values associated with the type specified.
*/
QStringList uniqueSet(UniqueSetType t) const;
CollectionListItem *lookup(const QString &file) { return m_itemsDict.find(file); }
virtual PlaylistItem *createItem(const FileHandle &file,
QListViewItem * = 0,
bool = false);
void emitVisibleColumnsChanged() { emit signalVisibleColumnsChanged(); }
virtual void clearItems(const PlaylistItemList &items);
void setupTreeViewEntries(ViewMode *viewMode) const;
virtual bool canReload() const { return true; }
public slots:
virtual void paste() { decode(kapp->clipboard()->data()); }
virtual void clear();
void slotCheckCache();
void slotRemoveItem(const QString &file);
void slotRefreshItem(const QString &file);
void slotNewItems(const KFileItemList &items);
void slotRefreshItems(const KFileItemList &items);
void slotDeleteItem(KFileItem *item);
protected:
CollectionList(PlaylistCollection *collection);
virtual ~CollectionList();
virtual void contentsDropEvent(QDropEvent *e);
virtual void contentsDragMoveEvent(QDragMoveEvent *e);
// These methods are used by CollectionListItem, which is a friend class.
void addToDict(const QString &file, CollectionListItem *item) { m_itemsDict.replace(file, item); }
void removeFromDict(const QString &file) { m_itemsDict.remove(file); }
// These methods are also used by CollectionListItem, to manage the
// strings used in generating the unique sets and tree view mode playlists.
QString addStringToDict(const QString &value, unsigned column);
void removeStringFromDict(const QString &value, unsigned column);
void addWatched(const QString &file) { m_dirWatch->addFile(file); }
void removeWatched(const QString &file) { m_dirWatch->removeFile(file); }
virtual bool hasItem(const QString &file) const { return m_itemsDict.find(file); }
signals:
void signalCollectionChanged();
/**
* This is emitted when the set of columns that is visible is changed.
*
* \see Playlist::hideColumn()
* \see Playlist::showColumn()
* \see Playlsit::isColumnVisible()
*/
void signalVisibleColumnsChanged();
void signalNewTag(const QString &, unsigned);
void signalRemovedTag(const QString &, unsigned);
private:
/**
* Just the size of the above enum to keep from hard coding it in several
* locations.
*/
static const int m_uniqueSetCount = 3;
static CollectionList *m_list;
QDict<CollectionListItem> m_itemsDict;
KDirWatch *m_dirWatch;
TagCountDicts m_columnTags;
};
class CollectionListItem : public PlaylistItem
{
friend class Playlist;
friend class CollectionList;
friend class PlaylistItem;
/**
* Needs access to the destructor, even though the destructor isn't used by QDict.
*/
friend class QDict<CollectionListItem>;
public:
virtual void refresh();
PlaylistItem *itemForPlaylist(const Playlist *playlist);
void updateCollectionDict(const QString &oldPath, const QString &newPath);
void repaint() const;
PlaylistItemList children() const { return m_children; }
protected:
CollectionListItem(const FileHandle &file);
virtual ~CollectionListItem();
void addChildItem(PlaylistItem *child);
void removeChildItem(PlaylistItem *child);
/**
* Returns true if the item is now up to date (even if this required a refresh) or
* false if the item is invalid.
*/
bool checkCurrent();
virtual CollectionListItem *collectionItem() { return this; }
private:
bool m_shuttingDown;
PlaylistItemList m_children;
};
#endif
|
