X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fgui%2Fqt4%2Fcomponents%2Fplaylist%2Fplaylist_model.cpp;h=54b4fbbe8adaabe544b10c3cc675d7104357bef2;hb=c745ebb55acfb4978e04a10992a98832c3fd7034;hp=29595620a18ad28a16a723e9b0a13d28127590a9;hpb=367c7701ec182923401425a43f8c0457bfb93922;p=vlc diff --git a/modules/gui/qt4/components/playlist/playlist_model.cpp b/modules/gui/qt4/components/playlist/playlist_model.cpp index 29595620a1..54b4fbbe8a 100644 --- a/modules/gui/qt4/components/playlist/playlist_model.cpp +++ b/modules/gui/qt4/components/playlist/playlist_model.cpp @@ -1,7 +1,7 @@ /***************************************************************************** * playlist_model.cpp : Manage playlist model **************************************************************************** - * Copyright (C) 2006-2007 the VideoLAN team + * Copyright (C) 2006-2011 the VideoLAN team * $Id$ * * Authors: Clément Stenac @@ -28,22 +28,32 @@ #endif #include "qt4.hpp" -#include "dialogs_provider.hpp" #include "components/playlist/playlist_model.hpp" -#include "dialogs/mediainfo.hpp" -#include "dialogs/playlist.hpp" -#include +#include "dialogs_provider.hpp" /* THEDP */ +#include "input_manager.hpp" /* THEMIM */ +#include "dialogs/mediainfo.hpp" /* MediaInfo Dialog */ +#include "dialogs/playlist.hpp" /* Playlist Dialog */ + +#include /* I_DIR */ #include "pixmaps/types/type_unknown.xpm" +#include "sorting.h" #include #include #include #include -#include -#include +#include +#include +#include +#include +#include -#include "sorting.h" +#define I_NEW_DIR \ + I_DIR_OR_FOLDER( N_("Create Directory"), N_( "Create Folder" ) ) +#define I_NEW_DIR_NAME \ + I_DIR_OR_FOLDER( N_( "Enter name for new directory:" ), \ + N_( "Enter name for new folder:" ) ) QIcon PLModel::icons[ITEM_TYPE_NUMBER]; @@ -55,13 +65,13 @@ PLModel::PLModel( playlist_t *_p_playlist, /* THEPL */ intf_thread_t *_p_intf, /* main Qt p_intf */ playlist_item_t * p_root, QObject *parent ) /* Basic Qt parent */ - : QAbstractItemModel( parent ) + : VLCModel( _p_intf, parent ) { - p_intf = _p_intf; p_playlist = _p_playlist; i_cached_id = -1; i_cached_input_id = -1; i_popup_item = i_popup_parent = -1; + sortingMenu = NULL; rootItem = NULL; /* PLItem rootItem, will be set in rebuild( ) */ @@ -78,11 +88,13 @@ PLModel::PLModel( playlist_t *_p_playlist, /* THEPL */ ADD_ICON( NODE, ":/type/node" ); #undef ADD_ICON + i_zoom = getSettings()->value( "Playlist/zoom", 0 ).toInt(); + rebuild( p_root ); - CONNECT( THEMIM->getIM(), metaChanged( input_item_t *), - this, processInputItemUpdate( input_item_t *) ); - CONNECT( THEMIM, inputChanged( input_thread_t * ), - this, processInputItemUpdate( input_thread_t* ) ); + DCONNECT( THEMIM->getIM(), metaChanged( input_item_t *), + this, processInputItemUpdate( input_item_t *) ); + DCONNECT( THEMIM, inputChanged( input_thread_t * ), + this, processInputItemUpdate( input_thread_t* ) ); CONNECT( THEMIM, playlistItemAppended( int, int ), this, processItemAppend( int, int ) ); CONNECT( THEMIM, playlistItemRemoved( int ), @@ -91,19 +103,21 @@ PLModel::PLModel( playlist_t *_p_playlist, /* THEPL */ PLModel::~PLModel() { + getSettings()->setValue( "Playlist/zoom", i_zoom ); delete rootItem; + delete sortingMenu; } Qt::DropActions PLModel::supportedDropActions() const { - return Qt::CopyAction; /* Why not Qt::MoveAction */ + return Qt::CopyAction | Qt::MoveAction; } Qt::ItemFlags PLModel::flags( const QModelIndex &index ) const { Qt::ItemFlags flags = QAbstractItemModel::flags( index ); - PLItem *item = index.isValid() ? getItem( index ) : rootItem; + const PLItem *item = index.isValid() ? getItem( index ) : rootItem; if( canEdit() ) { @@ -125,15 +139,22 @@ Qt::ItemFlags PLModel::flags( const QModelIndex &index ) const QStringList PLModel::mimeTypes() const { QStringList types; - types << "vlc/qt-playlist-item"; + types << "vlc/qt-input-items"; return types; } +bool modelIndexLessThen( const QModelIndex &i1, const QModelIndex &i2 ) +{ + if( !i1.isValid() || !i2.isValid() ) return false; + PLItem *item1 = static_cast( i1.internalPointer() ); + PLItem *item2 = static_cast( i2.internalPointer() ); + if( item1->parent() == item2->parent() ) return i1.row() < i2.row(); + else return *item1 < *item2; +} + QMimeData *PLModel::mimeData( const QModelIndexList &indexes ) const { - QMimeData *mimeData = new QMimeData(); - QByteArray encodedData; - QDataStream stream( &encodedData, QIODevice::WriteOnly ); + PlMimeData *plMimeData = new PlMimeData(); QModelIndexList list; foreach( const QModelIndex &index, indexes ) { @@ -141,136 +162,135 @@ QMimeData *PLModel::mimeData( const QModelIndexList &indexes ) const list.append(index); } - qSort(list); + qSort(list.begin(), list.end(), modelIndexLessThen); + PLItem *item = NULL; foreach( const QModelIndex &index, list ) { - PLItem *item = getItem( index ); - stream.writeRawData( (char*) &item, sizeof( PLItem* ) ); + if( item ) + { + PLItem *testee = getItem( index ); + while( testee->parent() ) + { + if( testee->parent() == item || + testee->parent() == item->parent() ) break; + testee = testee->parent(); + } + if( testee->parent() == item ) continue; + item = getItem( index ); + } + else + item = getItem( index ); + + plMimeData->appendItem( item->inputItem() ); } - mimeData->setData( "vlc/qt-playlist-item", encodedData ); - return mimeData; + + return plMimeData; } /* Drop operation */ bool PLModel::dropMimeData( const QMimeData *data, Qt::DropAction action, - int row, int column, const QModelIndex &parent ) + int row, int, const QModelIndex &parent ) { - if( data->hasFormat( "vlc/qt-playlist-item" ) ) - { - if( action == Qt::IgnoreAction ) - return true; - - PLItem *parentItem = parent.isValid() ? getItem( parent ) : rootItem; - - PL_LOCK; - playlist_item_t *p_parent = - playlist_ItemGetById( p_playlist, parentItem->i_id ); - if( !p_parent || p_parent->i_children == -1 ) - { - PL_UNLOCK; - return false; - } + bool copy = action == Qt::CopyAction; + if( !copy && action != Qt::MoveAction ) + return true; - bool copy = false; - playlist_item_t *p_pl = p_playlist->p_playing; - playlist_item_t *p_ml = p_playlist->p_media_library; - if - ( - row == -1 && ( - ( p_pl && p_parent == p_pl ) || - ( p_ml && p_parent == p_ml ) ) - ) - copy = true; - PL_UNLOCK; - - QByteArray encodedData = data->data( "vlc/qt-playlist-item" ); + const PlMimeData *plMimeData = qobject_cast( data ); + if( plMimeData ) + { if( copy ) - dropAppendCopy( encodedData, parentItem ); + dropAppendCopy( plMimeData, getItem( parent ), row ); else - dropMove( encodedData, parentItem, row ); + dropMove( plMimeData, getItem( parent ), row ); } return true; } -void PLModel::dropAppendCopy( QByteArray& data, PLItem *target ) +void PLModel::dropAppendCopy( const PlMimeData *plMimeData, PLItem *target, int pos ) { - QDataStream stream( &data, QIODevice::ReadOnly ); - PL_LOCK; + playlist_item_t *p_parent = - playlist_ItemGetById( p_playlist, target->i_id ); - while( !stream.atEnd() ) + playlist_ItemGetByInput( p_playlist, target->inputItem() ); + if( !p_parent ) return; + + if( pos == -1 ) pos = PLAYLIST_END; + + QList inputItems = plMimeData->inputItems(); + + foreach( input_item_t* p_input, inputItems ) { - PLItem *item; - stream.readRawData( (char*)&item, sizeof(PLItem*) ); - playlist_item_t *p_item = playlist_ItemGetById( p_playlist, item->i_id ); + playlist_item_t *p_item = playlist_ItemGetByInput( p_playlist, p_input ); if( !p_item ) continue; - input_item_t *p_input = p_item->p_input; - playlist_AddExt ( p_playlist, - p_input->psz_uri, p_input->psz_name, - PLAYLIST_APPEND | PLAYLIST_SPREPARSE, PLAYLIST_END, - p_input->i_duration, - p_input->i_options, p_input->ppsz_options, p_input->optflagc, - p_parent == p_playlist->p_playing, - true ); + pos = playlist_NodeAddCopy( p_playlist, p_item, p_parent, pos ); } + PL_UNLOCK; } -void PLModel::dropMove( QByteArray& data, PLItem *target, int row ) +void PLModel::dropMove( const PlMimeData * plMimeData, PLItem *target, int row ) { - QDataStream stream( &data, QIODevice::ReadOnly ); + QList inputItems = plMimeData->inputItems(); QList model_items; - QList ids; - int new_pos = row == -1 ? target->children.size() : row; + playlist_item_t *pp_items[inputItems.count()]; + + PL_LOCK; + + playlist_item_t *p_parent = + playlist_ItemGetByInput( p_playlist, target->inputItem() ); + + if( !p_parent || row > p_parent->i_children ) + { + PL_UNLOCK; return; + } + + int new_pos = row == -1 ? p_parent->i_children : row; int model_pos = new_pos; - while( !stream.atEnd() ) + int i = 0; + + foreach( input_item_t *p_input, inputItems ) { - PLItem *item; - stream.readRawData( (char*)&item, sizeof(PLItem*) ); + playlist_item_t *p_item = playlist_ItemGetByInput( p_playlist, p_input ); + if( !p_item ) continue; + + PLItem *item = findByInput( rootItem, p_input->i_id ); + if( !item ) continue; - /* better not try to move a node into itself: */ + /* Better not try to move a node into itself. + Abort the whole operation in that case, + because it is ambiguous. */ PLItem *climber = target; while( climber ) { - if( climber == item ) break; - climber = climber->parentItem; + if( climber == item ) + { + PL_UNLOCK; return; + } + climber = climber->parent(); } - if( climber ) continue; - if( item->parentItem == target && - target->children.indexOf( item ) < model_pos ) - model_pos--; + if( item->parent() == target && + target->children.indexOf( item ) < new_pos ) + model_pos--; - ids.append( item->i_id ); model_items.append( item ); - - takeItem( item ); + pp_items[i] = p_item; + i++; } - int count = ids.size(); - if( count ) + + if( model_items.isEmpty() ) { - playlist_item_t *pp_items[count]; + PL_UNLOCK; return; + } - PL_LOCK; - for( int i = 0; i < count; i++ ) - { - playlist_item_t *p_item = playlist_ItemGetById( p_playlist, ids[i] ); - if( !p_item ) - { - PL_UNLOCK; - return; - } - pp_items[i] = p_item; - } - playlist_item_t *p_parent = - playlist_ItemGetById( p_playlist, target->i_id ); - playlist_TreeMoveMany( p_playlist, count, pp_items, p_parent, - new_pos ); - PL_UNLOCK; + playlist_TreeMoveMany( p_playlist, i, pp_items, p_parent, new_pos ); - insertChildren( target, model_items, model_pos ); - } + PL_UNLOCK; + + foreach( PLItem *item, model_items ) + takeItem( item ); + + insertChildren( target, model_items, model_pos ); } /* remove item with its id */ @@ -283,7 +303,7 @@ void PLModel::removeItem( int i_id ) void PLModel::activateItem( const QModelIndex &index ) { assert( index.isValid() ); - PLItem *item = getItem( index ); + const PLItem *item = getItem( index ); assert( item ); PL_LOCK; playlist_item_t *p_item = playlist_ItemGetById( p_playlist, item->i_id ); @@ -298,19 +318,19 @@ void PLModel::activateItem( playlist_item_t *p_item ) playlist_item_t *p_parent = p_item; while( p_parent ) { - if( p_parent->i_id == rootItem->i_id ) break; + if( p_parent->i_id == rootItem->id() ) break; p_parent = p_parent->p_parent; } if( p_parent ) playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, - p_parent, p_item ); + p_parent, p_item ); } /****************** Base model mandatory implementations *****************/ -QVariant PLModel::data( const QModelIndex &index, int role ) const +QVariant PLModel::data( const QModelIndex &index, const int role ) const { if( !index.isValid() ) return QVariant(); - PLItem *item = getItem( index ); + const PLItem *item = getItem( index ); if( role == Qt::DisplayRole ) { int metadata = columnToMeta( index.column() ); @@ -319,9 +339,24 @@ QVariant PLModel::data( const QModelIndex &index, int role ) const QString returninfo; if( metadata == COLUMN_NUMBER ) returninfo = QString::number( index.row() + 1 ); + else if( metadata == COLUMN_COVER ) + { + QString artUrl; + artUrl = InputManager::decodeArtURL( item->inputItem() ); + if( artUrl.isEmpty() ) + { + for( int i = 0; i < item->childCount(); i++ ) + { + artUrl = InputManager::decodeArtURL( item->child( i )->inputItem() ); + if( !artUrl.isEmpty() ) + break; + } + } + return QVariant( artUrl ); + } else { - char *psz = psz_column_meta( item->p_input, metadata ); + char *psz = psz_column_meta( item->inputItem(), metadata ); returninfo = qfu( psz ); free( psz ); } @@ -330,34 +365,64 @@ QVariant PLModel::data( const QModelIndex &index, int role ) const else if( role == Qt::DecorationRole && index.column() == 0 ) { /* Used to segfault here because i_type wasn't always initialized */ - return QVariant( PLModel::icons[item->p_input->i_type] ); + return QVariant( PLModel::icons[item->inputItem()->i_type] ); } else if( role == Qt::FontRole ) { + QFont f; + f.setPointSize( f.pointSize() - 1 + i_zoom ); if( isCurrent( index ) ) - { - QFont f; f.setBold( true ); return QVariant( f ); - } + f.setBold( true ); + return QVariant( f ); } else if( role == Qt::BackgroundRole && isCurrent( index ) ) { return QVariant( QBrush( Qt::gray ) ); } else if( role == IsCurrentRole ) return QVariant( isCurrent( index ) ); + else if( role == IsLeafNodeRole ) + { + QVariant isLeaf; + PL_LOCK; + playlist_item_t *plItem = + playlist_ItemGetById( p_playlist, item->i_id ); + if( plItem ) + isLeaf = plItem->i_children == -1; + + PL_UNLOCK; + return isLeaf; + } + else if( role == IsCurrentsParentNodeRole ) + { + return QVariant( isParent( index, currentIndex() ) ); + } return QVariant(); } +/* Seek from current index toward the top and see if index is one of parent nodes */ +bool PLModel::isParent( const QModelIndex &index, const QModelIndex ¤t ) const +{ + if( !index.isValid() ) + return false; + + if( index == current ) + return true; + + if( !current.isValid() || !current.parent().isValid() ) + return false; + + return isParent( index, current.parent() ); +} + bool PLModel::isCurrent( const QModelIndex &index ) const { - input_thread_t *p_input_thread = THEMIM->getInput(); - if( !p_input_thread ) return false; - return getItem( index )->p_input == input_GetItem( p_input_thread ); + return getItem( index )->inputItem() == THEMIM->currentInputItem(); } int PLModel::itemId( const QModelIndex &index ) const { - return getItem( index )->i_id; + return getItem( index )->id(); } QVariant PLModel::headerData( int section, Qt::Orientation orientation, @@ -373,7 +438,7 @@ QVariant PLModel::headerData( int section, Qt::Orientation orientation, return QVariant( qfu( psz_column_title( meta_col ) ) ); } -QModelIndex PLModel::index( int row, int column, const QModelIndex &parent ) +QModelIndex PLModel::index( const int row, const int column, const QModelIndex &parent ) const { PLItem *parentItem = parent.isValid() ? getItem( parent ) : rootItem; @@ -385,9 +450,9 @@ QModelIndex PLModel::index( int row, int column, const QModelIndex &parent ) return QModelIndex(); } -QModelIndex PLModel::index( int i_id, int c ) +QModelIndex PLModel::index( const int i_id, const int c ) { - return index( findById( rootItem, i_id ), c ); + return index( findById( rootItem, i_id ), c ); } /* Return the index of a given item */ @@ -401,7 +466,7 @@ QModelIndex PLModel::index( PLItem *item, int column ) const return QModelIndex(); } -QModelIndex PLModel::currentIndex() +QModelIndex PLModel::currentIndex() const { input_thread_t *p_input_thread = THEMIM->getInput(); if( !p_input_thread ) return QModelIndex(); @@ -422,33 +487,32 @@ QModelIndex PLModel::parent( const QModelIndex &index ) const PLItem *parentItem = childItem->parent(); if( !parentItem || parentItem == rootItem ) return QModelIndex(); - if( !parentItem->parentItem ) + if( !parentItem->parent() ) { msg_Err( p_playlist, "No parent parent, trying row 0 " ); msg_Err( p_playlist, "----- PLEASE REPORT THIS ------" ); return createIndex( 0, 0, parentItem ); } - QModelIndex ind = createIndex(parentItem->row(), 0, parentItem); - return ind; + return createIndex(parentItem->row(), 0, parentItem); } -int PLModel::columnCount( const QModelIndex &i) const +int PLModel::columnCount( const QModelIndex &) const { return columnFromMeta( COLUMN_END ); } int PLModel::rowCount( const QModelIndex &parent ) const { - PLItem *parentItem = parent.isValid() ? getItem( parent ) : rootItem; + const PLItem *parentItem = parent.isValid() ? getItem( parent ) : rootItem; return parentItem->childCount(); } QStringList PLModel::selectedURIs() { QStringList lst; - for( int i = 0; i < current_selection.size(); i++ ) + for( int i = 0; i < current_selection.count(); i++ ) { - PLItem *item = getItem( current_selection[i] ); + const PLItem *item = getItem( current_selection[i] ); if( item ) { PL_LOCK; @@ -468,116 +532,60 @@ QStringList PLModel::selectedURIs() return lst; } - /************************* Lookups *****************************/ - -PLItem *PLModel::findById( PLItem *root, int i_id ) +PLItem *PLModel::findById( PLItem *root, int i_id ) const { return findInner( root, i_id, false ); } -PLItem *PLModel::findByInput( PLItem *root, int i_id ) +PLItem *PLModel::findByInput( PLItem *root, int i_id ) const { PLItem *result = findInner( root, i_id, true ); return result; } -#define CACHE( i, p ) { i_cached_id = i; p_cached_item = p; } -#define ICACHE( i, p ) { i_cached_input_id = i; p_cached_item_bi = p; } - -PLItem * PLModel::findInner( PLItem *root, int i_id, bool b_input ) +PLItem * PLModel::findInner( PLItem *root, int i_id, bool b_input ) const { if( !root ) return NULL; - if( ( !b_input && i_cached_id == i_id) || - ( b_input && i_cached_input_id ==i_id ) ) - { - return b_input ? p_cached_item_bi : p_cached_item; - } - if( !b_input && root->i_id == i_id ) - { - CACHE( i_id, root ); + if( !b_input && root->id() == i_id ) return root; - } - else if( b_input && root->p_input->i_id == i_id ) - { - ICACHE( i_id, root ); + + else if( b_input && root->inputItem()->i_id == i_id ) return root; - } QList::iterator it = root->children.begin(); while ( it != root->children.end() ) { - if( !b_input && (*it)->i_id == i_id ) - { - CACHE( i_id, (*it) ); - return p_cached_item; - } - else if( b_input && (*it)->p_input->i_id == i_id ) - { - ICACHE( i_id, (*it) ); - return p_cached_item_bi; - } - if( (*it)->children.size() ) + if( !b_input && (*it)->id() == i_id ) + return (*it); + + else if( b_input && (*it)->inputItem()->i_id == i_id ) + return (*it); + + if( (*it)->childCount() ) { PLItem *childFound = findInner( (*it), i_id, b_input ); if( childFound ) - { - if( b_input ) - ICACHE( i_id, childFound ) - else - CACHE( i_id, childFound ) return childFound; - } } - it++; + ++it; } return NULL; } -#undef CACHE -#undef ICACHE - -int PLModel::columnToMeta( int _column ) -{ - int meta = 1; - int column = 0; - - while( column != _column && meta != COLUMN_END ) - { - meta <<= 1; - column++; - } - - return meta; -} - -int PLModel::columnFromMeta( int meta_col ) -{ - int meta = 1; - int column = 0; - - while( meta != meta_col && meta != COLUMN_END ) - { - meta <<= 1; - column++; - } - - return column; -} bool PLModel::canEdit() const { - return ( - rootItem != NULL && - ( - rootItem->p_input == p_playlist->p_playing->p_input || - ( - p_playlist->p_media_library && - rootItem->p_input == p_playlist->p_media_library->p_input - ) - ) - ); + return ( + rootItem != NULL && + ( + rootItem->inputItem() == p_playlist->p_playing->p_input || + ( p_playlist->p_media_library && + rootItem->inputItem() == p_playlist->p_media_library->p_input ) + ) + ); } + /************************* Updates handling *****************************/ /**** Events processing ****/ @@ -610,52 +618,48 @@ void PLModel::processItemAppend( int i_item, int i_parent ) { playlist_item_t *p_item = NULL; PLItem *newItem = NULL; - input_thread_t *currentInputThread; int pos; - PLItem *nodeItem = findById( rootItem, i_parent ); - if( !nodeItem ) return; + /* Find the Parent */ + PLItem *nodeParentItem = findById( rootItem, i_parent ); + if( !nodeParentItem ) return; - foreach( PLItem *existing, nodeItem->children ) - if( existing->i_id == i_item ) return; + /* Search for an already matching children */ + foreach( const PLItem *existing, nodeParentItem->children ) + if( existing->i_id == i_item ) return; + /* Find the child */ PL_LOCK; p_item = playlist_ItemGetById( p_playlist, i_item ); - if( !p_item || p_item->i_flags & PLAYLIST_DBL_FLAG ) goto end; + if( !p_item || p_item->i_flags & PLAYLIST_DBL_FLAG ) + { + PL_UNLOCK; return; + } for( pos = 0; pos < p_item->p_parent->i_children; pos++ ) if( p_item->p_parent->pp_children[pos] == p_item ) break; - newItem = new PLItem( p_item, nodeItem ); + newItem = new PLItem( p_item, nodeParentItem ); PL_UNLOCK; - beginInsertRows( index( nodeItem, 0 ), pos, pos ); - nodeItem->insertChild( newItem, pos ); + /* We insert the newItem (children) inside the parent */ + beginInsertRows( index( nodeParentItem, 0 ), pos, pos ); + nodeParentItem->insertChild( newItem, pos ); endInsertRows(); - return; -end: - PL_UNLOCK; - return; -} - - -void PLModel::rebuild() -{ - rebuild( NULL ); + if( newItem->inputItem() == THEMIM->currentInputItem() ) + emit currentChanged( index( newItem, 0 ) ); } void PLModel::rebuild( playlist_item_t *p_root ) { - playlist_item_t* p_item; - /* Invalidate cache */ i_cached_id = i_cached_input_id = -1; if( rootItem ) rootItem->removeChildren(); PL_LOCK; - if( p_root ) + if( p_root ) // Can be NULL { delete rootItem; rootItem = new PLItem( p_root ); @@ -674,7 +678,7 @@ void PLModel::rebuild( playlist_item_t *p_root ) void PLModel::takeItem( PLItem *item ) { assert( item ); - PLItem *parent = item->parentItem; + PLItem *parent = item->parent(); assert( parent ); int i_index = parent->children.indexOf( item ); @@ -686,8 +690,9 @@ void PLModel::takeItem( PLItem *item ) void PLModel::insertChildren( PLItem *node, QList& items, int i_pos ) { assert( node ); - int count = items.size(); + int count = items.count(); if( !count ) return; + printf( "Here I am\n"); beginInsertRows( index( node, 0 ), i_pos, i_pos + count - 1 ); for( int i = 0; i < count; i++ ) { @@ -701,13 +706,13 @@ void PLModel::removeItem( PLItem *item ) { if( !item ) return; - if( item->i_id == i_cached_id ) i_cached_id = -1; + i_cached_id = -1; i_cached_input_id = -1; - if( item->parentItem ) { - int i = item->parentItem->children.indexOf( item ); - beginRemoveRows( index( item->parentItem, 0), i, i ); - item->parentItem->children.removeAt(i); + if( item->parent() ) { + int i = item->parent()->children.indexOf( item ); + beginRemoveRows( index( item->parent(), 0), i, i ); + item->parent()->children.removeAt(i); delete item; endRemoveRows(); } @@ -723,7 +728,7 @@ void PLModel::removeItem( PLItem *item ) /* This function must be entered WITH the playlist lock */ void PLModel::updateChildren( PLItem *root ) { - playlist_item_t *p_node = playlist_ItemGetById( p_playlist, root->i_id ); + playlist_item_t *p_node = playlist_ItemGetById( p_playlist, root->id() ); updateChildren( p_node, root ); } @@ -750,10 +755,8 @@ void PLModel::updateTreeItem( PLItem *item ) /************************* Actions ******************************/ /** - * Deletion, here we have to do a ugly slow hack as we retrieve the full - * list of indexes to delete at once: when we delete a node and all of - * its children, we need to update the list. - * Todo: investigate whethere we can use ranges to be sure to delete all items? + * Deletion, don't delete items childrens if item is going to be + * delete allready, so we remove childrens from selection-list. */ void PLModel::doDelete( QModelIndexList selected ) { @@ -767,11 +770,11 @@ void PLModel::doDelete( QModelIndexList selected ) if( index.column() != 0 ) continue; PLItem *item = getItem( index ); - if( item->children.size() ) + if( item->childCount() ) recurseDelete( item->children, &selected ); PL_LOCK; - playlist_DeleteFromInput( p_playlist, item->p_input, pl_Locked ); + playlist_DeleteFromInput( p_playlist, item->inputItem(), pl_Locked ); PL_UNLOCK; removeItem( item ); @@ -780,22 +783,22 @@ void PLModel::doDelete( QModelIndexList selected ) void PLModel::recurseDelete( QList children, QModelIndexList *fullList ) { - for( int i = children.size() - 1; i >= 0 ; i-- ) + for( int i = children.count() - 1; i >= 0 ; i-- ) { PLItem *item = children[i]; - if( item->children.size() ) + if( item->childCount() ) recurseDelete( item->children, fullList ); fullList->removeAll( index( item, 0 ) ); } } /******* Volume III: Sorting and searching ********/ -void PLModel::sort( int column, Qt::SortOrder order ) +void PLModel::sort( const int column, Qt::SortOrder order ) { - sort( rootItem->i_id, column, order ); + sort( rootItem->id(), column, order ); } -void PLModel::sort( int i_root_id, int column, Qt::SortOrder order ) +void PLModel::sort( const int i_root_id, const int column, Qt::SortOrder order ) { msg_Dbg( p_intf, "Sorting by column %i, order %i", column, order ); @@ -805,7 +808,7 @@ void PLModel::sort( int i_root_id, int column, Qt::SortOrder order ) PLItem *item = findById( rootItem, i_root_id ); if( !item ) return; QModelIndex qIndex = index( item, 0 ); - int count = item->children.size(); + int count = item->childCount(); if( count ) { beginRemoveRows( qIndex, 0, count - 1 ); @@ -835,6 +838,15 @@ void PLModel::sort( int i_root_id, int column, Qt::SortOrder order ) endInsertRows( ); } PL_UNLOCK; + /* if we have popup item, try to make sure that you keep that item visible */ + if( i_popup_item > -1 ) + { + PLItem *popupitem = findById( rootItem, i_popup_item ); + if( popupitem ) emit currentChanged( index( popupitem, 0 ) ); + /* reset i_popup_item as we don't show it as selected anymore anyway */ + i_popup_item = -1; + } + else if( currentIndex().isValid() ) emit currentChanged( currentIndex() ); } void PLModel::search( const QString& search_text, const QModelIndex & idx, bool b_recursive ) @@ -845,19 +857,18 @@ void PLModel::search( const QString& search_text, const QModelIndex & idx, bool playlist_item_t *p_root = playlist_ItemGetById( p_playlist, itemId( idx ) ); assert( p_root ); - const char *psz_name = search_text.toUtf8().data(); - playlist_LiveSearchUpdate( p_playlist , p_root, psz_name, b_recursive ); - + playlist_LiveSearchUpdate( p_playlist , p_root, qtu( search_text ), + b_recursive ); if( idx.isValid() ) { PLItem *searchRoot = getItem( idx ); - beginRemoveRows( idx, 0, searchRoot->children.size() - 1 ); + beginRemoveRows( idx, 0, searchRoot->childCount() - 1 ); searchRoot->removeChildren(); endRemoveRows( ); - beginInsertRows( idx, 0, searchRoot->children.size() - 1 ); - updateChildren( searchRoot ); + beginInsertRows( idx, 0, searchRoot->childCount() - 1 ); + updateChildren( searchRoot ); // The PL_LOCK is needed here endInsertRows(); PL_UNLOCK; @@ -871,7 +882,7 @@ void PLModel::search( const QString& search_text, const QModelIndex & idx, bool /*********** Popup *********/ bool PLModel::popup( const QModelIndex & index, const QPoint &point, const QModelIndexList &list ) { - int i_id = index.isValid() ? itemId( index ) : rootItem->i_id; + int i_id = index.isValid() ? itemId( index ) : rootItem->id(); PL_LOCK; playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_id ); @@ -881,13 +892,17 @@ bool PLModel::popup( const QModelIndex & index, const QPoint &point, const QMode return false; } + input_item_t *p_input = p_item->p_input; + vlc_gc_incref( p_input ); + i_popup_item = index.isValid() ? p_item->i_id : -1; i_popup_parent = index.isValid() ? ( p_item->p_parent ? p_item->p_parent->i_id : -1 ) : - ( rootItem->i_id ); + ( rootItem->id() ); i_popup_column = index.column(); - bool tree = var_InheritBool( p_intf, "playlist-tree" ); + bool tree = ( rootItem && rootItem->id() != p_playlist->p_playing->i_id ) || + var_InheritBool( p_intf, "playlist-tree" ); PL_UNLOCK; @@ -897,30 +912,32 @@ bool PLModel::popup( const QModelIndex & index, const QPoint &point, const QMode if( i_popup_item > -1 ) { menu.addAction( QIcon( ":/menu/play" ), qtr(I_POP_PLAY), this, SLOT( popupPlay() ) ); - menu.addAction( QIcon( ":/buttons/playlist/playlist_remove" ), - qtr(I_POP_DEL), this, SLOT( popupDel() ) ); - menu.addSeparator(); menu.addAction( QIcon( ":/menu/stream" ), qtr(I_POP_STREAM), this, SLOT( popupStream() ) ); menu.addAction( qtr(I_POP_SAVE), this, SLOT( popupSave() ) ); - menu.addSeparator(); menu.addAction( QIcon( ":/menu/info" ), qtr(I_POP_INFO), this, SLOT( popupInfo() ) ); - menu.addAction( QIcon( ":/type/folder-grey" ), - qtr( I_POP_EXPLORE ), this, SLOT( popupExplore() ) ); + if( p_input->psz_uri && !strncasecmp( p_input->psz_uri, "file://", 7 ) ) + { + menu.addAction( QIcon( ":/type/folder-grey" ), + qtr( I_POP_EXPLORE ), this, SLOT( popupExplore() ) ); + } + menu.addSeparator(); } + vlc_gc_decref( p_input ); + if( canEdit() ) { QIcon addIcon( ":/buttons/playlist/playlist_add" ); menu.addSeparator(); if( tree ) menu.addAction( addIcon, qtr(I_POP_NEWFOLDER), this, SLOT( popupAddNode() ) ); - if( rootItem->i_id == THEPL->p_playing->i_id ) + if( rootItem->id() == THEPL->p_playing->i_id ) { menu.addAction( addIcon, qtr(I_PL_ADDF), THEDP, SLOT( simplePLAppendDialog()) ); menu.addAction( addIcon, qtr(I_PL_ADDDIR), THEDP, SLOT( PLAppendDir()) ); menu.addAction( addIcon, qtr(I_OP_ADVOP), THEDP, SLOT( PLAppendDialog()) ); } else if( THEPL->p_media_library && - rootItem->i_id == THEPL->p_media_library->i_id ) + rootItem->id() == THEPL->p_media_library->i_id ) { menu.addAction( addIcon, qtr(I_PL_ADDF), THEDP, SLOT( simpleMLAppendDialog()) ); menu.addAction( addIcon, qtr(I_PL_ADDDIR), THEDP, SLOT( MLAppendDir() ) ); @@ -929,14 +946,31 @@ bool PLModel::popup( const QModelIndex & index, const QPoint &point, const QMode } if( i_popup_item > -1 ) { + if( rootItem->id() != THEPL->p_playing->i_id ) + menu.addAction( qtr( "Add to playlist"), this, SLOT( popupAddToPlaylist() ) ); + menu.addAction( QIcon( ":/buttons/playlist/playlist_remove" ), + qtr(I_POP_DEL), this, SLOT( popupDel() ) ); menu.addSeparator(); - QMenu *sort_menu = menu.addMenu( qtr( "Sort by" ) + QString(" ") + - qfu( psz_column_title( columnToMeta( index.column() ) ) ) ); - sort_menu->addAction( qtr( "Ascending" ), - this, SLOT( popupSortAsc() ) ); - sort_menu->addAction( qtr( "Descending" ), - this, SLOT( popupSortDesc() ) ); + if( !sortingMenu ) + { + sortingMenu = new QMenu( qtr( "Sort by" ) ); + sortingMapper = new QSignalMapper( this ); + for( int i = 1, j = 1; i < COLUMN_END; i <<= 1, j++ ) + { + if( i == COLUMN_NUMBER ) continue; + QMenu *m = sortingMenu->addMenu( qfu( psz_column_title( i ) ) ); + QAction *asc = m->addAction( qtr("Ascending") ); + QAction *desc = m->addAction( qtr("Descending") ); + sortingMapper->setMapping( asc, j ); + sortingMapper->setMapping( desc, -j ); + CONNECT( asc, triggered(), sortingMapper, map() ); + CONNECT( desc, triggered(), sortingMapper, map() ); + } + CONNECT( sortingMapper, mapped( int ), this, popupSort( int ) ); + } + menu.addMenu( sortingMenu ); } + if( !menu.isEmpty() ) { menu.exec( point ); return true; @@ -960,6 +994,22 @@ void PLModel::popupPlay() PL_UNLOCK; } +void PLModel::popupAddToPlaylist() +{ + playlist_Lock( THEPL ); + + foreach( QModelIndex currentIndex, current_selection ) + { + playlist_item_t *p_item = playlist_ItemGetById( THEPL, getId( currentIndex ) ); + if( !p_item ) continue; + + playlist_NodeAddCopy( THEPL, p_item, + THEPL->p_playing, + PLAYLIST_END ); + } + playlist_Unlock( THEPL ); +} + void PLModel::popupInfo() { PL_LOCK; @@ -984,7 +1034,6 @@ void PLModel::popupStream() QStringList mrls = selectedURIs(); if( !mrls.isEmpty() ) THEDP->streamingDialog( NULL, mrls[0], false ); - } void PLModel::popupSave() @@ -994,65 +1043,87 @@ void PLModel::popupSave() THEDP->streamingDialog( NULL, mrls[0] ); } -#include -#include -#include void PLModel::popupExplore() { PL_LOCK; - playlist_item_t *p_item = playlist_ItemGetById( p_playlist, - i_popup_item ); + playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_popup_item ); if( p_item ) { - input_item_t *p_input = p_item->p_input; - char *psz_meta = input_item_GetURI( p_input ); - PL_UNLOCK; - if( psz_meta ) - { - const char *psz_access; - const char *psz_demux; - char *psz_path; - input_SplitMRL( &psz_access, &psz_demux, &psz_path, psz_meta ); - - if( EMPTY_STR( psz_access ) || - !strncasecmp( psz_access, "file", 4 ) || - !strncasecmp( psz_access, "dire", 4 ) ) - { - QFileInfo info( qfu( psz_meta ) ); - QDesktopServices::openUrl( - QUrl::fromLocalFile( info.absolutePath() ) ); - } - free( psz_meta ); - } + input_item_t *p_input = p_item->p_input; + char *psz_meta = input_item_GetURI( p_input ); + PL_UNLOCK; + if( psz_meta ) + { + const char *psz_access; + const char *psz_demux; + char *psz_path; + input_SplitMRL( &psz_access, &psz_demux, &psz_path, psz_meta ); + + if( !EMPTY_STR( psz_access ) && ( + !strncasecmp( psz_access, "file", 4 ) || + !strncasecmp( psz_access, "dire", 4 ) )) + { +#if defined( WIN32 ) || defined( __OS2__ ) + /* Qt openURL doesn't know to open files that starts with a / or \ */ + if( psz_path[0] == '/' || psz_path[0] == '\\' ) + psz_path++; +#endif + + QFileInfo info( qfu( decode_URI( psz_path ) ) ); + QDesktopServices::openUrl( + QUrl::fromLocalFile( info.absolutePath() ) ); + } + free( psz_meta ); + } } else PL_UNLOCK; } -#include void PLModel::popupAddNode() { bool ok; QString name = QInputDialog::getText( PlaylistDialog::getInstance( p_intf ), - qtr( "Create Folder" ), qtr( "Enter name for new folder:" ), + qtr( I_NEW_DIR ), qtr( I_NEW_DIR_NAME ), QLineEdit::Normal, QString(), &ok); if( !ok || name.isEmpty() ) return; + PL_LOCK; playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_popup_parent ); if( p_item ) - { - playlist_NodeCreate( p_playlist, qtu( name ), p_item, 0, NULL ); - } + playlist_NodeCreate( p_playlist, qtu( name ), p_item, PLAYLIST_END, 0, NULL ); PL_UNLOCK; } -void PLModel::popupSortAsc() +void PLModel::popupSort( int column ) +{ + sort( i_popup_parent, + column > 0 ? column - 1 : -column - 1, + column > 0 ? Qt::AscendingOrder : Qt::DescendingOrder ); +} + +/******************* Drag and Drop helper class ******************/ +PlMimeData::~PlMimeData() +{ + foreach( input_item_t *p_item, _inputItems ) + vlc_gc_decref( p_item ); +} + +void PlMimeData::appendItem( input_item_t *p_item ) +{ + vlc_gc_incref( p_item ); + _inputItems.append( p_item ); +} + +QList PlMimeData::inputItems() const { - sort( i_popup_parent, i_popup_column, Qt::AscendingOrder ); + return _inputItems; } -void PLModel::popupSortDesc() +QStringList PlMimeData::formats () const { - sort( i_popup_parent, i_popup_column, Qt::DescendingOrder ); + QStringList fmts; + fmts << "vlc/qt-input-items"; + return fmts; }