src/covermanager.cpp

   1 // (c) Pierpaolo Di Panfilo 2004
   2 // (c) 2005 Isaiah Damron <xepo@trifault.net>
   3 // See COPYING file for licensing information
   4
   5 #include "covermanager.h"
   6
   7 #include "amarok.h"
   8 #include "amarokconfig.h"
   9 #include "browserToolBar.h"
  10 #include "debug.h"
  11 #include "querybuilder.h"
  12 #include "config-amarok.h"
  13 #include "pixmapviewer.h"
  14 #include "playlist/PlaylistModel.h"
  15 #include "playlist.h"
  16 #include "TheInstances.h"
  17
  18 #include <k3listview.h>
  19 #include <k3multipledrag.h>
  20 #include <k3urldrag.h>
  21 #include <KApplication>
  22 #include <KConfig>
  23 #include <KCursor>
  24 #include <KFileDialog>
  25 #include <KIconLoader>
  26 #include <KIO/NetAccess>
  27 #include <KLineEdit>
  28 #include <KLocale>
  29 #include <KMenu>    //showCoverMenu()
  30 #include <KMessageBox>    //showCoverMenu()
  31 #include <KPushButton>
  32 #include <KSqueezedTextLabel> //status label
  33 #include <KStandardDirs>   //KGlobal::dirs()
  34 #include <KStatusBar>
  35 #include <KToolBar>
  36 #include <KUrl>
  37 #include <KVBox>
  38 #include <KWindowSystem>
  39
  40 #include <QDesktopWidget>  //ctor: desktop size
  41 #include <QFile>
  42 #include <QFontMetrics>    //paintItem()
  43 #include <QImage>
  44 #include <QLabel>
  45 #include <QLayout>
  46 #include <QObject>    //used to delete all cover fetchers
  47 #include <QPainter>    //paintItem()
  48 #include <QPalette>    //paintItem()
  49 #include <QPixmap>
  50 #include <QPoint>
  51 #include <QProgressBar>
  52 #include <q3progressdialog.h>
  53 #include <QRect>
  54 #include <QStringList>
  55 #include <QToolTip>
  56 #include <QTimer>    //search filter timer
  57 //Added by qt3to4:
  58 #include <Q3ValueList>
  59 #include <Q3PtrList>
  60 #include <QDropEvent>
  61 #include <QToolButton>
  62
  63
  64 static QString artistToSelectInInitFunction;
  65 CoverManager *CoverManager::s_instance = 0;
  66
  67 class ArtistItem : public K3ListViewItem
  68 {
  69     public:
  70     ArtistItem(Q3ListView *view, Q3ListViewItem *item, const QString &text)
  71         : K3ListViewItem(view, item, text) {}
  72     protected:
  73     int compare( Q3ListViewItem* i, int col, bool ascending ) const
  74     {
  75         Q_UNUSED(col);
  76         Q_UNUSED(ascending);
  77
  78         QString a = text(0);
  79         QString b = i->text(0);
  80
  81         if ( a.startsWith( "the ", Qt::CaseInsensitive ) )
  82             Amarok::manipulateThe( a, true );
  83         if ( b.startsWith( "the ", Qt::CaseInsensitive ) )
  84             Amarok::manipulateThe( b, true );
  85
  86         return QString::localeAwareCompare( a.toLower(), b.toLower() );
  87     }
  88 };
  89
  90 CoverManager::CoverManager()
  91         : QSplitter( 0 )
  92         , m_timer( new QTimer( this ) )    //search filter timer
  93         , m_fetchCounter( 0 )
  94         , m_fetchingCovers( 0 )
  95         , m_coversFetched( 0 )
  96         , m_coverErrors( 0 )
  97 {
  98     DEBUG_BLOCK
  99
 100     setObjectName( "TheCoverManager" );
 101
 102     s_instance = this;
 103
 104     // Sets caption and icon correctly (needed e.g. for GNOME)
 105     kapp->setTopWidget( this );
 106     setWindowTitle( KDialog::makeStandardCaption( i18n("Cover Manager") ) );
 107     setAttribute( Qt::WA_DeleteOnClose );
 108     setContentsMargins( 4, 4, 4, 4 );
 109
 110     //artist listview
 111     m_artistView = new K3ListView( this );
 112     m_artistView->addColumn(i18n( "Albums By" ));
 113     m_artistView->setFullWidth( true );
 114     m_artistView->setSorting( 0 );
 115     m_artistView->setMinimumWidth( 180 );
 116     ArtistItem *item = 0;
 117
 118     //load artists from the collection db
 119     const QStringList artists = CollectionDB::instance()->artistList( false, false );
 120     foreach( QString artist, artists )
 121     {
 122         item = new ArtistItem( m_artistView, item, artist );
 123         item->setPixmap( 0, SmallIcon( Amarok::icon( "artist" ) ) );
 124     }
 125     m_artistView->sort();
 126
 127     m_artistView->setSorting( -1 );
 128     ArtistItem *last = static_cast<ArtistItem *>(m_artistView->lastItem());
 129     item = new ArtistItem( m_artistView, 0, i18n( "All Albums" ) );
 130     item->setPixmap( 0, SmallIcon( Amarok::icon( "album" ) ) );
 131
 132     QueryBuilder qb;
 133     qb.addReturnValue( QueryBuilder::tabAlbum, QueryBuilder::valName );
 134     qb.groupBy( QueryBuilder::tabAlbum, QueryBuilder::valName );
 135     qb.setOptions( QueryBuilder::optOnlyCompilations );
 136     qb.setLimit( 0, 1 );
 137     if ( qb.run().count() ) {
 138         item = new ArtistItem( m_artistView, last, i18n( "Various Artists" ) );
 139         item->setPixmap( 0, SmallIcon("personal") );
 140     }
 141
 142     KVBox *vbox = new KVBox( this );
 143     KHBox *hbox = new KHBox( vbox );
 144
 145     vbox->setSpacing( 4 );
 146     hbox->setSpacing( 4 );
 147
 148     { //<Search LineEdit>
 149         KHBox *searchBox = new KHBox( hbox );
 150         KToolBar* searchToolBar = new Browser::ToolBar( searchBox );
 151         QToolButton *button = new QToolButton( searchToolBar );
 152         button->setIcon( KIcon( "locationbar-erase") );
 153         m_searchEdit = new KLineEdit( searchToolBar );
 154         m_searchEdit->setClickMessage( i18n( "Enter search terms here" ) );
 155         m_searchEdit->setFrame( QFrame::Sunken );
 156
 157         m_searchEdit->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);
 158         connect( button, SIGNAL(clicked()), m_searchEdit, SLOT(clear()) );
 159
 160         button->setToolTip( i18n( "Clear search field" ) );
 161         m_searchEdit->setToolTip( i18n( "Enter space-separated terms to search in the albums" ) );
 162
 163         hbox->setStretchFactor( searchBox, 1 );
 164     } //</Search LineEdit>
 165
 166     // view menu
 167     m_viewMenu = new KMenu( this );
 168     m_selectAllAlbums          = m_viewMenu->addAction( i18n("All Albums"),           this, SLOT( slotShowAllAlbums() ) );
 169     m_selectAlbumsWithCover    = m_viewMenu->addAction( i18n("Albums With Cover"),    this, SLOT( slotShowAlbumsWithCover() ) );
 170     m_selectAlbumsWithoutCover = m_viewMenu->addAction( i18n("Albums Without Cover"), this, SLOT( slotShowAlbumsWithoutCover() ) );
 171
 172     QActionGroup *viewGroup = new QActionGroup( this );
 173     viewGroup->setExclusive( true );
 174     viewGroup->addAction( m_selectAllAlbums );
 175     viewGroup->addAction( m_selectAlbumsWithCover );
 176     viewGroup->addAction( m_selectAlbumsWithoutCover );
 177     m_selectAllAlbums->setChecked( true );
 178
 179     // amazon locale menu
 180     QString locale = AmarokConfig::amazonLocale();
 181     m_currentLocale = CoverFetcher::localeStringToID( locale );
 182
 183     QAction *a;
 184     QActionGroup *localeGroup = new QActionGroup( this );
 185     localeGroup->setExclusive( true );
 186
 187     m_amazonLocaleMenu = new KMenu( this );
 188
 189     a = m_amazonLocaleMenu->addAction( i18n("International"),  this, SLOT( slotSetLocaleIntl() ) );
 190     if( m_currentLocale == CoverFetcher::International ) a->setChecked( true );
 191     localeGroup->addAction( a );
 192
 193     a = m_amazonLocaleMenu->addAction( i18n("Canada"),         this, SLOT( slotSetLocaleCa() )   );
 194     if( m_currentLocale == CoverFetcher::Canada ) a->setChecked( true );
 195     localeGroup->addAction( a );
 196
 197     a = m_amazonLocaleMenu->addAction( i18n("France"),         this, SLOT( slotSetLocaleFr() )   );
 198     if( m_currentLocale == CoverFetcher::France ) a->setChecked( true );
 199     localeGroup->addAction( a );
 200
 201     a = m_amazonLocaleMenu->addAction( i18n("Germany"),        this, SLOT( slotSetLocaleDe() )   );
 202     if( m_currentLocale == CoverFetcher::Germany ) a->setChecked( true );
 203     localeGroup->addAction( a );
 204
 205     a = m_amazonLocaleMenu->addAction( i18n("Japan"),          this, SLOT( slotSetLocaleJp() )   );
 206     if( m_currentLocale == CoverFetcher::Japan ) a->setChecked( true );
 207     localeGroup->addAction( a );
 208
 209     a = m_amazonLocaleMenu->addAction( i18n("United Kingdom"), this, SLOT( slotSetLocaleUk() )   );
 210     if( m_currentLocale == CoverFetcher::UK ) a->setChecked( true );
 211     localeGroup->addAction( a );
 212
 213     KToolBar* toolBar = new KToolBar( hbox );
 214     toolBar->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
 215 //TODO port to kde4
 216 //    toolBar->setFrameShape( QFrame::NoFrame );
 217     {
 218         QAction* viewMenuAction = new QAction( KIcon( "view_choose" ), i18n( "View" ), this );
 219         viewMenuAction->setMenu( m_viewMenu );
 220         toolBar->addAction( viewMenuAction );
 221     }
 222     {
 223         QAction* localeMenuAction = new QAction( KIcon( "babelfish" ),  i18n( "Amazon Locale" ), this );
 224         localeMenuAction->setMenu( m_amazonLocaleMenu );
 225         toolBar->addAction( localeMenuAction );
 226     }
 227
 228     //fetch missing covers button
 229     m_fetchButton = new KPushButton( KGuiItem( i18n("Fetch Missing Covers"), Amarok::icon( "download" ) ), hbox );
 230     connect( m_fetchButton, SIGNAL(clicked()), SLOT(fetchMissingCovers()) );
 231
 232
 233     //cover view
 234     m_coverView = new CoverView( vbox );
 235
 236     //status bar
 237     KStatusBar *m_statusBar = new KStatusBar( vbox );
 238
 239     m_statusLabel = new KSqueezedTextLabel( m_statusBar );
 240     m_statusLabel->setIndent( 3 );
 241     m_progressBox = new KHBox( m_statusBar );
 242
 243     m_statusBar->addWidget( m_statusLabel, 4 );
 244     m_statusBar->addPermanentWidget( m_progressBox, 1 );
 245
 246     KPushButton *stopButton = new KPushButton( KGuiItem(i18n("Abort"), "stop"), m_progressBox );
 247     connect( stopButton, SIGNAL(clicked()), SLOT(stopFetching()) );
 248     m_progress = new QProgressBar( m_progressBox );
 249     m_progress->setTextVisible( true );
 250
 251     const int h = m_statusLabel->height() + 3;
 252     m_statusLabel->setFixedHeight( h );
 253     m_progressBox->setFixedHeight( h );
 254     m_progressBox->hide();
 255
 256
 257     // signals and slots connections
 258     connect( m_artistView, SIGNAL(selectionChanged( Q3ListViewItem* ) ),
 259                            SLOT(slotArtistSelected( Q3ListViewItem* )) );
 260     connect( m_coverView,  SIGNAL(contextMenuRequested( Q3IconViewItem*, const QPoint& )),
 261                            SLOT(showCoverMenu( Q3IconViewItem*, const QPoint& )) );
 262     connect( m_coverView,  SIGNAL(executed( Q3IconViewItem* )),
 263                            SLOT(coverItemExecuted( Q3IconViewItem* )) );
 264     connect( m_timer,      SIGNAL(timeout()),
 265                            SLOT(slotSetFilter()) );
 266     connect( m_searchEdit, SIGNAL(textChanged( const QString& )),
 267                            SLOT(slotSetFilterTimeout()) );
 268
 269     connect( CollectionDB::instance(), SIGNAL(coverFetched( const QString&, const QString& )),
 270                                        SLOT(coverFetched( const QString&, const QString& )) );
 271     connect( CollectionDB::instance(), SIGNAL(coverRemoved( const QString&, const QString& )),
 272                                        SLOT(coverRemoved( const QString&, const QString& )) );
 273     connect( CollectionDB::instance(), SIGNAL(coverFetcherError( const QString& )),
 274                                        SLOT(coverFetcherError()) );
 275
 276     m_currentView = AllAlbums;
 277
 278     QSize size = QApplication::desktop()->screenGeometry( this ).size() / 1.5;
 279     QSize sz = Amarok::config( "Cover Manager" ).readEntry( "Window Size", size );
 280     resize( sz.width(), sz.height() );
 281
 282     show();
 283
 284     QTimer::singleShot( 0, this, SLOT(init()) );
 285 }
 286
 287
 288 CoverManager::~CoverManager()
 289 {
 290     DEBUG_BLOCK
 291
 292     Amarok::config( "Cover Manager" ).writeEntry( "Window Size", size() );
 293
 294     s_instance = 0;
 295 }
 296
 297
 298 void CoverManager::init()
 299 {
 300     DEBUG_BLOCK
 301
 302     Q3ListViewItem *item = 0;
 303
 304     if ( !artistToSelectInInitFunction.isEmpty() )
 305         for ( item = m_artistView->firstChild(); item; item = item->nextSibling() )
 306             if ( item->text( 0 ) == artistToSelectInInitFunction )
 307                 break;
 308
 309     if ( item == 0 )
 310         item = m_artistView->firstChild();
 311
 312     m_artistView->setSelected( item, true );
 313 }
 314
 315
 316 CoverViewDialog::CoverViewDialog( const QString& artist, const QString& album, QWidget *parent )
 317     : QDialog( parent, 0, false, Qt::WType_TopLevel | Qt::WNoAutoErase )
 318     , m_pixmap( CollectionDB::instance()->albumImage( artist, album, false, 0 ) )
 319 {
 320     setAttribute( Qt::WA_DeleteOnClose );
 321 #ifdef Q_WS_X11
 322     KWindowSystem::setType( winId(), NET::Utility );
 323 #endif
 324     kapp->setTopWidget( this );
 325     setWindowTitle( KDialog::makeStandardCaption( i18n("%1 - %2", artist, album ) ) );
 326
 327     m_layout = new QHBoxLayout( this );
 328     m_pixmapViewer = new PixmapViewer( this, m_pixmap );
 329     m_layout->addWidget( m_pixmapViewer );
 330
 331     setFixedSize( m_pixmapViewer->maximalSize() );
 332 }
 333
 334
 335 void CoverManager::viewCover( const QString& artist, const QString& album, QWidget *parent ) //static
 336 {
 337     //QDialog means "escape" works as expected
 338     QDialog *dialog = new CoverViewDialog( artist, album, parent );
 339     dialog->show();
 340 }
 341
 342
 343 QString CoverManager::amazonTld() //static
 344 {
 345     if( AmarokConfig::amazonLocale() == "us" )
 346         return "com";
 347     else if( AmarokConfig::amazonLocale()== "jp" )
 348         return "co.jp";
 349     else if( AmarokConfig::amazonLocale() == "uk" )
 350         return "co.uk";
 351     else if( AmarokConfig::amazonLocale() == "ca" )
 352         return "ca";
 353     else
 354         return AmarokConfig::amazonLocale();
 355 }
 356
 357
 358 void CoverManager::fetchMissingCovers() //SLOT
 359 {
 360     DEBUG_BLOCK
 361
 362     for ( Q3IconViewItem *item = m_coverView->firstItem(); item; item = item->nextItem() ) {
 363         CoverViewItem *coverItem = static_cast<CoverViewItem*>( item );
 364         if( !coverItem->hasCover() ) {
 365             m_fetchCovers += coverItem->artist() + " @@@ " + coverItem->album();
 366             m_fetchingCovers++;
 367         }
 368     }
 369
 370     if( !m_fetchCounter )    //loop isn't started yet
 371         fetchCoversLoop();
 372
 373     updateStatusBar();
 374     m_fetchButton->setEnabled( false );
 375
 376 }
 377
 378
 379 void CoverManager::fetchCoversLoop() //SLOT
 380 {
 381     if( (int)m_fetchCounter < m_fetchCovers.count() )
 382     {
 383         //get artist and album from keyword
 384         const QStringList values = m_fetchCovers[m_fetchCounter].split( " @@@ ", QString::KeepEmptyParts );
 385
 386         if( values.count() > 1 )
 387            CollectionDB::instance()->fetchCover( this, values[0], values[1], m_fetchCovers.count() != 1); //edit mode when fetching 1 cover
 388
 389         m_fetchCounter++;
 390
 391         // Wait 1 second, since amazon caps the number of accesses per client
 392         QTimer::singleShot( 1000, this, SLOT( fetchCoversLoop() ) );
 393     }
 394     else {
 395         m_fetchCovers.clear();
 396         m_fetchCounter = 0;
 397     }
 398
 399 }
 400
 401
 402 void CoverManager::showOnce( const QString &artist )
 403 {
 404     if ( !s_instance ) {
 405         artistToSelectInInitFunction = artist;
 406         new CoverManager(); //shows itself
 407     }
 408     else {
 409         s_instance->activateWindow();
 410         s_instance->raise();
 411     }
 412 }
 413
 414 void CoverManager::slotArtistSelected( Q3ListViewItem *item ) //SLOT
 415 {
 416     if( item->depth() ) //album item
 417         return;
 418
 419     QString artist = item->text(0);
 420
 421     if( artist.endsWith( ", The" ) )
 422        Amarok::manipulateThe( artist, false );
 423
 424     m_coverView->clear();
 425     m_coverItems.clear();
 426
 427     // reset current view mode state to "AllAlbum" which is the default on artist change in left panel
 428     m_currentView = AllAlbums;
 429     m_selectAllAlbums->trigger();
 430     m_selectAllAlbums->setChecked( true );
 431
 432     Q3ProgressDialog progress( this, 0, true );
 433     progress.setLabelText( i18n("Loading Thumbnails...") );
 434     progress.QDialog::setWindowTitle( i18n("...") );
 435
 436     //NOTE we MUST show the dialog, otherwise the closeEvents get processed
 437     // in the processEvents() calls below, GRUMBLE! Qt sux0rs
 438     progress.show();
 439     progress.repaint();  //ensures the dialog isn't blank
 440
 441     //this is an extra processEvent call for the sake of init() and aesthetics
 442     //it isn't necessary
 443     kapp->processEvents();
 444
 445     //this can be a bit slow
 446     QApplication::setOverrideCursor( Qt::WaitCursor );
 447     QueryBuilder qb;
 448     QStringList albums;
 449
 450     qb.addReturnValue( QueryBuilder::tabArtist, QueryBuilder::valName );
 451     qb.addReturnValue( QueryBuilder::tabAlbum,  QueryBuilder::valName );
 452
 453     qb.excludeMatch( QueryBuilder::tabAlbum, i18n( "Unknown" ) );
 454     qb.sortBy( QueryBuilder::tabAlbum, QueryBuilder::valName );
 455     qb.setOptions( QueryBuilder::optRemoveDuplicates );
 456     qb.setOptions( QueryBuilder::optNoCompilations );
 457
 458     if ( item != m_artistView->firstChild() )
 459         qb.addMatch( QueryBuilder::tabArtist, artist );
 460
 461     albums = qb.run();
 462
 463     //also retrieve compilations when we're showing all items (first treenode) or
 464     //"Various Artists" (last treenode)
 465     if ( item == m_artistView->firstChild() || item == m_artistView->lastChild() )
 466     {
 467         QStringList cl;
 468
 469         qb.clear();
 470         qb.addReturnValue( QueryBuilder::tabAlbum,  QueryBuilder::valName );
 471
 472         qb.excludeMatch( QueryBuilder::tabAlbum, i18n( "Unknown" ) );
 473         qb.sortBy( QueryBuilder::tabAlbum, QueryBuilder::valName );
 474         qb.setOptions( QueryBuilder::optRemoveDuplicates );
 475         qb.setOptions( QueryBuilder::optOnlyCompilations );
 476         cl = qb.run();
 477
 478         for( int i = 0; i < cl.count(); i++ ) {
 479             albums.append( i18n( "Various Artists" ) );
 480             albums.append( cl[ i ] );
 481         }
 482     }
 483
 484     QApplication::restoreOverrideCursor();
 485
 486     progress.setTotalSteps( (albums.count()/2) + (albums.count()/10) );
 487
 488     //insert the covers first because the list view is soooo paint-happy
 489     //doing it in the second loop looks really bad, unfortunately
 490     //this is the slowest step in the bit that we can't process events
 491     uint x = 0;
 492     oldForeach( albums )
 493     {
 494         const QString artist = *it;
 495         const QString album = *(++it);
 496         m_coverItems.append( new CoverViewItem( m_coverView, m_coverView->lastItem(), artist, album ) );
 497
 498         if ( ++x % 50 == 0 ) {
 499             progress.setProgress( x / 5 ); // we do it less often due to bug in Qt, ask Max
 500             kapp->processEvents(); // QProgressDialog also calls this, but not always due to Qt bug!
 501
 502             //only worth testing for after processEvents() is called
 503             if( progress.wasCancelled() )
 504                break;
 505         }
 506     }
 507
 508     //now, load the thumbnails
 509     for( Q3IconViewItem *item = m_coverView->firstItem(); item; item = item->nextItem() ) {
 510         progress.setProgress( progress.progress() + 1 );
 511         kapp->processEvents();
 512
 513         if( progress.wasCancelled() )
 514            break;
 515
 516         static_cast<CoverViewItem*>(item)->loadCover();
 517     }
 518
 519     updateStatusBar();
 520 }
 521
 522 void CoverManager::showCoverMenu( Q3IconViewItem *item, const QPoint &p ) //SLOT
 523 {
 524     #define item static_cast<CoverViewItem*>(item)
 525     if( !item ) return;
 526
 527     KMenu menu;
 528
 529     menu.addTitle( i18n( "Cover Image" ) );
 530
 531     Q3PtrList<CoverViewItem> selected = selectedItems();
 532     const int nSelected = selected.count();
 533
 534     QAction* fetchSelectedAction = new QAction( KIcon( Amarok::icon( "download" ) )
 535         , i18np( "&Fetch From amazon.%1", "&Fetch Selected Covers", nSelected, CoverManager::amazonTld() )
 536         , &menu );
 537     connect( fetchSelectedAction, SIGNAL( triggered() ), this, SLOT( fetchSelectedCovers() ) );
 538
 539     QAction* setCustomAction = new QAction( KIcon( Amarok::icon( "files" ) )
 540         , i18np( "Set &Custom Cover", "Set &Custom Cover for Selected Albums", nSelected )
 541         , &menu );
 542     connect( setCustomAction, SIGNAL( triggered() ), this, SLOT( setCustomSelectedCovers() ) );
 543     QAction* unsetAction = new QAction( KIcon( Amarok::icon( "remove" ) ), i18np( "&Unset Cover", "&Unset Selected Covers", nSelected ), &menu );
 544     connect( unsetAction, SIGNAL( triggered() ), this, SLOT ( deleteSelectedCovers() ) );
 545
 546     QAction* playAlbumAction = new QAction( KIcon( Amarok::icon( "add_playlist" ) )
 547         , i18np( "&Append to Playlist", "&Append Selected Albums to Playlist", nSelected )
 548         , &menu );
 549
 550     connect( playAlbumAction, SIGNAL( triggered() ), this, SLOT( playSelectedAlbums() ) );
 551
 552     if( nSelected > 1 ) {
 553         menu.addAction( fetchSelectedAction );
 554         menu.addAction( setCustomAction );
 555         menu.addAction( playAlbumAction );
 556         menu.addAction( unsetAction );
 557     }
 558     else {
 559         QAction* viewAction = new QAction( KIcon( Amarok::icon( "zoom" ) ), i18n( "&Show Fullsize" ), &menu );
 560         connect( viewAction, SIGNAL( triggered() ), this, SLOT( viewSelectedCover() ) );
 561         viewAction ->setEnabled( item->hasCover() );
 562         unsetAction->setEnabled( item->canRemoveCover() );
 563         menu.addAction( viewAction );
 564         menu.addAction( fetchSelectedAction );
 565         menu.addAction( setCustomAction );
 566         menu.addAction( playAlbumAction );
 567         menu.addSeparator();
 568
 569         menu.addAction( unsetAction );
 570     }
 571
 572     menu.exec( p );
 573
 574     #undef item
 575 }
 576
 577 void CoverManager::viewSelectedCover()
 578 {
 579     CoverViewItem* item = selectedItems().first();
 580     viewCover( item->artist(), item->album(), this );
 581 }
 582
 583 void CoverManager::coverItemExecuted( Q3IconViewItem *item ) //SLOT
 584 {
 585     #define item static_cast<CoverViewItem*>(item)
 586
 587     if( !item ) return;
 588
 589     item->setSelected( true );
 590     if ( item->hasCover() )
 591         viewCover( item->artist(), item->album(), this );
 592     else
 593         fetchSelectedCovers();
 594
 595     #undef item
 596 }
 597
 598
 599 void CoverManager::slotSetFilter() //SLOT
 600 {
 601     m_filter = m_searchEdit->text();
 602
 603     m_coverView->selectAll( false);
 604     Q3IconViewItem *item = m_coverView->firstItem();
 605     while ( item )
 606     {
 607         Q3IconViewItem *tmp = item->nextItem();
 608         m_coverView->takeItem( item );
 609         item = tmp;
 610     }
 611
 612     m_coverView->setAutoArrange( false );
 613     for( Q3IconViewItem *item = m_coverItems.first(); item; item = m_coverItems.next() )
 614     {
 615         CoverViewItem *coverItem = static_cast<CoverViewItem*>(item);
 616         if( coverItem->album().contains( m_filter, Qt::CaseInsensitive ) || coverItem->artist().contains( m_filter, Qt::CaseInsensitive ) )
 617             m_coverView->insertItem( item, m_coverView->lastItem() );
 618     }
 619     m_coverView->setAutoArrange( true );
 620
 621     m_coverView->arrangeItemsInGrid();
 622     updateStatusBar();
 623 }
 624
 625
 626 void CoverManager::slotSetFilterTimeout() //SLOT
 627 {
 628     if ( m_timer->isActive() ) m_timer->stop();
 629     m_timer->setSingleShot( true );
 630     m_timer->start( 180 );
 631 }
 632
 633 void CoverManager::changeView( int id  ) //SLOT
 634 {
 635     if( m_currentView == id ) return;
 636
 637     //clear the iconview without deleting items
 638     m_coverView->selectAll( false);
 639     Q3IconViewItem *item = m_coverView->firstItem();
 640     while ( item ) {
 641         Q3IconViewItem *tmp = item->nextItem();
 642         m_coverView->takeItem( item );
 643         item = tmp;
 644     }
 645
 646     m_coverView->setAutoArrange(false );
 647     for( Q3IconViewItem *item = m_coverItems.first(); item; item = m_coverItems.next() ) {
 648         bool show = false;
 649         CoverViewItem *coverItem = static_cast<CoverViewItem*>(item);
 650         if( !m_filter.isEmpty() ) {
 651             if( !coverItem->album().contains( m_filter, Qt::CaseInsensitive ) && !coverItem->artist().contains( m_filter, Qt::CaseInsensitive ) )
 652                 continue;
 653         }
 654
 655         if( id == AllAlbums )    //show all albums
 656             show = true;
 657         else if( id == AlbumsWithCover && coverItem->hasCover() )    //show only albums with cover
 658             show = true;
 659         else if( id == AlbumsWithoutCover && !coverItem->hasCover() )   //show only albums without cover
 660             show = true;
 661
 662         if( show )    m_coverView->insertItem( item, m_coverView->lastItem() );
 663     }
 664     m_coverView->setAutoArrange( true );
 665
 666     m_coverView->arrangeItemsInGrid();
 667     m_currentView = id;
 668 }
 669
 670 void CoverManager::changeLocale( int id ) //SLOT
 671 {
 672     QString locale = CoverFetcher::localeIDToString( id );
 673     AmarokConfig::setAmazonLocale( locale );
 674     m_currentLocale = id;
 675 }
 676
 677
 678 void CoverManager::coverFetched( const QString &artist, const QString &album ) //SLOT
 679 {
 680     loadCover( artist, album );
 681     m_coversFetched++;
 682     updateStatusBar();
 683 }
 684
 685
 686 void CoverManager::coverRemoved( const QString &artist, const QString &album ) //SLOT
 687 {
 688     loadCover( artist, album );
 689     m_coversFetched--;
 690     updateStatusBar();
 691 }
 692
 693
 694 void CoverManager::coverFetcherError()
 695 {
 696     DEBUG_FUNC_INFO
 697
 698     m_coverErrors++;
 699     updateStatusBar();
 700 }
 701
 702
 703 void CoverManager::stopFetching()
 704 {
 705     Debug::Block block( __PRETTY_FUNCTION__ );
 706
 707     m_fetchCovers.clear();
 708     m_fetchCounter = 0;
 709
 710     //delete all cover fetchers
 711     QList<CoverFetcher *> list = qFindChildren<CoverFetcher*>(this);
 712     foreach( CoverFetcher *cf, list )
 713         cf->deleteLater();
 714
 715     m_fetchingCovers = 0;
 716     updateStatusBar();
 717 }
 718
 719 // PRIVATE
 720
 721 void CoverManager::loadCover( const QString &artist, const QString &album )
 722 {
 723     for( Q3IconViewItem *item = m_coverItems.first(); item; item = m_coverItems.next() )
 724     {
 725         CoverViewItem *coverItem = static_cast<CoverViewItem*>(item);
 726         if ( album == coverItem->album() && ( artist == coverItem->artist() || ( artist.isEmpty() && coverItem->artist().isEmpty() ) ) )
 727         {
 728             coverItem->loadCover();
 729             return;
 730         }
 731     }
 732 }
 733
 734 void CoverManager::setCustomSelectedCovers()
 735 {
 736     //function assumes something is selected
 737     Q3PtrList<CoverViewItem> selected = selectedItems();
 738     CoverViewItem* first = selected.getFirst();
 739
 740     QString artist_id; artist_id.setNum( CollectionDB::instance()->artistID( first->artist() ) );
 741     QString album_id; album_id.setNum( CollectionDB::instance()->albumID( first->album() ) );
 742     QStringList values = CollectionDB::instance()->albumTracks( artist_id, album_id );
 743
 744     QString startPath = ":homedir";
 745     if ( !values.isEmpty() ) {
 746         KUrl url;
 747         url.setPath( values.first() );
 748         startPath = url.directory();
 749     }
 750     KUrl file = KFileDialog::getImageOpenUrl( startPath, this, i18n( "Select Cover Image File" ) );
 751     if ( !file.isEmpty() ) {
 752         kapp->processEvents();    //it may takes a while so process pending events
 753         QString tmpFile;
 754         QImage image = CollectionDB::fetchImage(file, tmpFile);
 755         for ( CoverViewItem* item = selected.first(); item; item = selected.next() ) {
 756             CollectionDB::instance()->setAlbumImage( item->artist(), item->album(), image );
 757             item->loadCover();
 758         }
 759         KIO::NetAccess::removeTempFile( tmpFile );
 760     }
 761 }
 762
 763 void CoverManager::fetchSelectedCovers()
 764 {
 765     Q3PtrList<CoverViewItem> selected = selectedItems();
 766     for ( CoverViewItem* item = selected.first(); item; item = selected.next() )
 767         m_fetchCovers += item->artist() + " @@@ " + item->album();
 768
 769     m_fetchingCovers += selected.count();
 770
 771     if( !m_fetchCounter )    //loop isn't started yet
 772         fetchCoversLoop();
 773
 774     updateStatusBar();
 775 }
 776
 777
 778 void CoverManager::deleteSelectedCovers()
 779 {
 780     Q3PtrList<CoverViewItem> selected = selectedItems();
 781
 782     int button = KMessageBox::warningContinueCancel( this,
 783                             i18np( "Are you sure you want to remove this cover from the Collection?",
 784                                   "Are you sure you want to delete these %1 covers from the Collection?",
 785                                   selected.count() ),
 786                             QString(),
 787                             KStandardGuiItem::del() );
 788
 789     if ( button == KMessageBox::Continue ) {
 790         for ( CoverViewItem* item = selected.first(); item; item = selected.next() ) {
 791             kapp->processEvents();
 792             if ( CollectionDB::instance()->removeAlbumImage( item->artist(), item->album() ) )    //delete selected cover
 793                   coverRemoved( item->artist(), item->album() );
 794         }
 795     }
 796 }
 797
 798
 799 void CoverManager::playSelectedAlbums()
 800 {
 801     Q3PtrList<CoverViewItem> selected = selectedItems();
 802     QString artist_id, album_id;
 803     for ( CoverViewItem* item = selected.first(); item; item = selected.next() )
 804     {
 805         artist_id.setNum( CollectionDB::instance()->artistID( item->artist() ) );
 806         album_id.setNum( CollectionDB::instance()->albumID( item->album() ) );
 807         The::playlistModel()->insertMedia( CollectionDB::instance()->albumTracks( artist_id, album_id ), Playlist::Append );
 808     }
 809 }
 810
 811 Q3PtrList<CoverViewItem> CoverManager::selectedItems()
 812 {
 813     Q3PtrList<CoverViewItem> selectedItems;
 814     for ( Q3IconViewItem* item = m_coverView->firstItem(); item; item = item->nextItem() )
 815         if ( item->isSelected() )
 816               selectedItems.append( static_cast<CoverViewItem*>(item) );
 817
 818     return selectedItems;
 819 }
 820
 821
 822 void CoverManager::updateStatusBar()
 823 {
 824     QString text;
 825
 826     //cover fetching info
 827     if( m_fetchingCovers ) {
 828         //update the progress bar
 829         m_progress->setMaximum( m_fetchingCovers );
 830         m_progress->setValue( m_coversFetched + m_coverErrors );
 831         if( m_progressBox->isHidden() )
 832             m_progressBox->show();
 833
 834         //update the status text
 835         if( m_coversFetched + m_coverErrors >= m_progress->value() ) {
 836             //fetching finished
 837             text = i18n( "Finished." );
 838             if( m_coverErrors )
 839                 text += i18np( " Cover not found", " <b>%1</b> covers not found", m_coverErrors );
 840             //reset counters
 841             m_fetchingCovers = 0;
 842             m_coversFetched = 0;
 843             m_coverErrors = 0;
 844             QTimer::singleShot( 2000, this, SLOT( updateStatusBar() ) );
 845         }
 846
 847         if( m_fetchingCovers == 1 ) {
 848             QStringList values = m_fetchCovers[0].split( " @@@ ", QString::KeepEmptyParts ); //get artist and album name
 849             if ( values.count() >= 2 )
 850             {
 851                 if( values[0].isEmpty() )
 852                     text = i18n( "Fetching cover for %1..." , values[1] );
 853                 else
 854                     text = i18n( "Fetching cover for %1 - %2...", values[0], values[1] );
 855             }
 856         }
 857         else if( m_fetchingCovers ) {
 858             text = i18np( "Fetching 1 cover: ", "Fetching <b>%1</b> covers... : ", m_fetchingCovers );
 859             if( m_coversFetched )
 860                 text += i18np( "1 fetched", "%1 fetched", m_coversFetched );
 861             if( m_coverErrors ) {
 862             if( m_coversFetched ) text += i18n(" - ");
 863                 text += i18np( "1 not found", "%1 not found", m_coverErrors );
 864             }
 865             if( m_coversFetched + m_coverErrors == 0 )
 866                 text += i18n( "Connecting..." );
 867         }
 868     }
 869     else {
 870         m_coversFetched = 0;
 871         m_coverErrors = 0;
 872
 873         uint totalCounter = 0, missingCounter = 0;
 874
 875         if( m_progressBox->isVisible() )
 876             m_progressBox->hide();
 877
 878         //album info
 879         for( Q3IconViewItem *item = m_coverView->firstItem(); item; item = item->nextItem() ) {
 880             totalCounter++;
 881             if( !static_cast<CoverViewItem*>( item )->hasCover() )
 882                 missingCounter++;    //counter for albums without cover
 883         }
 884
 885         if( !m_filter.isEmpty() )
 886             text = i18np( "1 result for \"%1\"", "%1 results for \"%1\"", totalCounter, m_filter );
 887         else if( m_artistView->selectedItem() ) {
 888             text = i18np( "1 album", "%1 albums", totalCounter );
 889             if( m_artistView->selectedItem() != m_artistView->firstChild() ) //showing albums by an artist
 890             {
 891                 QString artist = m_artistView->selectedItem()->text(0);
 892                 if( artist.endsWith( ", The" ) )
 893                     Amarok::manipulateThe( artist, false );
 894                 text += i18n( " by " ) + artist;
 895             }
 896         }
 897
 898         if( missingCounter )
 899             text += i18n(" - ( <b>%1</b> without cover )", missingCounter );
 900
 901         m_fetchButton->setEnabled( missingCounter );
 902     }
 903
 904     m_statusLabel->setText( text );
 905 }
 906
 907 void CoverManager::setStatusText( QString text )
 908 {
 909     m_oldStatusText = m_statusLabel->text();
 910     m_statusLabel->setText( text );
 911 }
 912
 913 //////////////////////////////////////////////////////////////////////
 914 //    CLASS CoverView
 915 /////////////////////////////////////////////////////////////////////
 916
 917 CoverView::CoverView( QWidget *parent, const char *name, Qt::WFlags f )
 918     : K3IconView( parent, name, f )
 919 {
 920     Debug::Block block( __PRETTY_FUNCTION__ );
 921
 922     setArrangement( Q3IconView::LeftToRight );
 923     setResizeMode( Q3IconView::Adjust );
 924     setSelectionMode( Q3IconView::Extended );
 925     arrangeItemsInGrid();
 926     setAutoArrange( true );
 927     setItemsMovable( false );
 928
 929     // as long as QIconView only shows tooltips when the cursor is over the
 930     // icon (and not the text), we have to create our own tooltips
 931     setShowToolTips( false );
 932
 933     connect( this, SIGNAL( onItem( Q3IconViewItem * ) ), SLOT( setStatusText( Q3IconViewItem * ) ) );
 934     connect( this, SIGNAL( onViewport() ), CoverManager::instance(), SLOT( updateStatusBar() ) );
 935 }
 936
 937
 938 Q3DragObject *CoverView::dragObject()
 939 {
 940     CoverViewItem *item = static_cast<CoverViewItem*>( currentItem() );
 941     if( !item )
 942        return 0;
 943
 944     const QString sql = "SELECT tags.url FROM tags, album WHERE album.name %1 AND tags.album = album.id ORDER BY tags.track;";
 945     const QStringList values = CollectionDB::instance()->query( sql.arg( CollectionDB::likeCondition( item->album() ) ) );
 946
 947     KUrl::List urls;
 948     for( QStringList::ConstIterator it = values.begin(), end = values.end(); it != end; ++it )
 949         urls += *it;
 950
 951     QString imagePath = CollectionDB::instance()->albumImage( item->artist(), item->album(), false, 1 );
 952     K3MultipleDrag *drag = new K3MultipleDrag( this );
 953     drag->setPixmap( item->coverPixmap() );
 954     drag->addDragObject( new Q3IconDrag( this ) );
 955     drag->addDragObject( new Q3ImageDrag( QImage( imagePath ) ) );
 956     drag->addDragObject( new K3URLDrag( urls ) );
 957
 958     return drag;
 959 }
 960
 961 void CoverView::setStatusText( Q3IconViewItem *item )
 962 {
 963     #define item static_cast<CoverViewItem *>( item )
 964     if ( !item )
 965         return;
 966
 967     bool sampler = false;
 968     //compilations have valDummy for artist.  see QueryBuilder::addReturnValue(..) for explanation
 969     //FIXME: Don't rely on other independent code, use an sql query
 970     if( item->artist().isEmpty() ) sampler = true;
 971
 972     QString tipContent = i18n( "%1 - %2", sampler ? i18n("Various Artists") : item->artist() , item->album() );
 973
 974     CoverManager::instance()->setStatusText( tipContent );
 975
 976     #undef item
 977 }
 978
 979 //////////////////////////////////////////////////////////////////////
 980 //    CLASS CoverViewItem
 981 /////////////////////////////////////////////////////////////////////
 982
 983 CoverViewItem::CoverViewItem( Q3IconView *parent, Q3IconViewItem *after, const QString &artist, const QString &album )
 984     : K3IconViewItem( parent, after, album )
 985     , m_artist( artist )
 986     , m_album( album )
 987     , m_coverImagePath( CollectionDB::instance()->albumImage( m_artist, m_album, false, 0, &m_embedded ) )
 988     , m_coverPixmap( )
 989 {
 990     setDragEnabled( true );
 991     setDropEnabled( true );
 992     calcRect();
 993 }
 994
 995 bool CoverViewItem::hasCover() const
 996 {
 997     return !m_coverImagePath.endsWith( "nocover.png" ) && QFile::exists( m_coverImagePath );
 998 }
 999
1000 void CoverViewItem::loadCover()
1001 {
1002     m_coverImagePath = CollectionDB::instance()->albumImage( m_artist, m_album, false, 1, &m_embedded );
1003     m_coverPixmap = QPixmap( m_coverImagePath );  //create the scaled cover
1004
1005     repaint();
1006 }
1007
1008
1009 void CoverViewItem::calcRect( const QString& )
1010 {
1011     int thumbWidth = AmarokConfig::coverPreviewSize();
1012
1013     QFontMetrics fm = iconView()->fontMetrics();
1014     QRect itemPixmapRect( 5, 1, thumbWidth, thumbWidth );
1015     QRect itemRect = rect();
1016     itemRect.setWidth( thumbWidth + 10 );
1017     itemRect.setHeight( thumbWidth + fm.lineSpacing() + 2 );
1018     QRect itemTextRect( 0, thumbWidth+2, itemRect.width(), fm.lineSpacing() );
1019
1020     setPixmapRect( itemPixmapRect );
1021     setTextRect( itemTextRect );
1022     setItemRect( itemRect );
1023 }
1024
1025
1026 void CoverViewItem::paintItem(QPainter* p, const QColorGroup& cg)
1027 {
1028     Q_UNUSED( cg ); // FIXME is this correct (cg replaced by palette() )?
1029     QPalette palette = KApplication::palette();
1030     QRect itemRect = rect();
1031
1032     p->save();
1033     p->translate( itemRect.x(), itemRect.y() );
1034
1035     // draw the border
1036     p->setPen( palette.mid().color() );
1037     p->drawRect( 0, 0, itemRect.width(), pixmapRect().height()+2 );
1038
1039     // draw the cover image
1040     if( !m_coverPixmap.isNull() )
1041         p->drawPixmap( pixmapRect().x() + (pixmapRect().width() - m_coverPixmap.width())/2,
1042             pixmapRect().y() + (pixmapRect().height() - m_coverPixmap.height())/2, m_coverPixmap );
1043
1044     //justify the album name
1045     QString str = text();
1046     QFontMetrics fm = p->fontMetrics();
1047     str = fm.elidedText( str, Qt::ElideRight, textRect().width() );
1048
1049     p->setPen( palette.text().color() );
1050     p->drawText( textRect(), Qt::AlignCenter, str );
1051
1052     if( isSelected() ) {
1053        p->setPen( palette.highlight().color() );
1054        p->drawRect( pixmapRect() );
1055        p->drawRect( pixmapRect().left()+1, pixmapRect().top()+1, pixmapRect().width()-2, pixmapRect().height()-2);
1056        p->drawRect( pixmapRect().left()+2, pixmapRect().top()+2, pixmapRect().width()-4, pixmapRect().height()-4);
1057     }
1058
1059     p->restore();
1060 }
1061
1062
1063 void CoverViewItem::dropped( QDropEvent *e, const Q3ValueList<Q3IconDragItem> & )
1064 {
1065     if( Q3ImageDrag::canDecode( e ) ) {
1066        if( hasCover() ) {
1067            KGuiItem continueButton = KStandardGuiItem::cont();
1068            continueButton.setText( i18n("&Overwrite") );
1069            int button = KMessageBox::warningContinueCancel( iconView(),
1070                             i18n( "Are you sure you want to overwrite this cover?"),
1071                             i18n("Overwrite Confirmation"),
1072                             continueButton );
1073            if( button == KMessageBox::Cancel )
1074                return;
1075        }
1076
1077        QImage img;
1078        Q3ImageDrag::decode( e, img );
1079        CollectionDB::instance()->setAlbumImage( artist(), album(), img );
1080        m_coverImagePath = CollectionDB::instance()->albumImage( m_artist, m_album, false, 0 );
1081        loadCover();
1082     }
1083 }
1084
1085
1086 void CoverViewItem::dragEntered()
1087 {
1088     setSelected( true );
1089 }
1090
1091
1092 void CoverViewItem::dragLeft()
1093 {
1094     setSelected( false );
1095 }
1096
1097 #include "covermanager.moc"