]> git.sesse.net Git - vlc/blob - modules/gui/skins2/controls/ctrl_tree.cpp
Merge branch 'master' into lpcm_encoder
[vlc] / modules / gui / skins2 / controls / ctrl_tree.cpp
1 /*****************************************************************************
2  * ctrl_tree.cpp
3  *****************************************************************************
4  * Copyright (C) 2003 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea@videolan.org>
8  *          ClĂ©ment Stenac <zorglub@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 #include <math.h>
26 #include "../utils/var_bool.hpp"
27 #include "ctrl_tree.hpp"
28 #include "../src/os_factory.hpp"
29 #include "../src/os_graphics.hpp"
30 #include "../src/generic_bitmap.hpp"
31 #include "../src/generic_font.hpp"
32 #include "../src/scaled_bitmap.hpp"
33 #include "../utils/position.hpp"
34 #include "../utils/ustring.hpp"
35 #include "../events/evt_key.hpp"
36 #include "../events/evt_mouse.hpp"
37 #include "../events/evt_scroll.hpp"
38 #include <vlc_keys.h>
39
40 #define SCROLL_STEP 0.05
41 #define LINE_INTERVAL 1  // Number of pixels inserted between 2 lines
42
43
44 CtrlTree::CtrlTree( intf_thread_t *pIntf,
45                     VarTree &rTree,
46                     const GenericFont &rFont,
47                     const GenericBitmap *pBgBitmap,
48                     const GenericBitmap *pItemBitmap,
49                     const GenericBitmap *pOpenBitmap,
50                     const GenericBitmap *pClosedBitmap,
51                     uint32_t fgColor,
52                     uint32_t playColor,
53                     uint32_t bgColor1,
54                     uint32_t bgColor2,
55                     uint32_t selColor,
56                     const UString &rHelp,
57                     VarBool *pVisible,
58                     VarBool *pFlat ):
59     CtrlGeneric( pIntf,rHelp, pVisible), m_rTree( rTree), m_rFont( rFont ),
60     m_pBgBitmap( pBgBitmap ), m_pItemBitmap( pItemBitmap ),
61     m_pOpenBitmap( pOpenBitmap ), m_pClosedBitmap( pClosedBitmap ),
62     m_fgColor( fgColor ), m_playColor( playColor ), m_bgColor1( bgColor1 ),
63     m_bgColor2( bgColor2 ), m_selColor( selColor ),
64     m_pLastSelected( NULL ), m_pImage( NULL ), m_dontMove( false )
65 {
66     // Observe the tree and position variables
67     m_rTree.addObserver( this );
68     m_rTree.getPositionVar().addObserver( this );
69
70     m_flat = pFlat->get();
71
72     m_firstPos = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
73
74     makeImage();
75 }
76
77 CtrlTree::~CtrlTree()
78 {
79     m_rTree.getPositionVar().delObserver( this );
80     m_rTree.delObserver( this );
81     delete m_pImage;
82 }
83
84 int CtrlTree::itemHeight()
85 {
86     int itemHeight = m_rFont.getSize();
87     if( !m_flat )
88     {
89         if( m_pClosedBitmap )
90         {
91             itemHeight = __MAX( m_pClosedBitmap->getHeight(), itemHeight );
92         }
93         if( m_pOpenBitmap )
94         {
95             itemHeight = __MAX( m_pOpenBitmap->getHeight(), itemHeight );
96         }
97     }
98     if( m_pItemBitmap )
99     {
100         itemHeight = __MAX( m_pItemBitmap->getHeight(), itemHeight );
101     }
102     itemHeight += LINE_INTERVAL;
103     return itemHeight;
104 }
105
106 int CtrlTree::itemImageWidth()
107 {
108     int bitmapWidth = 5;
109     if( !m_flat )
110     {
111         if( m_pClosedBitmap )
112         {
113             bitmapWidth = __MAX( m_pClosedBitmap->getWidth(), bitmapWidth );
114         }
115         if( m_pOpenBitmap )
116         {
117             bitmapWidth = __MAX( m_pOpenBitmap->getWidth(), bitmapWidth );
118         }
119     }
120     if( m_pItemBitmap )
121     {
122         bitmapWidth = __MAX( m_pItemBitmap->getWidth(), bitmapWidth );
123     }
124     return bitmapWidth + 2;
125 }
126
127 int CtrlTree::maxItems()
128 {
129     const Position *pPos = getPosition();
130     if( !pPos )
131     {
132         return -1;
133     }
134     return pPos->getHeight() / itemHeight();
135 }
136
137
138 void CtrlTree::onUpdate( Subject<VarTree, tree_update> &rTree,
139                          tree_update *arg )
140 {
141     if( arg->i_type == 0 ) // Item update
142     {
143         if( arg->b_active_item )
144         {
145             autoScroll();
146             ///\todo We should make image if we are visible in the view
147             makeImage();
148         }
149     }
150     /// \todo handle delete in a more clever way
151     else if ( arg->i_type == 1 ) // Global change or deletion
152     {
153         m_firstPos = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
154
155         makeImage();
156     }
157     else if ( arg->i_type == 2 ) // Item-append
158     {
159         if( m_flat && m_firstPos->size() )
160             m_firstPos = m_rTree.getNextLeaf( m_firstPos );
161         /// \todo Check if the item is really visible in the view
162         // (we only check if it in the document)
163         if( arg->b_visible == true )
164         {
165             makeImage();
166         }
167     }
168     else if( arg->i_type == 3 ) // item-del
169     {
170         /* Make sure firstPos is valid */
171         while( m_firstPos->m_deleted &&
172                m_firstPos != (m_flat ? m_rTree.firstLeaf()
173                                      : m_rTree.begin()) )
174         {
175             m_firstPos = m_flat ? m_rTree.getPrevLeaf( m_firstPos )
176                                 : m_rTree.getPrevVisibleItem( m_firstPos );
177         }
178         if( m_firstPos->m_deleted )
179             m_firstPos = m_rTree.begin();
180
181         if( arg->b_visible == true )
182         {
183             makeImage();
184         }
185     }
186     notifyLayout();
187 }
188
189 void CtrlTree::onUpdate( Subject<VarPercent> &rPercent, void* arg)
190 {
191     // Determine what is the first item to display
192     VarTree::Iterator it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
193
194     if( m_dontMove ) return;
195
196     int excessItems;
197     if( m_flat )
198         excessItems = m_rTree.countLeafs() - maxItems();
199     else
200         excessItems = m_rTree.visibleItems() - maxItems();
201
202     if( excessItems > 0)
203     {
204         VarPercent &rVarPos = m_rTree.getPositionVar();
205         // a simple (int)(...) causes rounding errors !
206 #ifdef _MSC_VER
207 #   define lrint (int)
208 #endif
209         if( m_flat )
210             it = m_rTree.getLeaf(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
211         else
212             it = m_rTree.getVisibleItem(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
213     }
214     if( m_firstPos != it )
215     {
216         // Redraw the control if the position has changed
217         m_firstPos = it;
218         makeImage();
219         notifyLayout();
220     }
221 }
222
223 void CtrlTree::onResize()
224 {
225     // Determine what is the first item to display
226     VarTree::Iterator it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
227
228     int excessItems;
229     if( m_flat )
230         excessItems = m_rTree.countLeafs() - maxItems();
231     else
232         excessItems = m_rTree.visibleItems() - maxItems();
233
234     if( excessItems > 0)
235     {
236         VarPercent &rVarPos = m_rTree.getPositionVar();
237         // a simple (int)(...) causes rounding errors !
238 #ifdef _MSC_VER
239 #   define lrint (int)
240 #endif
241         if( m_flat )
242             it = m_rTree.getLeaf(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
243         else
244             it = m_rTree.getVisibleItem(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
245     }
246     // Redraw the control if the position has changed
247     m_firstPos = it;
248     makeImage();
249 }
250
251 void CtrlTree::onPositionChange()
252 {
253     makeImage();
254 }
255
256 void CtrlTree::handleEvent( EvtGeneric &rEvent )
257 {
258     bool bChangedPosition = false;
259     VarTree::Iterator toShow; bool needShow = false;
260     if( rEvent.getAsString().find( "key:down" ) != string::npos )
261     {
262         int key = ((EvtKey&)rEvent).getKey();
263         VarTree::Iterator it;
264         bool previousWasSelected = false;
265
266         /* Delete the selection */
267         if( key == KEY_DELETE )
268         {
269             /* Find first non selected item before m_pLastSelected */
270             VarTree::Iterator it_sel = m_flat ? m_rTree.firstLeaf()
271                                               : m_rTree.begin();
272             for( it = (m_flat ? m_rTree.firstLeaf() : m_rTree.begin());
273                  it != m_rTree.end();
274                  it = (m_flat ? m_rTree.getNextLeaf( it )
275                               : m_rTree.getNextVisibleItem( it )) )
276             {
277                 if( &*it == m_pLastSelected ) break;
278                 if( !it->m_selected ) it_sel = it;
279             }
280
281             /* Delete selected stuff */
282             m_rTree.delSelected();
283
284             /* Verify if there is still sthg selected (e.g read-only items) */
285             m_pLastSelected = NULL;
286             for( it = (m_flat ? m_rTree.firstLeaf() : m_rTree.begin());
287                  it != m_rTree.end();
288                  it = (m_flat ? m_rTree.getNextLeaf( it )
289                               : m_rTree.getNextVisibleItem( it )) )
290             {
291                 if( it->m_selected )
292                     m_pLastSelected = &*it;
293             }
294
295             /* if everything was deleted, use it_sel as last selection */
296             if( !m_pLastSelected )
297             {
298                 it_sel->m_selected = true;
299                 m_pLastSelected = &*it_sel;
300             }
301
302             // Redraw the control
303             makeImage();
304             notifyLayout();
305         }
306         else if( key == KEY_PAGEDOWN )
307         {
308             it = m_firstPos;
309             int i = (int)(maxItems()*1.5);
310             while( i >= 0 )
311             {
312                 VarTree::Iterator it_old = it;
313                 it = m_flat ? m_rTree.getNextLeaf( it )
314                             : m_rTree.getNextVisibleItem( it );
315                 /* End is already visible, dont' scroll */
316                 if( it == m_rTree.end() )
317                 {
318                     it = it_old;
319                     break;
320                 }
321                 needShow = true;
322                 i--;
323             }
324             if( needShow )
325             {
326                 ensureVisible( it );
327                 makeImage();
328                 notifyLayout();
329             }
330         }
331         else if (key == KEY_PAGEUP )
332         {
333             it = m_firstPos;
334             int i = maxItems();
335             while( i >= maxItems()/2 )
336             {
337                 it = m_flat ? m_rTree.getPrevLeaf( it )
338                             : m_rTree.getPrevVisibleItem( it );
339                 /* End is already visible, dont' scroll */
340                 if( it == ( m_flat ? m_rTree.firstLeaf() : m_rTree.begin() ) )
341                 {
342                     break;
343                 }
344                 i--;
345             }
346             ensureVisible( it );
347             makeImage();
348             notifyLayout();
349         }
350         else if ( key == KEY_UP ||
351                   key == KEY_DOWN ||
352                   key == KEY_LEFT ||
353                   key == KEY_RIGHT ||
354                   key == KEY_ENTER ||
355                   key == ' ' )
356         {
357             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
358                  it != m_rTree.end();
359                  it = m_flat ? m_rTree.getNextLeaf( it )
360                              : m_rTree.getNextVisibleItem( it ) )
361             {
362                 VarTree::Iterator next = m_flat ?
363                                          m_rTree.getNextLeaf( it ) :
364                                          m_rTree.getNextVisibleItem( it );
365                 if( key == KEY_UP )
366                 {
367                     // Scroll up one item
368                     if( ( it->parent()
369                           && it != it->parent()->begin() )
370                         || &*it != m_pLastSelected )
371                     {
372                         bool nextWasSelected = ( &*next == m_pLastSelected );
373                         it->m_selected = nextWasSelected;
374                         if( nextWasSelected )
375                         {
376                             m_pLastSelected = &*it;
377                             needShow = true; toShow = it;
378                         }
379                     }
380                 }
381                 else if( key == KEY_DOWN )
382                 {
383                     // Scroll down one item
384                     if( ( it->parent()
385                           && next != it->parent()->end() )
386                         || &*it != m_pLastSelected )
387                     {
388                         (*it).m_selected = previousWasSelected;
389                     }
390                     if( previousWasSelected )
391                     {
392                         m_pLastSelected = &*it;
393                         needShow = true; toShow = it;
394                         previousWasSelected = false;
395                     }
396                     else
397                     {
398                         previousWasSelected = ( &*it == m_pLastSelected );
399                     }
400
401                     // Fix last tree item selection
402                     if( ( m_flat ? m_rTree.getNextLeaf( it )
403                         : m_rTree.getNextVisibleItem( it ) ) == m_rTree.end()
404                      && &*it == m_pLastSelected )
405                     {
406                         (*it).m_selected = true;
407                     }
408                 }
409                 else if( key == KEY_RIGHT )
410                 {
411                     // Go down one level (and expand node)
412                     if( &*it == m_pLastSelected )
413                     {
414                         if( it->m_expanded )
415                         {
416                             if( it->size() )
417                             {
418                                 it->m_selected = false;
419                                 it->begin()->m_selected = true;
420                                 m_pLastSelected = &*(it->begin());
421                             }
422                             else
423                             {
424                                 m_rTree.action( &*it );
425                             }
426                         }
427                         else
428                         {
429                             it->m_expanded = true;
430                             bChangedPosition = true;
431                         }
432                     }
433                 }
434                 else if( key == KEY_LEFT )
435                 {
436                     // Go up one level (and close node)
437                     if( &*it == m_pLastSelected )
438                     {
439                         if( it->m_expanded && it->size() )
440                         {
441                             it->m_expanded = false;
442                             bChangedPosition = true;
443                         }
444                         else
445                         {
446                             if( it->parent() && it->parent() != &m_rTree)
447                             {
448                                 it->m_selected = false;
449                                 m_pLastSelected = it->parent();
450                                 m_pLastSelected->m_selected = true;
451                             }
452                         }
453                     }
454                 }
455                 else if( key == KEY_ENTER || key == ' ' )
456                 {
457                     // Go up one level (and close node)
458                     if( &*it == m_pLastSelected )
459                     {
460                         m_rTree.action( &*it );
461                     }
462                 }
463             }
464             if( needShow )
465                 ensureVisible( toShow );
466             // Redraw the control
467             makeImage();
468             notifyLayout();
469         }
470         else
471         {
472             // other keys to be forwarded to vlc core
473             EvtKey& rEvtKey = (EvtKey&)rEvent;
474             var_SetInteger( getIntf()->p_libvlc, "key-pressed",
475                             rEvtKey.getModKey() );
476         }
477
478     }
479
480     else if( rEvent.getAsString().find( "mouse:left" ) != string::npos )
481     {
482         EvtMouse &rEvtMouse = (EvtMouse&)rEvent;
483         const Position *pos = getPosition();
484         int yPos = ( rEvtMouse.getYPos() - pos->getTop() ) / itemHeight();
485         int xPos = rEvtMouse.getXPos() - pos->getLeft();
486         VarTree::Iterator it;
487
488         if( rEvent.getAsString().find( "mouse:left:down:ctrl,shift" ) !=
489             string::npos )
490         {
491             VarTree::Iterator itClicked = findItemAtPos( yPos );
492             // Flag to know if the current item must be selected
493             bool select = false;
494             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
495                  it != m_rTree.end();
496                  it = m_flat ? m_rTree.getNextLeaf( it )
497                              : m_rTree.getNextVisibleItem( it ) )
498             {
499                 bool nextSelect = select;
500                 if( it == itClicked || &*it == m_pLastSelected )
501                 {
502                     if( select )
503                     {
504                         nextSelect = false;
505                     }
506                     else
507                     {
508                         select = true;
509                         nextSelect = true;
510                     }
511                 }
512                 it->m_selected = (*it).m_selected || select;
513                 select = nextSelect;
514             }
515             // Redraw the control
516             makeImage();
517             notifyLayout();
518         }
519         else if( rEvent.getAsString().find( "mouse:left:down:ctrl" ) !=
520                  string::npos )
521         {
522             // Invert the selection of the item
523             it = findItemAtPos( yPos );
524             if( it != m_rTree.end() )
525             {
526                 it->m_selected = !it->m_selected;
527                 m_pLastSelected = &*it;
528             }
529             // Redraw the control
530             makeImage();
531             notifyLayout();
532         }
533         else if( rEvent.getAsString().find( "mouse:left:down:shift" ) !=
534                  string::npos )
535         {
536             VarTree::Iterator itClicked = findItemAtPos( yPos );
537             // Flag to know if the current item must be selected
538             bool select = false;
539             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
540                  it != m_rTree.end();
541                  it = m_flat ? m_rTree.getNextLeaf( it )
542                              : m_rTree.getNextVisibleItem( it ) )
543             {
544                 bool nextSelect = select;
545                 if( it == itClicked || &*it == m_pLastSelected )
546                 {
547                     if( select )
548                     {
549                         nextSelect = false;
550                     }
551                     else
552                     {
553                         select = true;
554                         nextSelect = true;
555                     }
556                 }
557                 it->m_selected = select;
558                 select = nextSelect;
559             }
560             // Redraw the control
561             makeImage();
562             notifyLayout();
563         }
564         else if( rEvent.getAsString().find( "mouse:left:down" ) !=
565                  string::npos )
566         {
567             it = findItemAtPos(yPos);
568             if( it != m_rTree.end() )
569             {
570                 if( ( it->size() && xPos > (it->depth() - 1) * itemImageWidth()
571                       && xPos < it->depth() * itemImageWidth() )
572                  && !m_flat )
573                 {
574                     // Fold/unfold the item
575                     it->m_expanded = !it->m_expanded;
576                     bChangedPosition = true;
577                 }
578                 else
579                 {
580                     // Unselect any previously selected item
581                     VarTree::Iterator it2;
582                     for( it2 = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
583                          it2 != m_rTree.end();
584                          it2 = m_flat ? m_rTree.getNextLeaf( it2 )
585                                       : m_rTree.getNextVisibleItem( it2 ) )
586                     {
587                         it2->m_selected = false;
588                     }
589                     // Select the new item
590                     if( it != m_rTree.end() )
591                     {
592                         it->m_selected = true;
593                         m_pLastSelected = &*it;
594                     }
595                 }
596             }
597             // Redraw the control
598             makeImage();
599             notifyLayout();
600         }
601         else if( rEvent.getAsString().find( "mouse:left:dblclick" ) !=
602                  string::npos )
603         {
604             it = findItemAtPos(yPos);
605             if( it != m_rTree.end() )
606             {
607                // Execute the action associated to this item
608                m_rTree.action( &*it );
609             }
610             // Redraw the control
611             makeImage();
612             notifyLayout();
613         }
614     }
615
616     else if( rEvent.getAsString().find( "scroll" ) != string::npos )
617     {
618         // XXX ctrl_slider.cpp has two more (but slightly different)
619         // XXX implementations of `scroll'. Figure out where it belongs.
620
621         int direction = static_cast<EvtScroll&>(rEvent).getDirection();
622
623         double percentage = m_rTree.getPositionVar().get();
624         double step = 2.0 / (double)( m_flat ? m_rTree.countLeafs()
625                                              : m_rTree.visibleItems() );
626         if( direction == EvtScroll::kUp )
627         {
628             percentage += step;
629         }
630         else
631         {
632             percentage -= step;
633         }
634         m_rTree.getPositionVar().set( percentage );
635     }
636
637     /* We changed the nodes, let's fix the position var */
638     if( bChangedPosition )
639     {
640         VarTree::Iterator it;
641         int iFirst = 0;
642         for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
643              it != m_rTree.end();
644              it = m_flat ? m_rTree.getNextLeaf( it )
645                          : m_rTree.getNextVisibleItem( it ) )
646         {
647             if( it == m_firstPos )
648                 break;
649             iFirst++;
650         }
651
652         int indexMax = ( m_flat ? m_rTree.countLeafs()
653                                 : m_rTree.visibleItems() ) - 1;
654         float f_new = (float)iFirst / (float)indexMax;
655
656         m_dontMove = true;
657         m_rTree.getPositionVar().set( 1.0 - f_new );
658         m_dontMove = false;
659     }
660 }
661
662 bool CtrlTree::mouseOver( int x, int y ) const
663 {
664     const Position *pPos = getPosition();
665     return !pPos ? false :
666         x >= 0 && x <= pPos->getWidth() && y >= 0 && y <= pPos->getHeight();
667 }
668
669 void CtrlTree::draw( OSGraphics &rImage, int xDest, int yDest, int w, int h)
670 {
671     const Position *pPos = getPosition();
672     rect region( pPos->getLeft(), pPos->getTop(),
673                  pPos->getWidth(), pPos->getHeight() );
674     rect clip( xDest, yDest, w, h );
675     rect inter;
676
677     if( rect::intersect( region, clip, &inter ) && m_pImage )
678         rImage.drawGraphics( *m_pImage,
679                       inter.x - pPos->getLeft(),
680                       inter.y - pPos->getTop(),
681                       inter.x, inter.y, inter.width, inter.height );
682 }
683
684 bool CtrlTree::ensureVisible( VarTree::Iterator item )
685 {
686     // Find the item to focus
687     int focusItemIndex = 0;
688     VarTree::Iterator it;
689
690     m_rTree.ensureExpanded( item );
691
692     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
693          it != m_rTree.end();
694          it = m_flat ? m_rTree.getNextLeaf( it )
695                      : m_rTree.getNextVisibleItem( it ) )
696     {
697         if( it->m_id == item->m_id ) break;
698         focusItemIndex++;
699     }
700    return ensureVisible( focusItemIndex );
701 }
702
703 bool CtrlTree::ensureVisible( int focusItemIndex )
704 {
705     // Find  m_firstPos
706     VarTree::Iterator it;
707     int firstPosIndex = 0;
708     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
709          it != m_rTree.end();
710          it = m_flat ? m_rTree.getNextLeaf( it )
711                      : m_rTree.getNextVisibleItem( it ) )
712     {
713         if( it == m_firstPos ) break;
714         firstPosIndex++;
715     }
716
717     if( it == m_rTree.end() ) return false;
718
719
720     if( it != m_rTree.end()
721         && ( focusItemIndex < firstPosIndex
722            || focusItemIndex > firstPosIndex + maxItems() - 1 ) )
723     {
724         // Scroll to have the wanted stream visible
725         VarPercent &rVarPos = m_rTree.getPositionVar();
726         int indexMax = ( m_flat ? m_rTree.countLeafs()
727                                 : m_rTree.visibleItems() ) - 1;
728         rVarPos.set( 1.0 - (double)focusItemIndex / (double)indexMax );
729         return true;
730     }
731     return false;
732 }
733
734 void CtrlTree::autoScroll()
735 {
736     // Find the current playing stream
737     int playIndex = 0;
738     VarTree::Iterator it;
739
740     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
741          it != m_rTree.end();
742          it = m_flat ? m_rTree.getNextLeaf( it )
743                      : m_rTree.getNextItem( it ) )
744     {
745         if( it->m_playing )
746         {
747            m_rTree.ensureExpanded( it );
748            break;
749         }
750     }
751
752     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
753          it != m_rTree.end();
754          it = m_flat ? m_rTree.getNextLeaf( it )
755                      : m_rTree.getNextVisibleItem( it ) )
756     {
757         if( it->m_playing )
758         {
759            ensureVisible( playIndex );
760            break;
761         }
762         playIndex++;
763     }
764 }
765
766
767 void CtrlTree::makeImage()
768 {
769     stats_TimerStart( getIntf(), "[Skins] Playlist image",
770                       STATS_TIMER_SKINS_PLAYTREE_IMAGE );
771     delete m_pImage;
772
773     // Get the size of the control
774     const Position *pPos = getPosition();
775     if( !pPos )
776     {
777         stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
778         return;
779     }
780     int width = pPos->getWidth();
781     int height = pPos->getHeight();
782
783     int i_itemHeight = itemHeight();
784
785     // Create an image
786     OSFactory *pOsFactory = OSFactory::instance( getIntf() );
787     m_pImage = pOsFactory->createOSGraphics( width, height );
788
789     VarTree::Iterator it = m_firstPos;
790
791     if( m_pBgBitmap )
792     {
793         // Draw the background bitmap
794         ScaledBitmap bmp( getIntf(), *m_pBgBitmap, width, height );
795         m_pImage->drawBitmap( bmp, 0, 0 );
796
797         for( int yPos = 0; yPos < height; yPos += i_itemHeight )
798         {
799             if( it != m_rTree.end() )
800             {
801                 if( (*it).m_selected )
802                 {
803                     int rectHeight = __MIN( i_itemHeight, height - yPos );
804                     m_pImage->fillRect( 0, yPos, width, rectHeight,
805                                         m_selColor );
806                 }
807                 do
808                 {
809                     it = m_flat ? m_rTree.getNextLeaf( it )
810                                 : m_rTree.getNextVisibleItem( it );
811                 } while( it != m_rTree.end() && it->m_deleted );
812             }
813         }
814     }
815     else
816     {
817         // FIXME (TRYME)
818         // Fill background with background color
819         uint32_t bgColor = m_bgColor1;
820         m_pImage->fillRect( 0, 0, width, height, bgColor );
821         for( int yPos = 0; yPos < height; yPos += i_itemHeight )
822         {
823             int rectHeight = __MIN( i_itemHeight, height - yPos );
824             if( it == m_rTree.end() )
825                 m_pImage->fillRect( 0, yPos, width, rectHeight, bgColor );
826             else
827             {
828                 uint32_t color = ( it->m_selected ? m_selColor : bgColor );
829                 m_pImage->fillRect( 0, yPos, width, rectHeight, color );
830                 do
831                 {
832                     it = m_flat ? m_rTree.getNextLeaf( it )
833                                 : m_rTree.getNextVisibleItem( it );
834                 } while( it != m_rTree.end() && it->m_deleted );
835             }
836             bgColor = ( bgColor == m_bgColor1 ? m_bgColor2 : m_bgColor1 );
837         }
838     }
839
840     int bitmapWidth = itemImageWidth();
841
842     int yPos = 0;
843     it = m_firstPos;
844     while( it != m_rTree.end() && yPos < height )
845     {
846         const GenericBitmap *m_pCurBitmap;
847         UString *pStr = (UString*)(it->m_cString.get());
848         uint32_t color = ( it->m_playing ? m_playColor : m_fgColor );
849
850         // Draw the text
851         if( pStr != NULL )
852         {
853             int depth = m_flat ? 1 : it->depth();
854             GenericBitmap *pText = m_rFont.drawString( *pStr, color, width - bitmapWidth * depth );
855             if( !pText )
856             {
857                 stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
858                 return;
859             }
860             if( it->size() )
861                 m_pCurBitmap = it->m_expanded ? m_pOpenBitmap : m_pClosedBitmap;
862             else
863                 m_pCurBitmap = m_pItemBitmap;
864
865             if( m_pCurBitmap )
866             {
867                 // Make sure we are centered on the line
868                 int yPos2 = yPos+(i_itemHeight-m_pCurBitmap->getHeight()+1)/2;
869                 if( yPos2 >= height )
870                 {
871                     delete pText;
872                     break;
873                 }
874                 m_pImage->drawBitmap( *m_pCurBitmap, 0, 0,
875                                       bitmapWidth * (depth - 1 ), yPos2,
876                                       m_pCurBitmap->getWidth(),
877                                       __MIN( m_pCurBitmap->getHeight(),
878                                              height -  yPos2), true );
879             }
880             yPos += i_itemHeight - pText->getHeight();
881             int ySrc = 0;
882             if( yPos < 0 )
883             {
884                 ySrc = - yPos;
885                 yPos = 0;
886             }
887             int lineHeight = __MIN( pText->getHeight() - ySrc, height - yPos );
888             m_pImage->drawBitmap( *pText, 0, ySrc, bitmapWidth * depth, yPos,
889                                   pText->getWidth(),
890                                   lineHeight, true );
891             yPos += (pText->getHeight() - ySrc );
892             delete pText;
893         }
894         do
895         {
896             it = m_flat ? m_rTree.getNextLeaf( it )
897                 : m_rTree.getNextVisibleItem( it );
898         } while( it != m_rTree.end() && it->m_deleted );
899     }
900     stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
901 }
902
903 VarTree::Iterator CtrlTree::findItemAtPos( int pos )
904 {
905     // The first item is m_firstPos.
906     // We decrement pos as we try the other items, until pos == 0.
907     VarTree::Iterator it;
908     for( it = m_firstPos; it != m_rTree.end() && pos != 0;
909          it = m_flat ? m_rTree.getNextLeaf( it )
910                      : m_rTree.getNextVisibleItem( it ) )
911     {
912         pos--;
913     }
914
915     return it;
916 }