Playtree: handle delete nicely
[vlc.git] / modules / gui / skins2 / utils / var_tree.cpp
1 /*****************************************************************************
2  * var_tree.cpp
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 #include "var_tree.hpp"
25
26
27 const string VarTree::m_type = "tree";
28
29 VarTree::VarTree( intf_thread_t *pIntf )
30     : Variable( pIntf ), m_id( 0 ), m_selected( false ), m_playing( false ),
31     m_expanded( false ), m_deleted( false ), m_readonly( false),
32     m_pData( NULL ), m_pParent( NULL )
33 {
34     // Create the position variable
35     m_cPosition = VariablePtr( new VarPercent( pIntf ) );
36     getPositionVar().set( 1.0 );
37 }
38
39 VarTree::VarTree( intf_thread_t *pIntf, VarTree *pParent, int id,
40                   const UStringPtr &rcString, bool selected, bool playing,
41                   bool expanded, bool readonly,
42                   void *pData )
43     : Variable( pIntf ), m_id( id ), m_cString( rcString ),
44     m_selected( selected ), m_playing( playing ), m_expanded( expanded ),
45     m_deleted( false ), m_readonly( readonly ),
46     m_pData( pData ), m_pParent( pParent )
47 {
48     fprintf( stderr, "Expanded is %i - RO %i\n", m_expanded, m_readonly );
49     // Create the position variable
50     m_cPosition = VariablePtr( new VarPercent( pIntf ) );
51     getPositionVar().set( 1.0 );
52 }
53
54 VarTree::~VarTree()
55 {
56 /// \todo check that children are deleted
57 }
58
59 void VarTree::add( int id, const UStringPtr &rcString, bool selected,
60                    bool playing, bool expanded, bool readonly,
61                    void *pData )
62 {
63     m_children.push_back( VarTree( getIntf(), this, id, rcString, selected,
64                                    playing, expanded, readonly,
65                                    pData ) );
66 }
67
68 void VarTree::delSelected()
69 {
70     Iterator it = begin();
71     while( it != end() )
72     {
73         //dig down the tree
74         if( size() ) it->delSelected();
75         //stay on some level
76         if( it->m_selected )
77         {
78             Iterator oldIt = it;
79             it++;
80             m_children.erase( oldIt );
81         }
82         else
83         {
84             it++;
85         }
86     }
87 }
88
89 void VarTree::clear()
90 {
91     m_children.clear();
92 }
93
94 VarTree::Iterator VarTree::operator[]( int n )
95 {
96     Iterator it;
97     int i;
98     for( it = begin(), i = 0;
99          i < n && it != end();
100          it++, i++ );
101     return it;
102 }
103
104 VarTree::ConstIterator VarTree::operator[]( int n ) const
105 {
106     ConstIterator it;
107     int i;
108     for( it = begin(), i = 0;
109          i < n && it != end();
110          it++, i++ );
111     return it;
112 }
113
114 VarTree::Iterator VarTree::getNextSibling( VarTree::Iterator current )
115 {
116     VarTree *p_parent = current->parent();
117     if( p_parent  && current != p_parent->end() )
118     {
119         Iterator it = current->parent()->begin();
120         while( it != p_parent->end() && it != current ) it++;
121         if( it != p_parent->end() )
122         {
123             it++;
124         }
125         return root()->end();
126     }
127     return root()->end();
128 }
129
130 /* find iterator to next ancestor
131  * ... which means parent++ or grandparent++ or grandgrandparent++ ... */
132 VarTree::Iterator VarTree::next_uncle()
133 {
134     VarTree *p_parent = parent();
135     if( p_parent != NULL )
136     {
137         VarTree *p_grandparent = p_parent->parent();
138         while( p_grandparent != NULL )
139         {
140             Iterator it = p_grandparent->begin();
141             while( it != p_grandparent->end() && &(*it) != p_parent ) it++;
142             if( it != p_grandparent->end() )
143             {
144                 it++;
145                 if( it != p_grandparent->end() )
146                 {
147                     return it;
148                 }
149             }
150             if( p_grandparent->parent() )
151             {
152                 p_parent = p_grandparent;
153                 p_grandparent = p_parent->parent();
154             }
155             else
156                 p_grandparent = NULL;
157         }
158     }
159
160     /* if we didn't return before, it means that we've reached the end */
161     return root()->end();
162 }
163
164 VarTree::Iterator VarTree::prev_uncle()
165 {
166     VarTree *p_parent = parent();
167     if( p_parent != NULL )
168     {
169         VarTree *p_grandparent = p_parent->parent();
170         while( p_grandparent != NULL )
171         {
172             Iterator it = p_grandparent->end();
173             while( it != p_grandparent->begin() && &(*it) != p_parent ) it--;
174             if( it != p_grandparent->begin() )
175             {
176                 it--;
177                 if( it != p_grandparent->begin() )
178                 {
179                     return it;
180                 }
181             }
182             if( p_grandparent->parent() )
183             {
184                 p_parent = p_grandparent;
185                 p_grandparent = p_parent->parent();
186             }
187             else
188                 p_grandparent = NULL;
189         }
190     }
191
192     /* if we didn't return before, it means that we've reached the end */
193     return root()->begin();
194 }
195
196
197 void VarTree::checkParents( VarTree *pParent )
198 {
199     m_pParent = pParent;
200     Iterator it = begin();
201     while( it != end() )
202     {
203         it->checkParents( this );
204         it++;
205     }
206 }
207
208 int VarTree::visibleItems()
209 {
210     int i_count = size();
211     Iterator it = begin();
212     while( it != end() )
213     {
214         if( it->m_expanded )
215         {
216             i_count += it->visibleItems();
217         }
218         it++;
219     }
220     return i_count;
221 }
222
223 VarTree::Iterator VarTree::getVisibleItem( int n )
224 {
225     Iterator it = begin();
226     while( it != end() )
227     {
228         n--;
229         if( n <= 0 ) return it;
230         if( it->m_expanded )
231         {
232             int i = n - it->visibleItems();
233             if( i <= 0 ) return it->getVisibleItem( n );
234             n = i;
235         }
236         it++;
237     }
238     return end();
239 }
240
241 VarTree::Iterator VarTree::getNextVisibleItem( Iterator it )
242 {
243     if( it->m_expanded && it->size() )
244     {
245         it = it->begin();
246     }
247     else
248     {
249         VarTree::Iterator it_old = it;
250         it++;
251         // Was 'it' the last brother? If so, look for uncles
252         if( it_old->parent() && it_old->parent()->end() == it )
253         {
254             it = it_old->next_uncle();
255         }
256     }
257     return it;
258 }
259
260 VarTree::Iterator VarTree::getPrevVisibleItem( Iterator it )
261 {
262     VarTree::Iterator it_old = it;
263     if( it == root()->begin() || it == ++(root()->begin()) ) return it;
264     if( it->parent() )
265     {
266     }
267     /* Was it the first child of its parent ? */
268     if( it->parent() && it == it->parent()->begin() )
269     {
270         /* Yes, get previous uncle */
271         it = it_old->prev_uncle();
272    }
273     else
274         it--;
275
276     /* We have found an expanded uncle, take its last child */
277     while( it != root()->begin() && it->size() && it->m_expanded )
278     {
279             it = it->end();
280             it--;
281     }
282     return it;
283 }
284
285 VarTree::Iterator VarTree::getNextItem( Iterator it )
286 {
287     if( it->size() )
288     {
289         it = it->begin();
290     }
291     else
292     {
293         VarTree::Iterator it_old = it;
294         it++;
295         // Was 'it' the last brother? If so, look for uncles
296         if( it_old->parent() && it_old->parent()->end() == it )
297         {
298             it = it_old->next_uncle();
299         }
300     }
301     return it;
302 }
303
304
305 VarTree::Iterator VarTree::findById( int id )
306 {
307     for (Iterator it = begin(); it != end(); ++it )
308     {
309         if( it->m_id == id )
310         {
311             return it;
312         }
313         Iterator result = it->findById( id );
314         if( result != it->end() ) return result;
315     }
316     return end();
317 }
318
319
320 void VarTree::ensureExpanded( VarTree::Iterator it )
321 {
322     /// Don't expand ourselves, only our parents
323     VarTree *current = &(*it);
324     current = current->parent();
325     while( current->parent() != NULL )
326     {
327         current->m_expanded = true;
328         current = current->parent();
329     }
330 }