[PATCH 2/2] Qt4 Playlist fix: when moving items keep their original
Jakob Leben
jakob.leben at gmail.com
Thu Jul 30 20:15:41 CEST 2009
order...
When moving selected items in Qt4 playlist, their new order dependes on the
order of selection. This is fixed by ordering items before the drag
operation starts (PLModel::mimeData()).
Moreover, the order of items gets reversed when they are moved to drop
position, because they are all dropped onto the same index one after
another. This is fixed by always taking the index of previously inserted
item when moving next one.
This patch also allows for moving items to the top of the playlist by
interpreting the arguments to PLModel::dropMimeData() as they are intended
by qt design, which means that for a move operation items have to be dropped
between other items and not onto them. (Another patch will follow, which
will disable dropping onto items if they are not containers themself.)
The patch makes the drop operation atomic in the sense that it calls PL_LOCK
and PL_UNLOCK only once before and after the whole operation, thus
preventing any other thread from messing with it.
---
.../gui/qt4/components/playlist/playlist_model.cpp | 89
++++++++++++-------
1 files changed, 56 insertions(+), 33 deletions(-)
diff --git a/modules/gui/qt4/components/playlist/playlist_model.cpp
b/modules/gui/qt4/components/playlist/playlist_model.cpp
index 998ebb2..1226a6f 100644
--- a/modules/gui/qt4/components/playlist/playlist_model.cpp
+++ b/modules/gui/qt4/components/playlist/playlist_model.cpp
@@ -135,10 +135,17 @@ QMimeData *PLModel::mimeData( const QModelIndexList
&indexes ) const
QMimeData *mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream( &encodedData, QIODevice::WriteOnly );
+ QModelIndexList list;
foreach( const QModelIndex &index, indexes ) {
if( index.isValid() && index.column() == 0 )
- stream << itemId( index );
+ list.append(index);
+ }
+
+ qSort(list);
+
+ foreach( const QModelIndex &index, list ) {
+ stream << itemId( index );
}
mimeData->setData( "vlc/playlist-item-id", encodedData );
return mimeData;
@@ -153,58 +160,74 @@ bool PLModel::dropMimeData( const QMimeData *data,
Qt::DropAction action,
if( action == Qt::IgnoreAction )
return true;
- if( !target.isValid() )
- /* We don't want to move on an invalid position */
- return true;
+ PL_LOCK;
- PLItem *targetItem = static_cast<PLItem*>( target.internalPointer()
);
+ playlist_item_t *p_parent;
+
+ if( !parent.isValid())
+ {
+ if( row > -1)
+ {
+ // dropped into top node
+ p_parent = playlist_ItemGetById( p_playlist, rootItem->i_id
);
+ }
+ else
+ {
+ // dropped outside any item
+ PL_UNLOCK;
+ return true;
+ }
+ }
+ else
+ {
+ // dropped into/onto an item (depends on (row = -1) or (row >
-1))
+ PLItem *parentItem = static_cast<PLItem*>(
parent.internalPointer() );
+ p_parent = playlist_ItemGetById( p_playlist, parentItem->i_id
);
+ }
+ if( !p_parent || p_parent->i_children == -1 )
+ {
+ PL_UNLOCK;
+ return false;
+ }
QByteArray encodedData = data->data( "vlc/playlist-item-id" );
QDataStream stream( &encodedData, QIODevice::ReadOnly );
- PLItem *newParentItem;
+ /* easiest way to never miss the right index to move to is to
+ track the previously moved item */
+ playlist_item_t *p_target = 0;
+
while( !stream.atEnd() )
{
- int i;
- int srcId;
- stream >> srcId;
-
- PL_LOCK;
- playlist_item_t *p_target =
- playlist_ItemGetById( p_playlist, targetItem->i_id
);
- playlist_item_t *p_src = playlist_ItemGetById( p_playlist,
srcId );
+ int src_id;
+ stream >> src_id;
+ playlist_item_t *p_src = playlist_ItemGetById( p_playlist,
src_id );
- if( !p_target || !p_src )
+ if( !p_src )
{
PL_UNLOCK;
return false;
}
- if( p_target->i_children == -1 ) /* A leaf */
+ if( !p_target )
{
- PLItem *parentItem = targetItem->parent();
- assert( parentItem );
- playlist_item_t *p_parent =
- playlist_ItemGetById( p_playlist, parentItem->i_id
);
- if( !p_parent )
+ if(row == -1)
{
- PL_UNLOCK;
- return false;
+ playlist_TreeMove( p_playlist, p_src, p_parent, 0 );
+ }
+ else {
+ playlist_TreeMove( p_playlist, p_src, p_parent, row );
}
- for( i = 0 ; i< p_parent->i_children ; i++ )
- if( p_parent->pp_children[i] == p_target ) break;
- // Move the item to the element after i
- playlist_TreeMove( p_playlist, p_src, p_parent, i + 1 );
- newParentItem = parentItem;
}
else
{
- /* \todo: if we drop on a top-level node, use copy instead
? */
- playlist_TreeMove( p_playlist, p_src, p_target, 0 );
- i = 0;
- newParentItem = targetItem;
+ int i;
+ for( i = 0 ; i< p_parent->i_children ; i++ )
+ if( p_parent->pp_children[i] == p_target ) break;
+ playlist_TreeMove( p_playlist, p_src, p_parent, i + 1 );
}
- PL_UNLOCK;
+ p_target = p_src;
}
+ PL_UNLOCK;
/*TODO: That's not a good idea to rebuild the playlist */
rebuild();
}
--
1.6.4.msysgit.0
--000e0cd255b83444e8046ff08ed1
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: base64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--000e0cd255b83444e8046ff08ed1--
More information about the vlc-devel
mailing list