src/playlist/PlaylistModel.cpp

   1 /***************************************************************************
   2  * copyright            : (C) 2007 Ian Monroe <ian@monroe.nu>              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License version 2        *
   6  *   as published by the Free Software Foundation.                         *
   7  ***************************************************************************/
   8
   9 #include "PlaylistModel.h"
  10
  11 #include "amarok.h"
  12 #include "AmarokMimeData.h"
  13 #include "debug.h"
  14 #include "enginecontroller.h"
  15 #include "PlaylistItem.h"
  16 #include "RepeatTrackNavigator.h"
  17 #include "StandardTrackNavigator.h"
  18 #include "statusbar.h"
  19 #include "TheInstances.h"
  20 #include "UndoCommands.h"
  21
  22 #include "collection/BlockingQuery.h"
  23 #include "collection/Collection.h"
  24 #include "collection/CollectionManager.h"
  25 #include "collection/QueryMaker.h"
  26 #include "meta/lastfm/LastFmMeta.h"
  27
  28 #include <QAction>
  29 #include <QStringList>
  30 #include <QUndoStack>
  31
  32 #include <KIcon>
  33 #include <KUrl>
  34
  35 using namespace Playlist;
  36 using namespace Meta;
  37
  38 Model *Model::s_instance = 0;
  39
  40 Model::Model( QObject* parent )
  41     : QAbstractListModel( parent )
  42     , m_activeRow( -1 )
  43     , m_advancer( new StandardTrackNavigator( this ) )
  44     , m_undoStack( new QUndoStack( this ) )
  45     , m_playlistLoader ( new PlaylistLoader )
  46 {
  47     connect( EngineController::instance(), SIGNAL( trackFinished() ), this, SLOT( trackFinished() ) );
  48     connect( EngineController::instance(), SIGNAL( orderCurrent() ), this, SLOT( playCurrentTrack() ) );
  49     s_instance = this;
  50 }
  51
  52 void
  53 Model::init()
  54 {
  55     KActionCollection* ac = Amarok::actionCollection();
  56     QAction* undoButton  = m_undoStack->createUndoAction( this, i18n("Undo") );
  57     undoButton->setIcon( KIcon( Amarok::icon( "undo" ) ) );
  58     ac->addAction("playlist_undo", undoButton);
  59     QAction* redoButton  = m_undoStack->createRedoAction( this, i18n("Redo") );
  60     ac->addAction("playlist_redo", redoButton);
  61     redoButton->setIcon( KIcon( Amarok::icon( "redo" ) ) );
  62 }
  63
  64 Model::~Model()
  65 {
  66     delete m_advancer;
  67     delete m_playlistLoader;
  68 }
  69
  70 int
  71 Model::rowCount( const QModelIndex& ) const
  72 {
  73     return m_items.size();
  74 }
  75
  76 QVariant
  77 Model::data( const QModelIndex& index, int role ) const
  78 {
  79     int row = index.row();
  80     /*if( ( role ==  Qt::FontRole) && ( row == m_activeRow ) )
  81     {
  82         QFont original;
  83         original.setBold( true );
  84         return original;
  85     }
  86     else*/
  87     if( role == ItemRole && ( row != -1 ) )
  88     {
  89         return QVariant::fromValue( m_items.at( row ) );
  90     }
  91     else if( role == ActiveTrackRole )
  92         return ( row == m_activeRow );
  93     else if( role == TrackRole && ( row != -1 ) && m_items.at( row )->track() )
  94     {
  95         return QVariant::fromValue( m_items.at( row )->track() );
  96     }
  97     else if( role == Qt::DisplayRole && row != -1 )
  98     {
  99         return m_items.at( row )->track()->name();
 100     }
 101     else
 102     {
 103         return QVariant();
 104     }
 105 /*        switch( role )
 106         {
 107             case AlbumArtist: return track->album()->albumArtist()->name();
 108             case Album: return track->album()->name();
 109             case Artist: return track->artist()->name();
 110             case Bitrate: return track->bitrate();
 111             case Composer: return track->composer()->name();
 112             case CoverImage: return track->album()->image( 50 );
 113             case Comment: return track->comment();
 114             case DiscNumber: return track->discNumber();
 115             case Filesize: return track->filesize();
 116             case Genre: return track->genre()->name();
 117             case Length: return track->length();
 118             case Rating: return track->rating();
 119             case Score: return track->score();
 120             case Title: return track->name();
 121             case TrackNumber: return track->trackNumber();
 122             case Year: return track->year()->name().toInt();
 123             default: return QVariant();
 124         } */
 125 }
 126
 127 // void
 128 // insertColumns( int column, Column type )
 129 // {
 130 //     beginInsertColumns( QModelIndex(), column, column + 1 );
 131 //     m_columns.insert( column, type );
 132 //     endInsertColumns();
 133 //     return true;
 134 // }
 135
 136 void
 137 Model::insertTrack( int row, TrackPtr track )
 138 {
 139     DEBUG_BLOCK
 140     TrackList list;
 141     list.append( track );
 142     insertTracks( row, list );
 143
 144 }
 145
 146 void
 147 Model::insertTracks( int row, TrackList tracks )
 148 {
 149     m_undoStack->push( new AddTracksCmd( 0, row, tracks ) );
 150 }
 151
 152 bool
 153 Model::removeRows( int position, int rows, const QModelIndex& /*parent*/  )
 154 {
 155     m_undoStack->push( new RemoveTracksCmd( 0, position, rows ) );
 156     return true;
 157 }
 158
 159
 160 void
 161 Model::insertTracks( int row, QueryMaker *qm )
 162 {
 163     qm->startTrackQuery();
 164     connect( qm, SIGNAL( queryDone() ), SLOT( queryDone() ) );
 165     connect( qm, SIGNAL( newResultReady( QString, Meta::TrackList ) ), SLOT( newResultReady( QString, Meta::TrackList ) ) );
 166     m_queryMap.insert( qm, row );
 167     qm->run();
 168 }
 169
 170 void
 171 Model::testData()
 172 {
 173     DEBUG_BLOCK
 174     Collection *local = 0;
 175     foreach( Collection *coll, CollectionManager::instance()->collections() )
 176     {
 177         if( coll->collectionId() == "localCollection" )
 178             local = coll;
 179     }
 180     if( !local )
 181         return;
 182     QueryMaker *qm = local->queryMaker();
 183     qm->startTrackQuery();
 184     qm->limitMaxResultSize( 10 );
 185     BlockingQuery bq( qm );
 186     bq.startQuery();
 187     insertTracks( 0, bq.tracks( "localCollection" ) );
 188     reset();
 189 }
 190
 191 Qt::DropActions
 192 Model::supportedDropActions() const
 193 {
 194     return Qt::CopyAction | Qt::MoveAction;
 195 }
 196
 197 void
 198 Model::trackFinished()
 199 {
 200     if( m_activeRow < 0 || m_activeRow >= m_items.size() )
 201         return;
 202     Meta::TrackPtr track = m_items.at( m_activeRow )->track();
 203     track->finishedPlaying( 1.0 ); //TODO: get correct value for parameter
 204     m_advancer->advanceTrack();
 205 }
 206
 207 void
 208 Model::play( const QModelIndex& index )
 209 {
 210     play( index.row() );
 211 }
 212
 213 void
 214 Model::play( int row )
 215 {
 216     setActiveRow( row );
 217     EngineController::instance()->play( m_items[ m_activeRow ]->track() );
 218 }
 219
 220 void
 221 Model::playlistRepeatMode( int item )
 222 {
 223     if( item == 0 )
 224         playModeChanged( Playlist::Standard );
 225     else //for now just turn on repeat if anything but "off" is clicked
 226         playModeChanged( Playlist::Repeat );
 227 }
 228
 229 void
 230 Model::next()
 231 {
 232     if( m_activeRow < 0 || m_activeRow >= m_items.size() )
 233         return;
 234     Meta::TrackPtr track = m_items.at( m_activeRow )->track();
 235     track->finishedPlaying( 0.5 ); //TODO: get correct value for parameter
 236     m_advancer->userAdvanceTrack();
 237 }
 238
 239 void
 240 Model::back()
 241 {
 242     if( m_activeRow < 0 || m_activeRow >= m_items.size() )
 243         return;
 244     Meta::TrackPtr track = m_items.at( m_activeRow )->track();
 245     track->finishedPlaying( 0.5 ); //TODO: get correct value for parameter
 246     m_advancer->recedeTrack();
 247 }
 248
 249 void
 250 Model::playCurrentTrack()
 251 {
 252     int selected = m_activeRow;
 253     if( selected < 0 || selected >= m_items.size() )
 254     {
 255         //play first track if there are tracks in the playlist
 256         if( m_items.size() )
 257             selected = 0;
 258         else
 259             return;
 260     }
 261     play( selected );
 262 }
 263
 264
 265 QString
 266 Model::prettyColumnName( Column index ) //static
 267 {
 268     switch( index )
 269     {
 270         case Filename:   return i18n( "Filename"    );
 271         case Title:      return i18n( "Title"       );
 272         case Artist:     return i18n( "Artist"      );
 273         case AlbumArtist:return i18n( "Album Artist");
 274         case Composer:   return i18n( "Composer"    );
 275         case Year:       return i18n( "Year"        );
 276         case Album:      return i18n( "Album"       );
 277         case DiscNumber: return i18n( "Disc Number" );
 278         case TrackNumber:return i18n( "Track"       );
 279         case Bpm:        return i18n( "BPM"         );
 280         case Genre:      return i18n( "Genre"       );
 281         case Comment:    return i18n( "Comment"     );
 282         case Directory:  return i18n( "Directory"   );
 283         case Type:       return i18n( "Type"        );
 284         case Length:     return i18n( "Length"      );
 285         case Bitrate:    return i18n( "Bitrate"     );
 286         case SampleRate: return i18n( "Sample Rate" );
 287         case Score:      return i18n( "Score"       );
 288         case Rating:     return i18n( "Rating"      );
 289         case PlayCount:  return i18n( "Play Count"  );
 290         case LastPlayed: return i18nc( "Column name", "Last Played" );
 291         case Mood:       return i18n( "Mood"        );
 292         case Filesize:   return i18n( "File Size"   );
 293         default:         return "This is a bug.";
 294     }
 295
 296 }
 297
 298 void
 299 Model::playModeChanged( int row )
 300 {
 301     delete m_advancer;
 302     switch (row)
 303     {
 304         case Playlist::Standard:
 305             m_advancer = new StandardTrackNavigator(this);
 306             break;
 307         case Playlist::Repeat:
 308             m_advancer = new RepeatTrackNavigator(this);
 309             break;
 310     }
 311 }
 312
 313 void
 314 Model::setActiveRow( int row )
 315 {
 316     DEBUG_BLOCK
 317
 318     int max = qMax( row, m_activeRow );
 319     int min = qMin( row, m_activeRow );
 320     if( ( max - min ) == 1 )
 321         emit dataChanged( createIndex( min, 0 ), createIndex( max, 0 ) );
 322     else
 323     {
 324         emit dataChanged( createIndex( min, 0 ), createIndex( min, 0 ) );
 325         emit dataChanged( createIndex( max, 0 ), createIndex( max, 0 ) );
 326     }
 327     debug() << "between " << min << " and " << max;
 328     m_activeRow = row;
 329 }
 330
 331 void
 332 Model::metadataChanged( Meta::Track *track )
 333 {
 334     DEBUG_BLOCK
 335     const int size = m_items.size();
 336     const Meta::TrackPtr needle =  Meta::TrackPtr( track );
 337     for( int i = 0; i < size; i++ )
 338     {
 339         if( m_items.at( i )->track() == needle )
 340         {
 341             debug() << "Track in playlist";
 342             emit dataChanged( createIndex( i, 0 ), createIndex( i, 0 ) );
 343             break;
 344         }
 345     }
 346
 347 #if 0
 348     int index = m_tracks.indexOf( Meta::TrackPtr( track ), 0 );
 349     if( index != -1 )
 350         emit dataChanged( createIndex( index, 0 ), createIndex( index, 0 ) );
 351 #endif
 352 }
 353
 354 void
 355 Model::metadataChanged(Meta::Album * album)
 356 {
 357     DEBUG_BLOCK
 358     //process each track
 359     TrackList tracks = album->tracks();
 360     foreach( TrackPtr track, tracks ) {
 361         metadataChanged( track.data() );
 362     }
 363
 364 }
 365
 366 void
 367 Model::clear()
 368 {
 369     removeRows( 0, m_items.size() );
 370 //    m_activeRow = -1;
 371 }
 372
 373 void
 374 Model::insertOptioned( Meta::TrackList list, int options )
 375 {
 376
 377     if( list.isEmpty() ) {
 378         Amarok::StatusBar::instance()->shortMessage( i18n("Attempted to insert nothing into playlist.") );
 379         return; // don't add empty items
 380     }
 381
 382
 383     if( options & Unique )
 384     {
 385         int alreadyOnPlaylist = 0;
 386         for( int i = 0; i < list.size(); ++i )
 387         {
 388
 389             Item* item;
 390             foreach( item, m_items )
 391             {
 392                 if( item->track() == list.at( i ) )
 393                 {
 394                     list.removeAt( i );
 395                     alreadyOnPlaylist++;
 396                     break;
 397                 }
 398             }
 399
 400         }
 401         if ( alreadyOnPlaylist )
 402             Amarok::StatusBar::instance()->shortMessage( i18np("One track was already in the playlist, so it was not added.", "%1 tracks were already in the playlist, so they were not added.", alreadyOnPlaylist ) );
 403     }
 404
 405    int orgCount = rowCount(); //needed because recursion messes up counting
 406    bool playlistAdded = false;
 407
 408    //HACK! Check if any of the incomming tracks is really a playlist. Warning, this can get highly recursive
 409    for( int i = 0; i < list.size(); ++i )
 410    {
 411        if ( m_playlistLoader->isPlaylist( list.at( i )->url() ) ) {
 412            playlistAdded = true;
 413            m_playlistLoader->load( list.takeAt( i )->url() );
 414        }
 415    }
 416
 417
 418     int firstItemAdded = -1;
 419     if( options & Replace )
 420     {
 421         clear();
 422         firstItemAdded = 0;
 423         insertTracks( 0, list );
 424     }
 425     else if( options & Append )
 426     {
 427         if ( playlistAdded )
 428            firstItemAdded = orgCount;
 429         else
 430            firstItemAdded = rowCount();
 431
 432         if ( rowCount() > firstItemAdded )
 433             insertTracks( firstItemAdded, list );
 434     }
 435     else if( options & Queue )
 436     {
 437         //TODO implement queue
 438     }
 439     if( options & DirectPlay )
 440     {
 441         if ( rowCount() > firstItemAdded )
 442         play( firstItemAdded );
 443     }
 444     else if( ( options & StartPlay ) && ( EngineController::engine()->state() != Engine::Playing ) && ( rowCount() != 0 ) )
 445     {
 446         play( firstItemAdded );
 447     }
 448     Amarok::actionCollection()->action( "playlist_clear" )->setEnabled( !m_items.isEmpty() );
 449 }
 450
 451 void
 452 Model::insertOptioned( Meta::TrackPtr track, int options )
 453 {
 454     Meta::TrackList list;
 455     list.append( track );
 456     insertOptioned( list, options );
 457 }
 458
 459 void
 460 Model::insertOptioned( QueryMaker *qm, int options )
 461 {
 462     qm->startTrackQuery();
 463     connect( qm, SIGNAL( queryDone() ), SLOT( queryDone() ) );
 464     connect( qm, SIGNAL( newResultReady( QString, Meta::TrackList ) ), SLOT( newResultReady( QString, Meta::TrackList ) ) );
 465     m_optionedQueryMap.insert( qm, options );
 466     qm->run();
 467 }
 468
 469 void
 470 Model::insertMedia( KUrl::List list, int options )
 471 {
 472     KUrl url;
 473     Meta::TrackList trackList;
 474     foreach( url, list )
 475     {
 476         Meta::TrackPtr track = CollectionManager::instance()->trackForUrl( url );
 477         if( track )
 478             trackList.push_back( track );
 479     }
 480     if( trackList.isEmpty() )
 481         debug() << "Attempted to insert nothing into the playlist!";
 482
 483     insertOptioned( trackList, options );
 484 }
 485
 486 bool
 487 Model::saveM3U( const QString &path, bool relative ) const
 488 {
 489     Q_UNUSED( path ); Q_UNUSED( relative );
 490 //     Q3ValueList<KUrl> urls;
 491 //     Q3ValueList<QString> titles;
 492 //     Q3ValueList<int> lengths;
 493 //     for( MyIt it( firstChild(), MyIt::Visible ); *it; ++it )
 494 //     {
 495 //         urls << (*it)->url();
 496 //         titles << (*it)->title();
 497 //         lengths << (*it)->length();
 498 //     }
 499 //     return PlaylistBrowser::savePlaylist( path, urls, titles, lengths, relative );
 500     return false;
 501 }
 502
 503 Qt::ItemFlags
 504 Model::flags(const QModelIndex &index) const
 505 {
 506     if( index.isValid() )
 507     {
 508         return ( Qt::ItemIsEnabled     | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled |
 509                  Qt::ItemIsDragEnabled | Qt::ItemIsSelectable );
 510     }
 511     return Qt::ItemIsDropEnabled;
 512 }
 513
 514 QStringList
 515 Model::mimeTypes() const //reimplemented
 516 {
 517     QStringList ret = QAbstractListModel::mimeTypes();
 518     ret << AmarokMimeData::TRACK_MIME;
 519     return ret;
 520 }
 521
 522 QMimeData*
 523 Model::mimeData( const QModelIndexList &indexes ) const //reimplemented
 524 {
 525     AmarokMimeData* mime = new AmarokMimeData();
 526     Meta::TrackList selectedTracks;
 527
 528     foreach( QModelIndex it, indexes )
 529         selectedTracks << m_items.at( it.row() )->track();
 530
 531     mime->setTracks( selectedTracks );
 532     return mime;
 533 }
 534
 535 bool
 536 Model::dropMimeData ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent ) //reimplemented
 537 {
 538     Q_UNUSED( column ); Q_UNUSED( parent );
 539     DEBUG_BLOCK
 540
 541     if( action == Qt::IgnoreAction )
 542         return true;
 543
 544     if( data->hasFormat( AmarokMimeData::TRACK_MIME ) )
 545     {
 546         debug() << "Found track mime type";
 547
 548         const AmarokMimeData* trackListDrag = dynamic_cast<const AmarokMimeData*>( data );
 549         if( trackListDrag )
 550         {
 551             if( row < 0 )
 552             {
 553                 debug() << "Inserting at row: " << row << " so we're appending to the list.";
 554                 insertOptioned( trackListDrag->tracks(), Playlist::Append );
 555             }
 556             else
 557             {
 558                 debug() << "Inserting at row: " << row <<" so its inserted correctly.";
 559                 insertTracks( row, trackListDrag->tracks() );
 560             }
 561             return true;
 562         }
 563     }
 564     else if( data->hasUrls() )
 565     {
 566         //probably a drop from an external source
 567         debug() << "Drop from external source";
 568         QList<QUrl> urls = data->urls();
 569         Meta::TrackList tracks;
 570         foreach( QUrl url, urls )
 571         {
 572             Meta::TrackPtr track = CollectionManager::instance()->trackForUrl( KUrl( url ) );
 573             if( track )
 574                 tracks.append( track );
 575         }
 576         if( !tracks.isEmpty() )
 577             insertOptioned( tracks, Playlist::Append );
 578         return true;
 579     }
 580     return false;
 581 }
 582
 583 ////////////
 584 //Private Methods
 585 ///////////
 586
 587
 588 void
 589 Model::insertTracksCommand( int row, TrackList list )
 590 {
 591     DEBUG_BLOCK
 592     debug() << "inserting... " << row << ' ' << list.count();
 593     if( !list.size() )
 594         return;
 595
 596     beginInsertRows( QModelIndex(), row, row + list.size() - 1 );
 597     int i = 0;
 598     foreach( TrackPtr track , list )
 599     {
 600         if( track )
 601         {
 602             track->subscribe( this );
 603             if( track->album() )
 604                 track->album()->subscribe( this );
 605             m_items.insert( row + i, new Item( track ) );
 606             i++;
 607         }
 608     }
 609     endInsertRows();
 610     //push up the active row if needed
 611     if( m_activeRow > row )
 612     {
 613         int oldActiveRow = m_activeRow;
 614         m_activeRow += list.size();
 615         Q_UNUSED( oldActiveRow );
 616         //dataChanged( createIndex( oldActiveRow, 0 ), createIndex( oldActiveRow, columnCount() -1 ) );
 617         //dataChanged( createIndex( m_activeRow, 0 ), createIndex( m_activeRow, columnCount() -1 ) );
 618     }
 619     dataChanged( createIndex( row, 0 ), createIndex( rowCount() - 1, 0 ) );
 620     Amarok::actionCollection()->action( "playlist_clear" )->setEnabled( !m_items.isEmpty() );
 621
 622     emit playlistCountChanged( rowCount() );
 623 }
 624
 625
 626 TrackList
 627 Model::removeRowsCommand( int position, int rows )
 628 {
 629     DEBUG_BLOCK
 630
 631     beginRemoveRows( QModelIndex(), position, position + rows - 1 );
 632 //     TrackList::iterator start = m_tracks.begin() + position;
 633 //     TrackList::iterator end = start + rows;
 634 //     m_tracks.erase( start, end );
 635     TrackList ret;
 636     for( int i = position; i < position + rows; i++ )
 637     {
 638         Item* item = m_items.takeAt( position ); //take at position, row times
 639         item->track()->unsubscribe( this );
 640         if( item->track()->album() )
 641             item->track()->album()->unsubscribe( this );
 642         ret.push_back( item->track() );
 643         delete item;
 644     }
 645     endRemoveRows();
 646
 647     Amarok::actionCollection()->action( "playlist_clear" )->setEnabled( !m_items.isEmpty() );
 648
 649     //update m_activeRow
 650     bool activeRowChanged = true;
 651     bool oldActiveRow = m_activeRow;
 652     if( m_activeRow >= position && m_activeRow < ( position + rows ) )
 653         m_activeRow = -1;
 654     else if( m_activeRow >= position )
 655         m_activeRow = m_activeRow - position;
 656     else
 657         activeRowChanged = false;
 658     if( activeRowChanged )
 659     {
 660         dataChanged( createIndex( oldActiveRow, 0 ), createIndex( oldActiveRow, columnCount() -1 ) );
 661         dataChanged( createIndex( m_activeRow, 0 ), createIndex( m_activeRow, columnCount() -1 ) );
 662     }
 663     dataChanged( createIndex( position, 0 ), createIndex( rowCount(), 0 ) );
 664     emit playlistCountChanged( rowCount() );
 665     return ret;
 666 }
 667
 668 void
 669 Model::queryDone() //Slot
 670 {
 671     QueryMaker *qm = dynamic_cast<QueryMaker*>( sender() );
 672     if( qm )
 673     {
 674         m_queryMap.remove( qm );
 675         qm->deleteLater();
 676     }
 677 }
 678
 679 void
 680 Model::newResultReady( const QString &collectionId, const Meta::TrackList &tracks ) //Slot
 681 {
 682     Q_UNUSED( collectionId )
 683     QueryMaker *qm = dynamic_cast<QueryMaker*>( sender() );
 684     if( qm )
 685     {
 686         //requires better handling of queries which return multiple results
 687         if( m_queryMap.contains( qm ) )
 688             insertTracks( m_queryMap.value( qm ), tracks );
 689         else if( m_optionedQueryMap.contains( qm ) )
 690             insertOptioned( tracks, m_optionedQueryMap.value( qm ) );
 691     }
 692 }
 693
 694 namespace The {
 695     Playlist::Model* playlistModel() { return Playlist::Model::s_instance; }
 696 }
 697
 698
 699
 700
 701 #include "PlaylistModel.moc"