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
198
|
/***************************************************************************
begin : Fri Sep 13 2002
copyright : (C) 2002 - 2004 by Scott Wheeler
email : [email protected]
***************************************************************************/
/***************************************************************************
* *
* 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 <tdefileitem.h>
#include <tqdict.h>
#include <tqclipboard.h>
#include <tqvaluevector.h>
#include "playlist.h"
#include "playlistitem.h"
#include "sortedstringlist.h"
class CollectionListItem;
class ViewMode;
/**
* This type is for mapping TQString track attributes like the album, artist
* and track to an integer count representing the number of outstanding items
* that hold the string.
*/
typedef TQDict<int> TagCountDict;
typedef TQDictIterator<int> TagCountDictIterator;
/**
* We then have an array of dicts, one for each column in the list view. We
* use pointers to TagCountDicts because TQDict has a broken copy ctor, which
* doesn't copy the case sensitivity setting.
*/
typedef TQValueVector<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.
*/
TQStringList uniqueSet(UniqueSetType t) const;
CollectionListItem *lookup(const TQString &file) { return m_itemsDict.find(file); }
virtual PlaylistItem *createItem(const FileHandle &file,
TQListViewItem * = 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 TQString &file);
void slotRefreshItem(const TQString &file);
void slotNewItems(const KFileItemList &items);
void slotRefreshItems(const KFileItemList &items);
void slotDeleteItem(KFileItem *item);
protected:
CollectionList(PlaylistCollection *collection);
virtual ~CollectionList();
virtual void contentsDropEvent(TQDropEvent *e);
virtual void contentsDragMoveEvent(TQDragMoveEvent *e);
// These methods are used by CollectionListItem, which is a friend class.
void addToDict(const TQString &file, CollectionListItem *item) { m_itemsDict.replace(file, item); }
void removeFromDict(const TQString &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.
TQString addStringToDict(const TQString &value, unsigned column);
void removeStringFromDict(const TQString &value, unsigned column);
void addWatched(const TQString &file) { m_dirWatch->addFile(file); }
void removeWatched(const TQString &file) { m_dirWatch->removeFile(file); }
virtual bool hasItem(const TQString &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 TQString &, unsigned);
void signalRemovedTag(const TQString &, 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;
TQDict<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 TQDict.
*/
friend class TQDict<CollectionListItem>;
public:
virtual void refresh();
PlaylistItem *itemForPlaylist(const Playlist *playlist);
void updateCollectionDict(const TQString &oldPath, const TQString &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
|
