src/mediabrowser.cpp

   1 // (c) 2004 Christian Muehlhaeuser <chris@chris.de>
   2 // (c) 2005-2006 Martin Aumueller <aumuell@reserv.at>
   3 // (c) 2005 Seb Ruiz <ruiz@kde.org>
   4 // (c) 2006 T.R.Shashwath <trshash84@gmail.com>
   5 // See COPYING file for licensing information
   6
   7
   8 #define DEBUG_PREFIX "MediaBrowser"
   9
  10 #include "mediabrowser.h"
  11
  12 #include "config-amarok.h"
  13
  14 #include "amarok.h"
  15 #include "amarokconfig.h"
  16 #include "app.h"
  17 #include "browserToolBar.h"
  18 #include "collectiondb.h"
  19 #include "debug.h"
  20 #include "editfilterdialog.h"
  21 #include "deviceconfiguredialog.h"
  22 #include "expression.h"
  23 #include "hintlineedit.h"
  24 #include "MediaItem.h"
  25 #include "MediaDevice.h"
  26 #include "MediaDeviceCache.h"
  27 #include "medium.h"
  28 //#include "mediumpluginmanager.h"
  29 #include "metabundle.h"
  30 #include "mountpointmanager.h"
  31 #include "playlist/PlaylistModel.h"
  32 #include "pluginmanager.h"
  33 #include "podcastbundle.h"
  34 #include "scriptmanager.h"
  35 #include "scrobbler.h"
  36 #include "searchwidget.h"
  37 #include "statusbar.h"
  38 #include "transferdialog.h"
  39 #include "TheInstances.h"
  40
  41 #include <q3header.h>
  42 #include <Q3PopupMenu>
  43 #include <q3simplerichtext.h>
  44 #include <QByteArray>
  45 #include <QCheckBox>
  46 #include <QDateTime>
  47 #include <QDir>
  48 #include <QDomDocument>
  49 #include <QDomElement>
  50 #include <QDomNode>
  51 #include <QDropEvent>
  52 #include <QFileInfo>
  53 #include <QGroupBox>
  54 #include <QImage>
  55 #include <QKeyEvent>
  56 #include <QLabel>
  57 #include <QList>
  58 #include <QListIterator>
  59 #include <QObject>
  60 #include <QPainter>
  61 #include <QPaintEvent>
  62 #include <QPixmap>
  63 #include <QProgressBar>
  64 #include <QRadioButton>
  65 #include <QTimer>
  66 #include <QToolButton>
  67 #include <QToolTip>       //QToolTip::add()
  68
  69 #include <k3multipledrag.h>
  70 #include <k3process.h>
  71 #include <k3tempfile.h>
  72 #include <k3urldrag.h>       //dragObject()
  73 #include <KActionCollection>
  74 #include <KApplication> //kapp
  75 #include <KComboBox>
  76 #include <KDirLister>
  77 #include <KFileDialog>
  78 #include <KGlobal>
  79 #include <KIconLoader>
  80 #include <KInputDialog>
  81 #include <KIO/Job>
  82 #include <KLocale>
  83 #include <KMenu>
  84 #include <KMessageBox>
  85 #include <KPushButton>
  86 #include <KRun>
  87 #include <KStandardDirs> //locate file
  88 #include <KTabBar>
  89 #include <solid/device.h>
  90 #include <solid/deviceinterface.h>
  91 #include <solid/devicenotifier.h>
  92 #include <solid/portablemediaplayer.h>
  93
  94
  95 MediaBrowser *MediaBrowser::s_instance = 0;
  96
  97 bool MediaBrowser::isAvailable() //static
  98 {
  99     if( !MediaBrowser::instance() )
 100         return false;
 101
 102     return true;
 103
 104     //to re-enable hiding, uncomment this and get rid of the return true above:
 105     //return MediaBrowser::instance()->m_haveDevices;
 106 }
 107
 108 class DummyMediaDevice : public MediaDevice
 109 {
 110     public:
 111     DummyMediaDevice() : MediaDevice()
 112     {
 113         m_name = i18n( "No Device Available" );
 114         m_type = "dummy-mediadevice";
 115         m_uid = "manual|DummyDevice|none|none";
 116     }
 117     void init( MediaBrowser *browser ) { MediaDevice::init( browser ); }
 118     virtual ~DummyMediaDevice() {}
 119     virtual bool isConnected() { return false; }
 120     virtual MediaItem* trackExists(const MetaBundle&) { return 0; }
 121     virtual bool lockDevice(bool) { return true; }
 122     virtual void unlockDevice() {}
 123     virtual bool openDevice( bool silent )
 124     {
 125         if( !silent )
 126         {
 127             //QString msg = i18n( "Sorry, you do not have a supported portable music player." );
 128             //Amarok::StatusBar::instance()->longMessage( msg, KDE::StatusBar::Sorry );
 129         }
 130         return false;
 131     }
 132     virtual bool closeDevice() { return false; }
 133     virtual void synchronizeDevice() {}
 134     virtual MediaItem* copyTrackToDevice(const MetaBundle&) { return 0; }
 135     virtual int deleteItemFromDevice(MediaItem*, int) { return -1; }
 136 };
 137
 138
 139 MediaBrowser::MediaBrowser( const char * /*name*/ )
 140         : KVBox( 0)
 141         , m_timer( new QTimer( this ) )
 142         , m_currentDevice( 0 )
 143         , m_waitForTranscode( false )
 144         , m_quitting( false )
 145         , m_connectAction( 0 )
 146         , m_disconnectAction( 0 )
 147         , m_customAction( 0 )
 148         , m_configAction( 0 )
 149         , m_transferAction( 0 )
 150 {
 151     s_instance = this;
 152
 153     m_timer->setSingleShot( true );
 154
 155     m_toolbar = new Browser::ToolBar( this );
 156     m_toolbar->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum );
 157     m_toolbar->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
 158
 159     //TODO: how to fix getButton
 160     // perhaps the action can be referenced instead?
 161     m_connectAction = new KAction(KIcon("connect_creating"), i18n("Connect"), this);
 162     connect(m_connectAction, SIGNAL(triggered()), this, SLOT(connectClicked()));
 163     m_toolbar->addAction(m_connectAction);
 164 //     m_toolbar->insertButton( "connect_creating", CONNECT, true, i18n("Connect") );
 165 //     m_toolbar->getButton(CONNECT)->setToolTip( i18n( "Connect media device" ) );
 166
 167     m_disconnectAction = new KAction(KIcon("media-eject"), i18n("Disconnect"), this);
 168     connect(m_disconnectAction, SIGNAL(triggered()), this, SLOT(disconnectClicked()));
 169     m_toolbar->addAction(m_disconnectAction);
 170 //     m_toolbar->insertButton( "media-eject", DISCONNECT, true, i18n("Disconnect") );
 171 //     m_toolbar->getButton(DISCONNECT)->setToolTip( i18n( "Disconnect media device" ) );
 172
 173     m_transferAction = new KAction(KIcon("rebuild"), i18n("Transfer"), this);
 174     connect(m_transferAction, SIGNAL(triggered()), this, SLOT(transferClicked()));
 175     m_toolbar->addAction(m_transferAction);
 176 //     m_toolbar->insertButton( "rebuild", TRANSFER, true, i18n("Transfer") );
 177 //     m_toolbar->getButton(TRANSFER)->setToolTip( i18n( "Transfer tracks to media device" ) );
 178
 179     m_toolbar->addSeparator();
 180
 181    // m_toolbar->setIconText( KToolBar::IconTextRight, true );
 182     m_customAction = new KAction(KIcon( "add_playlist" ), i18n("custom"), this);
 183     connect(m_customAction, SIGNAL(triggered()), this, SLOT(customClicked()));
 184     m_customAction->setText( i18n("Special Device Functions") );
 185     m_customAction->setToolTip( i18n("Device-specific special functions or information") );
 186     m_toolbar->addAction(m_customAction);
 187 //     m_toolbar->insertButton( Amarok::icon( "add_playlist" ), CUSTOM, SIGNAL( clicked() ), this, SLOT( customClicked() ), true, "custom" );
 188 //     m_toolbar->getButton(TRANSFER)->setToolTip( i18n( "Transfer tracks to media device" ) );
 189
 190     m_toolbar->setToolButtonStyle( Qt::ToolButtonIconOnly );
 191
 192     m_configAction = new KAction(KIcon("configure"), i18n("Configure"), this);
 193     connect(m_configAction, SIGNAL(triggered()), this, SLOT(config()));
 194     m_toolbar->addAction(m_configAction);
 195 //     m_toolbar->insertButton( Amarok::icon( "configure" ), CONFIGURE, true, i18n("Configure") );
 196 //     m_toolbar->getButton(CONFIGURE)->setToolTip( i18n( "Configure device" ) );
 197
 198
 199     m_deviceCombo = new KComboBox( this );
 200
 201     // searching/filtering
 202     QToolBar* searchToolBar = new Browser::ToolBar( this );
 203     searchToolBar->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum );
 204     m_searchWidget = new SearchWidget( searchToolBar, this );
 205     searchToolBar->addWidget( m_searchWidget );
 206     connect( m_timer, SIGNAL( timeout() ), SLOT( slotSetFilter() ) );
 207
 208     // connect to device cache
 209     connect( MediaDeviceCache::instance(), SIGNAL( deviceAdded(const QString&) ),
 210             SLOT( deviceAdded(const QString&) ) );
 211     connect( MediaDeviceCache::instance(), SIGNAL( deviceRemoved(const QString&) ),
 212             SLOT( deviceRemoved(const QString&) ) );
 213
 214
 215     // we always have a dummy device
 216     m_pluginName[ i18n( "Disable" ) ] = "dummy-mediadevice";
 217     m_pluginAmarokName["dummy-mediadevice"] = i18n( "Disable" );
 218     m_pluginName[ i18n( "Do not handle" ) ] = "ignore";
 219     m_pluginAmarokName["ignore"] = i18n( "Do not handle" );
 220     // query available device plugins
 221     m_plugins = PluginManager::query( "[X-KDE-Amarok-plugintype] == 'mediadevice'" );
 222     for( KService::List::ConstIterator it = m_plugins.begin(); it != m_plugins.end(); ++it ) {
 223         // Save name properties in QMap for lookup
 224         m_pluginName[(*it)->name()] = (*it)->property( "X-KDE-Amarok-name" ).toString();
 225         m_pluginAmarokName[(*it)->property( "X-KDE-Amarok-name" ).toString()] = (*it)->name();
 226     }
 227
 228     m_views = new KVBox( this );
 229     m_queue = new MediaQueue( this );
 230     m_progressBox  = new KHBox( this );
 231     m_progress     = new QProgressBar( m_progressBox );
 232     m_cancelButton = new KPushButton( KIcon( Amarok::icon( "cancel" ) ), i18n("Cancel"), m_progressBox );
 233
 234
 235     m_stats = new SpaceLabel(this);
 236
 237     m_progressBox->hide();
 238
 239     MediaDevice *dev = new DummyMediaDevice();
 240     dev->init( this );
 241     addDevice( dev );
 242     activateDevice( 0, false );
 243     updateDevices();
 244     queue()->load( Amarok::saveLocation() + "transferlist.xml" );
 245     queue()->computeSize();
 246
 247     setFocusProxy( m_queue );
 248
 249     updateStats();
 250
 251     MediaDeviceCache::instance()->refreshCache();
 252     foreach( QString udi, MediaDeviceCache::instance()->getAll() )
 253         deviceAdded( udi );
 254
 255     //TODO: Take generic storage devices into account too -- or do we rely on the
 256     //Solid backend to tell us if it's a PMP with "storage" type?
 257
 258     connect( m_deviceCombo,      SIGNAL( activated( int ) ), SLOT( activateDevice( int ) ) );
 259
 260     connect( m_cancelButton,     SIGNAL( clicked() ),        SLOT( cancelClicked() ) );
 261     connect( pApp,               SIGNAL( prepareToQuit() ),  SLOT( prepareToQuit() ) );
 262     connect( CollectionDB::instance(), SIGNAL( tagsChanged( const MetaBundle& ) ),
 263             SLOT( tagsChanged( const MetaBundle& ) ) );
 264
 265     //TODO: If we will be supporting manually adding devices, probably need the following section
 266     /*m_haveDevices = false;
 267     QMap<QString,QString> savedDevices = Amarok::config( "MediaBrowser" ).entryMap();
 268     for( QMap<QString,QString>::Iterator it = savedDevices.begin();
 269             it != savedDevices.end();
 270             ++it )
 271     {
 272         if( it.data() != "deleted" && it.data() != "ignore" )
 273         {
 274             m_haveDevices = true;
 275             break;
 276         }
 277     }
 278     */
 279 }
 280
 281 bool
 282 MediaBrowser::blockQuit() const
 283 {
 284     for( QList<MediaDevice *>::const_iterator it = m_devices.begin();
 285             it != m_devices.end();
 286             ++it )
 287     {
 288         if( *it && (*it)->isConnected() )
 289             return true;
 290     }
 291
 292     return false;
 293 }
 294
 295 void
 296 MediaBrowser::tagsChanged( const MetaBundle &bundle )
 297 {
 298     m_itemMapMutex.lock();
 299     debug() << "tags changed for " << bundle.url().url();
 300     ItemMap::iterator it = m_itemMap.find( bundle.url().url() );
 301     if( it != m_itemMap.end() )
 302     {
 303         MediaItem *item = *it;
 304         m_itemMapMutex.unlock();
 305         if( item->device() )
 306         {
 307             item->device()->tagsChanged( item, bundle );
 308         }
 309         else
 310         {
 311             // it's an item on the transfer queue
 312             item->setBundle( new MetaBundle( bundle ) );
 313
 314             QString text = item->bundle()->prettyTitle();
 315             if( text.isEmpty() || (!item->bundle()->isValidMedia() && !item->bundle()->podcastBundle()) )
 316                 text = item->bundle()->url().prettyUrl();
 317             if( !item->m_playlistName.isNull() )
 318             {
 319                 text += " (" + item->m_playlistName + ')';
 320             }
 321             item->setText( 0, text);
 322         }
 323     }
 324     else
 325     {
 326         m_itemMapMutex.unlock();
 327     }
 328 }
 329
 330 bool
 331 MediaBrowser::getBundle( const KUrl &url, MetaBundle *bundle ) const
 332 {
 333     QMutexLocker locker( &m_itemMapMutex );
 334     ItemMap::const_iterator it = m_itemMap.find( url.url() );
 335     if( it == m_itemMap.end() )
 336         return false;
 337
 338     if( bundle )
 339         *bundle = *(*it)->bundle();
 340
 341     return true;
 342 }
 343
 344 KUrl
 345 MediaBrowser::getProxyUrl( const KUrl& daapUrl ) const
 346 {
 347     DEBUG_BLOCK
 348     KUrl url;
 349     MediaDevice* dc = findChildren<MediaDevice *>( "DaapClient" ).first();
 350     if( dc )
 351         url = dc->getProxyUrl( daapUrl );
 352     return url;
 353 }
 354
 355 MediaDevice *
 356 MediaBrowser::deviceFromId( const QString &id ) const
 357 {
 358     for( QList<MediaDevice *>::const_iterator it = m_devices.constBegin();
 359                 it != m_devices.end();
 360                 it++ )
 361         {
 362             if( (*it)->uid() == id )
 363                 return (*it);
 364         }
 365
 366     return NULL;
 367 }
 368
 369 void
 370 MediaBrowser::activateDevice( const MediaDevice *dev )
 371 {
 372     int index = 0;
 373     for( QList<MediaDevice *>::iterator it = m_devices.begin();
 374             it != m_devices.end();
 375             it++ )
 376     {
 377         if( *it == dev )
 378         {
 379             activateDevice( index );
 380             break;
 381         }
 382         index++;
 383     }
 384 }
 385
 386 void
 387 MediaBrowser::activateDevice( int index, bool skipDummy )
 388 {
 389     if( m_currentDevice && m_currentDevice->customAction() )
 390     {
 391         m_toolbar->removeAction( m_currentDevice->customAction() );
 392         m_toolbar->hide();
 393         m_toolbar->show();
 394     }
 395
 396     foreach( MediaDevice *md, m_devices )
 397     {
 398         if( md && md->view() )
 399             md->view()->hide();
 400     }
 401
 402     if( index < 0 )
 403     {
 404         m_currentDevice = m_devices.last();
 405         return;
 406     }
 407
 408     if( skipDummy )
 409        index++;
 410
 411     if( index >= m_devices.count() )
 412     {
 413         if( !m_devices.isEmpty() )
 414             m_currentDevice = m_devices.last();
 415         else
 416             m_currentDevice = 0;
 417         updateButtons();
 418         queue()->computeSize();
 419         updateStats();
 420         return;
 421     }
 422
 423     m_currentDevice = m_devices[index];
 424     if( m_currentDevice && m_currentDevice->view() )
 425     {
 426         m_currentDevice->view()->show();
 427         if( m_currentDevice->customAction() )
 428         {
 429             m_toolbar->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
 430             m_toolbar->addAction( m_currentDevice->customAction() );
 431             m_toolbar->hide();
 432             m_toolbar->show();
 433         }
 434     }
 435     m_deviceCombo->setCurrentIndex( index-1 );
 436
 437     updateButtons();
 438     queue()->computeSize();
 439     updateStats();
 440 }
 441
 442 void
 443 MediaBrowser::addDevice( MediaDevice *device )
 444 {
 445     m_devices.append( device );
 446
 447     device->loadConfig();
 448
 449     if( device->autoConnect() )
 450     {
 451         device->connectDevice( true );
 452         updateButtons();
 453     }
 454
 455     updateDevices();
 456 }
 457
 458 void
 459 MediaBrowser::removeDevice( MediaDevice *device )
 460 {
 461     DEBUG_BLOCK
 462
 463     debug() << "remove device: type=" << device->deviceType();
 464
 465     for( QList<MediaDevice *>::iterator it = m_devices.begin();
 466             it != m_devices.end();
 467             it++ )
 468     {
 469         if( *it == device )
 470         {
 471             bool current = ( (*it)->uid() == m_currentDevice->uid() );
 472             m_devices.erase( it );
 473             if( current )
 474                 activateDevice( 0, false );
 475             break;
 476         }
 477     }
 478
 479     if( device->isConnected() )
 480     {
 481         if( device->disconnectDevice( false /* don't run post-disconnect command */ ) )
 482             unloadDevicePlugin( device );
 483         else
 484         {
 485             debug() << "Cannot remove device because disconnect failed";
 486             Amarok::StatusBar::instance()->longMessage(
 487                     i18n( "Cannot remove device because disconnect failed" ),
 488                     KDE::StatusBar::Warning );
 489         }
 490     }
 491     else
 492         unloadDevicePlugin( device );
 493
 494     updateDevices();
 495 }
 496
 497 void
 498 MediaBrowser::updateDevices()
 499 {
 500     m_deviceCombo->clear();
 501     uint i = 0;
 502     for( QList<MediaDevice *>::iterator it = m_devices.begin();
 503             it != m_devices.end();
 504             it++ )
 505     {
 506         if( m_devices.count() > 1 && dynamic_cast<DummyMediaDevice *>(*it) )
 507             continue;
 508         QString name = (*it)->name();
 509         if( !(*it)->deviceNode().isEmpty() )
 510         {
 511             name = i18n( "%1 at %2", name, (*it)->deviceNode() );
 512         }
 513         if( (*it)->hasMountPoint() && !(*it)->mountPoint().isEmpty() )
 514         {
 515             name += i18n( " (mounted at %1)", (*it)->mountPoint() );
 516         }
 517         m_deviceCombo->addItem( name, i );
 518         if( !m_currentDevice || (*it)->uid() == m_currentDevice->uid() )
 519         {
 520             m_deviceCombo->setCurrentItem( name );
 521         }
 522         i++;
 523     }
 524     m_deviceCombo->setEnabled( m_devices.count() > 1 );
 525     m_haveDevices = m_devices.count() > 1;
 526 }
 527
 528 QStringList
 529 MediaBrowser::deviceNames() const
 530 {
 531     QStringList list;
 532
 533     for( QList<MediaDevice *>::const_iterator it = m_devices.constBegin();
 534             it != m_devices.constEnd();
 535             it++ )
 536     {
 537         QString name = (*it)->name();
 538         list << name;
 539     }
 540
 541     return list;
 542 }
 543
 544 bool
 545 MediaBrowser::deviceSwitch( const QString &name )
 546 {
 547     int index = 0;
 548     for( QList<MediaDevice *>::iterator it = m_devices.begin();
 549             it != m_devices.end();
 550             it++ )
 551     {
 552         if( (*it)->name() == name )
 553         {
 554             activateDevice( index, false );
 555             return true;
 556         }
 557         index++;
 558     }
 559
 560     return false;
 561 }
 562
 563 void
 564 MediaBrowser::transcodingFinished( const QString &src, const QString &dst )
 565 {
 566     KUrl srcJob = KUrl( m_transcodeSrc );
 567     KUrl srcResult = KUrl( src );
 568
 569     if( srcJob.path() == srcResult.path() )
 570     {
 571         m_transcodedUrl = KUrl( dst );
 572         m_waitForTranscode = false;
 573     }
 574     else
 575     {
 576         debug() << "transcoding for " << src << " finished, "
 577             << "but we are waiting for " << m_transcodeSrc << " -- aborting";
 578         m_waitForTranscode = false;
 579     }
 580 }
 581
 582 KUrl
 583 MediaBrowser::transcode( const KUrl &src, const QString &filetype )
 584 {
 585     const ScriptManager* const sm = ScriptManager::instance();
 586
 587     if( sm->transcodeScriptRunning().isEmpty() )
 588     {
 589         debug() << "cannot transcode with no transcoder registered";
 590         return KUrl();
 591     }
 592
 593     m_waitForTranscode = true;
 594     m_transcodeSrc = src.url();
 595     m_transcodedUrl = KUrl();
 596     ScriptManager::instance()->notifyTranscode( src.url(), filetype );
 597
 598     while( m_waitForTranscode && !sm->transcodeScriptRunning().isEmpty() )
 599     {
 600         usleep( 10000 );
 601         kapp->processEvents( QEventLoop::AllEvents );
 602     }
 603
 604     return m_transcodedUrl;
 605 }
 606
 607
 608 void
 609 MediaBrowser::slotSetFilterTimeout() //SLOT
 610 {
 611     m_timer->start( 280 ); //stops the timer for us first
 612 }
 613
 614 void
 615 MediaBrowser::slotSetFilter() //SLOT
 616 {
 617     m_timer->stop();
 618
 619     if( m_currentDevice )
 620         m_currentDevice->view()->setFilter( m_searchWidget->lineEdit()->text() );
 621 }
 622
 623 void
 624 MediaBrowser::slotSetFilter( const QString &text )
 625 {
 626     m_searchWidget->lineEdit()->setText( text );
 627     slotSetFilter();
 628 }
 629
 630 void
 631 MediaBrowser::slotEditFilter()
 632 {
 633     EditFilterDialog *fd = new EditFilterDialog( this, true, m_searchWidget->lineEdit()->text() );
 634     connect( fd, SIGNAL(filterChanged(const QString &)), SLOT(slotSetFilter(const QString &)) );
 635     if( fd->exec() )
 636         m_searchWidget->lineEdit()->setText( fd->filter() );
 637     delete fd;
 638 }
 639
 640 void
 641 MediaBrowser::prepareToQuit()
 642 {
 643     m_waitForTranscode = false;
 644     m_quitting = true;
 645     for( QList<MediaDevice *>::iterator it = m_devices.begin();
 646             it != m_devices.end();
 647             ++it )
 648     {
 649         if( (*it)->isConnected() )
 650             (*it)->disconnectDevice( false /* don't unmount */ );
 651     }
 652 }
 653
 654 MediaBrowser::~MediaBrowser()
 655 {
 656     debug() << "having to remove " << m_devices.count() << " devices";
 657     while( !m_devices.isEmpty() )
 658     {
 659         removeDevice( m_devices.last() );
 660     }
 661
 662     queue()->save( Amarok::saveLocation() + "transferlist.xml" );
 663
 664     delete m_deviceCombo;
 665     delete m_queue;
 666 }
 667
 668 MediaView::MediaView( QWidget* parent, MediaDevice *device )
 669     : K3ListView( parent )
 670     , m_parent( parent )
 671     , m_device( device )
 672 {
 673     hide();
 674     setSelectionMode( Q3ListView::Extended );
 675     setItemsMovable( false );
 676     setShowSortIndicator( true );
 677     setFullWidth( true );
 678     setRootIsDecorated( true );
 679     setDragEnabled( true );
 680     setDropVisualizer( true );    //the visualizer (a line marker) is drawn when dragging over tracks
 681     setDropHighlighter( true );    //and the highligther (a focus rect) is drawn when dragging over playlists
 682     setDropVisualizerWidth( 3 );
 683     setAcceptDrops( true );
 684
 685     header()->hide();
 686     addColumn( i18n( "Remote Media" ) );
 687
 688     KActionCollection* ac = new KActionCollection( this );
 689     KStandardAction::selectAll( this, SLOT( selectAll() ), ac );
 690
 691     connect( this, SIGNAL( contextMenuRequested( Q3ListViewItem*, const QPoint&, int ) ),
 692              this,   SLOT( rmbPressed( Q3ListViewItem*, const QPoint&, int ) ) );
 693
 694     connect( this, SIGNAL( itemRenamed( Q3ListViewItem* ) ),
 695              this,   SLOT( renameItem( Q3ListViewItem* ) ) );
 696
 697     connect( this, SIGNAL( expanded( Q3ListViewItem* ) ),
 698              this,   SLOT( slotExpand( Q3ListViewItem* ) ) );
 699
 700     connect( this, SIGNAL( returnPressed( Q3ListViewItem* ) ),
 701              this,   SLOT( invokeItem( Q3ListViewItem* ) ) );
 702
 703     connect( this, SIGNAL( doubleClicked( Q3ListViewItem*, const QPoint&, int ) ),
 704              this,   SLOT( invokeItem( Q3ListViewItem*, const QPoint &, int ) ) );
 705 }
 706
 707 void
 708 MediaView::keyPressEvent( QKeyEvent *e )
 709 {
 710     if( e->key() == Qt::Key_Delete )
 711         m_device->deleteFromDevice();
 712     else
 713         K3ListView::keyPressEvent( e );
 714 }
 715
 716 void
 717 MediaView::invokeItem( Q3ListViewItem* i, const QPoint& point, int column ) //SLOT
 718 {
 719     if( column == -1 )
 720         return;
 721
 722     QPoint p = mapFromGlobal( point );
 723     if ( p.x() > header()->sectionPos( header()->mapToIndex( 0 ) ) + treeStepSize() * ( i->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin()
 724             || p.x() < header()->sectionPos( header()->mapToIndex( 0 ) ) )
 725         invokeItem( i );
 726 }
 727
 728
 729 void
 730 MediaView::invokeItem( Q3ListViewItem *i )
 731 {
 732     MediaItem *item = static_cast<MediaItem *>( i );
 733     if( !item )
 734         return;
 735
 736     KUrl::List urls = nodeBuildDragList( item );
 737     The::playlistModel()->insertMedia( urls, Playlist::AppendAndPlay );
 738 }
 739
 740 void
 741 MediaView::renameItem( Q3ListViewItem *item )
 742 {
 743     m_device->renameItem( item );
 744 }
 745
 746 void
 747 MediaView::slotExpand( Q3ListViewItem *item )
 748 {
 749     m_device->expandItem( item );
 750 }
 751
 752
 753 MediaView::~MediaView()
 754 {
 755 }
 756
 757
 758 Q3DragObject *
 759 MediaView::dragObject()
 760 {
 761     KUrl::List urls = nodeBuildDragList( 0 );
 762     K3MultipleDrag *md = new K3MultipleDrag( viewport() );
 763     md->addDragObject( K3ListView::dragObject() );
 764     K3URLDrag* ud = new K3URLDrag( urls, viewport() );
 765     md->addDragObject( ud );
 766     md->setPixmap( CollectionDB::createDragPixmap( urls ),
 767                   QPoint( CollectionDB::DRAGPIXMAP_OFFSET_X, CollectionDB::DRAGPIXMAP_OFFSET_Y ) );
 768     return md;
 769 }
 770
 771
 772 KUrl::List
 773 MediaView::nodeBuildDragList( MediaItem* item, int flags )
 774 {
 775     KUrl::List items;
 776     MediaItem* fi;
 777
 778     if ( !item )
 779     {
 780         fi = static_cast<MediaItem*>(firstChild());
 781     }
 782     else
 783         fi = item;
 784
 785     while ( fi )
 786     {
 787         if( fi->isVisible() )
 788         {
 789             if ( fi->isSelected() || !(flags & OnlySelected ) )
 790             {
 791                 if( fi->isLeafItem() || fi->type() == MediaItem::DIRECTORY )
 792                     items += fi->url();
 793                 else
 794                 {
 795                     if(fi->childCount() )
 796                         items += nodeBuildDragList( static_cast<MediaItem*>(fi->firstChild()), None );
 797                 }
 798             }
 799             else
 800             {
 801                 if ( fi->childCount() )
 802                     items += nodeBuildDragList( static_cast<MediaItem*>(fi->firstChild()), OnlySelected );
 803             }
 804         }
 805         fi = static_cast<MediaItem*>(fi->nextSibling());
 806     }
 807     return items;
 808 }
 809
 810 int
 811 MediaView::getSelectedLeaves( MediaItem *parent, QList<MediaItem*> *list, int flags )
 812 {
 813     int numFiles = 0;
 814     if( !list )
 815         list = new QList<MediaItem*>;
 816
 817     MediaItem *it;
 818     if( !parent )
 819         it = static_cast<MediaItem *>(firstChild());
 820     else
 821         it = static_cast<MediaItem *>(parent->firstChild());
 822
 823     for( ; it; it = static_cast<MediaItem*>(it->nextSibling()))
 824     {
 825         if( it->isVisible() )
 826         {
 827             if( it->childCount() && !( it->type() == MediaItem::DIRECTORY && it->isSelected() ) )
 828             {
 829                 int f = flags;
 830                 if( it->isSelected() )
 831                     f &= ~OnlySelected;
 832                 numFiles += getSelectedLeaves(it, list, f );
 833             }
 834             if( it->isSelected() || !(flags & OnlySelected) )
 835             {
 836                 if( it->type() == MediaItem::TRACK       ||
 837                     it->type() == MediaItem::DIRECTORY   ||
 838                     it->type() == MediaItem::PODCASTITEM ||
 839                     it->type() == MediaItem::PLAYLISTITEM||
 840                     it->type() == MediaItem::INVISIBLE   ||
 841                     it->type() == MediaItem::ORPHANED     )
 842                 {
 843                     if( flags & OnlyPlayed )
 844                     {
 845                         if( it->played() > 0 )
 846                             numFiles++;
 847                     }
 848                     else
 849                         numFiles++;
 850                 }
 851                 if( ( it->isLeafItem() && (!(flags & OnlyPlayed) || it->played()>0) )
 852                         || it->type() == MediaItem::DIRECTORY )
 853                     list->append( it );
 854             }
 855         }
 856     }
 857     return numFiles;
 858 }
 859
 860
 861 bool
 862 MediaView::acceptDrag( QDropEvent *e ) const
 863 {
 864     if( e->source() == MediaBrowser::queue()->viewport() )
 865         return false;
 866
 867     return e->source() == viewport()
 868         || e->mimeData()->hasFormat( "amarok-sql" )
 869         || KUrl::List::canDecode( e->mimeData() );
 870 }
 871
 872 void
 873 MediaView::contentsDropEvent( QDropEvent *e )
 874 {
 875     cleanDropVisualizer();
 876     cleanItemHighlighter();
 877
 878     if(e->source() == viewport())
 879     {
 880         const QPoint p = contentsToViewport( e->pos() );
 881         MediaItem *item = static_cast<MediaItem *>(itemAt( p ));
 882
 883         if( !item && MediaBrowser::instance()->currentDevice()->m_type != "generic-mediadevice" )
 884             return;
 885
 886         QList<MediaItem*> items;
 887
 888         if( !item || item->type() == MediaItem::DIRECTORY ||
 889                     item->type() == MediaItem::TRACK )
 890         {
 891             QList<MediaItem*> items;
 892             getSelectedLeaves( 0, &items );
 893             m_device->addToDirectory( item, items );
 894         }
 895         else if( item->type() == MediaItem::PLAYLIST )
 896         {
 897             MediaItem *list = item;
 898             MediaItem *after = 0;
 899             for(MediaItem *it = static_cast<MediaItem *>(item->firstChild());
 900                     it;
 901                     it = static_cast<MediaItem *>(it->nextSibling()))
 902                 after = it;
 903
 904             getSelectedLeaves( 0, &items );
 905             m_device->addToPlaylist( list, after, items );
 906         }
 907         else if( item->type() == MediaItem::PLAYLISTITEM )
 908         {
 909             MediaItem *list = static_cast<MediaItem *>(item->parent());
 910             MediaItem *after = 0;
 911             for(MediaItem *it = static_cast<MediaItem*>(item->parent()->firstChild());
 912                     it;
 913                     it = static_cast<MediaItem *>(it->nextSibling()))
 914             {
 915                 if(it == item)
 916                     break;
 917                 after = it;
 918             }
 919
 920             getSelectedLeaves( 0, &items );
 921             m_device->addToPlaylist( list, after, items );
 922         }
 923         else if( item->type() == MediaItem::PLAYLISTSROOT )
 924         {
 925             QList<MediaItem*> items;
 926             getSelectedLeaves( 0, &items );
 927             QString base( i18n("New Playlist") );
 928             QString name = base;
 929             int i=1;
 930             while( item->findItem(name) )
 931             {
 932                 QString num;
 933                 num.setNum(i);
 934                 name = base + ' ' + num;
 935                 i++;
 936             }
 937             MediaItem *pl = m_device->newPlaylist(name, item, items);
 938             ensureItemVisible(pl);
 939             rename(pl, 0);
 940         }
 941     }
 942     else
 943     {
 944         if( e->mimeData()->hasFormat( "amarok-sql" ) )
 945         {
 946             QString data( e->mimeData()->data( "amarok-sql" ) );
 947             QString playlist = data.section( "\n", 0, 0 );
 948             QString query = data.section( "\n", 1 );
 949             QStringList values = CollectionDB::instance()->query( query );
 950             KUrl::List list = CollectionDB::instance()->URLsFromSqlDrag( values );
 951             MediaBrowser::queue()->addUrls( list, playlist );
 952         }
 953         else if ( KUrl::List::canDecode( e->mimeData() ) )
 954         {
 955             KUrl::List list = KUrl::List::fromMimeData( e->mimeData() );
 956             MediaBrowser::queue()->addUrls( list );
 957         }
 958     }
 959 }
 960
 961 void
 962 MediaView::viewportPaintEvent( QPaintEvent *e )
 963 {
 964     K3ListView::viewportPaintEvent( e );
 965
 966     // Superimpose bubble help:
 967
 968     if ( !MediaBrowser::instance()->currentDevice() || !MediaBrowser::instance()->currentDevice()->isConnected() )
 969     {
 970         QPainter p( viewport() );
 971
 972         Q3SimpleRichText t( i18n(
 973                 "<div align=center>"
 974                   "<h3>Media Device Browser</h3>"
 975                   "Configure your media device and then "
 976                   "click the Connect button to access your media device. "
 977                   "Drag and drop files to enqueue them for transfer."
 978                 "</div>" ), QApplication::font() );
 979
 980         t.setWidth( width() - 50 );
 981
 982         const uint w = t.width() + 20;
 983         const uint h = t.height() + 20;
 984
 985         p.setBrush( palette().background() );
 986         p.drawRoundRect( 15, 15, w, h, (8*200)/w, (8*200)/h );
 987         t.draw( &p, 20, 20, QRect(), palette() );
 988     }
 989     MediaBrowser::instance()->updateButtons();
 990 }
 991
 992 void
 993 MediaView::rmbPressed( Q3ListViewItem *item, const QPoint &p, int i )
 994 {
 995     if( m_device->isConnected() )
 996         m_device->rmbPressed( item, p, i );
 997 }
 998
 999 MediaItem *
1000 MediaView::newDirectory( MediaItem *parent )
1001 {
1002     bool ok;
1003     const QString name = KInputDialog::getText(i18n("Add Directory"), i18n("Directory Name:"), QString(), &ok, this);
1004
1005     if( ok && !name.isEmpty() )
1006     {
1007         m_device->newDirectory( name, parent );
1008     }
1009
1010     return 0;
1011 }
1012
1013 void
1014 MediaBrowser::deviceAdded( const QString &udi )
1015 {
1016     DEBUG_BLOCK
1017     debug() << "deviceAdded called with a udi of: " << udi;
1018     MediaDevice *md = loadDevicePlugin( udi );
1019     if( md )
1020     {
1021         addDevice( md );
1022         if( m_currentDevice == *(m_devices.begin()) || m_currentDevice == *(m_devices.end()) )
1023             activateDevice( m_devices.count()-1, false );
1024     }
1025 }
1026
1027 void
1028 MediaBrowser::deviceRemoved( const QString &udi )
1029 {
1030     for( QList<MediaDevice *>::iterator it = m_devices.begin();
1031             it != m_devices.end();
1032             it++ )
1033     {
1034         if( (*it)->m_uid == udi )
1035         {
1036             if( (*it)->isConnected() )
1037             {
1038                 if( (*it)->disconnectDevice() )
1039                     removeDevice( *it );
1040                 Amarok::StatusBar::instance()->longMessage(
1041                         i18n( "The device %1 was removed before it was disconnected. "
1042                             "In order to avoid possible data loss, press the \"Disconnect\" "
1043                             "button before disconnecting the device.", (*it)->name() ),
1044                         KDE::StatusBar::Warning );
1045             }
1046             else
1047                 removeDevice( *it );
1048             break;
1049         }
1050     }
1051 }
1052
1053 MediaDevice *
1054 MediaBrowser::loadDevicePlugin( const QString &udi )
1055 {
1056     DEBUG_BLOCK
1057
1058     QString name;
1059     QString mountPoint;
1060     QString protocol;
1061
1062     if( MediaDeviceCache::instance()->deviceType( udi ) == MediaDeviceCache::SolidType )
1063     {
1064         debug() << "udi " << udi << " detected as a Solid device";
1065         Solid::Device solidDevice( udi );
1066
1067         Solid::PortableMediaPlayer* pmp = solidDevice.as<Solid::PortableMediaPlayer>();
1068
1069         //TODO: Generic storage? need to set mount point if so...
1070         if( !pmp )
1071         {
1072             debug() << "Failed to convert Solid device to PortableMediaPlayer";
1073             return 0;
1074         }
1075         if( pmp->supportedProtocols().size() == 0 )
1076         {
1077             debug() << "Portable Media Player " << udi << " does not support any protocols";
1078             return 0;
1079         }
1080
1081         foreach( QString supported, pmp->supportedProtocols() )
1082             debug() << "Device supports protocol " << supported;
1083
1084         protocol = pmp->supportedProtocols()[0];
1085         if( protocol == "storage" )
1086             protocol = "generic";
1087         if( protocol == "pde" )
1088             protocol == "njb";
1089
1090         name = solidDevice.vendor() + " - " + solidDevice.product();
1091     }
1092     else if( MediaDeviceCache::instance()->deviceType( udi ) == MediaDeviceCache::ManualType )
1093     {
1094         QString handler = Amarok::config( "PortableDevices" ).readEntry( udi, QString() );
1095         if( handler.isEmpty() || !handler.startsWith( "manual" ) )
1096         {
1097             //this shouldn't happen, as manually adding the device should create the necessary entry
1098             debug() << "Something's wrong, trying to manually load a non-existant or non-manual manual device";
1099             return 0;
1100         }
1101         QStringList sl = handler.split( "|" );
1102         if( sl[0] != "manual" )
1103             return 0;
1104         name = sl[2];
1105         protocol = sl[1];
1106         mountPoint = sl[3];
1107     }
1108
1109     protocol += "-mediadevice";
1110     QString query = "[X-KDE-Amarok-plugintype] == 'mediadevice' and [X-KDE-Amarok-name] == '%1'";
1111     Amarok::Plugin *plugin = PluginManager::createFromQuery( query.arg( protocol ) );
1112
1113     if( plugin )
1114     {
1115         debug() << "Returning plugin!";
1116         MediaDevice *device = static_cast<MediaDevice *>( plugin );
1117         device->init( this );
1118         device->m_uid = udi;
1119         device->m_name = name;
1120         device->m_type = protocol;
1121         device->m_mountPoint = mountPoint;
1122         return device;
1123     }
1124
1125     debug() << "no plugin for " << protocol;
1126     return 0;
1127 }
1128
1129 void
1130 MediaBrowser::unloadDevicePlugin( MediaDevice *device )
1131 {
1132     DEBUG_BLOCK
1133
1134     if( !device )
1135         return;
1136
1137     disconnect( device ); // disconnect all signals
1138
1139     if( dynamic_cast<DummyMediaDevice *>(device) )
1140     {
1141         delete device;
1142     }
1143     else
1144     {
1145         PluginManager::unload( device );
1146     }
1147 }
1148
1149 bool
1150 MediaBrowser::config()
1151 {
1152     if( m_deviceCombo->currentText() == "No Device Selected" )
1153     {
1154         Amarok::StatusBar::instance()->longMessage( i18n( "No device selected to configure." ),
1155                                                        KDE::StatusBar::Sorry );
1156         return true;
1157     }
1158
1159     DeviceConfigureDialog* dcd = new DeviceConfigureDialog( m_currentDevice );
1160     dcd->exec();
1161     bool successful = dcd->successful();
1162     delete dcd;
1163     return successful;
1164 }
1165
1166 void
1167 MediaBrowser::updateButtons()
1168 {
1169     if( !connectAction() || !disconnectAction() || !transferAction() )
1170         return;
1171
1172     if( m_currentDevice )
1173     {
1174         transferAction()->setVisible( m_currentDevice->m_transfer );
1175         customAction()->setVisible( m_currentDevice->m_customButton );
1176         configAction()->setVisible( m_currentDevice->m_configure );
1177
1178         connectAction()->setEnabled( !m_currentDevice->isConnected() );
1179         disconnectAction()->setEnabled( m_currentDevice->isConnected() );
1180         transferAction()->setEnabled( m_currentDevice->isConnected() && m_queue->childCount() > 0 );
1181         if( customAction() )
1182             customAction()->setEnabled( true );
1183     }
1184     else
1185     {
1186         connectAction()->setEnabled( false );
1187         disconnectAction()->setEnabled( false );
1188         transferAction()->setEnabled( false );
1189         if( customAction() )
1190             customAction()->setEnabled( false );
1191     }
1192 }
1193
1194 void
1195 MediaBrowser::updateStats()
1196 {
1197     if( !m_stats )
1198         return;
1199
1200     KIO::filesize_t queued = m_queue->totalSize();
1201
1202     QString text = i18np( "  1 track in queue", "  %1 tracks in queue", m_queue->childCount() );
1203     if(m_queue->childCount() > 0)
1204     {
1205         text += i18n(" (%1)", KIO::convertSize( queued ) );
1206     }
1207
1208     KIO::filesize_t total, avail;
1209     if( m_currentDevice && m_currentDevice->getCapacity(&total, &avail) )
1210     {
1211         text += i18n( " - %1 of %2 available", KIO::convertSize( avail ), KIO::convertSize( total ) );
1212
1213         m_stats->m_used = total-avail;
1214         m_stats->m_total = total;
1215         m_stats->m_scheduled = queued;
1216     }
1217     else
1218     {
1219         m_stats->m_used = 0;
1220         m_stats->m_total = 0;
1221         m_stats->m_scheduled = queued;
1222     }
1223
1224     m_stats->setText(text);
1225     m_stats->setToolTip( text );
1226 }
1227
1228
1229 bool
1230 MediaView::setFilter( const QString &filter, MediaItem *parent )
1231 {
1232     bool advanced = ExpressionParser::isAdvancedExpression( filter );
1233     QList<int> defaultColumns;
1234     defaultColumns << MetaBundle::Album;
1235     defaultColumns << MetaBundle::Title;
1236     defaultColumns << MetaBundle::Artist;
1237
1238     bool root = false;
1239     MediaItem *it;
1240     if( !parent )
1241     {
1242         root = true;
1243         it = static_cast<MediaItem *>(firstChild());
1244     }
1245     else
1246     {
1247         it = static_cast<MediaItem *>(parent->firstChild());
1248     }
1249
1250     bool childrenVisible = false;
1251     for( ; it; it = static_cast<MediaItem *>(it->nextSibling()))
1252     {
1253         bool visible = true;
1254         if(it->isLeafItem())
1255         {
1256             if( advanced )
1257             {
1258                 ParsedExpression parsed = ExpressionParser::parse( filter );
1259                 visible = it->bundle() && it->bundle()->matchesParsedExpression( parsed, defaultColumns );
1260             }
1261             else
1262             {
1263                 visible = it->bundle() && it->bundle()->matchesSimpleExpression( filter, defaultColumns );
1264             }
1265         }
1266         else
1267         {
1268             visible = setFilter(filter, it);
1269             if(it->type()==MediaItem::PLAYLISTSROOT || it->type()==MediaItem::PLAYLIST)
1270             {
1271                 visible = true;
1272             }
1273             else if(it->type()==MediaItem::DIRECTORY)
1274             {
1275                 bool match = true;
1276                 QStringList list = filter.split( " ", QString::SkipEmptyParts );
1277                 for( QStringList::iterator i = list.begin();
1278                         i != list.end();
1279                         ++i )
1280                 {
1281                     if( !(*it).text(0).contains( *i ) )
1282                     {
1283                         match = false;
1284                         break;
1285                     }
1286                 }
1287                 if( match )
1288                     visible = true;
1289             }
1290         }
1291         if( filter.isEmpty() )
1292             visible = true;
1293         it->setVisible( visible );
1294         if(visible)
1295             childrenVisible = true;
1296     }
1297
1298     if( root && m_device )
1299         m_device->updateRootItems();
1300
1301     return childrenVisible;
1302 }
1303
1304 void
1305 MediaQueue::syncPlaylist( const QString &name, const QString &query, bool loading )
1306 {
1307     MediaItem* item = new MediaItem( this, lastItem() );
1308     item->setType( MediaItem::PLAYLIST );
1309     item->setExpandable( false );
1310     item->setData( query );
1311     item->m_playlistName = name;
1312     item->setText( 0, name );
1313     item->m_flags |= MediaItem::SmartPlaylist;
1314     m_parent->m_progress->setRange( 0, m_parent->m_progress->maximum() + 1 );
1315     itemCountChanged();
1316     if( !loading )
1317         URLsAdded();
1318 }
1319
1320 void
1321 MediaQueue::syncPlaylist( const QString &name, const KUrl &url, bool loading )
1322 {
1323     MediaItem* item = new MediaItem( this, lastItem() );
1324     item->setType( MediaItem::PLAYLIST );
1325     item->setExpandable( false );
1326     item->setData( url.url() );
1327     item->m_playlistName = name;
1328     item->setText( 0, name );
1329     m_parent->m_progress->setRange( 0, m_parent->m_progress->maximum() + 1 );
1330     itemCountChanged();
1331     if( !loading )
1332         URLsAdded();
1333 }
1334
1335 void
1336 MediaQueue::addUrl( const KUrl& url2, MetaBundle *bundle, const QString &playlistName )
1337 {
1338     KUrl url = Amarok::mostLocalURL( url2 );
1339
1340 //Port 2.0
1341 //     if( PlaylistFile::isPlaylistFile( url ) )
1342 //     {
1343 //         QString name = url.path().section( "/", -1 ).section( ".", 0, -2 ).replace( "_", " " );
1344 //      PlaylistFile playlist( url.path() );
1345 //
1346 //         if( playlist.isError() )
1347 //         {
1348 //             Amarok::StatusBar::instance()->longMessage( i18n( "Failed to load playlist: %1", url.path() ),
1349 //                     KDE::StatusBar::Sorry );
1350 //             return;
1351 //         }
1352 //
1353 //         for( BundleList::iterator it = playlist.bundles().begin();
1354 //                 it != playlist.bundles().end();
1355 //                 ++it )
1356 //         {
1357 //             addUrl( (*it).url(), 0, name );
1358 //         }
1359 //         return;
1360 //     }
1361     if( url.protocol() == "file" && QFileInfo( url.path() ).isDir() )
1362     {
1363         //TODO: PORT
1364 //         KUrl::List urls = Amarok::recursiveUrlExpand( url );
1365 //         oldForeachType( KUrl::List, urls )
1366 //             addUrl( *it );
1367 //         return;
1368     }
1369
1370     if( playlistName.isNull() )
1371     {
1372         for( MediaItem *it = static_cast<MediaItem *>(firstChild());
1373                 it;
1374                 it = static_cast<MediaItem *>(it->nextSibling()) )
1375         {
1376             if( it->url() == url )
1377             {
1378                 Amarok::StatusBar::instance()->shortMessage(
1379                         i18n( "Track already queued for transfer: %1", url.url() ) );
1380                 return;
1381             }
1382         }
1383     }
1384
1385     if(!bundle)
1386         bundle = new MetaBundle( url );
1387
1388     MediaItem* item = new MediaItem( this, lastItem() );
1389     item->setExpandable( false );
1390     item->setDropEnabled( true );
1391     item->setBundle( bundle );
1392     if(bundle->podcastBundle() )
1393     {
1394         item->setType( MediaItem::PODCASTITEM );
1395     }
1396     item->m_playlistName = playlistName;
1397
1398     QString text = item->bundle()->prettyTitle();
1399     if( text.isEmpty() || (!item->bundle()->isValidMedia() && !item->bundle()->podcastBundle()) )
1400         text = item->bundle()->url().prettyUrl();
1401     if( !item->m_playlistName.isNull() )
1402     {
1403         text += " (" + item->m_playlistName + ')';
1404     }
1405     item->setText( 0, text);
1406
1407     m_parent->updateButtons();
1408     m_parent->m_progress->setRange( 0, m_parent->m_progress->maximum() + 1 );
1409     addItemToSize( item );
1410     itemCountChanged();
1411 }
1412
1413 void
1414 MediaQueue::addUrl( const KUrl &url, MediaItem *item )
1415 {
1416     DEBUG_BLOCK
1417     MediaItem *newitem = new MediaItem( this, lastItem() );
1418     newitem->setExpandable( false );
1419     newitem->setDropEnabled( true );
1420     MetaBundle *bundle = new MetaBundle( *item->bundle() );
1421     KUrl filepath(url);
1422     filepath.addPath( bundle->filename() );
1423     bundle->setUrl( filepath );
1424     newitem->m_device = item->m_device;
1425     if(bundle->podcastBundle() )
1426     {
1427         item->setType( MediaItem::PODCASTITEM );
1428     }
1429     QString text = item->bundle()->prettyTitle();
1430     if( text.isEmpty() || (!item->bundle()->isValidMedia() && !item->bundle()->podcastBundle()) )
1431         text = item->bundle()->url().prettyUrl();
1432     if( !item->m_playlistName.isEmpty() )
1433     {
1434         text += " (" + item->m_playlistName + ')';
1435     }
1436     newitem->setText( 0, text);
1437     newitem->setBundle( bundle );
1438     m_parent->updateButtons();
1439     m_parent->m_progress->setRange( 0, m_parent->m_progress->maximum() + 1 );
1440     addItemToSize( item );
1441     itemCountChanged();
1442
1443 }
1444
1445 void
1446 MediaQueue::addUrls( const KUrl::List urls, const QString &playlistName )
1447 {
1448     KUrl::List::ConstIterator it = urls.begin();
1449     for ( ; it != urls.end(); ++it )
1450         addUrl( *it, 0, playlistName );
1451
1452     URLsAdded();
1453 }
1454
1455 void
1456 MediaQueue::URLsAdded()
1457 {
1458     m_parent->updateStats();
1459     m_parent->updateButtons();
1460     if( m_parent->currentDevice()
1461             && m_parent->currentDevice()->isConnected()
1462             && m_parent->currentDevice()->asynchronousTransfer()
1463             && !m_parent->currentDevice()->isTransferring() )
1464         m_parent->currentDevice()->transferFiles();
1465
1466     save( Amarok::saveLocation() + "transferlist.xml" );
1467 }
1468
1469 Q3DragObject *
1470 MediaQueue::dragObject()
1471 {
1472     KUrl::List urls;
1473     for( Q3ListViewItem *it = firstChild(); it; it = it->nextSibling() )
1474     {
1475         if( it->isVisible() && it->isSelected() && static_cast<MediaItem *>(it) )
1476             urls += static_cast<MediaItem *>(it)->url();
1477     }
1478
1479     K3MultipleDrag *md = new K3MultipleDrag( viewport() );
1480     Q3DragObject *d = K3ListView::dragObject();
1481     K3URLDrag* urldrag = new K3URLDrag( urls, viewport() );
1482     md->addDragObject( d );
1483     md->addDragObject( urldrag );
1484     md->setPixmap( CollectionDB::createDragPixmap( urls ),
1485                   QPoint( CollectionDB::DRAGPIXMAP_OFFSET_X, CollectionDB::DRAGPIXMAP_OFFSET_Y ) );
1486     return md;
1487 }
1488
1489 void
1490 MediaBrowser::cancelClicked()
1491 {
1492     DEBUG_BLOCK
1493
1494     m_waitForTranscode = false;
1495     if( m_currentDevice )
1496         m_currentDevice->abortTransfer();
1497 }
1498
1499 void
1500 MediaBrowser::transferClicked()
1501 {
1502     transferAction()->setEnabled( false );
1503     if( m_currentDevice
1504             && m_currentDevice->isConnected()
1505             && !m_currentDevice->isTransferring() )
1506     {
1507         if( !m_currentDevice->hasTransferDialog() )
1508             m_currentDevice->transferFiles();
1509         else
1510         {
1511             m_currentDevice->runTransferDialog();
1512             //may not work with non-TransferDialog-class object, but maybe some run time introspection could solve it?
1513             if( m_currentDevice->getTransferDialog() &&
1514               ( reinterpret_cast<TransferDialog *>(m_currentDevice->getTransferDialog()))->isAccepted() )
1515                 m_currentDevice->transferFiles();
1516             else
1517                 updateButtons();
1518         }
1519     }
1520     m_currentDevice->m_transferDir = m_currentDevice->mountPoint();
1521 }
1522
1523 void
1524 MediaBrowser::connectClicked()
1525 {
1526     bool haveToConfig = false;
1527     // it was just clicked, so isOn() == true.
1528     if( m_currentDevice && !m_currentDevice->isConnected() )
1529     {
1530         haveToConfig = !m_currentDevice->connectDevice();
1531     }
1532
1533     haveToConfig |= !m_currentDevice;
1534     haveToConfig |= ( m_currentDevice && !m_currentDevice->isConnected() );
1535
1536     if ( !m_currentDevice->needsManualConfig() )
1537         haveToConfig = false;
1538
1539     if( haveToConfig && m_devices.at( 0 ) == m_currentDevice )
1540     {
1541         if( config() && m_currentDevice && !m_currentDevice->isConnected() )
1542             m_currentDevice->connectDevice();
1543     }
1544
1545     updateDevices();
1546     updateButtons();
1547     updateStats();
1548 }
1549
1550
1551 void
1552 MediaBrowser::disconnectClicked()
1553 {
1554     if( m_currentDevice && m_currentDevice->isTransferring() )
1555     {
1556         int action = KMessageBox::questionYesNoCancel( MediaBrowser::instance(),
1557                 i18n( "Transfer in progress. Finish or stop after current track?" ),
1558                 i18n( "Stop Transfer?" ),
1559                 KGuiItem(i18n("&Finish"), "goto-page"),
1560                 KGuiItem(i18n("&Stop"), "media-eject") );
1561         if( action == KMessageBox::Cancel )
1562         {
1563             return;
1564         }
1565         else if( action == KMessageBox::Yes )
1566         {
1567             m_currentDevice->scheduleDisconnect();
1568             return;
1569         }
1570     }
1571
1572     transferAction()->setEnabled( false );
1573     disconnectAction()->setEnabled( false );
1574
1575     if( m_currentDevice )
1576     {
1577         m_currentDevice->disconnectDevice( true );
1578     }
1579
1580     updateDevices();
1581     updateButtons();
1582     updateStats();
1583 }
1584
1585 void
1586 MediaBrowser::customClicked()
1587 {
1588     if( m_currentDevice )
1589         m_currentDevice->customClicked();
1590 }
1591
1592 void
1593 MediaItem::syncStatsFromPath( const QString &url )
1594 {
1595     if( url.isEmpty() )
1596         return;
1597
1598     // copy Amarok rating, play count and last played time to device
1599     int rating = CollectionDB::instance()->getSongRating( url )*10;
1600     if( rating )
1601         setRating( rating );
1602     int playcount = CollectionDB::instance()->getPlayCount( url );
1603     if( playcount > played() )
1604         setPlayCount( playcount );
1605     QDateTime lastplay = CollectionDB::instance()->getLastPlay( url );
1606     if( lastplay > playTime() )
1607         setLastPlayed( lastplay.toTime_t() );
1608 }
1609
1610 void
1611 MediaQueue::save( const QString &path )
1612 {
1613     QFile file( path );
1614
1615     if( !file.open( QIODevice::WriteOnly ) ) return;
1616
1617     QDomDocument newdoc;
1618     QDomElement transferlist = newdoc.createElement( "playlist" );
1619     transferlist.setAttribute( "product", "Amarok" );
1620     transferlist.setAttribute( "version", APP_VERSION );
1621     newdoc.appendChild( transferlist );
1622
1623     for( const MediaItem *item = static_cast<MediaItem *>( firstChild() );
1624             item;
1625             item = static_cast<MediaItem *>( item->nextSibling() ) )
1626     {
1627         QDomElement i = newdoc.createElement("item");
1628         i.setAttribute("url", item->url().url());
1629
1630         if( item->bundle() )
1631         {
1632             QDomElement attr = newdoc.createElement( "Title" );
1633             QDomText t = newdoc.createTextNode( item->bundle()->title() );
1634             attr.appendChild( t );
1635             i.appendChild( attr );
1636
1637             attr = newdoc.createElement( "Artist" );
1638             t = newdoc.createTextNode( item->bundle()->artist() );
1639             attr.appendChild( t );
1640             i.appendChild( attr );
1641
1642             attr = newdoc.createElement( "Album" );
1643             t = newdoc.createTextNode( item->bundle()->album() );
1644             attr.appendChild( t );
1645             i.appendChild( attr );
1646
1647             attr = newdoc.createElement( "Year" );
1648             t = newdoc.createTextNode( QString::number( item->bundle()->year() ) );
1649             attr.appendChild( t );
1650             i.appendChild( attr );
1651
1652             attr = newdoc.createElement( "Comment" );
1653             t = newdoc.createTextNode( item->bundle()->comment() );
1654             attr.appendChild( t );
1655             i.appendChild( attr );
1656
1657             attr = newdoc.createElement( "Genre" );
1658             t = newdoc.createTextNode( item->bundle()->genre() );
1659             attr.appendChild( t );
1660             i.appendChild( attr );
1661
1662             attr = newdoc.createElement( "Track" );
1663             t = newdoc.createTextNode( QString::number( item->bundle()->track() ) );
1664             attr.appendChild( t );
1665             i.appendChild( attr );
1666         }
1667
1668         if(item->type() == MediaItem::PODCASTITEM)
1669         {
1670             i.setAttribute( "podcast", "1" );
1671         }
1672
1673         if(item->type() == MediaItem::PODCASTITEM
1674                 && item->bundle()->podcastBundle())
1675         {
1676             PodcastEpisodeBundle *peb = item->bundle()->podcastBundle();
1677             QDomElement attr = newdoc.createElement( "PodcastDescription" );
1678             QDomText t = newdoc.createTextNode( peb->description() );
1679             attr.appendChild( t );
1680             i.appendChild( attr );
1681
1682             attr = newdoc.createElement( "PodcastAuthor" );
1683             t = newdoc.createTextNode( peb->author() );
1684             attr.appendChild( t );
1685             i.appendChild( attr );
1686
1687             attr = newdoc.createElement( "PodcastRSS" );
1688             t = newdoc.createTextNode( peb->parent().url() );
1689             attr.appendChild( t );
1690             i.appendChild( attr );
1691
1692             attr = newdoc.createElement( "PodcastURL" );
1693             t = newdoc.createTextNode( peb->url().url() );
1694             attr.appendChild( t );
1695             i.appendChild( attr );
1696         }
1697
1698         if( !item->m_playlistName.isEmpty() )
1699         {
1700             i.setAttribute( "playlist", item->m_playlistName );
1701         }
1702
1703         if(item->type() == MediaItem::PLAYLIST)
1704         {
1705             i.setAttribute( "playlistdata", item->data() );
1706             if( item->flags() & MediaItem::SmartPlaylist )
1707                 i.setAttribute( "smartplaylist", "1" );
1708         }
1709
1710         transferlist.appendChild( i );
1711     }
1712
1713     QTextStream stream( &file );
1714     stream.setCodec( QTextCodec::codecForName( "UTF-8" ) );
1715     stream.setAutoDetectUnicode( true );
1716     stream << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
1717     stream << newdoc.toString();
1718 }
1719
1720
1721 void
1722 MediaQueue::load( const QString& filename )
1723 {
1724     QFile file( filename );
1725     if( !file.open( QIODevice::ReadOnly ) ) {
1726         return;
1727     }
1728
1729     clearItems();
1730
1731     QTextStream stream( &file );
1732     stream.setCodec( QTextCodec::codecForName( "UTF-8" ) );
1733     stream.setAutoDetectUnicode( true );
1734
1735     QDomDocument d;
1736     QString er;
1737     int l, c;
1738     if( !d.setContent( stream.readAll(), &er, &l, &c ) ) { // return error values
1739         Amarok::StatusBar::instance()->longMessageThreadSafe( i18n(
1740                 //TODO add a link to the path to the playlist
1741                 "The XML in the transferlist was invalid. Please report this as a bug to the Amarok "
1742                 "developers. Thank you." ), KDE::StatusBar::Error );
1743         error() << "[TRANSFERLISTLOADER]: Error loading xml file: " << filename << "(" << er << ")"
1744                 << " at line " << l << ", column " << c;
1745         return;
1746     }
1747
1748     QList<QDomNode> nodes;
1749     const QString ITEM( "item" ); //so we don't construct this QString all the time
1750     for( QDomNode n = d.namedItem( "playlist" ).firstChild(); !n.isNull(); n = n.nextSibling() )
1751     {
1752         if( n.nodeName() != ITEM ) continue;
1753
1754         QDomElement elem = n.toElement();
1755         if( !elem.isNull() )
1756             nodes += n;
1757
1758         if( !elem.hasAttribute( "url" ) )
1759         {
1760             continue;
1761         }
1762         KUrl url(elem.attribute("url"));
1763
1764         bool podcast = elem.hasAttribute( "podcast" );
1765         PodcastEpisodeBundle peb;
1766         if( url.isLocalFile() )
1767             peb.setLocalURL( url );
1768         MetaBundle *bundle = new MetaBundle( url );
1769         for(QDomNode node = elem.firstChild();
1770                 !node.isNull();
1771                 node = node.nextSibling())
1772         {
1773             if(node.firstChild().isNull())
1774                 continue;
1775
1776             if(node.nodeName() == "Title" )
1777                 bundle->setTitle(node.firstChild().toText().nodeValue());
1778             else if(node.nodeName() == "Artist" )
1779                 bundle->setArtist(node.firstChild().toText().nodeValue());
1780             else if(node.nodeName() == "Album" )
1781                 bundle->setAlbum(node.firstChild().toText().nodeValue());
1782             else if(node.nodeName() == "Year" )
1783                 bundle->setYear(node.firstChild().toText().nodeValue().toUInt());
1784             else if(node.nodeName() == "Genre" )
1785                 bundle->setGenre(node.firstChild().toText().nodeValue());
1786             else if(node.nodeName() == "Comment" )
1787                 bundle->setComment(node.firstChild().toText().nodeValue());
1788             else if(node.nodeName() == "PodcastDescription" )
1789                 peb.setDescription( node.firstChild().toText().nodeValue() );
1790             else if(node.nodeName() == "PodcastAuthor" )
1791                 peb.setAuthor( node.firstChild().toText().nodeValue() );
1792             else if(node.nodeName() == "PodcastRSS" )
1793                 peb.setParent( KUrl( node.firstChild().toText().nodeValue() ) );
1794             else if(node.nodeName() == "PodcastURL" )
1795                 peb.setUrl( KUrl( node.firstChild().toText().nodeValue() ) );
1796         }
1797
1798         if( podcast )
1799         {
1800             bundle->setPodcastBundle( peb );
1801         }
1802
1803         QString playlist = elem.attribute( "playlist" );
1804         QString playlistdata = elem.attribute( "playlistdata" );
1805         if( !playlistdata.isEmpty() )
1806         {
1807             QString smart = elem.attribute( "smartplaylist" );
1808             if( smart.isEmpty() )
1809                 syncPlaylist( playlist, KUrl( playlistdata ), true );
1810             else
1811                 syncPlaylist( playlist, playlistdata, true );
1812         }
1813         else
1814             addUrl( url, bundle, playlist );
1815     }
1816
1817     URLsAdded();
1818 }
1819
1820 MediaQueue::MediaQueue(MediaBrowser *parent)
1821     : K3ListView( parent ), m_parent( parent )
1822 {
1823     setFixedHeight( 200 );
1824     setSelectionMode( Q3ListView::Extended );
1825     setItemsMovable( true );
1826     setDragEnabled( true );
1827     setShowSortIndicator( false );
1828     setSorting( -1 );
1829     setFullWidth( true );
1830     setRootIsDecorated( false );
1831     setDropVisualizer( true );     //the visualizer (a line marker) is drawn when dragging over tracks
1832     setDropHighlighter( true );    //and the highligther (a focus rect) is drawn when dragging over playlists
1833     setDropVisualizerWidth( 3 );
1834     setAcceptDrops( true );
1835     addColumn( i18n( "Transfer Queue" ) );
1836
1837     itemCountChanged();
1838
1839     KActionCollection* ac = new KActionCollection( this );
1840     KStandardAction::selectAll( this, SLOT( selectAll() ), ac );
1841
1842     connect( this, SIGNAL( contextMenuRequested( Q3ListViewItem*, const QPoint&, int ) ),
1843             SLOT( slotShowContextMenu( Q3ListViewItem*, const QPoint&, int ) ) );
1844     connect( this, SIGNAL( dropped(QDropEvent*, Q3ListViewItem*, Q3ListViewItem*) ),
1845             SLOT( slotDropped(QDropEvent*, Q3ListViewItem*, Q3ListViewItem*) ) );
1846 }
1847
1848 bool
1849 MediaQueue::acceptDrag( QDropEvent *e ) const
1850 {
1851
1852     return e->source() == viewport()
1853         || e->mimeData()->hasFormat( "amarok-sql" )
1854         || KUrl::List::canDecode( e->mimeData() );
1855 }
1856
1857 void
1858 MediaQueue::slotDropped( QDropEvent* e, Q3ListViewItem* parent, Q3ListViewItem* after)
1859 {
1860     if( e->source() != viewport() )
1861     {
1862         if( e->mimeData()->hasFormat( "amarok-sql" ) )
1863         {
1864             QString data( e->mimeData()->data( "amarok-sql" ) );
1865             QString playlist = data.section( "\n", 0, 0 );
1866             QString query = data.section( "\n", 1 );
1867             QStringList values = CollectionDB::instance()->query( query );
1868             KUrl::List list = CollectionDB::instance()->URLsFromSqlDrag( values );
1869             addUrls( list, playlist );
1870         }
1871         else if ( KUrl::List::canDecode( e->mimeData() ) )
1872         {
1873             KUrl::List list = KUrl::List::fromMimeData( e->mimeData() );
1874             if (!list.isEmpty() )
1875                 addUrls( list );
1876         }
1877     }
1878     else if( Q3ListViewItem *i = currentItem() )
1879     {
1880         moveItem( i, parent, after );
1881     }
1882 }
1883
1884 void
1885 MediaQueue::dropProxyEvent( QDropEvent *e )
1886 {
1887     slotDropped( e, 0, 0 );
1888 }
1889
1890 MediaItem*
1891 MediaQueue::findPath( QString path )
1892 {
1893     for( Q3ListViewItem *item = firstChild();
1894             item;
1895             item = item->nextSibling())
1896     {
1897         if(static_cast<MediaItem *>(item)->url().path() == path)
1898             return static_cast<MediaItem *>(item);
1899     }
1900
1901     return 0;
1902 }
1903
1904 void
1905 MediaQueue::computeSize() const
1906 {
1907     m_totalSize = 0;
1908     for( Q3ListViewItem *it = firstChild();
1909             it;
1910             it = it->nextSibling())
1911     {
1912         MediaItem *item = static_cast<MediaItem *>(it);
1913
1914         if( item && item->bundle() &&
1915                 ( !m_parent->currentDevice()
1916                   || !m_parent->currentDevice()->isConnected()
1917                   || !m_parent->currentDevice()->trackExists(*item->bundle()) ) )
1918             m_totalSize += ((item->size()+1023)/1024)*1024;
1919     }
1920 }
1921
1922 KIO::filesize_t
1923 MediaQueue::totalSize() const
1924 {
1925     return m_totalSize;
1926 }
1927
1928 void
1929 MediaQueue::addItemToSize( const MediaItem *item ) const
1930 {
1931     if( item && item->bundle() &&
1932             ( !m_parent->currentDevice()
1933               || !m_parent->currentDevice()->isConnected()
1934               || !m_parent->currentDevice()->trackExists(*item->bundle()) ) )
1935         m_totalSize += ((item->size()+1023)/1024)*1024;
1936 }
1937
1938 void
1939 MediaQueue::subtractItemFromSize( const MediaItem *item, bool unconditionally ) const
1940 {
1941     if( item && item->bundle() &&
1942             ( !m_parent->currentDevice()
1943               || !m_parent->currentDevice()->isConnected()
1944               || (unconditionally || !m_parent->currentDevice()->trackExists(*item->bundle())) ) )
1945         m_totalSize -= ((item->size()+1023)/1024)*1024;
1946 }
1947
1948 void
1949 MediaQueue::removeSelected()
1950 {
1951     QList<Q3ListViewItem*>  selected = selectedItems();
1952
1953     QListIterator<Q3ListViewItem*> iter( selected );
1954     while( iter.hasNext() )
1955     {
1956         Q3ListViewItem *item = iter.next();
1957         if( !(static_cast<MediaItem *>(item)->flags() & MediaItem::Transferring) )
1958         {
1959             subtractItemFromSize( static_cast<MediaItem *>(item) );
1960             delete item;
1961             if( m_parent->currentDevice() && m_parent->currentDevice()->isTransferring() )
1962             {
1963                 MediaBrowser::instance()->m_progress->setRange( 0, MediaBrowser::instance()->m_progress->maximum() - 1 );
1964             }
1965         }
1966     }
1967
1968     MediaBrowser::instance()->updateStats();
1969     MediaBrowser::instance()->updateButtons();
1970     itemCountChanged();
1971 }
1972
1973 void
1974 MediaQueue::keyPressEvent( QKeyEvent *e )
1975 {
1976     if( e->key() == Qt::Key_Delete )
1977         removeSelected();
1978     else
1979         K3ListView::keyPressEvent( e );
1980 }
1981
1982 void
1983 MediaQueue::itemCountChanged()
1984 {
1985     if( childCount() == 0 )
1986         hide();
1987     else if( !isShown() )
1988         show();
1989 }
1990
1991 void
1992 MediaQueue::slotShowContextMenu( Q3ListViewItem* item, const QPoint& point, int )
1993 {
1994     if( !childCount() )
1995         return;
1996
1997     Q3PopupMenu menu( this );
1998
1999     enum Actions { REMOVE_SELECTED, CLEAR_ALL, START_TRANSFER };
2000
2001     if( item )
2002         menu.insertItem( KIcon( Amarok::icon( "remove_from_playlist" ) ), i18n( "&Remove From Queue" ), REMOVE_SELECTED );
2003
2004     menu.insertItem( KIcon( Amarok::icon( "playlist_clear" ) ), i18n( "&Clear Queue" ), CLEAR_ALL );
2005     menu.insertItem( KIcon( Amarok::icon( "playlist_refresh" ) ), i18n( "&Start Transfer" ), START_TRANSFER );
2006     menu.setItemEnabled( START_TRANSFER,
2007             MediaBrowser::instance()->currentDevice() &&
2008             MediaBrowser::instance()->currentDevice()->isConnected() &&
2009             MediaBrowser::instance()->currentDevice()->m_transfer );
2010
2011     switch( menu.exec( point ) )
2012     {
2013         case REMOVE_SELECTED:
2014             removeSelected();
2015             break;
2016         case CLEAR_ALL:
2017             clearItems();
2018             break;
2019         case START_TRANSFER:
2020             MediaBrowser::instance()->transferClicked();
2021             break;
2022     }
2023 }
2024
2025 void
2026 MediaQueue::clearItems()
2027 {
2028     clear();
2029     itemCountChanged();
2030     if(m_parent)
2031     {
2032         computeSize();
2033         m_parent->updateStats();
2034         m_parent->updateButtons();
2035     }
2036 }
2037
2038
2039 #include "mediabrowser.moc"