truck/DashInterface/MenuList.cpp

// Menu List
//
// Douglas Thrift
//
// $Id$

#include <iostream>

#include <foreach.hpp>

#include "MenuList.hpp"

MenuList *MenuList::previous;

MenuList::MenuItem::MenuItem(MenuList *list) : list(list)
{
}

MenuList::MusicItem::MusicItem(Audacious::Audacious &audacious, bool &append) : audacious(audacious), append(append)
{
}

MenuList::MenuList(MenuList *parent, Display &display, size_t size) : parent(parent), display(display), cursor(0), list(size)
{
}

MenuList::MenuList(MenuList *parent) : parent(parent), display(parent->display), cursor(0), list(1)
{
}

MenuList::~MenuList()
{
        _foreach (std::vector<MenuItem *>, item, list)
                delete *item;

        if (parent != NULL && parent != this)
                delete parent;
}

MenuList *MenuList::Enter()
{
        return Select(list[state.item]);
}

MenuList *MenuList::Right()
{
        MenuItem *item(list[state.item]);

        if (dynamic_cast<SubItem *>(item))
                return Select(item);

        return this;
}

MenuList *MenuList::Left()
{
        MenuList *parent(this->parent);

        if (parent != this)
        {
                this->parent = NULL;

                delete this;
        }

        return parent;
}

void MenuList::Render()
{
        display.SetCursorPosition(19, cursor);

        size_t size(list.size());

        if (this != previous || state != old)
        {
                display.Set(0, 0, (state.top != 0 ? '\x1a' : ' '));
                display.Set(0, 1, '\x12');
                display.Set(0, 2, '\x13');
                display.Set(0, 3, (state.bottom < size ? '\x1b' : ' '));

                _forall (size_t, index, state.top, state.bottom)
                        if (index < size)
                        {
                                MenuItem *item(list[index]);
                                std::string value(*item);

                                value.resize(18, ' ');

                                if (BoolItem *item_ = dynamic_cast<BoolItem *>(item))
                                        value += (*item_ ? '\x94' : '\xcf');
                                else if (dynamic_cast<SubItem *>(item))
                                        value += '\x10';
                                else
                                        value += ' ';

                                display.Set(1, _index, value);
                        }
                        else
                                display.Set(1, _index, std::string(19, ' '));

                previous = this;
        }
        else
                _forall (size_t, index, state.top, size < state.bottom ? size : state.bottom)
                        if (BoolItem *item = dynamic_cast<BoolItem *>(list[index]))
                                display.Set(19, _index, (*item ? _B("\x94") : _B("\xcf")));
}

MenuList &MenuList::operator ++()
{
        old = state;

        size_t next(state.item + 1);

        if (next != list.size())
        {
                if (next == state.bottom)
                        ++state.top, ++state.bottom;
                else
                        ++cursor;

                state.item = next;
        }

        return *this;
}

MenuList &MenuList::operator --()
{
        old = state;

        if (state.item != 0)
                if (state.item-- == state.top)
                        --state.top, --state.bottom;
                else
                        --cursor;

        return *this;
}

TopList::AppendItem::AppendItem(MenuList *list, bool &append) : MenuItem(list), append(append)
{
}

MenuList *TopList::AppendItem::Select()
{
        append = !append;

        return list;
}

TopList::AppendItem::operator std::string() const
{
        return _B("Playlist Append");
}

TopList::AppendItem::operator bool() const
{
        return append;
}

TopList::ShuffleItem::ShuffleItem(MenuList *list, Audacious::Audacious &audacious) : MenuItem(list), audacious(audacious)
{
}

MenuList *TopList::ShuffleItem::Select()
{
        if (audacious.IsRunning())
                audacious.ToggleShuffle();

        return list;
}

TopList::ShuffleItem::operator std::string() const
{
        return _B("Shuffle");
}

TopList::ShuffleItem::operator bool() const
{
        return audacious.IsRunning() ? audacious.IsShuffle() : false;
}

TopList::MusicItem::MusicItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuItem(list), MenuList::MusicItem(audacious, append), library(library)
{
}

MenuList *TopList::MusicItem::Select()
{
        return new ArtistList(list, audacious, append, library);
}

TopList::MusicItem::operator std::string() const
{
        return _B("Music");
}

TopList::TopList(Display &display, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuList(this, display, 3)
{
        previous = NULL;
        list[0] = new AppendItem(this, append);
        list[1] = new ShuffleItem(this, audacious);
        list[2] = new MusicItem(this, audacious, append, library);
}

ArtistList::ArtistList(MenuList *parent, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuList(parent)
{
        list[0] = new AllItem(this, audacious, append, library);
}

ArtistList::AllItem::AllItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuItem(list), MusicItem(audacious, append), library(library)
{
}

MenuList *ArtistList::AllItem::Select()
{
        _L<std::string> songs;

        _foreach (const _L<Music::Song>, song, library.GetSongs())
                songs.push_back(song->GetPath());

        if (audacious.IsRunning())
                audacious.Playlist(songs, append);

        return NULL;
}

ArtistList::AllItem::operator std::string() const
{
        return _B("All Artists");
}
Revision:	51
Committed:	2008-03-09T14:24:55-07:00 (17 years, 3 months ago) by douglas
File size:	4652 byte(s)
Log Message:	Finish the renaming!
#	Content
1	// Menu List
2	//
3	// Douglas Thrift
4	//
5	// $Id$
6
7	#include <iostream>
8
9	#include <foreach.hpp>
10
11	#include "MenuList.hpp"
12
13	MenuList *MenuList::previous;
14
15	MenuList::MenuItem::MenuItem(MenuList *list) : list(list)
16	{
17	}
18
19	MenuList::MusicItem::MusicItem(Audacious::Audacious &audacious, bool &append) : audacious(audacious), append(append)
20	{
21	}
22
23	MenuList::MenuList(MenuList *parent, Display &display, size_t size) : parent(parent), display(display), cursor(0), list(size)
24	{
25	}
26
27	MenuList::MenuList(MenuList *parent) : parent(parent), display(parent->display), cursor(0), list(1)
28	{
29	}
30
31	MenuList::~MenuList()
32	{
33	_foreach (std::vector<MenuItem *>, item, list)
34	delete *item;
35
36	if (parent != NULL && parent != this)
37	delete parent;
38	}
39
40	MenuList *MenuList::Enter()
41	{
42	return Select(list[state.item]);
43	}
44
45	MenuList *MenuList::Right()
46	{
47	MenuItem *item(list[state.item]);
48
49	if (dynamic_cast<SubItem *>(item))
50	return Select(item);
51
52	return this;
53	}
54
55	MenuList *MenuList::Left()
56	{
57	MenuList *parent(this->parent);
58
59	if (parent != this)
60	{
61	this->parent = NULL;
62
63	delete this;
64	}
65
66	return parent;
67	}
68
69	void MenuList::Render()
70	{
71	display.SetCursorPosition(19, cursor);
72
73	size_t size(list.size());
74
75	if (this != previous \|\| state != old)
76	{
77	display.Set(0, 0, (state.top != 0 ? '\x1a' : ' '));
78	display.Set(0, 1, '\x12');
79	display.Set(0, 2, '\x13');
80	display.Set(0, 3, (state.bottom < size ? '\x1b' : ' '));
81
82	_forall (size_t, index, state.top, state.bottom)
83	if (index < size)
84	{
85	MenuItem *item(list[index]);
86	std::string value(*item);
87
88	value.resize(18, ' ');
89
90	if (BoolItem item_ = dynamic_cast<BoolItem >(item))
91	value += (*item_ ? '\x94' : '\xcf');
92	else if (dynamic_cast<SubItem *>(item))
93	value += '\x10';
94	else
95	value += ' ';
96
97	display.Set(1, _index, value);
98	}
99	else
100	display.Set(1, _index, std::string(19, ' '));
101
102	previous = this;
103	}
104	else
105	_forall (size_t, index, state.top, size < state.bottom ? size : state.bottom)
106	if (BoolItem item = dynamic_cast<BoolItem >(list[index]))
107	display.Set(19, _index, (*item ? _B("\x94") : _B("\xcf")));
108	}
109
110	MenuList &MenuList::operator ++()
111	{
112	old = state;
113
114	size_t next(state.item + 1);
115
116	if (next != list.size())
117	{
118	if (next == state.bottom)
119	++state.top, ++state.bottom;
120	else
121	++cursor;
122
123	state.item = next;
124	}
125
126	return *this;
127	}
128
129	MenuList &MenuList::operator --()
130	{
131	old = state;
132
133	if (state.item != 0)
134	if (state.item-- == state.top)
135	--state.top, --state.bottom;
136	else
137	--cursor;
138
139	return *this;
140	}
141
142	TopList::AppendItem::AppendItem(MenuList *list, bool &append) : MenuItem(list), append(append)
143	{
144	}
145
146	MenuList *TopList::AppendItem::Select()
147	{
148	append = !append;
149
150	return list;
151	}
152
153	TopList::AppendItem::operator std::string() const
154	{
155	return _B("Playlist Append");
156	}
157
158	TopList::AppendItem::operator bool() const
159	{
160	return append;
161	}
162
163	TopList::ShuffleItem::ShuffleItem(MenuList *list, Audacious::Audacious &audacious) : MenuItem(list), audacious(audacious)
164	{
165	}
166
167	MenuList *TopList::ShuffleItem::Select()
168	{
169	if (audacious.IsRunning())
170	audacious.ToggleShuffle();
171
172	return list;
173	}
174
175	TopList::ShuffleItem::operator std::string() const
176	{
177	return _B("Shuffle");
178	}
179
180	TopList::ShuffleItem::operator bool() const
181	{
182	return audacious.IsRunning() ? audacious.IsShuffle() : false;
183	}
184
185	TopList::MusicItem::MusicItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuItem(list), MenuList::MusicItem(audacious, append), library(library)
186	{
187	}
188
189	MenuList *TopList::MusicItem::Select()
190	{
191	return new ArtistList(list, audacious, append, library);
192	}
193
194	TopList::MusicItem::operator std::string() const
195	{
196	return _B("Music");
197	}
198
199	TopList::TopList(Display &display, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuList(this, display, 3)
200	{
201	previous = NULL;
202	list[0] = new AppendItem(this, append);
203	list[1] = new ShuffleItem(this, audacious);
204	list[2] = new MusicItem(this, audacious, append, library);
205	}
206
207	ArtistList::ArtistList(MenuList *parent, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuList(parent)
208	{
209	list[0] = new AllItem(this, audacious, append, library);
210	}
211
212	ArtistList::AllItem::AllItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library) : MenuItem(list), MusicItem(audacious, append), library(library)
213	{
214	}
215
216	MenuList *ArtistList::AllItem::Select()
217	{
218	_L<std::string> songs;
219
220	_foreach (const _L<Music::Song>, song, library.GetSongs())
221	songs.push_back(song->GetPath());
222
223	if (audacious.IsRunning())
224	audacious.Playlist(songs, append);
225
226	return NULL;
227	}
228
229	ArtistList::AllItem::operator std::string() const
230	{
231	return _B("All Artists");
232	}