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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/***************************************************************************
begin : Sun Feb 17 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 PLAYLISTITEM_H
#define PLAYLISTITEM_H
#include <klistview.h>
#include <ksharedptr.h>
#include <kdebug.h>
#include <tqvaluevector.h>
#include <tqptrdict.h>
#include "tagguesser.h"
#include "filehandle.h"
class Playlist;
class PlaylistItem;
class CollectionListItem;
class CollectionList;
typedef TQValueList<PlaylistItem *> PlaylistItemList;
/**
* Items for the Playlist and the baseclass for CollectionListItem.
* The constructors and destructor are protected and new items should be
* created via Playlist::createItem(). Items should be removed by
* Playlist::clear(), Playlist::deleteFromDisk(), Playlist::clearItem() or
* Playlist::clearItem().
*/
class PlaylistItem : public KListViewItem
{
friend class Playlist;
friend class SearchPlaylist;
friend class UpcomingPlaylist;
friend class CollectionList;
friend class CollectionListItem;
friend class TQPtrDict<PlaylistItem>;
friend class Pointer;
public:
enum ColumnType { TrackColumn = 0,
ArtistColumn = 1,
AlbumColumn = 2,
CoverColumn = 3,
TrackNumberColumn = 4,
GenreColumn = 5,
YearColumn = 6,
LengthColumn = 7,
BitrateColumn = 8,
CommentColumn = 9,
FileNameColumn = 10,
FullPathColumn = 11 };
/**
* A helper class to implement guarded pointer semantics.
*/
class Pointer
{
public:
Pointer() : m_item(0) {}
Pointer(PlaylistItem *item);
Pointer(const Pointer &p);
~Pointer();
Pointer &operator=(PlaylistItem *item);
bool operator==(const Pointer &p) const { return m_item == p.m_item; }
bool operator!=(const Pointer &p) const { return m_item != p.m_item; }
PlaylistItem *operator->() const { return m_item; }
PlaylistItem &operator*() const { return *m_item; }
operator PlaylistItem*() const { return m_item; }
static void clear(PlaylistItem *item);
private:
PlaylistItem *m_item;
static TQMap<PlaylistItem *, TQValueList<Pointer *> > m_map;
};
friend class Pointer;
static int lastColumn() { return FullPathColumn; }
void setFile(const FileHandle &file);
void setFile(const TQString &file);
FileHandle file() const;
virtual const TQPixmap *pixmap(int column) const;
virtual TQString text(int column) const;
virtual void setText(int column, const TQString &text);
void setPlaying(bool playing = true, bool master = true);
virtual void setSelected(bool selected);
void guessTagInfo(TagGuesser::Type type);
Playlist *playlist() const;
virtual CollectionListItem *collectionItem() const { return m_collectionItem; }
/**
* The widths of items are cached when they're updated for us in computations
* in the "weighted" listview column width mode.
*/
TQValueVector<int> cachedWidths() const;
/**
* This just refreshes from the in memory data. This may seem pointless at
* first, but this data is shared between all of the list view items that are
* based on the same file, so if another one of those items changes its data
* it is important to refresh the others.
*/
virtual void refresh();
/**
* This rereads the tag from disk. This affects all PlaylistItems based on
* the same file.
*/
virtual void refreshFromDisk();
/**
* Asks the item's playlist to remove the item (which uses deleteLater()).
*/
virtual void clear();
/**
* Returns properly casted item below this one.
*/
PlaylistItem *itemBelow() { return static_cast<PlaylistItem *>(KListViewItem::itemBelow()); }
/**
* Returns properly casted item above this one.
*/
PlaylistItem *itemAbove() { return static_cast<PlaylistItem *>(KListViewItem::itemAbove()); }
/**
* Returns a reference to the list of the currnetly playing items, with the
* first being the "master" item (i.e. the item from which the next track is
* chosen).
*/
static const PlaylistItemList &playingItems() { return m_playingItems; }
protected:
/**
* Items should always be created using Playlist::createItem() or through a
* subclss or friend class.
*/
PlaylistItem(CollectionListItem *item, Playlist *parent);
PlaylistItem(CollectionListItem *item, Playlist *parent, TQListViewItem *after);
/**
* This is the constructor that shold be used by subclasses.
*/
PlaylistItem(CollectionList *parent);
/**
* See the class documentation for an explanation of construction and deletion
* of PlaylistItems.
*/
virtual ~PlaylistItem();
virtual void paintCell(TQPainter *p, const TQColorGroup &cg, int column, int width, int align);
virtual void paintFocus(TQPainter *, const TQColorGroup &, const TQRect &) {}
virtual int compare(TQListViewItem *item, int column, bool ascending) const;
int compare(const PlaylistItem *firstItem, const PlaylistItem *secondItem, int column, bool ascending) const;
bool isValid() const;
struct Data : public KShared
{
Data() {}
Data(const TQFileInfo &info, const TQString &path) : fileHandle(info, path) {}
Data(const TQString &path) : fileHandle(path) {}
FileHandle fileHandle;
TQValueVector<TQCString> local8Bit;
TQValueVector<int> cachedWidths;
};
KSharedPtr<Data> data() const { return d; }
private:
KSharedPtr<Data> d;
void setup(CollectionListItem *item);
CollectionListItem *m_collectionItem;
bool m_watched;
static PlaylistItemList m_playingItems;
};
inline kdbgstream &operator<<(kdbgstream &s, const PlaylistItem &item)
{
if(&item == 0)
s << "(nil)";
else
s << item.text(PlaylistItem::TrackColumn);
return s;
}
#endif
|
