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::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 list[state.item]->Select();
}

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

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

        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, ' '));
        }
        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, MusicLibrary::Library &library) : MenuItem(list), audacious(audacious), append(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, MusicLibrary::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, MusicLibrary::Library &library) : MenuList(parent)
{
        list[0] = new AllItem(this, audacious, append, library);
}

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

MenuList *ArtistList::AllItem::Select()
{
        std::cerr << _B("All Artists!") << std::endl;

        return list;
}

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