96cd19bf12ea9ae123de7bd58592023091b51032
[vlc.git] / modules / gui / skins2 / utils / var_tree.hpp
1 /*****************************************************************************
2  * var_tree.hpp
3  *****************************************************************************
4  * Copyright (C) 2005 VideoLAN
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifndef VAR_TREE_HPP
25 #define VAR_TREE_HPP
26
27 #include <list>
28
29 #include "variable.hpp"
30 #include "observer.hpp"
31 #include "ustring.hpp"
32 #include "var_percent.hpp"
33
34 /// Description of an update to the tree
35 typedef struct tree_update
36 {
37      int i_type;
38      int i_parent;
39      int i_id;
40      bool b_active_item;
41      bool b_visible;
42 } tree_update;
43
44 /// Tree variable
45 class VarTree: public Variable, public Subject<VarTree, tree_update*>
46 {
47     public:
48         VarTree( intf_thread_t *pIntf );
49
50         VarTree( intf_thread_t *pIntf, VarTree *pParent, int id,
51                  const UStringPtr &rcString, bool selected, bool playing,
52                  bool expanded, void *pData );
53
54         virtual ~VarTree();
55
56         /// Get the variable type
57         virtual const string &getType() const { return m_type; }
58
59         /// Add a pointer on string in the children's list
60         virtual void add( int id, const UStringPtr &rcString, bool selected,
61                           bool playing, bool expanded, void *pData );
62
63         /// Remove the selected item from the children's list
64         virtual void delSelected();
65
66         /// Remove all elements from the children's list
67         virtual void clear();
68
69         /// \todo Use accessors for these fields ?
70         int m_id;
71         UStringPtr m_cString;
72         bool m_selected;
73         bool m_playing;
74         bool m_expanded;
75         void *m_pData;
76
77         /// Get the number of children
78         int size() const { return m_children.size(); }
79
80         /// Iterators
81         typedef list<VarTree>::iterator Iterator;
82         typedef list<VarTree>::const_iterator ConstIterator;
83
84         /// Begining of the children's list
85         Iterator begin() { return m_children.begin(); }
86         ConstIterator begin() const { return m_children.begin(); }
87
88         /// End of children's list
89         Iterator end() { return m_children.end(); }
90         ConstIterator end() const { return m_children.end(); }
91
92         /// Back of children's list
93         VarTree &back() { return m_children.back(); }
94
95         /// Return an iterator on the n'th element of the children's list
96         Iterator operator[]( int n );
97         ConstIterator operator[]( int n ) const;
98
99         /// Parent node
100         VarTree *parent() { return m_pParent; }
101         void checkParents( VarTree *pParent );
102
103         Iterator next_uncle();
104         Iterator prev_uncle();
105
106         /// Get root node
107         VarTree *root()
108         {
109             VarTree *parent = this;
110             while( parent->parent() != NULL )
111                 parent = parent->parent();
112             return parent;
113         }
114
115         /// Get depth (root depth is 0)
116         int depth()
117         {
118             VarTree *parent = this;
119             int depth = 0;
120             while( ( parent = parent->parent() ) != NULL )
121                 depth++;
122             return depth;
123         }
124
125         /// Execute the action associated to this item
126         virtual void action( VarTree *pItem ) {}
127
128         /// Get a reference on the position variable
129         VarPercent &getPositionVar() const
130         { return *((VarPercent*)m_cPosition.get()); }
131
132         /// Get a counted pointer on the position variable
133         const VariablePtr &getPositionVarPtr() const { return m_cPosition; }
134
135         /// Count the number of items that should be displayed if the playlist window wasn't limited
136         int visibleItems();
137
138         /// Return iterator to the n'th visible item
139         Iterator getVisibleItem( int n );
140
141         /// Given an iterator to a visible item, return the next visible item
142         Iterator getNextVisibleItem( Iterator it );
143
144         /// Given an it to a visible item, return the previous visible item
145         Iterator getPrevVisibleItem( Iterator it );
146
147         /// Given an iterator to an item, return the next item
148         Iterator getNextItem( Iterator it );
149
150         /// Find a children node with the given id
151         Iterator findById( int id );
152
153         /// Ensure an item is expanded
154         void ensureExpanded( VarTree::Iterator );
155
156     private:
157         /// List of children
158         list<VarTree> m_children;
159
160         /// Pointer to parent node
161         VarTree *m_pParent;
162
163         /// Variable type
164         static const string m_type;
165
166         /// Position variable
167         VariablePtr m_cPosition;
168 };
169
170 #endif