1 /*****************************************************************************
2 * playlist_model.cpp : Manage playlist model
3 ****************************************************************************
4 * Copyright (C) 2006-2007 the VideoLAN team
7 * Authors: Clément Stenac <zorglub@videolan.org>
8 * Ilkka Ollakkka <ileoo (at) videolan dot org>
9 * Jakob Leben <jleben@videolan.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
31 #include "dialogs_provider.hpp"
32 #include "components/playlist/playlist_model.hpp"
33 #include "dialogs/mediainfo.hpp"
34 #include "dialogs/playlist.hpp"
35 #include <vlc_intf_strings.h>
37 #include "pixmaps/types/type_unknown.xpm"
43 #include <QApplication>
48 QIcon
PLModel::icons
[ITEM_TYPE_NUMBER
];
50 /*************************************************************************
51 * Playlist model implementation
52 *************************************************************************/
55 This model is called two times, for the selector and the standard panel
57 PLModel::PLModel( playlist_t
*_p_playlist
, /* THEPL */
58 intf_thread_t
*_p_intf
, /* main Qt p_intf */
59 playlist_item_t
* p_root
,
60 /*playlist_GetPreferredNode( THEPL, THEPL->p_local_category );
61 and THEPL->p_root_category for SelectPL */
62 QObject
*parent
) /* Basic Qt parent */
63 : QAbstractItemModel( parent
)
66 p_playlist
= _p_playlist
;
68 i_cached_input_id
= -1;
69 i_popup_item
= i_popup_parent
= -1;
72 rootItem
= NULL
; /* PLItem rootItem, will be set in rebuild( ) */
74 /* Icons initialization */
75 #define ADD_ICON(type, x) icons[ITEM_TYPE_##type] = QIcon( x )
76 ADD_ICON( UNKNOWN
, type_unknown_xpm
);
77 ADD_ICON( FILE, ":/type/file" );
78 ADD_ICON( DIRECTORY
, ":/type/directory" );
79 ADD_ICON( DISC
, ":/type/disc" );
80 ADD_ICON( CDDA
, ":/type/cdda" );
81 ADD_ICON( CARD
, ":/type/capture-card" );
82 ADD_ICON( NET
, ":/type/net" );
83 ADD_ICON( PLAYLIST
, ":/type/playlist" );
84 ADD_ICON( NODE
, ":/type/node" );
87 rebuild( p_root
, true );
88 CONNECT( THEMIM
->getIM(), metaChanged( input_item_t
*),
89 this, processInputItemUpdate( input_item_t
*) );
90 CONNECT( THEMIM
, inputChanged( input_thread_t
* ),
91 this, processInputItemUpdate( input_thread_t
* ) );
92 CONNECT( THEMIM
, playlistItemAppended( int, int ),
93 this, processItemAppend( int, int ) );
94 CONNECT( THEMIM
, playlistItemRemoved( int ),
95 this, processItemRemoval( int ) );
103 Qt::DropActions
PLModel::supportedDropActions() const
105 return Qt::CopyAction
; /* Why not Qt::MoveAction */
108 Qt::ItemFlags
PLModel::flags( const QModelIndex
&index
) const
110 Qt::ItemFlags flags
= QAbstractItemModel::flags( index
);
112 PLItem
*item
= index
.isValid() ? getItem( index
) : rootItem
;
117 playlist_item_t
*plItem
=
118 playlist_ItemGetById( p_playlist
, item
->i_id
);
120 if ( plItem
&& ( plItem
->i_children
> -1 ) )
121 flags
|= Qt::ItemIsDropEnabled
;
126 flags
|= Qt::ItemIsDragEnabled
;
131 QStringList
PLModel::mimeTypes() const
134 types
<< "vlc/qt-playlist-item";
138 QMimeData
*PLModel::mimeData( const QModelIndexList
&indexes
) const
140 QMimeData
*mimeData
= new QMimeData();
141 QByteArray encodedData
;
142 QDataStream
stream( &encodedData
, QIODevice::WriteOnly
);
143 QModelIndexList list
;
145 foreach( const QModelIndex
&index
, indexes
) {
146 if( index
.isValid() && index
.column() == 0 )
152 foreach( const QModelIndex
&index
, list
) {
153 PLItem
*item
= getItem( index
);
154 stream
.writeRawData( (char*) &item
, sizeof( PLItem
* ) );
156 mimeData
->setData( "vlc/qt-playlist-item", encodedData
);
161 bool PLModel::dropMimeData( const QMimeData
*data
, Qt::DropAction action
,
162 int row
, int column
, const QModelIndex
&parent
)
164 if( data
->hasFormat( "vlc/qt-playlist-item" ) )
166 if( action
== Qt::IgnoreAction
)
169 PLItem
*parentItem
= parent
.isValid() ? getItem( parent
) : rootItem
;
172 playlist_item_t
*p_parent
=
173 playlist_ItemGetById( p_playlist
, parentItem
->i_id
);
174 if( !p_parent
|| p_parent
->i_children
== -1 )
181 playlist_item_t
*p_pl
= p_playlist
->p_local_category
;
182 playlist_item_t
*p_ml
= p_playlist
->p_ml_category
;
186 ( p_pl
&& p_parent
->p_input
== p_pl
->p_input
) ||
187 ( p_ml
&& p_parent
->p_input
== p_ml
->p_input
) )
192 QByteArray encodedData
= data
->data( "vlc/qt-playlist-item" );
194 dropAppendCopy( encodedData
, parentItem
);
196 dropMove( encodedData
, parentItem
, row
);
201 void PLModel::dropAppendCopy( QByteArray
& data
, PLItem
*target
)
203 QDataStream
stream( &data
, QIODevice::ReadOnly
);
206 playlist_item_t
*p_parent
=
207 playlist_ItemGetById( p_playlist
, target
->i_id
);
208 while( !stream
.atEnd() )
211 stream
.readRawData( (char*)&item
, sizeof(PLItem
*) );
212 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, item
->i_id
);
213 if( !p_item
) continue;
214 input_item_t
*p_input
= p_item
->p_input
;
215 playlist_AddExt ( p_playlist
,
216 p_input
->psz_uri
, p_input
->psz_name
,
217 PLAYLIST_APPEND
| PLAYLIST_SPREPARSE
, PLAYLIST_END
,
219 p_input
->i_options
, p_input
->ppsz_options
, p_input
->optflagc
,
220 ( p_parent
== p_playlist
->p_local_category
||
221 p_parent
== p_playlist
->p_local_onelevel
),
227 void PLModel::dropMove( QByteArray
& data
, PLItem
*target
, int row
)
229 QDataStream
stream( &data
, QIODevice::ReadOnly
);
230 QList
<PLItem
*> model_items
;
232 int new_pos
= row
== -1 ? target
->children
.size() : row
;
233 int model_pos
= new_pos
;
234 while( !stream
.atEnd() )
237 stream
.readRawData( (char*)&item
, sizeof(PLItem
*) );
239 /* better not try to move a node into itself: */
240 PLItem
*climber
= target
;
243 if( climber
== item
) break;
244 climber
= climber
->parentItem
;
246 if( climber
) continue;
248 if( item
->parentItem
== target
&&
249 target
->children
.indexOf( item
) < model_pos
)
252 ids
.append( item
->i_id
);
253 model_items
.append( item
);
257 int count
= ids
.size();
260 playlist_item_t
*pp_items
[count
];
263 for( int i
= 0; i
< count
; i
++ )
265 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, ids
[i
] );
271 pp_items
[i
] = p_item
;
273 playlist_item_t
*p_parent
=
274 playlist_ItemGetById( p_playlist
, target
->i_id
);
275 playlist_TreeMoveMany( p_playlist
, count
, pp_items
, p_parent
,
279 insertChildren( target
, model_items
, model_pos
);
283 /* remove item with its id */
284 void PLModel::removeItem( int i_id
)
286 PLItem
*item
= findById( rootItem
, i_id
);
290 void PLModel::activateItem( const QModelIndex
&index
)
292 assert( index
.isValid() );
293 PLItem
*item
= getItem( index
);
296 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, item
->i_id
);
297 activateItem( p_item
);
301 /* Must be entered with lock */
302 void PLModel::activateItem( playlist_item_t
*p_item
)
304 if( !p_item
) return;
305 playlist_item_t
*p_parent
= p_item
;
308 if( p_parent
->i_id
== rootItem
->i_id
) break;
309 p_parent
= p_parent
->p_parent
;
312 playlist_Control( p_playlist
, PLAYLIST_VIEWPLAY
, pl_Locked
,
316 /****************** Base model mandatory implementations *****************/
317 QVariant
PLModel::data( const QModelIndex
&index
, int role
) const
319 if( !index
.isValid() ) return QVariant();
320 PLItem
*item
= getItem( index
);
321 if( role
== Qt::DisplayRole
)
323 int metadata
= columnToMeta( index
.column() );
324 if( metadata
== COLUMN_END
) return QVariant();
327 if( metadata
== COLUMN_NUMBER
)
328 returninfo
= QString::number( index
.row() + 1 );
331 char *psz
= psz_column_meta( item
->p_input
, metadata
);
332 returninfo
= qfu( psz
);
335 return QVariant( returninfo
);
337 else if( role
== Qt::DecorationRole
&& index
.column() == 0 )
339 /* Used to segfault here because i_type wasn't always initialized */
340 return QVariant( PLModel::icons
[item
->p_input
->i_type
] );
342 else if( role
== Qt::FontRole
)
344 if( isCurrent( index
) )
346 QFont f
; f
.setBold( true ); return QVariant( f
);
352 bool PLModel::isCurrent( const QModelIndex
&index
) const
354 if( !currentItem
) return false;
355 return getItem( index
)->p_input
== currentItem
->p_input
;
358 int PLModel::itemId( const QModelIndex
&index
) const
360 return getItem( index
)->i_id
;
363 QVariant
PLModel::headerData( int section
, Qt::Orientation orientation
,
366 if (orientation
!= Qt::Horizontal
|| role
!= Qt::DisplayRole
)
369 int meta_col
= columnToMeta( section
);
371 if( meta_col
== COLUMN_END
) return QVariant();
373 return QVariant( qfu( psz_column_title( meta_col
) ) );
376 QModelIndex
PLModel::index( int row
, int column
, const QModelIndex
&parent
)
379 PLItem
*parentItem
= parent
.isValid() ? getItem( parent
) : rootItem
;
381 PLItem
*childItem
= parentItem
->child( row
);
383 return createIndex( row
, column
, childItem
);
385 return QModelIndex();
388 /* Return the index of a given item */
389 QModelIndex
PLModel::index( PLItem
*item
, int column
) const
391 if( !item
) return QModelIndex();
392 const PLItem
*parent
= item
->parent();
394 return createIndex( parent
->children
.lastIndexOf( item
),
396 return QModelIndex();
399 QModelIndex
PLModel::parent( const QModelIndex
&index
) const
401 if( !index
.isValid() ) return QModelIndex();
403 PLItem
*childItem
= getItem( index
);
406 msg_Err( p_playlist
, "NULL CHILD" );
407 return QModelIndex();
410 PLItem
*parentItem
= childItem
->parent();
411 if( !parentItem
|| parentItem
== rootItem
) return QModelIndex();
412 if( !parentItem
->parentItem
)
414 msg_Err( p_playlist
, "No parent parent, trying row 0 " );
415 msg_Err( p_playlist
, "----- PLEASE REPORT THIS ------" );
416 return createIndex( 0, 0, parentItem
);
418 QModelIndex ind
= createIndex(parentItem
->row(), 0, parentItem
);
422 int PLModel::columnCount( const QModelIndex
&i
) const
424 return columnFromMeta( COLUMN_END
);
427 int PLModel::rowCount( const QModelIndex
&parent
) const
429 PLItem
*parentItem
= parent
.isValid() ? getItem( parent
) : rootItem
;
430 return parentItem
->childCount();
433 QStringList
PLModel::selectedURIs()
436 for( int i
= 0; i
< current_selection
.size(); i
++ )
438 PLItem
*item
= getItem( current_selection
[i
] );
442 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, item
->i_id
);
445 char *psz
= input_item_GetURI( p_item
->p_input
);
448 lst
.append( qfu(psz
) );
459 /************************* Lookups *****************************/
461 PLItem
*PLModel::findById( PLItem
*root
, int i_id
)
463 return findInner( root
, i_id
, false );
466 PLItem
*PLModel::findByInput( PLItem
*root
, int i_id
)
468 PLItem
*result
= findInner( root
, i_id
, true );
472 #define CACHE( i, p ) { i_cached_id = i; p_cached_item = p; }
473 #define ICACHE( i, p ) { i_cached_input_id = i; p_cached_item_bi = p; }
475 PLItem
* PLModel::findInner( PLItem
*root
, int i_id
, bool b_input
)
477 if( !root
) return NULL
;
478 if( ( !b_input
&& i_cached_id
== i_id
) ||
479 ( b_input
&& i_cached_input_id
==i_id
) )
481 return b_input
? p_cached_item_bi
: p_cached_item
;
484 if( !b_input
&& root
->i_id
== i_id
)
489 else if( b_input
&& root
->p_input
->i_id
== i_id
)
491 ICACHE( i_id
, root
);
495 QList
<PLItem
*>::iterator it
= root
->children
.begin();
496 while ( it
!= root
->children
.end() )
498 if( !b_input
&& (*it
)->i_id
== i_id
)
500 CACHE( i_id
, (*it
) );
501 return p_cached_item
;
503 else if( b_input
&& (*it
)->p_input
->i_id
== i_id
)
505 ICACHE( i_id
, (*it
) );
506 return p_cached_item_bi
;
508 if( (*it
)->children
.size() )
510 PLItem
*childFound
= findInner( (*it
), i_id
, b_input
);
514 ICACHE( i_id
, childFound
)
516 CACHE( i_id
, childFound
)
527 PLItem
*PLModel::getItem( QModelIndex index
)
529 assert( index
.isValid() );
530 return static_cast<PLItem
*>( index
.internalPointer() );
533 int PLModel::columnToMeta( int _column
) const
538 while( column
!= _column
&& meta
!= COLUMN_END
)
547 int PLModel::columnFromMeta( int meta_col
) const
552 while( meta
!= meta_col
&& meta
!= COLUMN_END
)
561 bool PLModel::canEdit() const
566 rootItem
->p_input
== p_playlist
->p_local_category
->p_input
||
568 p_playlist
->p_ml_category
&&
569 rootItem
->p_input
== p_playlist
->p_ml_category
->p_input
574 /************************* Updates handling *****************************/
576 /**** Events processing ****/
577 void PLModel::processInputItemUpdate( input_thread_t
*p_input
)
579 if( !p_input
) return;
580 processInputItemUpdate( input_GetItem( p_input
) );
581 if( p_input
&& !( p_input
->b_dead
|| !vlc_object_alive( p_input
) ) )
583 PLItem
*item
= findByInput( rootItem
, input_GetItem( p_input
)->i_id
);
585 emit
currentChanged( index( item
, 0 ) );
592 void PLModel::processInputItemUpdate( input_item_t
*p_item
)
594 if( !p_item
|| p_item
->i_id
<= 0 ) return;
595 PLItem
*item
= findByInput( rootItem
, p_item
->i_id
);
597 updateTreeItem( item
);
600 void PLModel::processItemRemoval( int i_id
)
602 if( i_id
<= 0 ) return;
606 void PLModel::processItemAppend( int i_item
, int i_parent
)
608 playlist_item_t
*p_item
= NULL
;
609 PLItem
*newItem
= NULL
;
611 PLItem
*nodeItem
= findById( rootItem
, i_parent
);
612 if( !nodeItem
) return;
614 foreach( PLItem
*existing
, nodeItem
->children
)
615 if( existing
->i_id
== i_item
) return;
618 p_item
= playlist_ItemGetById( p_playlist
, i_item
);
619 if( !p_item
|| p_item
->i_flags
& PLAYLIST_DBL_FLAG
) goto end
;
621 newItem
= new PLItem( p_item
, nodeItem
);
624 beginInsertRows( index( nodeItem
, 0 ), nodeItem
->childCount(), nodeItem
->childCount() );
625 nodeItem
->appendChild( newItem
);
627 updateTreeItem( newItem
);
635 void PLModel::rebuild()
637 rebuild( NULL
, false );
640 void PLModel::rebuild( playlist_item_t
*p_root
, bool b_first
)
642 playlist_item_t
* p_item
;
644 /* Invalidate cache */
645 i_cached_id
= i_cached_input_id
= -1;
647 if( rootItem
) rootItem
->removeChildren();
653 rootItem
= new PLItem( p_root
);
656 /* Recreate from root */
657 updateChildren( rootItem
);
658 if( (p_item
= playlist_CurrentPlayingItem(p_playlist
)) )
659 currentItem
= findByInput( rootItem
, p_item
->p_input
->i_id
);
664 /* And signal the view */
667 emit
currentChanged( index( currentItem
, 0 ) );
670 void PLModel::takeItem( PLItem
*item
)
673 PLItem
*parent
= item
->parentItem
;
675 int i_index
= parent
->children
.indexOf( item
);
677 beginRemoveRows( index( parent
, 0 ), i_index
, i_index
);
678 parent
->takeChildAt( i_index
);
682 void PLModel::insertChildren( PLItem
*node
, QList
<PLItem
*>& items
, int i_pos
)
685 int count
= items
.size();
687 beginInsertRows( index( node
, 0 ), i_pos
, i_pos
+ count
- 1 );
688 for( int i
= 0; i
< count
; i
++ )
690 node
->children
.insert( i_pos
+ i
, items
[i
] );
691 items
[i
]->parentItem
= node
;
696 void PLModel::removeItem( PLItem
*item
)
700 if( item
->i_id
== i_cached_id
) i_cached_id
= -1;
701 i_cached_input_id
= -1;
703 if( currentItem
== item
|| rootItem
== item
)
706 emit
currentChanged( QModelIndex() );
712 if( item
->parentItem
) {
713 int i
= item
->parentItem
->children
.indexOf( item
);
714 beginRemoveRows( index( item
->parentItem
, 0), i
, i
);
715 item
->parentItem
->children
.removeAt(i
);
723 /* This function must be entered WITH the playlist lock */
724 void PLModel::updateChildren( PLItem
*root
)
726 playlist_item_t
*p_node
= playlist_ItemGetById( p_playlist
, root
->i_id
);
727 updateChildren( p_node
, root
);
730 /* This function must be entered WITH the playlist lock */
731 void PLModel::updateChildren( playlist_item_t
*p_node
, PLItem
*root
)
733 playlist_item_t
*p_item
= playlist_CurrentPlayingItem(p_playlist
);
734 for( int i
= 0; i
< p_node
->i_children
; i
++ )
736 if( p_node
->pp_children
[i
]->i_flags
& PLAYLIST_DBL_FLAG
) continue;
737 PLItem
*newItem
= new PLItem( p_node
->pp_children
[i
], root
);
738 root
->appendChild( newItem
);
739 if( p_item
&& newItem
->p_input
== p_item
->p_input
)
741 currentItem
= newItem
;
742 emit
currentChanged( index( currentItem
, 0 ) );
744 if( p_node
->pp_children
[i
]->i_children
!= -1 )
745 updateChildren( p_node
->pp_children
[i
], newItem
);
749 /* Function doesn't need playlist-lock, as we don't touch playlist_item_t stuff here*/
750 void PLModel::updateTreeItem( PLItem
*item
)
753 emit
dataChanged( index( item
, 0 ) , index( item
, columnCount( QModelIndex() ) ) );
756 /************************* Actions ******************************/
759 * Deletion, here we have to do a ugly slow hack as we retrieve the full
760 * list of indexes to delete at once: when we delete a node and all of
761 * its children, we need to update the list.
762 * Todo: investigate whethere we can use ranges to be sure to delete all items?
764 void PLModel::doDelete( QModelIndexList selected
)
766 if( !canEdit() ) return;
768 for( int i
= selected
.size() -1 ; i
>= 0; i
-- )
770 QModelIndex index
= selected
[i
];
771 if( index
.column() != 0 ) continue;
772 PLItem
*item
= getItem( index
);
775 if( item
->children
.size() )
776 recurseDelete( item
->children
, &selected
);
777 doDeleteItem( item
, &selected
);
779 if( i
> selected
.size() ) i
= selected
.size();
783 void PLModel::recurseDelete( QList
<PLItem
*> children
, QModelIndexList
*fullList
)
785 for( int i
= children
.size() - 1; i
>= 0 ; i
-- )
787 PLItem
*item
= children
[i
];
788 if( item
->children
.size() )
789 recurseDelete( item
->children
, fullList
);
790 doDeleteItem( item
, fullList
);
794 void PLModel::doDeleteItem( PLItem
*item
, QModelIndexList
*fullList
)
796 QModelIndex deleteIndex
= index( item
, 0 );
797 fullList
->removeAll( deleteIndex
);
800 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, item
->i_id
);
806 if( p_item
->i_children
== -1 )
807 playlist_DeleteFromInput( p_playlist
, p_item
->p_input
, pl_Locked
);
809 playlist_NodeDelete( p_playlist
, p_item
, true, false );
812 /* And finally, remove it from the tree */
816 /******* Volume III: Sorting and searching ********/
817 void PLModel::sort( int column
, Qt::SortOrder order
)
819 sort( rootItem
->i_id
, column
, order
);
822 void PLModel::sort( int i_root_id
, int column
, Qt::SortOrder order
)
824 int meta
= columnToMeta( column
);
825 if( meta
== COLUMN_END
) return;
827 PLItem
*item
= findById( rootItem
, i_root_id
);
829 QModelIndex qIndex
= index( item
, 0 );
830 int count
= item
->children
.size();
833 beginRemoveRows( qIndex
, 0, count
- 1 );
834 item
->removeChildren();
840 playlist_item_t
*p_root
= playlist_ItemGetById( p_playlist
,
844 playlist_RecursiveNodeSort( p_playlist
, p_root
,
845 i_column_sorting( meta
),
846 order
== Qt::AscendingOrder
?
847 ORDER_NORMAL
: ORDER_REVERSE
);
851 i_cached_id
= i_cached_input_id
= -1;
855 beginInsertRows( qIndex
, 0, count
- 1 );
856 updateChildren( item
);
862 void PLModel::search( const QString
& search_text
)
864 /** \todo Fire the search with a small delay ? */
867 playlist_item_t
*p_root
= playlist_ItemGetById( p_playlist
,
870 const char *psz_name
= search_text
.toUtf8().data();
871 playlist_LiveSearchUpdate( p_playlist
, p_root
, psz_name
);
877 /*********** Popup *********/
878 void PLModel::popup( QModelIndex
& index
, QPoint
&point
, QModelIndexList list
)
880 int i_id
= index
.isValid() ? itemId( index
) : rootItem
->i_id
;
883 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, i_id
);
888 i_popup_item
= index
.isValid() ? p_item
->i_id
: -1;
889 i_popup_parent
= index
.isValid() ?
890 ( p_item
->p_parent
? p_item
->p_parent
->i_id
: -1 ) :
892 i_popup_column
= index
.column();
893 /* check whether we are in tree view */
895 playlist_item_t
*p_up
= p_item
;
898 if ( p_up
== p_playlist
->p_root_category
) tree
= true;
899 p_up
= p_up
->p_parent
;
903 current_selection
= list
;
906 if( i_popup_item
> -1 )
908 menu
.addAction( qtr(I_POP_PLAY
), this, SLOT( popupPlay() ) );
909 menu
.addAction( qtr(I_POP_DEL
), this, SLOT( popupDel() ) );
911 menu
.addAction( qtr(I_POP_STREAM
), this, SLOT( popupStream() ) );
912 menu
.addAction( qtr(I_POP_SAVE
), this, SLOT( popupSave() ) );
914 menu
.addAction( qtr(I_POP_INFO
), this, SLOT( popupInfo() ) );
916 QMenu
*sort_menu
= menu
.addMenu( qtr( "Sort by ") +
917 qfu( psz_column_title( columnToMeta( index
.column() ) ) ) );
918 sort_menu
->addAction( qtr( "Ascending" ),
919 this, SLOT( popupSortAsc() ) );
920 sort_menu
->addAction( qtr( "Descending" ),
921 this, SLOT( popupSortDesc() ) );
923 if( tree
&& canEdit() )
924 menu
.addAction( qtr(I_POP_ADD
), this, SLOT( popupAddNode() ) );
925 if( i_popup_item
> -1 )
928 menu
.addAction( qtr( I_POP_EXPLORE
), this, SLOT( popupExplore() ) );
930 if( !menu
.isEmpty() ) menu
.exec( point
);
933 void PLModel::popupDel()
935 doDelete( current_selection
);
938 void PLModel::popupPlay()
942 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
,
944 activateItem( p_item
);
949 void PLModel::popupInfo()
952 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
,
956 input_item_t
* p_input
= p_item
->p_input
;
957 vlc_gc_incref( p_input
);
959 MediaInfoDialog
*mid
= new MediaInfoDialog( p_intf
, p_input
);
960 vlc_gc_decref( p_input
);
961 mid
->setParent( PlaylistDialog::getInstance( p_intf
),
968 void PLModel::popupStream()
970 QStringList mrls
= selectedURIs();
971 if( !mrls
.isEmpty() )
972 THEDP
->streamingDialog( NULL
, mrls
[0], false );
976 void PLModel::popupSave()
978 QStringList mrls
= selectedURIs();
979 if( !mrls
.isEmpty() )
980 THEDP
->streamingDialog( NULL
, mrls
[0] );
985 #include <QDesktopServices>
986 void PLModel::popupExplore()
989 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
,
993 input_item_t
*p_input
= p_item
->p_input
;
994 char *psz_meta
= input_item_GetURI( p_input
);
998 const char *psz_access
;
999 const char *psz_demux
;
1001 input_SplitMRL( &psz_access
, &psz_demux
, &psz_path
, psz_meta
);
1003 if( EMPTY_STR( psz_access
) ||
1004 !strncasecmp( psz_access
, "file", 4 ) ||
1005 !strncasecmp( psz_access
, "dire", 4 ) )
1007 QFileInfo
info( qfu( psz_meta
) );
1008 QDesktopServices::openUrl(
1009 QUrl::fromLocalFile( info
.absolutePath() ) );
1018 #include <QInputDialog>
1019 void PLModel::popupAddNode()
1022 QString name
= QInputDialog::getText( PlaylistDialog::getInstance( p_intf
),
1023 qtr( I_POP_ADD
), qtr( "Enter name for new node:" ),
1024 QLineEdit::Normal
, QString(), &ok
);
1025 if( !ok
|| name
.isEmpty() ) return;
1027 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
,
1031 playlist_NodeCreate( p_playlist
, qtu( name
), p_item
, 0, NULL
);
1036 void PLModel::popupSortAsc()
1038 sort( i_popup_parent
, i_popup_column
, Qt::AscendingOrder
);
1041 void PLModel::popupSortDesc()
1043 sort( i_popup_parent
, i_popup_column
, Qt::DescendingOrder
);