truck/DashInterface/MenuList.hpp

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

#ifndef _MenuList_hpp_
#define _MenuList_hpp_

#include <vector>

#include <Audacious.hpp>
#include <Music.hpp>

#include "Display.hpp"
#include "Filter.hpp"

class MenuList
{
        static MenuList *previous;
        MenuList *parent;
        Display &display;
        size_t cursor;

        struct State
        {
                size_t item, top, bottom;

                State() : item(0), top(0), bottom(4) {}

                bool operator !=(const State &state) const
                {
                        return top != state.top;
                }
        } state, old;

protected:
        struct MenuItem
        {
        protected:
                MenuList *list;

                MenuItem(MenuList *list);

        public:
                virtual MenuList *Select() = 0;
                virtual operator std::string() const = 0;
        };

private:
        inline MenuList *Select(MenuItem *item)
        {
                MenuList *list(item->Select());

                if (list == NULL)
                        delete this;

                return list;
        }

protected:
        struct BoolItem
        {
                virtual operator bool() const = 0;
        };

        struct SubItem {};

        struct MusicItem
        {
        protected:
                Audacious::Audacious &audacious;
                bool &append;

                MusicItem(Audacious::Audacious &audacious, bool &append);
        };

        std::vector<MenuItem *> list;

public:
        MenuList(MenuList *parent, Display &display, size_t size);
        MenuList(MenuList *parent);
        virtual ~MenuList();

        MenuList *Enter();
        MenuList *Left();
        MenuList *Right();
        void Render();
        MenuList &operator ++();
        MenuList &operator --();

        friend struct TopList;
};

class TopList : public MenuList
{
        class AppendItem : public MenuItem, public BoolItem
        {
                bool &append;

        public:
                AppendItem(MenuList *list, bool &append);

                virtual MenuList *Select();
                virtual operator std::string() const;
                virtual operator bool() const;
        };

        class ShuffleItem : public MenuItem, public BoolItem
        {
                Audacious::Audacious &audacious;

        public:
                ShuffleItem(MenuList *list, Audacious::Audacious &audacious);

                virtual MenuList *Select();
                virtual operator std::string() const;
                virtual operator bool() const;
        };

        class MusicItem : public MenuItem, public SubItem, public MenuList::MusicItem
        {
                Music::Library &library;

        public:
                MusicItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library);

                virtual MenuList *Select();
                virtual operator std::string() const;
        };

public:
        TopList(Display &display, Audacious::Audacious &audacious, bool &append, Music::Library &library);
};

class ArtistList : public MenuList
{
        class AllItem : public MenuItem, public MusicItem
        {
                Music::Library &library;

        public:
                AllItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library);

                virtual MenuList *Select();
                virtual operator std::string() const;
        };

        class ArtistItem : public MenuItem, public SubItem, public MusicItem
        {
                Music::Artist artist;

        public:
                ArtistItem(MenuList *list, Audacious::Audacious &audacious, bool append, Music::Artist artist);
                virtual ~ArtistItem() {}

                virtual MenuList *Select();
                virtual operator std::string() const;
        };

public:
        ArtistList(MenuList *parent, Audacious::Audacious &audacious, bool &append, Music::Library &library);
};

class AlbumList : public MenuList
{
        /*struct AllItem : public MenuItem
        {
        };

        struct AlbumItem : public MenuItem, public SubItem
        {
        };*/

public:
        AlbumList(MenuList *parent, Audacious::Audacious &audacious, bool &append);
};

class SongList : public MenuList
{
        /*struct AllItem : public MenuItem
        {
        };

        struct SongItem : public MenuItem
        {
        };*/

public:
        SongList(MenuList *parent, Audacious::Audacious &audacious, bool &append);
};

#endif//_MenuList_hpp_
Revision:	51
Committed:	2008-03-09T14:24:55-07:00 (17 years, 3 months ago) by douglas
File size:	3514 byte(s)
Log Message:	Finish the renaming!
#	Content
1	// Menu List
2	//
3	// Douglas Thrift
4	//
5	// $Id$
6
7	#ifndef _MenuList_hpp_
8	#define _MenuList_hpp_
9
10	#include <vector>
11
12	#include <Audacious.hpp>
13	#include <Music.hpp>
14
15	#include "Display.hpp"
16	#include "Filter.hpp"
17
18	class MenuList
19	{
20	static MenuList *previous;
21	MenuList *parent;
22	Display &display;
23	size_t cursor;
24
25	struct State
26	{
27	size_t item, top, bottom;
28
29	State() : item(0), top(0), bottom(4) {}
30
31	bool operator !=(const State &state) const
32	{
33	return top != state.top;
34	}
35	} state, old;
36
37	protected:
38	struct MenuItem
39	{
40	protected:
41	MenuList *list;
42
43	MenuItem(MenuList *list);
44
45	public:
46	virtual MenuList *Select() = 0;
47	virtual operator std::string() const = 0;
48	};
49
50	private:
51	inline MenuList Select(MenuItem item)
52	{
53	MenuList *list(item->Select());
54
55	if (list == NULL)
56	delete this;
57
58	return list;
59	}
60
61	protected:
62	struct BoolItem
63	{
64	virtual operator bool() const = 0;
65	};
66
67	struct SubItem {};
68
69	struct MusicItem
70	{
71	protected:
72	Audacious::Audacious &audacious;
73	bool &append;
74
75	MusicItem(Audacious::Audacious &audacious, bool &append);
76	};
77
78	std::vector<MenuItem *> list;
79
80	public:
81	MenuList(MenuList *parent, Display &display, size_t size);
82	MenuList(MenuList *parent);
83	virtual ~MenuList();
84
85	MenuList *Enter();
86	MenuList *Left();
87	MenuList *Right();
88	void Render();
89	MenuList &operator ++();
90	MenuList &operator --();
91
92	friend struct TopList;
93	};
94
95	class TopList : public MenuList
96	{
97	class AppendItem : public MenuItem, public BoolItem
98	{
99	bool &append;
100
101	public:
102	AppendItem(MenuList *list, bool &append);
103
104	virtual MenuList *Select();
105	virtual operator std::string() const;
106	virtual operator bool() const;
107	};
108
109	class ShuffleItem : public MenuItem, public BoolItem
110	{
111	Audacious::Audacious &audacious;
112
113	public:
114	ShuffleItem(MenuList *list, Audacious::Audacious &audacious);
115
116	virtual MenuList *Select();
117	virtual operator std::string() const;
118	virtual operator bool() const;
119	};
120
121	class MusicItem : public MenuItem, public SubItem, public MenuList::MusicItem
122	{
123	Music::Library &library;
124
125	public:
126	MusicItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library);
127
128	virtual MenuList *Select();
129	virtual operator std::string() const;
130	};
131
132	public:
133	TopList(Display &display, Audacious::Audacious &audacious, bool &append, Music::Library &library);
134	};
135
136	class ArtistList : public MenuList
137	{
138	class AllItem : public MenuItem, public MusicItem
139	{
140	Music::Library &library;
141
142	public:
143	AllItem(MenuList *list, Audacious::Audacious &audacious, bool &append, Music::Library &library);
144
145	virtual MenuList *Select();
146	virtual operator std::string() const;
147	};
148
149	class ArtistItem : public MenuItem, public SubItem, public MusicItem
150	{
151	Music::Artist artist;
152
153	public:
154	ArtistItem(MenuList *list, Audacious::Audacious &audacious, bool append, Music::Artist artist);
155	virtual ~ArtistItem() {}
156
157	virtual MenuList *Select();
158	virtual operator std::string() const;
159	};
160
161	public:
162	ArtistList(MenuList *parent, Audacious::Audacious &audacious, bool &append, Music::Library &library);
163	};
164
165	class AlbumList : public MenuList
166	{
167	/*struct AllItem : public MenuItem
168	{
169	};
170
171	struct AlbumItem : public MenuItem, public SubItem
172	{
173	};*/
174
175	public:
176	AlbumList(MenuList *parent, Audacious::Audacious &audacious, bool &append);
177	};
178
179	class SongList : public MenuList
180	{
181	/*struct AllItem : public MenuItem
182	{
183	};
184
185	struct SongItem : public MenuItem
186	{
187	};*/
188
189	public:
190	SongList(MenuList *parent, Audacious::Audacious &audacious, bool &append);
191	};
192
193	#endif//_MenuList_hpp_