git.sesse.net Git - vlc/blob - modules/gui/qt4/components/playlist/standardpanel.cpp

   1 /*****************************************************************************
   2  * standardpanel.cpp : The "standard" playlist panel : just a treeview
   3  ****************************************************************************
   4  * Copyright © 2000-2010 VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *          Jean-Baptiste Kempf <jb@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 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include "components/playlist/standardpanel.hpp"
  30
  31 #include "components/playlist/vlc_model.hpp"      /* VLCModel */
  32 #include "components/playlist/playlist_model.hpp" /* PLModel */
  33 #include "components/playlist/ml_model.hpp"       /* MLModel */
  34 #include "components/playlist/views.hpp"          /* 3 views */
  35 #include "components/playlist/selector.hpp"       /* PLSelector */
  36 #include "menus.hpp"                              /* Popup */
  37 #include "input_manager.hpp"                      /* THEMIM */
  38 #include "dialogs_provider.hpp"                   /* THEDP */
  39 #include "dialogs/playlist.hpp"                   /* Playlist Dialog */
  40 #include "dialogs/mediainfo.hpp"                  /* MediaInfoDialog */
  41
  42 #include <vlc_services_discovery.h>               /* SD_CMD_SEARCH */
  43 #include <vlc_intf_strings.h>                     /* POP_ */
  44
  45 #define I_NEW_DIR \
  46     I_DIR_OR_FOLDER( N_("Create Directory"), N_( "Create Folder" ) )
  47 #define I_NEW_DIR_NAME \
  48     I_DIR_OR_FOLDER( N_( "Enter name for new directory:" ), \
  49                      N_( "Enter name for new folder:" ) )
  50
  51 #include <QHeaderView>
  52 #include <QMenu>
  53 #include <QKeyEvent>
  54 #include <QWheelEvent>
  55 #include <QStackedLayout>
  56 #include <QSignalMapper>
  57 #include <QSettings>
  58 #include <QStylePainter>
  59 #include <QInputDialog>
  60 #include <QDesktopServices>
  61 #include <QUrl>
  62 #include <QFont>
  63
  64 #include <assert.h>
  65
  66 StandardPLPanel::StandardPLPanel( PlaylistWidget *_parent,
  67                                   intf_thread_t *_p_intf,
  68                                   playlist_item_t *p_root,
  69                                   PLSelector *_p_selector,
  70                                   PLModel *_p_model,
  71                                   MLModel *_p_plmodel)
  72                 : QWidget( _parent ),
  73                   model( _p_model ),
  74                   mlmodel( _p_plmodel),
  75                   p_intf( _p_intf ),
  76                   p_selector( _p_selector )
  77 {
  78     viewStack = new QStackedLayout( this );
  79     viewStack->setSpacing( 0 ); viewStack->setMargin( 0 );
  80     setMinimumWidth( 300 );
  81
  82     iconView    = NULL;
  83     treeView    = NULL;
  84     listView    = NULL;
  85     picFlowView = NULL;
  86
  87     currentRootIndexId  = -1;
  88     lastActivatedId     = -1;
  89
  90     /* Saved Settings */
  91     int i_savedViewMode = getSettings()->value( "Playlist/view-mode", TREE_VIEW ).toInt();
  92     i_zoom = getSettings()->value( "Playlist/zoom", 0 ).toInt();
  93
  94     showView( i_savedViewMode );
  95
  96     DCONNECT( THEMIM, leafBecameParent( int ),
  97               this, browseInto( int ) );
  98
  99     CONNECT( model, currentIndexChanged( const QModelIndex& ),
 100              this, handleExpansion( const QModelIndex& ) );
 101     CONNECT( model, rootIndexChanged(), this, browseInto() );
 102
 103     setRootItem( p_root, false );
 104 }
 105
 106 StandardPLPanel::~StandardPLPanel()
 107 {
 108     getSettings()->beginGroup("Playlist");
 109     if( treeView )
 110         getSettings()->setValue( "headerStateV2", treeView->header()->saveState() );
 111     getSettings()->setValue( "view-mode", currentViewIndex() );
 112     getSettings()->setValue( "zoom", i_zoom );
 113     getSettings()->endGroup();
 114 }
 115
 116 /* Unused anymore, but might be useful, like in right-click menu */
 117 void StandardPLPanel::gotoPlayingItem()
 118 {
 119     currentView->scrollTo( model->currentIndex() );
 120 }
 121
 122 void StandardPLPanel::handleExpansion( const QModelIndex& index )
 123 {
 124     assert( currentView );
 125     if( currentRootIndexId != -1 && currentRootIndexId != model->itemId( index.parent() ) )
 126         browseInto( index.parent() );
 127     currentView->scrollTo( index );
 128 }
 129
 130 void StandardPLPanel::popupPlView( const QPoint &point )
 131 {
 132     QModelIndex index = currentView->indexAt( point );
 133     QPoint globalPoint = currentView->viewport()->mapToGlobal( point );
 134     QItemSelectionModel *selection = currentView->selectionModel();
 135     QModelIndexList list = selection->selectedRows();
 136
 137     if( !popup( index, globalPoint, list ) )
 138         VLCMenuBar::PopupMenu( p_intf, true );
 139 }
 140
 141 /*********** Popup *********/
 142 bool StandardPLPanel::popup( const QModelIndex & index, const QPoint &point, const QModelIndexList &selectionlist )
 143 {
 144     VLCModel *model = qobject_cast<VLCModel*>(currentView->model());
 145     QModelIndexList callerAsList;
 146     callerAsList << ( index.isValid() ? index : QModelIndex() );
 147     popupIndex = index; /* suitable for modal only */
 148
 149 #define ADD_MENU_ENTRY( icon, title, act, data ) \
 150     action = menu.addAction( icon, title ); \
 151     container.action = act; \
 152     container.indexes = data; \
 153     action->setData( QVariant::fromValue( container ) )
 154
 155     /* */
 156     QMenu menu;
 157     QAction *action;
 158     PLModel::actionsContainerType container;
 159
 160     /* Play/Stream/Info static actions */
 161     if( index.isValid() )
 162     {
 163         ADD_MENU_ENTRY( QIcon( ":/menu/play" ), qtr(I_POP_PLAY),
 164                         container.ACTION_PLAY, callerAsList );
 165
 166         menu.addAction( QIcon( ":/menu/stream" ), qtr(I_POP_STREAM),
 167                         this, SLOT( popupStream() ) );
 168
 169         menu.addAction( QIcon(), qtr(I_POP_SAVE),
 170                         this, SLOT( popupSave() ) );
 171
 172         menu.addAction( QIcon( ":/menu/info" ), qtr(I_POP_INFO),
 173                         this, SLOT( popupInfoDialog() ) );
 174
 175         menu.addSeparator();
 176
 177         if( model->getURI( index ).startsWith( "file://" ) )
 178             menu.addAction( QIcon( ":/type/folder-grey" ), qtr(I_POP_EXPLORE),
 179                             this, SLOT( popupExplore() ) );
 180     }
 181
 182     /* In PL or ML, allow to add a file/folder */
 183     if( model->canEdit() )
 184     {
 185         QIcon addIcon( ":/buttons/playlist/playlist_add" );
 186
 187         if( model->isTree() )
 188             menu.addAction( addIcon, qtr(I_POP_NEWFOLDER),
 189                             this, SLOT( popupPromptAndCreateNode() ) );
 190
 191         menu.addSeparator();
 192         if( model->isCurrentItem( model->rootIndex(), PLModel::IN_PLAYLIST ) )
 193         {
 194             menu.addAction( addIcon, qtr(I_PL_ADDF), THEDP, SLOT( simplePLAppendDialog()) );
 195             menu.addAction( addIcon, qtr(I_PL_ADDDIR), THEDP, SLOT( PLAppendDir()) );
 196             menu.addAction( addIcon, qtr(I_OP_ADVOP), THEDP, SLOT( PLAppendDialog()) );
 197         }
 198         else if( model->isCurrentItem( model->rootIndex(), PLModel::IN_MEDIALIBRARY ) )
 199         {
 200             menu.addAction( addIcon, qtr(I_PL_ADDF), THEDP, SLOT( simpleMLAppendDialog()) );
 201             menu.addAction( addIcon, qtr(I_PL_ADDDIR), THEDP, SLOT( MLAppendDir() ) );
 202             menu.addAction( addIcon, qtr(I_OP_ADVOP), THEDP, SLOT( MLAppendDialog() ) );
 203         }
 204     }
 205
 206     if( index.isValid() )
 207     {
 208         if( !model->isCurrentItem( model->rootIndex(), PLModel::IN_PLAYLIST ) )
 209         {
 210             ADD_MENU_ENTRY( QIcon(), qtr("Add to playlist"),
 211                             container.ACTION_ADDTOPLAYLIST, selectionlist );
 212         }
 213     }
 214
 215     menu.addSeparator();
 216
 217     /* Item removal */
 218     if( index.isValid() )
 219     {
 220         ADD_MENU_ENTRY( QIcon( ":/buttons/playlist/playlist_remove" ), qtr(I_POP_DEL),
 221                         container.ACTION_REMOVE, selectionlist );
 222     }
 223
 224     if( model->canEdit() ) {
 225         menu.addAction( QIcon( ":/toolbar/clear" ), qtr("Clear playlist"),
 226                         model, SLOT( clearPlaylist() ) );
 227     }
 228
 229     menu.addSeparator();
 230
 231     /* Playlist sorting */
 232     QMenu *sortingMenu = new QMenu( qtr( "Sort by" ) );
 233     /* Choose what columns to show in sorting menu, not sure if this should be configurable*/
 234     QList<int> sortingColumns;
 235     sortingColumns << COLUMN_TITLE << COLUMN_ARTIST << COLUMN_ALBUM << COLUMN_TRACK_NUMBER << COLUMN_URI;
 236     container.action = container.ACTION_SORT;
 237     container.indexes = callerAsList;
 238     foreach( int Column, sortingColumns )
 239     {
 240         action = sortingMenu->addAction( qfu( psz_column_title( Column ) ) + " " + qtr("Ascending") );
 241         container.column = model->columnFromMeta(Column) + 1;
 242         action->setData( QVariant::fromValue( container ) );
 243
 244         action = sortingMenu->addAction( qfu( psz_column_title( Column ) ) + " " + qtr("Descending") );
 245         container.column = -1 * (model->columnFromMeta(Column)+1);
 246         action->setData( QVariant::fromValue( container ) );
 247     }
 248     menu.addMenu( sortingMenu );
 249
 250     /* Zoom */
 251     QMenu *zoomMenu = new QMenu( qtr( "Display size" ) );
 252     zoomMenu->addAction( qtr( "Increase" ), this, SLOT( increaseZoom() ) );
 253     zoomMenu->addAction( qtr( "Decrease" ), this, SLOT( decreaseZoom() ) );
 254     menu.addMenu( zoomMenu );
 255
 256     CONNECT( &menu, triggered( QAction * ), model, actionSlot( QAction * ) );
 257
 258     QMenu *viewMenu = new QMenu( qtr( "Playlist View Mode" ) );
 259
 260     /* View selection menu */
 261     QSignalMapper *viewSelectionMapper = new QSignalMapper( this );
 262     CONNECT( viewSelectionMapper, mapped( int ), this, showView( int ) );
 263
 264     QActionGroup *viewGroup = new QActionGroup( this );
 265 # define MAX_VIEW StandardPLPanel::VIEW_COUNT
 266     for( int i = 0; i < MAX_VIEW; i++ )
 267     {
 268         QAction *action = viewMenu->addAction( viewNames[i] );
 269         action->setCheckable( true );
 270         viewGroup->addAction( action );
 271         viewSelectionMapper->setMapping( action, i );
 272         CONNECT( action, triggered(), viewSelectionMapper, map() );
 273         if( currentViewIndex() == i )
 274             action->setChecked( true );
 275     }
 276     menu.addMenu( viewMenu );
 277
 278     /* Display and forward the result */
 279     if( !menu.isEmpty() )
 280     {
 281         menu.exec( point ); return true;
 282     }
 283     else return false;
 284
 285 #undef ADD_MENU_ENTRY
 286 }
 287
 288 void StandardPLPanel::popupSelectColumn( QPoint )
 289 {
 290     QMenu menu;
 291     assert( treeView );
 292
 293     /* We do not offer the option to hide index 0 column, or
 294      * QTreeView will behave weird */
 295     for( int i = 1 << 1, j = 1; i < COLUMN_END; i <<= 1, j++ )
 296     {
 297         QAction* option = menu.addAction( qfu( psz_column_title( i ) ) );
 298         option->setCheckable( true );
 299         option->setChecked( !treeView->isColumnHidden( j ) );
 300         selectColumnsSigMapper->setMapping( option, j );
 301         CONNECT( option, triggered(), selectColumnsSigMapper, map() );
 302     }
 303     menu.exec( QCursor::pos() );
 304 }
 305
 306 void StandardPLPanel::popupPromptAndCreateNode()
 307 {
 308     bool ok;
 309     QString name = QInputDialog::getText( PlaylistDialog::getInstance( p_intf ),
 310         qtr( I_NEW_DIR ), qtr( I_NEW_DIR_NAME ),
 311         QLineEdit::Normal, QString(), &ok);
 312     if ( !ok ) return;
 313     qobject_cast<VLCModel *>(currentView->model())->createNode( popupIndex, name );
 314 }
 315
 316 void StandardPLPanel::popupInfoDialog()
 317 {
 318     if( popupIndex.isValid() )
 319     {
 320         VLCModel *model = qobject_cast<VLCModel *>(currentView->model());
 321         input_item_t* p_input = model->getInputItem( popupIndex );
 322         MediaInfoDialog *mid = new MediaInfoDialog( p_intf, p_input );
 323         mid->setParent( PlaylistDialog::getInstance( p_intf ),
 324                         Qt::Dialog );
 325         mid->show();
 326     }
 327 }
 328
 329 void StandardPLPanel::popupExplore()
 330 {
 331     VLCModel *model = qobject_cast<VLCModel *>(currentView->model());
 332     QString uri = model->getURI( popupIndex );
 333     char *path = NULL;
 334
 335     if( ! uri.isEmpty() )
 336         path = make_path( uri.toAscii().constData() );
 337
 338     if( path == NULL )
 339         return;
 340
 341     QDesktopServices::openUrl(
 342                 QUrl::fromLocalFile( QFileInfo( qfu( path ) ).absolutePath() ) );
 343
 344     free( path );
 345 }
 346
 347 void StandardPLPanel::popupStream()
 348 {
 349     VLCModel *model = qobject_cast<VLCModel *>(currentView->model());
 350     QString uri = model->getURI( popupIndex );
 351     if ( ! uri.isEmpty() )
 352         THEDP->streamingDialog( NULL, uri, false );
 353 }
 354
 355 void StandardPLPanel::popupSave()
 356 {
 357     VLCModel *model = qobject_cast<VLCModel *>(currentView->model());
 358     QString uri = model->getURI( popupIndex );
 359     if ( ! uri.isEmpty() )
 360         THEDP->streamingDialog( NULL, uri );
 361 }
 362
 363 void StandardPLPanel::toggleColumnShown( int i )
 364 {
 365     treeView->setColumnHidden( i, !treeView->isColumnHidden( i ) );
 366 }
 367
 368 /* Search in the playlist */
 369 void StandardPLPanel::search( const QString& searchText )
 370 {
 371     int type;
 372     QString name;
 373     bool can_search;
 374     p_selector->getCurrentItemInfos( &type, &can_search, &name );
 375
 376     if( type != SD_TYPE || !can_search )
 377     {
 378         bool flat = ( currentView == iconView ||
 379                       currentView == listView ||
 380                       currentView == picFlowView );
 381         model->search( searchText,
 382                        flat ? currentView->rootIndex() : QModelIndex(),
 383                        !flat );
 384     }
 385 }
 386
 387 void StandardPLPanel::searchDelayed( const QString& searchText )
 388 {
 389     int type;
 390     QString name;
 391     bool can_search;
 392     p_selector->getCurrentItemInfos( &type, &can_search, &name );
 393
 394     if( type == SD_TYPE && can_search )
 395     {
 396         if( !name.isEmpty() && !searchText.isEmpty() )
 397             playlist_ServicesDiscoveryControl( THEPL, qtu( name ), SD_CMD_SEARCH,
 398                                               qtu( searchText ) );
 399     }
 400 }
 401
 402 /* Set the root of the new Playlist */
 403 /* This activated by the selector selection */
 404 void StandardPLPanel::setRootItem( playlist_item_t *p_item, bool b )
 405 {
 406 #ifdef MEDIA_LIBRARY
 407     if( b )
 408     {
 409         msg_Dbg( p_intf, "Setting the SQL ML" );
 410         currentView->setModel( mlmodel );
 411     }
 412     else
 413 #else
 414     Q_UNUSED( b );
 415 #endif
 416     {
 417         if( currentView->model() != model )
 418             currentView->setModel( model );
 419         model->rebuild( p_item );
 420     }
 421 }
 422
 423 void StandardPLPanel::browseInto( const QModelIndex &index )
 424 {
 425     if( currentView == iconView || currentView == listView || currentView == picFlowView )
 426     {
 427
 428         currentView->setRootIndex( index );
 429
 430         /* When going toward root in LocationBar, scroll to the item
 431            that was previously as root */
 432         QModelIndex newIndex = model->index(currentRootIndexId,0);
 433         while( newIndex.isValid() && (newIndex.parent() != index) )
 434             newIndex = newIndex.parent();
 435         if( newIndex.isValid() )
 436             currentView->scrollTo( newIndex );
 437
 438         /* Store new rootindexid*/
 439         currentRootIndexId = model->itemId( index );
 440         model->ensureArtRequested( index );
 441     }
 442
 443     emit viewChanged( index );
 444 }
 445
 446 void StandardPLPanel::browseInto()
 447 {
 448     browseInto( (currentRootIndexId != -1 && currentView != treeView) ?
 449                  model->index( currentRootIndexId, 0 ) :
 450                  QModelIndex() );
 451 }
 452
 453 void StandardPLPanel::wheelEvent( QWheelEvent *e )
 454 {
 455     // Accept this event in order to prevent unwanted volume up/down changes
 456     e->accept();
 457 }
 458
 459 bool StandardPLPanel::eventFilter ( QObject *obj, QEvent * event )
 460 {
 461     if (event->type() == QEvent::KeyPress)
 462     {
 463         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 464         if( keyEvent->key() == Qt::Key_Delete ||
 465             keyEvent->key() == Qt::Key_Backspace )
 466         {
 467             deleteSelection();
 468             return true;
 469         }
 470     }
 471     else if ( event->type() == QEvent::Paint )
 472     {/* Warn! Don't filter events from anything else than views ! */
 473         if ( model->rowCount() == 0 && p_selector->getCurrentItemCategory() == PL_ITEM_TYPE )
 474         {
 475             QWidget *viewport = qobject_cast<QWidget *>( obj );
 476             QStylePainter painter( viewport );
 477             QPixmap dropzone(":/dropzone");
 478             QRect rect = viewport->geometry();
 479             QSize size = rect.size() / 2 - dropzone.size() / 2;
 480             rect.adjust( 0, size.height(), 0 , 0 );
 481             painter.drawItemPixmap( rect, Qt::AlignHCenter, dropzone );
 482             /* now select the zone just below the drop zone and let Qt center
 483                the text by itself */
 484             rect.adjust( 0, dropzone.size().height() + 10, 0, 0 );
 485             rect.setRight( viewport->geometry().width() );
 486             rect.setLeft( 0 );
 487             painter.drawItemText( rect,
 488                                   Qt::AlignHCenter,
 489                                   palette(),
 490                                   true,
 491                                   qtr("Playlist is currently empty.\n"
 492                                       "Drop a file here or select a "
 493                                       "media source from the left."),
 494                                   QPalette::Text );
 495         }
 496     }
 497     return false;
 498 }
 499
 500 void StandardPLPanel::deleteSelection()
 501 {
 502     QItemSelectionModel *selection = currentView->selectionModel();
 503     QModelIndexList list = selection->selectedIndexes();
 504     model->doDelete( list );
 505 }
 506
 507 void StandardPLPanel::createIconView()
 508 {
 509     iconView = new PlIconView( model, this );
 510     iconView->setContextMenuPolicy( Qt::CustomContextMenu );
 511     CONNECT( iconView, customContextMenuRequested( const QPoint & ),
 512              this, popupPlView( const QPoint & ) );
 513     CONNECT( iconView, activated( const QModelIndex & ),
 514              this, activate( const QModelIndex & ) );
 515     iconView->installEventFilter( this );
 516     iconView->viewport()->installEventFilter( this );
 517     viewStack->addWidget( iconView );
 518 }
 519
 520 void StandardPLPanel::createListView()
 521 {
 522     listView = new PlListView( model, this );
 523     listView->setContextMenuPolicy( Qt::CustomContextMenu );
 524     CONNECT( listView, customContextMenuRequested( const QPoint & ),
 525              this, popupPlView( const QPoint & ) );
 526     CONNECT( listView, activated( const QModelIndex & ),
 527              this, activate( const QModelIndex & ) );
 528     listView->installEventFilter( this );
 529     listView->viewport()->installEventFilter( this );
 530     viewStack->addWidget( listView );
 531 }
 532
 533 void StandardPLPanel::createCoverView()
 534 {
 535     picFlowView = new PicFlowView( model, this );
 536     picFlowView->setContextMenuPolicy( Qt::CustomContextMenu );
 537     CONNECT( picFlowView, customContextMenuRequested( const QPoint & ),
 538              this, popupPlView( const QPoint & ) );
 539     CONNECT( picFlowView, activated( const QModelIndex & ),
 540              this, activate( const QModelIndex & ) );
 541     viewStack->addWidget( picFlowView );
 542     picFlowView->installEventFilter( this );
 543 }
 544
 545 void StandardPLPanel::createTreeView()
 546 {
 547     /* Create and configure the QTreeView */
 548     treeView = new PlTreeView( model, this );
 549
 550     /* setModel after setSortingEnabled(true), or the model will sort immediately! */
 551
 552     /* Connections for the TreeView */
 553     CONNECT( treeView, activated( const QModelIndex& ),
 554              this, activate( const QModelIndex& ) );
 555     CONNECT( treeView->header(), customContextMenuRequested( const QPoint & ),
 556              this, popupSelectColumn( QPoint ) );
 557     CONNECT( treeView, customContextMenuRequested( const QPoint & ),
 558              this, popupPlView( const QPoint & ) );
 559     treeView->installEventFilter( this );
 560     treeView->viewport()->installEventFilter( this );
 561
 562     /* SignalMapper for columns */
 563     selectColumnsSigMapper = new QSignalMapper( this );
 564     CONNECT( selectColumnsSigMapper, mapped( int ),
 565              this, toggleColumnShown( int ) );
 566
 567     viewStack->addWidget( treeView );
 568 }
 569
 570 void StandardPLPanel::updateZoom( int i )
 571 {
 572     if ( i < 4 - QApplication::font().pointSize() ) return;
 573     i_zoom = i;
 574 #define A_ZOOM( view ) \
 575     if ( view ) \
 576     qobject_cast<AbstractPlViewItemDelegate*>( view->itemDelegate() )->setZoom( i_zoom )
 577     /* Can't iterate as picflow & tree aren't using custom delegate */
 578     A_ZOOM( iconView );
 579     A_ZOOM( listView );
 580 #undef A_ZOOM
 581 }
 582
 583 void StandardPLPanel::changeModel( bool b_ml )
 584 {
 585 #ifdef MEDIA_LIBRARY
 586     VLCModel *mod;
 587     if( b_ml )
 588         mod = mlmodel;
 589     else
 590         mod = model;
 591     if( currentView->model() != mod )
 592         currentView->setModel( mod );
 593 #else
 594     Q_UNUSED( b_ml );
 595     if( currentView->model() != model )
 596         currentView->setModel( model );
 597 #endif
 598 }
 599
 600 void StandardPLPanel::showView( int i_view )
 601 {
 602     bool b_treeViewCreated = false;
 603
 604     switch( i_view )
 605     {
 606     case ICON_VIEW:
 607     {
 608         if( iconView == NULL )
 609             createIconView();
 610         currentView = iconView;
 611         break;
 612     }
 613     case LIST_VIEW:
 614     {
 615         if( listView == NULL )
 616             createListView();
 617         currentView = listView;
 618         break;
 619     }
 620     case PICTUREFLOW_VIEW:
 621     {
 622         if( picFlowView == NULL )
 623             createCoverView();
 624         currentView = picFlowView;
 625         break;
 626     }
 627     default:
 628     case TREE_VIEW:
 629     {
 630         if( treeView == NULL )
 631         {
 632             createTreeView();
 633             b_treeViewCreated = true;
 634         }
 635         currentView = treeView;
 636         break;
 637     }
 638     }
 639
 640     changeModel( false );
 641
 642     /* Restoring the header Columns must come after changeModel */
 643     if( b_treeViewCreated )
 644     {
 645         assert( treeView );
 646         if( getSettings()->contains( "Playlist/headerStateV2" ) )
 647         {
 648             treeView->header()->restoreState(getSettings()
 649                     ->value( "Playlist/headerStateV2" ).toByteArray() );
 650             /* if there is allready stuff in playlist, we don't sort it and we reset
 651                sorting */
 652             if( model->rowCount() )
 653             {
 654                 treeView->header()->setSortIndicator( -1 , Qt::AscendingOrder );
 655             }
 656         }
 657         else
 658         {
 659             for( int m = 1, c = 0; m != COLUMN_END; m <<= 1, c++ )
 660             {
 661                 treeView->setColumnHidden( c, !( m & COLUMN_DEFAULT ) );
 662                 if( m == COLUMN_TITLE ) treeView->header()->resizeSection( c, 200 );
 663                 else if( m == COLUMN_DURATION ) treeView->header()->resizeSection( c, 80 );
 664             }
 665         }
 666     }
 667
 668     updateZoom( i_zoom );
 669     viewStack->setCurrentWidget( currentView );
 670     browseInto();
 671     gotoPlayingItem();
 672 }
 673
 674 int StandardPLPanel::currentViewIndex() const
 675 {
 676     if( currentView == treeView )
 677         return TREE_VIEW;
 678     else if( currentView == iconView )
 679         return ICON_VIEW;
 680     else if( currentView == listView )
 681         return LIST_VIEW;
 682     else
 683         return PICTUREFLOW_VIEW;
 684 }
 685
 686 void StandardPLPanel::cycleViews()
 687 {
 688     if( currentView == iconView )
 689         showView( TREE_VIEW );
 690     else if( currentView == treeView )
 691         showView( LIST_VIEW );
 692     else if( currentView == listView )
 693 #ifndef NDEBUG
 694         showView( PICTUREFLOW_VIEW  );
 695     else if( currentView == picFlowView )
 696 #endif
 697         showView( ICON_VIEW );
 698     else
 699         assert( 0 );
 700 }
 701
 702 void StandardPLPanel::activate( const QModelIndex &index )
 703 {
 704     if( currentView->model() == model )
 705     {
 706         /* If we are not a leaf node */
 707         if( !index.data( PLModel::IsLeafNodeRole ).toBool() )
 708         {
 709             if( currentView != treeView )
 710                 browseInto( index );
 711         }
 712         else
 713         {
 714             playlist_Lock( THEPL );
 715             playlist_item_t *p_item = playlist_ItemGetById( THEPL, model->itemId( index ) );
 716             p_item->i_flags |= PLAYLIST_SUBITEM_STOP_FLAG;
 717             lastActivatedId = p_item->p_input->i_id;
 718             playlist_Unlock( THEPL );
 719             model->activateItem( index );
 720         }
 721     }
 722 }
 723
 724 void StandardPLPanel::browseInto( int i_id )
 725 {
 726     if( i_id != lastActivatedId ) return;
 727
 728     QModelIndex index = model->index( i_id, 0 );
 729
 730     if( currentView == treeView )
 731         treeView->setExpanded( index, true );
 732     else
 733         browseInto( index );
 734
 735     lastActivatedId = -1;
 736 }