git.sesse.net Git - vlc/blob - 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         }
 516         else if( rEvent.getAsString().find( "mouse:left:down:ctrl" ) !=
 517                  string::npos )
 518         {
 519             // Invert the selection of the item
 520             it = findItemAtPos( yPos );
 521             if( it != m_rTree.end() )
 522             {
 523                 it->m_selected = !it->m_selected;
 524                 m_pLastSelected = &*it;
 525             }
 526         }
 527         else if( rEvent.getAsString().find( "mouse:left:down:shift" ) !=
 528                  string::npos )
 529         {
 530             VarTree::Iterator itClicked = findItemAtPos( yPos );
 531             // Flag to know if the current item must be selected
 532             bool select = false;
 533             for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 534                  it != m_rTree.end();
 535                  it = m_flat ? m_rTree.getNextLeaf( it )
 536                              : m_rTree.getNextVisibleItem( it ) )
 537             {
 538                 bool nextSelect = select;
 539                 if( it == itClicked || &*it == m_pLastSelected )
 540                 {
 541                     if( select )
 542                     {
 543                         nextSelect = false;
 544                     }
 545                     else
 546                     {
 547                         select = true;
 548                         nextSelect = true;
 549                     }
 550                 }
 551                 it->m_selected = select;
 552                 select = nextSelect;
 553             }
 554         }
 555         else if( rEvent.getAsString().find( "mouse:left:down" ) !=
 556                  string::npos )
 557         {
 558             it = findItemAtPos(yPos);
 559             if( it != m_rTree.end() )
 560             {
 561                 if( ( it->size() && xPos > (it->depth() - 1) * itemImageWidth()
 562                       && xPos < it->depth() * itemImageWidth() )
 563                  && !m_flat )
 564                 {
 565                     // Fold/unfold the item
 566                     it->m_expanded = !it->m_expanded;
 567                     bChangedPosition = true;
 568                 }
 569                 else
 570                 {
 571                     // Unselect any previously selected item
 572                     VarTree::Iterator it2;
 573                     for( it2 = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 574                          it2 != m_rTree.end();
 575                          it2 = m_flat ? m_rTree.getNextLeaf( it2 )
 576                                       : m_rTree.getNextVisibleItem( it2 ) )
 577                     {
 578                         it2->m_selected = false;
 579                     }
 580                     // Select the new item
 581                     if( it != m_rTree.end() )
 582                     {
 583                         it->m_selected = true;
 584                         m_pLastSelected = &*it;
 585                     }
 586                 }
 587             }
 588         }
 589
 590         else if( rEvent.getAsString().find( "mouse:left:dblclick" ) !=
 591                  string::npos )
 592         {
 593             it = findItemAtPos(yPos);
 594             if( it != m_rTree.end() )
 595             {
 596                // Execute the action associated to this item
 597                m_rTree.action( &*it );
 598             }
 599         }
 600         // Redraw the control
 601         makeImage();
 602         notifyLayout();
 603     }
 604
 605     else if( rEvent.getAsString().find( "scroll" ) != string::npos )
 606     {
 607         // XXX ctrl_slider.cpp has two more (but slightly different)
 608         // XXX implementations of `scroll'. Figure out where it belongs.
 609
 610         int direction = static_cast<EvtScroll&>(rEvent).getDirection();
 611
 612         double percentage = m_rTree.getPositionVar().get();
 613         double step = 2.0 / (double)( m_flat ? m_rTree.countLeafs()
 614                                              : m_rTree.visibleItems() );
 615         if( direction == EvtScroll::kUp )
 616         {
 617             percentage += step;
 618         }
 619         else
 620         {
 621             percentage -= step;
 622         }
 623         m_rTree.getPositionVar().set( percentage );
 624     }
 625
 626     /* We changed the nodes, let's fix the position var */
 627     if( bChangedPosition )
 628     {
 629         VarTree::Iterator it;
 630         int iFirst = 0;
 631         for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 632              it != m_rTree.end();
 633              it = m_flat ? m_rTree.getNextLeaf( it )
 634                          : m_rTree.getNextVisibleItem( it ) )
 635         {
 636             if( it == m_firstPos )
 637                 break;
 638             iFirst++;
 639         }
 640
 641         int indexMax = ( m_flat ? m_rTree.countLeafs()
 642                                 : m_rTree.visibleItems() ) - 1;
 643         float f_new = (float)iFirst / (float)indexMax;
 644
 645         m_dontMove = true;
 646         m_rTree.getPositionVar().set( 1.0 - f_new );
 647         m_dontMove = false;
 648     }
 649 }
 650
 651 bool CtrlTree::mouseOver( int x, int y ) const
 652 {
 653     const Position *pPos = getPosition();
 654     return !pPos ? false :
 655         x >= 0 && x <= pPos->getWidth() && y >= 0 && y <= pPos->getHeight();
 656 }
 657
 658 void CtrlTree::draw( OSGraphics &rImage, int xDest, int yDest, int w, int h)
 659 {
 660     const Position *pPos = getPosition();
 661     rect region( pPos->getLeft(), pPos->getTop(),
 662                  pPos->getWidth(), pPos->getHeight() );
 663     rect clip( xDest, yDest, w, h );
 664     rect inter;
 665
 666     if( rect::intersect( region, clip, &inter ) && m_pImage )
 667         rImage.drawGraphics( *m_pImage,
 668                       inter.x - pPos->getLeft(),
 669                       inter.y - pPos->getTop(),
 670                       inter.x, inter.y, inter.width, inter.height );
 671 }
 672
 673 bool CtrlTree::ensureVisible( VarTree::Iterator item )
 674 {
 675     // Find the item to focus
 676     int focusItemIndex = 0;
 677     VarTree::Iterator it;
 678
 679     m_rTree.ensureExpanded( item );
 680
 681     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 682          it != m_rTree.end();
 683          it = m_flat ? m_rTree.getNextLeaf( it )
 684                      : m_rTree.getNextVisibleItem( it ) )
 685     {
 686         if( it->m_id == item->m_id ) break;
 687         focusItemIndex++;
 688     }
 689    return ensureVisible( focusItemIndex );
 690 }
 691
 692 bool CtrlTree::ensureVisible( int focusItemIndex )
 693 {
 694     // Find  m_firstPos
 695     VarTree::Iterator it;
 696     int firstPosIndex = 0;
 697     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 698          it != m_rTree.end();
 699          it = m_flat ? m_rTree.getNextLeaf( it )
 700                      : m_rTree.getNextVisibleItem( it ) )
 701     {
 702         if( it == m_firstPos ) break;
 703         firstPosIndex++;
 704     }
 705
 706     if( it == m_rTree.end() ) return false;
 707
 708
 709     if( it != m_rTree.end()
 710         && ( focusItemIndex < firstPosIndex
 711            || focusItemIndex > firstPosIndex + maxItems() - 1 ) )
 712     {
 713         // Scroll to have the wanted stream visible
 714         VarPercent &rVarPos = m_rTree.getPositionVar();
 715         int indexMax = ( m_flat ? m_rTree.countLeafs()
 716                                 : m_rTree.visibleItems() ) - 1;
 717         rVarPos.set( 1.0 - (double)focusItemIndex / (double)indexMax );
 718         return true;
 719     }
 720     return false;
 721 }
 722
 723 void CtrlTree::autoScroll()
 724 {
 725     // Find the current playing stream
 726     int playIndex = 0;
 727     VarTree::Iterator it;
 728
 729     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 730          it != m_rTree.end();
 731          it = m_flat ? m_rTree.getNextLeaf( it )
 732                      : m_rTree.getNextItem( it ) )
 733     {
 734         if( it->m_playing )
 735         {
 736            m_rTree.ensureExpanded( it );
 737            break;
 738         }
 739     }
 740
 741     for( it = m_flat ? m_rTree.firstLeaf() : m_rTree.begin();
 742          it != m_rTree.end();
 743          it = m_flat ? m_rTree.getNextLeaf( it )
 744                      : m_rTree.getNextVisibleItem( it ) )
 745     {
 746         if( it->m_playing )
 747         {
 748            ensureVisible( playIndex );
 749            break;
 750         }
 751         playIndex++;
 752     }
 753 }
 754
 755
 756 void CtrlTree::makeImage()
 757 {
 758     stats_TimerStart( getIntf(), "[Skins] Playlist image",
 759                       STATS_TIMER_SKINS_PLAYTREE_IMAGE );
 760     delete m_pImage;
 761
 762     // Get the size of the control
 763     const Position *pPos = getPosition();
 764     if( !pPos )
 765     {
 766         stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
 767         return;
 768     }
 769     int width = pPos->getWidth();
 770     int height = pPos->getHeight();
 771
 772     int i_itemHeight = itemHeight();
 773
 774     // Create an image
 775     OSFactory *pOsFactory = OSFactory::instance( getIntf() );
 776     m_pImage = pOsFactory->createOSGraphics( width, height );
 777
 778     VarTree::Iterator it = m_firstPos;
 779
 780     if( m_pBgBitmap )
 781     {
 782         // Draw the background bitmap
 783         ScaledBitmap bmp( getIntf(), *m_pBgBitmap, width, height );
 784         m_pImage->drawBitmap( bmp, 0, 0 );
 785
 786         for( int yPos = 0; yPos < height; yPos += i_itemHeight )
 787         {
 788             if( it != m_rTree.end() )
 789             {
 790                 if( (*it).m_selected )
 791                 {
 792                     int rectHeight = __MIN( i_itemHeight, height - yPos );
 793                     m_pImage->fillRect( 0, yPos, width, rectHeight,
 794                                         m_selColor );
 795                 }
 796                 do
 797                 {
 798                     it = m_flat ? m_rTree.getNextLeaf( it )
 799                                 : m_rTree.getNextVisibleItem( it );
 800                 } while( it != m_rTree.end() && it->m_deleted );
 801             }
 802         }
 803     }
 804     else
 805     {
 806         // FIXME (TRYME)
 807         // Fill background with background color
 808         uint32_t bgColor = m_bgColor1;
 809         m_pImage->fillRect( 0, 0, width, height, bgColor );
 810         for( int yPos = 0; yPos < height; yPos += i_itemHeight )
 811         {
 812             int rectHeight = __MIN( i_itemHeight, height - yPos );
 813             if( it == m_rTree.end() )
 814                 m_pImage->fillRect( 0, yPos, width, rectHeight, bgColor );
 815             else
 816             {
 817                 uint32_t color = ( it->m_selected ? m_selColor : bgColor );
 818                 m_pImage->fillRect( 0, yPos, width, rectHeight, color );
 819                 do
 820                 {
 821                     it = m_flat ? m_rTree.getNextLeaf( it )
 822                                 : m_rTree.getNextVisibleItem( it );
 823                 } while( it != m_rTree.end() && it->m_deleted );
 824             }
 825             bgColor = ( bgColor == m_bgColor1 ? m_bgColor2 : m_bgColor1 );
 826         }
 827     }
 828
 829     int bitmapWidth = itemImageWidth();
 830
 831     int yPos = 0;
 832     it = m_firstPos;
 833     while( it != m_rTree.end() && yPos < height )
 834     {
 835         const GenericBitmap *m_pCurBitmap;
 836         UString *pStr = (UString*)(it->m_cString.get());
 837         uint32_t color = ( it->m_playing ? m_playColor : m_fgColor );
 838
 839         // Draw the text
 840         if( pStr != NULL )
 841         {
 842             int depth = m_flat ? 1 : it->depth();
 843             GenericBitmap *pText = m_rFont.drawString( *pStr, color, width - bitmapWidth * depth );
 844             if( !pText )
 845             {
 846                 stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
 847                 return;
 848             }
 849             if( it->size() )
 850                 m_pCurBitmap = it->m_expanded ? m_pOpenBitmap : m_pClosedBitmap;
 851             else
 852                 m_pCurBitmap = m_pItemBitmap;
 853
 854             if( m_pCurBitmap )
 855             {
 856                 // Make sure we are centered on the line
 857                 int yPos2 = yPos+(i_itemHeight-m_pCurBitmap->getHeight()+1)/2;
 858                 if( yPos2 >= height )
 859                 {
 860                     delete pText;
 861                     break;
 862                 }
 863                 m_pImage->drawBitmap( *m_pCurBitmap, 0, 0,
 864                                       bitmapWidth * (depth - 1 ), yPos2,
 865                                       m_pCurBitmap->getWidth(),
 866                                       __MIN( m_pCurBitmap->getHeight(),
 867                                              height -  yPos2), true );
 868             }
 869             yPos += i_itemHeight - pText->getHeight();
 870             int ySrc = 0;
 871             if( yPos < 0 )
 872             {
 873                 ySrc = - yPos;
 874                 yPos = 0;
 875             }
 876             int lineHeight = __MIN( pText->getHeight() - ySrc, height - yPos );
 877             m_pImage->drawBitmap( *pText, 0, ySrc, bitmapWidth * depth, yPos,
 878                                   pText->getWidth(),
 879                                   lineHeight, true );
 880             yPos += (pText->getHeight() - ySrc );
 881             delete pText;
 882         }
 883         do
 884         {
 885             it = m_flat ? m_rTree.getNextLeaf( it )
 886                 : m_rTree.getNextVisibleItem( it );
 887         } while( it != m_rTree.end() && it->m_deleted );
 888     }
 889     stats_TimerStop( getIntf(), STATS_TIMER_SKINS_PLAYTREE_IMAGE );
 890 }
 891
 892 VarTree::Iterator CtrlTree::findItemAtPos( int pos )
 893 {
 894     // The first item is m_firstPos.
 895     // We decrement pos as we try the other items, until pos == 0.
 896     VarTree::Iterator it;
 897     for( it = m_firstPos; it != m_rTree.end() && pos != 0;
 898          it = m_flat ? m_rTree.getNextLeaf( it )
 899                      : m_rTree.getNextVisibleItem( it ) )
 900     {
 901         pos--;
 902     }
 903
 904     return it;
 905 }