truck/DashInterface/MenuList.hpp

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

#ifndef _MenuList_hpp_
#define _MenuList_hpp_

#include <vector>

#include <Audacious.hpp>
#include <MusicLibrary.hpp>

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

struct MenuList
{
protected:
        static MenuList *previous;

private:
        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;
                MusicLibrary::Library &library;

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

        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 --();
};

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;
        };

        struct MusicItem : public MenuItem, public SubItem, public MenuList::MusicItem
        {
                MusicItem(MenuList *list, Audacious::Audacious &audacious, bool &append, MusicLibrary::Library &library);

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

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

class ArtistList : public MenuList
{
        struct AllItem : public MenuItem, public MusicItem
        {
                AllItem(MenuList *list, Audacious::Audacious &audacious, bool &append, MusicLibrary::Library &library);

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

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

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