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

   1 /*****************************************************************************
   2  * selector.cpp : Playlist source selector
   3  ****************************************************************************
   4  * Copyright (C) 2006-2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *          Jean-Baptiste Kempf
   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 "qt4.hpp"
  30 #include "components/playlist/selector.hpp"
  31 #include "playlist_model.hpp"                /* plMimeData */
  32 #include "input_manager.hpp"                 /* MainInputManager, for podcast */
  33
  34 #include <QApplication>
  35 #include <QInputDialog>
  36 #include <QMessageBox>
  37 #include <QMimeData>
  38 #include <QDragMoveEvent>
  39 #include <QTreeWidgetItem>
  40 #include <QHBoxLayout>
  41 #include <QPainter>
  42 #include <QPalette>
  43 #include <QScrollBar>
  44
  45 #include <vlc_playlist.h>
  46 #include <vlc_services_discovery.h>
  47
  48 void SelectorActionButton::paintEvent( QPaintEvent *event )
  49 {
  50     QPainter p( this );
  51     QColor color = palette().color( QPalette::HighlightedText );
  52     color.setAlpha( 80 );
  53     if( underMouse() )
  54         p.fillRect( rect(), color );
  55     p.setPen( color );
  56     int frame = style()->pixelMetric( QStyle::PM_DefaultFrameWidth, 0, this );
  57     p.drawLine( rect().topLeft() + QPoint( 0, frame ),
  58                 rect().bottomLeft() - QPoint( 0, frame ) );
  59     QFramelessButton::paintEvent( event );
  60 }
  61
  62 PLSelItem::PLSelItem ( QTreeWidgetItem *i, const QString& text )
  63     : qitem(i), lblAction( NULL)
  64 {
  65     layout = new QHBoxLayout( this );
  66     layout->setContentsMargins(0,0,0,0);
  67     layout->addSpacing( 3 );
  68
  69     lbl = new QElidingLabel( text );
  70     layout->addWidget(lbl, 1);
  71
  72     int height = qMax( 22, fontMetrics().height() + 8 );
  73     setMinimumHeight( height );
  74 }
  75
  76 void PLSelItem::addAction( ItemAction act, const QString& tooltip )
  77 {
  78     if( lblAction ) return; //might change later
  79
  80     QIcon icon;
  81
  82     switch( act )
  83     {
  84     case ADD_ACTION:
  85         icon = QIcon( ":/buttons/playlist/playlist_add" ); break;
  86     case RM_ACTION:
  87         icon = QIcon( ":/buttons/playlist/playlist_remove" ); break;
  88     default:
  89         return;
  90     }
  91
  92     lblAction = new SelectorActionButton();
  93     lblAction->setIcon( icon );
  94     lblAction->setMinimumWidth( lblAction->sizeHint().width() + 6 );
  95
  96     if( !tooltip.isEmpty() ) lblAction->setToolTip( tooltip );
  97
  98     layout->addWidget( lblAction, 0 );
  99     lblAction->hide();
 100
 101     CONNECT( lblAction, clicked(), this, triggerAction() );
 102 }
 103
 104
 105 PLSelector::PLSelector( QWidget *p, intf_thread_t *_p_intf )
 106            : QTreeWidget( p ), p_intf(_p_intf)
 107 {
 108     /* Properties */
 109     setFrameStyle( QFrame::NoFrame );
 110     setAttribute( Qt::WA_MacShowFocusRect, false );
 111     viewport()->setAutoFillBackground( false );
 112     setIconSize( QSize( 24,24 ) );
 113     setIndentation( 12 );
 114     setHeaderHidden( true );
 115     setRootIsDecorated( true );
 116     setAlternatingRowColors( false );
 117
 118     /* drops */
 119     viewport()->setAcceptDrops(true);
 120     setDropIndicatorShown(true);
 121     invisibleRootItem()->setFlags( invisibleRootItem()->flags() & ~Qt::ItemIsDropEnabled );
 122
 123 #ifdef Q_WS_MAC
 124     setAutoFillBackground( true );
 125     QPalette palette;
 126     palette.setColor( QPalette::Window, QColor(209,215,226) );
 127     setPalette( palette );
 128 #endif
 129     setMinimumHeight( 120 );
 130
 131     /* Podcasts */
 132     podcastsParent = NULL;
 133     podcastsParentId = -1;
 134
 135     /* Podcast connects */
 136     CONNECT( THEMIM, playlistItemAppended( int, int ),
 137              this, plItemAdded( int, int ) );
 138     CONNECT( THEMIM, playlistItemRemoved( int ),
 139              this, plItemRemoved( int ) );
 140     DCONNECT( THEMIM->getIM(), metaChanged( input_item_t *),
 141               this, inputItemUpdate( input_item_t * ) );
 142
 143     createItems();
 144
 145     /* Expand at least to show level 2 */
 146     for ( int i = 0; i < topLevelItemCount(); i++ )
 147         expandItem( topLevelItem( i ) );
 148
 149     /***
 150      * We need to react to both clicks and activation (enter-key) here.
 151      * We use curItem to avoid rebuilding twice.
 152      * See QStyle::SH_ItemView_ActivateItemOnSingleClick
 153      ***/
 154     curItem = NULL;
 155     CONNECT( this, itemActivated( QTreeWidgetItem *, int ),
 156              this, setSource( QTreeWidgetItem *) );
 157     CONNECT( this, itemClicked( QTreeWidgetItem *, int ),
 158              this, setSource( QTreeWidgetItem *) );
 159 }
 160
 161 PLSelector::~PLSelector()
 162 {
 163     if( podcastsParent )
 164     {
 165         int c = podcastsParent->childCount();
 166         for( int i = 0; i < c; i++ )
 167         {
 168             QTreeWidgetItem *item = podcastsParent->child(i);
 169             input_item_t *p_input = item->data( 0, IN_ITEM_ROLE ).value<input_item_t*>();
 170             vlc_gc_decref( p_input );
 171         }
 172     }
 173 }
 174
 175 PLSelItem * putSDData( PLSelItem* item, const char* name, const char* longname )
 176 {
 177     item->treeItem()->setData( 0, NAME_ROLE, qfu( name ) );
 178     item->treeItem()->setData( 0, LONGNAME_ROLE, qfu( longname ) );
 179     return item;
 180 }
 181
 182 PLSelItem * putPLData( PLSelItem* item, playlist_item_t* plItem )
 183 {
 184     item->treeItem()->setData( 0, PL_ITEM_ROLE, QVariant::fromValue( plItem ) );
 185 /*    item->setData( 0, PL_ITEM_ID_ROLE, plItem->i_id );
 186     item->setData( 0, IN_ITEM_ROLE, QVariant::fromValue( (void*) plItem->p_input ) ); );*/
 187     return item;
 188 }
 189
 190 void PLSelector::createItems()
 191 {
 192     /* PL */
 193     PLSelItem *pl = putPLData( addItem( PL_ITEM_TYPE, N_("Playlist"), true ),
 194                               THEPL->p_playing );
 195     pl->treeItem()->setData( 0, SPECIAL_ROLE, QVariant( IS_PL ) );
 196     setCurrentItem( pl->treeItem() );
 197
 198     /* ML */
 199     PLSelItem *ml = putPLData( addItem( PL_ITEM_TYPE, N_("Media Library"), true ),
 200                               THEPL->p_media_library );
 201     ml->treeItem()->setData( 0, SPECIAL_ROLE, QVariant( IS_ML ) );
 202
 203 #ifdef MEDIA_LIBRARY
 204     /* SQL ML */
 205     addItem( SQL_ML_TYPE, "SQL Media Library" )->treeItem();
 206 #endif
 207
 208     /* SD nodes */
 209     QTreeWidgetItem *mycomp = addItem( CATEGORY_TYPE, N_("My Computer") )->treeItem();
 210     QTreeWidgetItem *devices = addItem( CATEGORY_TYPE, N_("Devices") )->treeItem();
 211     QTreeWidgetItem *lan = addItem( CATEGORY_TYPE, N_("Local Network") )->treeItem();
 212     QTreeWidgetItem *internet = addItem( CATEGORY_TYPE, N_("Internet") )->treeItem();
 213
 214     /* SD subnodes */
 215     char **ppsz_longnames;
 216     int *p_categories;
 217     char **ppsz_names = vlc_sd_GetNames( THEPL, &ppsz_longnames, &p_categories );
 218     if( !ppsz_names )
 219         return;
 220
 221     char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
 222     int *p_category = p_categories;
 223     for( ; *ppsz_name; ppsz_name++, ppsz_longname++, p_category++ )
 224     {
 225         //msg_Dbg( p_intf, "Adding a SD item: %s", *ppsz_longname );
 226
 227         PLSelItem *selItem;
 228         switch( *p_category )
 229         {
 230         case SD_CAT_INTERNET:
 231             {
 232             selItem = addItem( SD_TYPE, *ppsz_longname, false, internet );
 233             if( !strncmp( *ppsz_name, "podcast", 7 ) )
 234             {
 235                 selItem->treeItem()->setData( 0, SPECIAL_ROLE, QVariant( IS_PODCAST ) );
 236                 selItem->addAction( ADD_ACTION, qtr( "Subscribe to a podcast" ) );
 237                 CONNECT( selItem, action( PLSelItem* ), this, podcastAdd( PLSelItem* ) );
 238                 podcastsParent = selItem->treeItem();
 239             }
 240             }
 241             break;
 242         case SD_CAT_DEVICES:
 243             selItem = addItem( SD_TYPE, *ppsz_longname, false, devices );
 244             break;
 245         case SD_CAT_LAN:
 246             selItem = addItem( SD_TYPE, *ppsz_longname, false, lan );
 247             break;
 248         case SD_CAT_MYCOMPUTER:
 249             selItem = addItem( SD_TYPE, *ppsz_longname, false, mycomp );
 250             break;
 251         default:
 252             selItem = addItem( SD_TYPE, *ppsz_longname );
 253         }
 254
 255         putSDData( selItem, *ppsz_name, *ppsz_longname );
 256         free( *ppsz_name );
 257         free( *ppsz_longname );
 258     }
 259     free( ppsz_names );
 260     free( ppsz_longnames );
 261     free( p_categories );
 262
 263     if( mycomp->childCount() == 0 ) delete mycomp;
 264     if( devices->childCount() == 0 ) delete devices;
 265     if( lan->childCount() == 0 ) delete lan;
 266     if( internet->childCount() == 0 ) delete internet;
 267 }
 268
 269 void PLSelector::setSource( QTreeWidgetItem *item )
 270 {
 271     if( !item || item == curItem )
 272         return;
 273
 274     bool b_ok;
 275     int i_type = item->data( 0, TYPE_ROLE ).toInt( &b_ok );
 276     if( !b_ok || i_type == CATEGORY_TYPE )
 277         return;
 278
 279     bool sd_loaded;
 280     if( i_type == SD_TYPE )
 281     {
 282         QString qs = item->data( 0, NAME_ROLE ).toString();
 283         sd_loaded = playlist_IsServicesDiscoveryLoaded( THEPL, qtu( qs ) );
 284         if( !sd_loaded )
 285         {
 286             if ( playlist_ServicesDiscoveryAdd( THEPL, qtu( qs ) ) != VLC_SUCCESS )
 287                 return ;
 288
 289             services_discovery_descriptor_t *p_test = new services_discovery_descriptor_t;
 290             int i_ret = playlist_ServicesDiscoveryControl( THEPL, qtu( qs ), SD_CMD_DESCRIPTOR, p_test );
 291             if( i_ret == VLC_SUCCESS && p_test->i_capabilities & SD_CAP_SEARCH )
 292                 item->setData( 0, CAP_SEARCH_ROLE, true );
 293         }
 294     }
 295 #ifdef MEDIA_LIBRARY
 296     else if( i_type == SQL_ML_TYPE )
 297     {
 298         emit categoryActivated( NULL, true );
 299         return;
 300     }
 301 #endif
 302
 303     curItem = item;
 304
 305     /* */
 306     playlist_Lock( THEPL );
 307     playlist_item_t *pl_item = NULL;
 308
 309     /* Special case for podcast */
 310     // FIXME: simplify
 311     if( i_type == SD_TYPE )
 312     {
 313         /* Find the right item for the SD */
 314         pl_item = playlist_ChildSearchName( THEPL->p_root,
 315                       qtu( item->data(0, LONGNAME_ROLE ).toString() ) );
 316
 317         /* Podcasts */
 318         if( item->data( 0, SPECIAL_ROLE ).toInt() == IS_PODCAST )
 319         {
 320             if( pl_item && !sd_loaded )
 321             {
 322                 podcastsParentId = pl_item->i_id;
 323                 for( int i=0; i < pl_item->i_children; i++ )
 324                     addPodcastItem( pl_item->pp_children[i] );
 325             }
 326             pl_item = NULL; //to prevent activating it
 327         }
 328     }
 329     else
 330         pl_item = item->data( 0, PL_ITEM_ROLE ).value<playlist_item_t*>();
 331
 332     playlist_Unlock( THEPL );
 333
 334     /* */
 335     if( pl_item )
 336         emit categoryActivated( pl_item, false );
 337 }
 338
 339 PLSelItem * PLSelector::addItem (
 340     SelectorItemType type, const char* str, bool drop,
 341     QTreeWidgetItem* parentItem )
 342 {
 343   QTreeWidgetItem *item = parentItem ?
 344       new QTreeWidgetItem( parentItem ) : new QTreeWidgetItem( this );
 345
 346   PLSelItem *selItem = new PLSelItem( item, qtr( str ) );
 347   setItemWidget( item, 0, selItem );
 348   item->setData( 0, TYPE_ROLE, (int)type );
 349   if( !drop ) item->setFlags( item->flags() & ~Qt::ItemIsDropEnabled );
 350
 351   return selItem;
 352 }
 353
 354 PLSelItem *PLSelector::addPodcastItem( playlist_item_t *p_item )
 355 {
 356     vlc_gc_incref( p_item->p_input );
 357
 358     char *psz_name = input_item_GetName( p_item->p_input );
 359     PLSelItem *item = addItem( PL_ITEM_TYPE,  psz_name, false, podcastsParent );
 360     free( psz_name );
 361
 362     item->addAction( RM_ACTION, qtr( "Remove this podcast subscription" ) );
 363     item->treeItem()->setData( 0, PL_ITEM_ROLE, QVariant::fromValue( p_item ) );
 364     item->treeItem()->setData( 0, PL_ITEM_ID_ROLE, QVariant(p_item->i_id) );
 365     item->treeItem()->setData( 0, IN_ITEM_ROLE, QVariant::fromValue( p_item->p_input ) );
 366     CONNECT( item, action( PLSelItem* ), this, podcastRemove( PLSelItem* ) );
 367     return item;
 368 }
 369
 370 QStringList PLSelector::mimeTypes() const
 371 {
 372     QStringList types;
 373     types << "vlc/qt-input-items";
 374     return types;
 375 }
 376
 377 bool PLSelector::dropMimeData ( QTreeWidgetItem * parent, int,
 378     const QMimeData * data, Qt::DropAction )
 379 {
 380     if( !parent ) return false;
 381
 382     QVariant type = parent->data( 0, TYPE_ROLE );
 383     if( type == QVariant() ) return false;
 384
 385     int i_truth = parent->data( 0, SPECIAL_ROLE ).toInt();
 386     if( i_truth != IS_PL && i_truth != IS_ML ) return false;
 387
 388     bool to_pl = ( i_truth == IS_PL );
 389
 390     const PlMimeData *plMimeData = qobject_cast<const PlMimeData*>( data );
 391     if( !plMimeData ) return false;
 392
 393     QList<input_item_t*> inputItems = plMimeData->inputItems();
 394
 395     playlist_Lock( THEPL );
 396
 397     foreach( input_item_t *p_input, inputItems )
 398     {
 399         playlist_item_t *p_item = playlist_ItemGetByInput( THEPL, p_input );
 400         if( !p_item ) continue;
 401
 402         playlist_NodeAddCopy( THEPL, p_item,
 403                               to_pl ? THEPL->p_playing : THEPL->p_media_library,
 404                               PLAYLIST_END );
 405     }
 406
 407     playlist_Unlock( THEPL );
 408
 409     return true;
 410 }
 411
 412 void PLSelector::dragMoveEvent ( QDragMoveEvent * event )
 413 {
 414     event->setDropAction( Qt::CopyAction );
 415     QAbstractItemView::dragMoveEvent( event );
 416 }
 417
 418 void PLSelector::plItemAdded( int item, int parent )
 419 {
 420     if( parent != podcastsParentId ) return;
 421
 422     playlist_Lock( THEPL );
 423
 424     playlist_item_t *p_item = playlist_ItemGetById( THEPL, item );
 425     if( !p_item ) {
 426         playlist_Unlock( THEPL );
 427         return;
 428     }
 429
 430     int c = podcastsParent->childCount();
 431     for( int i = 0; i < c; i++ )
 432     {
 433         QTreeWidgetItem *podItem = podcastsParent->child(i);
 434         if( podItem->data( 0, PL_ITEM_ID_ROLE ).toInt() == item )
 435         {
 436           //msg_Dbg( p_intf, "Podcast already in: (%d) %s", item, p_item->p_input->psz_uri);
 437           playlist_Unlock( THEPL );
 438           return;
 439         }
 440     }
 441
 442     //msg_Dbg( p_intf, "Adding podcast: (%d) %s", item, p_item->p_input->psz_uri );
 443     addPodcastItem( p_item );
 444
 445     playlist_Unlock( THEPL );
 446
 447     podcastsParent->setExpanded( true );
 448 }
 449
 450 void PLSelector::plItemRemoved( int id )
 451 {
 452     int c = podcastsParent->childCount();
 453     for( int i = 0; i < c; i++ )
 454     {
 455         QTreeWidgetItem *item = podcastsParent->child(i);
 456         if( item->data( 0, PL_ITEM_ID_ROLE ).toInt() == id )
 457         {
 458             input_item_t *p_input = item->data( 0, IN_ITEM_ROLE ).value<input_item_t*>();
 459             //msg_Dbg( p_intf, "Removing podcast: (%d) %s", id, p_input->psz_uri );
 460             vlc_gc_decref( p_input );
 461             delete item;
 462             return;
 463         }
 464     }
 465 }
 466
 467 void PLSelector::inputItemUpdate( input_item_t *arg )
 468 {
 469     int c = podcastsParent->childCount();
 470     for( int i = 0; i < c; i++ )
 471     {
 472         QTreeWidgetItem *item = podcastsParent->child(i);
 473         input_item_t *p_input = item->data( 0, IN_ITEM_ROLE ).value<input_item_t*>();
 474         if( p_input == arg )
 475         {
 476             PLSelItem *si = itemWidget( item );
 477             char *psz_name = input_item_GetName( p_input );
 478             si->setText( qfu( psz_name ) );
 479             free( psz_name );
 480             return;
 481         }
 482     }
 483 }
 484
 485 void PLSelector::podcastAdd( PLSelItem * )
 486 {
 487     bool ok;
 488     QString url = QInputDialog::getText( this, qtr( "Subscribe" ),
 489                                          qtr( "Enter URL of the podcast to subscribe to:" ),
 490                                          QLineEdit::Normal, QString(), &ok );
 491     if( !ok || url.isEmpty() ) return;
 492
 493     setSource( podcastsParent ); //to load the SD in case it's not loaded
 494
 495     vlc_object_t *p_obj = (vlc_object_t*) vlc_object_find_name( p_intf->p_libvlc, "podcast" );
 496     if( !p_obj ) return;
 497
 498     QString request("ADD:");
 499     request += url.trimmed();
 500     var_SetString( p_obj, "podcast-request", qtu( request ) );
 501     vlc_object_release( p_obj );
 502 }
 503
 504 void PLSelector::podcastRemove( PLSelItem* item )
 505 {
 506     QString question ( qtr( "Do you really want to unsubscribe from %1?" ) );
 507     question = question.arg( item->text() );
 508     QMessageBox::StandardButton res =
 509         QMessageBox::question( this, qtr( "Unsubscribe" ), question,
 510                                QMessageBox::Ok | QMessageBox::Cancel,
 511                                QMessageBox::Cancel );
 512     if( res == QMessageBox::Cancel ) return;
 513
 514     input_item_t *input = item->treeItem()->data( 0, IN_ITEM_ROLE ).value<input_item_t*>();
 515     if( !input ) return;
 516
 517     vlc_object_t *p_obj = (vlc_object_t*) vlc_object_find_name(
 518         p_intf->p_libvlc, "podcast" );
 519     if( !p_obj ) return;
 520
 521     QString request("RM:");
 522     char *psz_uri = input_item_GetURI( input );
 523     request += qfu( psz_uri );
 524     var_SetString( p_obj, "podcast-request", qtu( request ) );
 525     vlc_object_release( p_obj );
 526     free( psz_uri );
 527 }
 528
 529 PLSelItem * PLSelector::itemWidget( QTreeWidgetItem *item )
 530 {
 531     return ( static_cast<PLSelItem*>( QTreeWidget::itemWidget( item, 0 ) ) );
 532 }
 533
 534 void PLSelector::drawBranches ( QPainter * painter, const QRect & rect, const QModelIndex & index ) const
 535 {
 536     if( !model()->hasChildren( index ) ) return;
 537     QStyleOption option;
 538     option.initFrom( this );
 539     option.rect = rect.adjusted( rect.width() - indentation(), 0, 0, 0 );
 540     style()->drawPrimitive( isExpanded( index ) ?
 541                             QStyle::PE_IndicatorArrowDown :
 542                             QStyle::PE_IndicatorArrowRight, &option, painter );
 543 }
 544
 545 void PLSelector::getCurrentItemInfos( int* type, bool* can_delay_search, QString *string)
 546 {
 547     *type = currentItem()->data( 0, TYPE_ROLE ).toInt();
 548     *string = currentItem()->data( 0, NAME_ROLE ).toString();
 549     *can_delay_search = currentItem()->data( 0, CAP_SEARCH_ROLE ).toBool();
 550 }
 551
 552 int PLSelector::getCurrentItemCategory()
 553 {
 554     return currentItem()->data( 0, SPECIAL_ROLE ).toInt();
 555 }
 556
 557 void PLSelector::wheelEvent( QWheelEvent *e )
 558 {
 559     if( verticalScrollBar()->isVisible() && (
 560         (verticalScrollBar()->value() != verticalScrollBar()->minimum() && e->delta() >= 0 ) ||
 561         (verticalScrollBar()->value() != verticalScrollBar()->maximum() && e->delta() < 0 )
 562         ) )
 563         QApplication::sendEvent(verticalScrollBar(), e);
 564
 565     // Accept this event in order to prevent unwanted volume up/down changes
 566     e->accept();
 567 }