]> git.sesse.net Git - vlc/blob - modules/gui/skins2/controls/ctrl_tree.cpp
b816d02b3f179b115ed918ff16b31006bf6dbc78
[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     m_firstPos = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
142
143     if( arg->i_type == 0 ) // Item update
144     {
145         if( arg->b_active_item )
146         {
147             autoScroll();
148             ///\todo We should make image if we are visible in the view
149             makeImage();
150         }
151     }
152     /// \todo handle delete in a more clever way
153     else if ( arg->i_type == 1 ) // Global change or deletion
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 and lastSelected are still valid */
171         while( m_firstPos->m_deleted && m_firstPos != m_rTree.root()->begin() )
172         {
173             m_firstPos = m_flat ? m_rTree.getPrevLeaf( m_firstPos )
174                                 : m_rTree.getPrevVisibleItem( m_firstPos );
175         }
176         if( m_firstPos->m_deleted )
177             m_firstPos = m_flat ? m_rTree.firstLeaf()
178                                 : m_rTree.root()->begin();
179
180         if( arg->b_visible == true )
181         {
182             makeImage();
183         }
184     }
185     notifyLayout();
186 }
187
188 void CtrlTree::onUpdate( Subject<VarPercent> &rPercent, void* arg)
189 {
190     // Determine what is the first item to display
191     VarTree::Iterator it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
192
193     if( m_dontMove ) return;
194
195     int excessItems;
196     if( m_flat )
197         excessItems = m_rTree.countLeafs() - maxItems();
198     else
199         excessItems = m_rTree.visibleItems() - maxItems();
200
201     if( excessItems > 0)
202     {
203         VarPercent &rVarPos = m_rTree.getPositionVar();
204         // a simple (int)(...) causes rounding errors !
205 #ifdef _MSC_VER
206 #   define lrint (int)
207 #endif
208         if( m_flat )
209             it = m_rTree.getLeaf(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
210         else
211             it = m_rTree.getVisibleItem(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
212     }
213     if( m_firstPos != it )
214     {
215         // Redraw the control if the position has changed
216         m_firstPos = it;
217         makeImage();
218         notifyLayout();
219     }
220 }
221
222 void CtrlTree::onResize()
223 {
224     // Determine what is the first item to display
225     VarTree::Iterator it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
226
227     int excessItems;
228     if( m_flat )
229         excessItems = m_rTree.countLeafs() - maxItems();
230     else
231         excessItems = m_rTree.visibleItems() - maxItems();
232
233     if( excessItems > 0)
234     {
235         VarPercent &rVarPos = m_rTree.getPositionVar();
236         // a simple (int)(...) causes rounding errors !
237 #ifdef _MSC_VER
238 #   define lrint (int)
239 #endif
240         if( m_flat )
241             it = m_rTree.getLeaf(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
242         else
243             it = m_rTree.getVisibleItem(lrint( (1.0 - rVarPos.get()) * (double)excessItems ) + 1 );
244     }
245     // Redraw the control if the position has changed
246     m_firstPos = it;
247     makeImage();
248 }
249
250 void CtrlTree::onPositionChange()
251 {
252     makeImage();
253 }
254
255 void CtrlTree::handleEvent( EvtGeneric &rEvent )
256 {
257     bool bChangedPosition = false;
258     VarTree::Iterator toShow; bool needShow = false;
259     if( rEvent.getAsString().find( "key:down" ) != string::npos )
260     {
261         int key = ((EvtKey&)rEvent).getKey();
262         VarTree::Iterator it;
263         bool previousWasSelected = false;
264
265         /* Delete the selection */
266         if( key == KEY_DELETE )
267         {
268             /* Find first non selected item before m_pLastSelected */
269             VarTree::Iterator it_sel = m_flat ? m_rTree.firstLeaf()
270                                               : m_rTree.begin();
271             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
272                  it != m_rTree.end();
273                  it = m_flat ? m_rTree.getNextLeaf( it )
274                              : m_rTree.getNextVisibleItem( it ) )
275             {
276                 if( &*it == m_pLastSelected ) break;
277                 if( !it->m_selected ) it_sel = it;
278             }
279
280             /* Delete selected stuff */
281             m_rTree.delSelected();
282
283             /* Select it_sel */
284             it_sel->m_selected = true;
285             m_pLastSelected = &*it_sel;
286         }
287         else if( key == KEY_PAGEDOWN )
288         {
289             it = m_firstPos;
290             int i = (int)(maxItems()*1.5);
291             while( i >= 0 )
292             {
293                 VarTree::Iterator it_old = it;
294                 it = m_flat ? m_rTree.getNextLeaf( it )
295                             : m_rTree.getNextVisibleItem( it );
296                 /* End is already visible, dont' scroll */
297                 if( it == m_rTree.end() )
298                 {
299                     it = it_old;
300                     break;
301                 }
302                 needShow = true;
303                 i--;
304             }
305             if( needShow )
306             {
307                 ensureVisible( it );
308                 makeImage();
309                 notifyLayout();
310                 return;
311             }
312         }
313         else if (key == KEY_PAGEUP )
314         {
315             it = m_firstPos;
316             int i = maxItems();
317             while( i >= maxItems()/2 )
318             {
319                 it = m_flat ? m_rTree.getPrevLeaf( it )
320                             : m_rTree.getPrevVisibleItem( it );
321                 /* End is already visible, dont' scroll */
322                 if( it == ( m_flat ? m_rTree.firstLeaf() : m_rTree.begin() ) )
323                 {
324                     break;
325                 }
326                 i--;
327             }
328             ensureVisible( it );
329             makeImage();
330             notifyLayout();
331             return;
332         }
333         else
334         {
335             // other keys to be forwarded to vlc core
336             EvtKey& rEvtKey = (EvtKey&)rEvent;
337             var_SetInteger( getIntf()->p_libvlc, "key-pressed",
338                             rEvtKey.getModKey() );
339             return;
340         }
341
342
343         for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
344              it != m_rTree.end();
345              it = m_flat ? m_rTree.getNextLeaf( it )
346                          : m_rTree.getNextVisibleItem( it ) )
347         {
348             VarTree::Iterator next = m_flat ? m_rTree.getNextLeaf( it )
349                                             : m_rTree.getNextVisibleItem( it );
350             if( key == KEY_UP )
351             {
352                 // Scroll up one item
353                 if( ( it->parent()
354                       && it != it->parent()->begin() )
355                     || &*it != m_pLastSelected )
356                 {
357                     bool nextWasSelected = ( &*next == m_pLastSelected );
358                     it->m_selected = nextWasSelected;
359                     if( nextWasSelected )
360                     {
361                         m_pLastSelected = &*it;
362                         needShow = true; toShow = it;
363                     }
364                 }
365             }
366             else if( key == KEY_DOWN )
367             {
368                 // Scroll down one item
369                 if( ( it->parent()
370                       && next != it->parent()->end() )
371                     || &*it != m_pLastSelected )
372                 {
373                     (*it).m_selected = previousWasSelected;
374                 }
375                 if( previousWasSelected )
376                 {
377                     m_pLastSelected = &*it;
378                     needShow = true; toShow = it;
379                     previousWasSelected = false;
380                 }
381                 else
382                 {
383                     previousWasSelected = ( &*it == m_pLastSelected );
384                 }
385
386                 // Fix last tree item selection
387                 if( ( m_flat ? m_rTree.getNextLeaf( it )
388                     : m_rTree.getNextVisibleItem( it ) ) == m_rTree.end()
389                  && &*it == m_pLastSelected )
390                 {
391                     (*it).m_selected = true;
392                 }
393             }
394             else if( key == KEY_RIGHT )
395             {
396                 // Go down one level (and expand node)
397                 if( &*it == m_pLastSelected )
398                 {
399                     if( it->m_expanded )
400                     {
401                         if( it->size() )
402                         {
403                             it->m_selected = false;
404                             it->begin()->m_selected = true;
405                             m_pLastSelected = &*(it->begin());
406                         }
407                         else
408                         {
409                             m_rTree.action( &*it );
410                         }
411                     }
412                     else
413                     {
414                         it->m_expanded = true;
415                         bChangedPosition = true;
416                     }
417                 }
418             }
419             else if( key == KEY_LEFT )
420             {
421                 // Go up one level (and close node)
422                 if( &*it == m_pLastSelected )
423                 {
424                     if( it->m_expanded && it->size() )
425                     {
426                         it->m_expanded = false;
427                         bChangedPosition = true;
428                     }
429                     else
430                     {
431                         if( it->parent() && it->parent() != &m_rTree)
432                         {
433                             it->m_selected = false;
434                             m_pLastSelected = it->parent();
435                             m_pLastSelected->m_selected = true;
436                         }
437                     }
438                 }
439             }
440             else if( key == KEY_ENTER || key == ' ' )
441             {
442                 // Go up one level (and close node)
443                 if( &*it == m_pLastSelected )
444                 {
445                     m_rTree.action( &*it );
446                 }
447             }
448         }
449         if( needShow )
450             ensureVisible( toShow );
451
452         // Redraw the control
453         makeImage();
454         notifyLayout();
455     }
456
457     else if( rEvent.getAsString().find( "mouse:left" ) != string::npos )
458     {
459         EvtMouse &rEvtMouse = (EvtMouse&)rEvent;
460         const Position *pos = getPosition();
461         int yPos = ( rEvtMouse.getYPos() - pos->getTop() ) / itemHeight();
462         int xPos = rEvtMouse.getXPos() - pos->getLeft();
463         VarTree::Iterator it;
464
465         if( rEvent.getAsString().find( "mouse:left:down:ctrl,shift" ) !=
466             string::npos )
467         {
468             VarTree::Iterator itClicked = findItemAtPos( yPos );
469             // Flag to know if the current item must be selected
470             bool select = false;
471             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
472                  it != m_rTree.end();
473                  it = m_flat ? m_rTree.getNextLeaf( it )
474                              : m_rTree.getNextVisibleItem( it ) )
475             {
476                 bool nextSelect = select;
477                 if( it == itClicked || &*it == m_pLastSelected )
478                 {
479                     if( select )
480                     {
481                         nextSelect = false;
482                     }
483                     else
484                     {
485                         select = true;
486                         nextSelect = true;
487                     }
488                 }
489                 it->m_selected = (*it).m_selected || select;
490                 select = nextSelect;
491             }
492         }
493         else if( rEvent.getAsString().find( "mouse:left:down:ctrl" ) !=
494                  string::npos )
495         {
496             // Invert the selection of the item
497             it = findItemAtPos( yPos );
498             if( it != m_rTree.end() )
499             {
500                 it->m_selected = !it->m_selected;
501                 m_pLastSelected = &*it;
502             }
503         }
504         else if( rEvent.getAsString().find( "mouse:left:down:shift" ) !=
505                  string::npos )
506         {
507             VarTree::Iterator itClicked = findItemAtPos( yPos );
508             // Flag to know if the current item must be selected
509             bool select = false;
510             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
511                  it != m_rTree.end();
512                  it = m_flat ? m_rTree.getNextLeaf( it )
513                              : m_rTree.getNextVisibleItem( it ) )
514             {
515                 bool nextSelect = select;
516                 if( it == itClicked || &*it == m_pLastSelected )
517                 {
518                     if( select )
519                     {
520                         nextSelect = false;
521                     }
522                     else
523                     {
524                         select = true;
525                         nextSelect = true;
526                     }
527                 }
528                 it->m_selected = select;
529                 select = nextSelect;
530             }
531         }
532         else if( rEvent.getAsString().find( "mouse:left:down" ) !=
533                  string::npos )
534         {
535             it = findItemAtPos(yPos);
536             if( it != m_rTree.end() )
537             {
538                 if( ( it->size() && xPos > (it->depth() - 1) * itemImageWidth()
539                       && xPos < it->depth() * itemImageWidth() )
540                  && !m_flat )
541                 {
542                     // Fold/unfold the item
543                     it->m_expanded = !it->m_expanded;
544                     bChangedPosition = true;
545                 }
546                 else
547                 {
548                     // Unselect any previously selected item
549                     VarTree::Iterator it2;
550                     for( it2 = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
551                          it2 != m_rTree.end();
552                          it2 = m_flat ? m_rTree.getNextLeaf( it2 )
553                                       : m_rTree.getNextVisibleItem( it2 ) )
554                     {
555                         it2->m_selected = false;
556                     }
557                     // Select the new item
558                     if( it != m_rTree.end() )
559                     {
560                         it->m_selected = true;
561                         m_pLastSelected = &*it;
562                     }
563                 }
564             }
565         }
566
567         else if( rEvent.getAsString().find( "mouse:left:dblclick" ) !=
568                  string::npos )
569         {
570             it = findItemAtPos(yPos);
571             if( it != m_rTree.end() )
572             {
573                // Execute the action associated to this item
574                m_rTree.action( &*it );
575             }
576         }
577         // Redraw the control
578         makeImage();
579         notifyLayout();
580     }
581
582     else if( rEvent.getAsString().find( "scroll" ) != string::npos )
583     {
584         // XXX ctrl_slider.cpp has two more (but slightly different)
585         // XXX implementations of `scroll'. Figure out where it belongs.
586
587         int direction = static_cast<EvtScroll&>(rEvent).getDirection();
588
589         double percentage = m_rTree.getPositionVar().get();
590         double step = 2.0 / (double)( m_flat ? m_rTree.countLeafs()
591                                              : m_rTree.visibleItems() );
592         if( direction == EvtScroll::kUp )
593         {
594             percentage += step;
595         }
596         else
597         {
598             percentage -= step;
599         }
600         m_rTree.getPositionVar().set( percentage );
601     }
602
603     /* We changed the nodes, let's fix teh position var */
604     if( bChangedPosition )
605     {
606         VarTree::Iterator it;
607         int i = 0;
608         int iFirst = 0;
609         for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
610              it != m_rTree.end();
611              it = m_flat ? m_rTree.getNextLeaf( it )
612                          : m_rTree.getNextVisibleItem( it ) )
613         {
614             i++;
615             if( it == m_firstPos )
616             {
617                 iFirst = i;
618                 break;
619             }
620         }
621         iFirst += maxItems();
622         if( iFirst >= m_flat ? m_rTree.countLeafs() : m_rTree.visibleItems() )
623             iFirst = m_flat ? m_rTree.countLeafs() : m_rTree.visibleItems();
624         float f_new = (float)iFirst / (float)( m_flat ? m_rTree.countLeafs()
625                                                       :m_rTree.visibleItems() );
626         m_dontMove = true;
627         m_rTree.getPositionVar().set( 1.0 - f_new );
628         m_dontMove = false;
629     }
630 }
631
632 bool CtrlTree::mouseOver( int x, int y ) const
633 {
634     const Position *pPos = getPosition();
635     return !pPos ? false :
636         x >= 0 && x <= pPos->getWidth() && y >= 0 && y <= pPos->getHeight();
637 }
638
639 void CtrlTree::draw( OSGraphics &rImage, int xDest, int yDest, int w, int h)
640 {
641     const Position *pPos = getPosition();
642     rect region( pPos->getLeft(), pPos->getTop(),
643                  pPos->getWidth(), pPos->getHeight() );
644     rect clip( xDest, yDest, w, h );
645     rect inter;
646
647     if( rect::intersect( region, clip, &inter ) && m_pImage )
648         rImage.drawGraphics( *m_pImage,
649                       inter.x - pPos->getLeft(),
650                       inter.y - pPos->getTop(),
651                       inter.x, inter.y, inter.width, inter.height );
652 }
653
654 bool CtrlTree::ensureVisible( VarTree::Iterator item )
655 {
656     // Find the item to focus
657     int focusItemIndex = 0;
658     VarTree::Iterator it;
659
660     m_rTree.ensureExpanded( item );
661
662     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
663          it != m_rTree.end();
664          it = m_flat ? m_rTree.getNextLeaf( it )
665                      : m_rTree.getNextVisibleItem( it ) )
666     {
667         if( it->m_id == item->m_id ) break;
668         focusItemIndex++;
669     }
670    return ensureVisible( focusItemIndex );
671 }
672
673 bool CtrlTree::ensureVisible( int focusItemIndex )
674 {
675     // Find  m_firstPos
676     VarTree::Iterator it;
677     int firstPosIndex = 0;
678     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
679          it != m_rTree.end();
680          it = m_flat ? m_rTree.getNextLeaf( it )
681                      : m_rTree.getNextVisibleItem( it ) )
682     {
683         if( it == m_firstPos ) break;
684         firstPosIndex++;
685     }
686
687     if( it == m_rTree.end() ) return false;
688
689
690     if( it != m_rTree.end()
691         && ( focusItemIndex < firstPosIndex
692            || focusItemIndex > firstPosIndex + maxItems() ) )
693     {
694         // Scroll to have the wanted stream visible
695         VarPercent &rVarPos = m_rTree.getPositionVar();
696         rVarPos.set( 1.0 - (double)focusItemIndex /
697                            (double)( m_flat ? m_rTree.countLeafs()
698                                             : m_rTree.visibleItems() ) );
699         return true;
700     }
701     return false;
702 }
703
704 void CtrlTree::autoScroll()
705 {
706     // Find the current playing stream
707     int playIndex = 0;
708     VarTree::Iterator it;
709
710     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
711          it != m_rTree.end();
712          it = m_flat ? m_rTree.getNextLeaf( it )
713                      : m_rTree.getNextItem( it ) )
714     {
715         if( it->m_playing )
716         {
717            m_rTree.ensureExpanded( it );
718            break;
719         }
720     }
721     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
722          it != m_rTree.end();
723          it = m_flat ? m_rTree.getNextLeaf( it )
724                      : m_rTree.getNextVisibleItem( it ) )
725     {
726         if( it->m_playing )
727            break;
728         playIndex++;
729     }
730
731     if( it == m_rTree.end() ) return;
732
733
734     ensureVisible( playIndex );
735 }
736
737
738 void CtrlTree::makeImage()
739 {
740     stats_TimerStart( getIntf(), "[Skins] Playlist image",
741                       STATS_TIMER_SKINS_PLAYTREE_IMAGE );
742     delete m_pImage;
743
744     // Get the size of the control
745     const Position *pPos = getPosition();
746     if( !pPos )
747     {
748         stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
749         return;
750     }
751     int width = pPos->getWidth();
752     int height = pPos->getHeight();
753
754     int i_itemHeight = itemHeight();
755
756     // Create an image
757     OSFactory *pOsFactory = OSFactory::instance( getIntf() );
758     m_pImage = pOsFactory->createOSGraphics( width, height );
759
760     VarTree::Iterator it = m_firstPos;
761
762     if( m_pBgBitmap )
763     {
764         // Draw the background bitmap
765         ScaledBitmap bmp( getIntf(), *m_pBgBitmap, width, height );
766         m_pImage->drawBitmap( bmp, 0, 0 );
767
768         for( int yPos = 0; yPos < height; yPos += i_itemHeight )
769         {
770             if( it != m_rTree.end() )
771             {
772                 if( (*it).m_selected )
773                 {
774                     int rectHeight = __MIN( i_itemHeight, height - yPos );
775                     m_pImage->fillRect( 0, yPos, width, rectHeight,
776                                         m_selColor );
777                 }
778                 do
779                 {
780                     it = m_flat ? m_rTree.getNextLeaf( it )
781                                 : m_rTree.getNextVisibleItem( it );
782                 } while( it != m_rTree.end() && it->m_deleted );
783             }
784         }
785     }
786     else
787     {
788         // FIXME (TRYME)
789         // Fill background with background color
790         uint32_t bgColor = m_bgColor1;
791         m_pImage->fillRect( 0, 0, width, height, bgColor );
792         for( int yPos = 0; yPos < height; yPos += i_itemHeight )
793         {
794             int rectHeight = __MIN( i_itemHeight, height - yPos );
795             if( it == m_rTree.end() )
796                 m_pImage->fillRect( 0, yPos, width, rectHeight, bgColor );
797             else
798             {
799                 uint32_t color = ( it->m_selected ? m_selColor : bgColor );
800                 m_pImage->fillRect( 0, yPos, width, rectHeight, color );
801                 do
802                 {
803                     it = m_flat ? m_rTree.getNextLeaf( it )
804                                 : m_rTree.getNextVisibleItem( it );
805                 } while( it != m_rTree.end() && it->m_deleted );
806             }
807             bgColor = ( bgColor == m_bgColor1 ? m_bgColor2 : m_bgColor1 );
808         }
809     }
810
811     int bitmapWidth = itemImageWidth();
812
813     int yPos = 0;
814     it = m_firstPos;
815     while( it != m_rTree.end() && yPos < height )
816     {
817         const GenericBitmap *m_pCurBitmap;
818         UString *pStr = (UString*)(it->m_cString.get());
819         uint32_t color = ( it->m_playing ? m_playColor : m_fgColor );
820
821         // Draw the text
822         if( pStr != NULL )
823         {
824             int depth = m_flat ? 1 : it->depth();
825             GenericBitmap *pText = m_rFont.drawString( *pStr, color, width - bitmapWidth * depth );
826             if( !pText )
827             {
828                 stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
829                 return;
830             }
831             if( it->size() )
832                 m_pCurBitmap = it->m_expanded ? m_pOpenBitmap : m_pClosedBitmap;
833             else
834                 m_pCurBitmap = m_pItemBitmap;
835
836             if( m_pCurBitmap )
837             {
838                 // Make sure we are centered on the line
839                 int yPos2 = yPos+(i_itemHeight-m_pCurBitmap->getHeight()+1)/2;
840                 if( yPos2 >= height )
841                 {
842                     delete pText;
843                     break;
844                 }
845                 m_pImage->drawBitmap( *m_pCurBitmap, 0, 0,
846                                       bitmapWidth * (depth - 1 ), yPos2,
847                                       m_pCurBitmap->getWidth(),
848                                       __MIN( m_pCurBitmap->getHeight(),
849                                              height -  yPos2), true );
850             }
851             yPos += i_itemHeight - pText->getHeight();
852             int ySrc = 0;
853             if( yPos < 0 )
854             {
855                 ySrc = - yPos;
856                 yPos = 0;
857             }
858             int lineHeight = __MIN( pText->getHeight() - ySrc, height - yPos );
859             m_pImage->drawBitmap( *pText, 0, ySrc, bitmapWidth * depth, yPos,
860                                   pText->getWidth(),
861                                   lineHeight, true );
862             yPos += (pText->getHeight() - ySrc );
863             delete pText;
864         }
865         do
866         {
867             it = m_flat ? m_rTree.getNextLeaf( it )
868                 : m_rTree.getNextVisibleItem( it );
869         } while( it != m_rTree.end() && it->m_deleted );
870     }
871     stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
872 }
873
874 VarTree::Iterator CtrlTree::findItemAtPos( int pos )
875 {
876     // The first item is m_firstPos.
877     // We decrement pos as we try the other items, until pos == 0.
878     VarTree::Iterator it;
879     for( it = m_firstPos; it != m_rTree.end() && pos != 0;
880          it = m_flat ? m_rTree.getNextLeaf( it )
881                      : m_rTree.getNextVisibleItem( it ) )
882     {
883         pos--;
884     }
885
886     return it;
887 }