← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/amarok/gutsy-updates

« back to all changes in this revision

Viewing changes to amarok/src/mediadevice/ipod/ipodmediadevice.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Mercatante
  • Date: 2006-11-03 23:57:33 UTC
  • mfrom: (1.31.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061103235733-a41oyfz4mzienqin
Tags: 2:1.4.4-0ubuntu2
Add debian/kubuntu-media-amarok and
debian amarok_play_audiocd.desktop for good KDE integration

Show diffs side-by-side

added added

removed removed

Lines of Context:
amarok/src/mediadevice/ipod/ipodmediadevice.cpp
64
64
    QString description;
65
65
    QDateTime date;
66
66
    QString author;
 
67
    bool listened;
67
68
 
68
69
    // per channel
69
70
    QString rss;
 
71
 
 
72
    PodcastInfo() { listened = false; }
70
73
};
71
74
 
72
75
class TrackList : public QPtrList<Itdb_Track>
128
131
            bundle->setPath      ( path );
129
132
            bundle->setFilesize  ( track->size );
130
133
 
 
134
            QString rss( track->podcastrss );
 
135
            QString url( track->podcasturl );
 
136
            QString desc( track->description );
 
137
            QString subtitle( track->subtitle );
 
138
            QDateTime date;
 
139
            date.setTime_t( itdb_time_mac_to_host( track->time_released) );
 
140
 
 
141
            if( !rss.isEmpty() || !url.isEmpty() )
 
142
            {
 
143
                PodcastEpisodeBundle peb( KURL::fromPathOrURL(url), KURL::fromPathOrURL(rss),
 
144
                        track->title, track->artist, desc, date.toString(Qt::ISODate), QString::null /*type*/,
 
145
                        bundle->length(), QString::null /*guid*/, track->playcount<=0 );
 
146
                bundle->setPodcastBundle( peb );
 
147
            }
 
148
 
131
149
            setBundle( bundle );
132
150
        }
133
151
 
148
166
 
149
167
        bool ratingChanged() const { return m_track ? m_track->rating != m_track->app_rating : false; }
150
168
 
 
169
        void setListened( bool l )
 
170
        {
 
171
            MediaItem::setListened( l );
 
172
            if( type() == PODCASTITEM )
 
173
            {
 
174
                if( m_podcastInfo )
 
175
                    m_podcastInfo->listened = listened();
 
176
#ifdef HAVE_ITDB_MARK_UNPLAYED
 
177
                if( m_track )
 
178
                    m_track->mark_unplayed = listened() ? 0x01 : 0x02;
 
179
#endif
 
180
            }
 
181
        }
 
182
 
151
183
        QDateTime playTime() const
152
184
        {
153
185
            QDateTime t;
230
262
}
231
263
 
232
264
MediaItem *
233
 
IpodMediaDevice::insertTrackIntoDB( const QString &pathname, const MetaBundle &bundle, const PodcastInfo *podcastInfo )
 
265
IpodMediaDevice::insertTrackIntoDB( const QString &pathname,
 
266
        const MetaBundle &metaBundle, const MetaBundle &propertiesBundle,
 
267
        const PodcastInfo *podcastInfo )
234
268
{
235
 
    return updateTrackInDB( 0, pathname, bundle, podcastInfo );
 
269
    return updateTrackInDB( 0, pathname, metaBundle, propertiesBundle, podcastInfo );
236
270
}
237
271
 
238
272
MediaItem *
239
273
IpodMediaDevice::updateTrackInDB( IpodMediaItem *item, const QString &pathname,
240
 
                                  const MetaBundle &bundle, const PodcastInfo *podcastInfo )
 
274
                                  const MetaBundle &metaBundle, const MetaBundle &propertiesBundle,
 
275
                                  const PodcastInfo *podcastInfo )
241
276
{
242
277
    if( !m_itdb )
243
278
        return 0;
258
293
    track->ipod_path = g_strdup( ipodPath(pathname).latin1() );
259
294
    debug() << "on iPod: " << track->ipod_path << ", podcast=" << podcastInfo << endl;
260
295
 
261
 
    track->title = g_strdup( bundle.title().utf8() );
262
 
    track->album = g_strdup( bundle.album()->utf8() );
263
 
    track->artist = g_strdup( bundle.artist()->utf8() );
264
 
    track->genre = g_strdup( bundle.genre()->utf8() );
 
296
    if( metaBundle.isValidMedia() || !metaBundle.title().isEmpty() )
 
297
        track->title = g_strdup( metaBundle.title().utf8() );
 
298
    else
 
299
        track->title = g_strdup( metaBundle.url().filename().utf8() );
 
300
    track->album = g_strdup( metaBundle.album()->utf8() );
 
301
    track->artist = g_strdup( metaBundle.artist()->utf8() );
 
302
    track->genre = g_strdup( metaBundle.genre()->utf8() );
 
303
 
 
304
 
265
305
    track->unk208 = 0x01; // for audio
266
306
    if(type=="wav")
267
307
    {
271
311
    {
272
312
        track->filetype = g_strdup( "mpeg" );
273
313
    }
274
 
    else if(type=="mp4" || type=="aac" || type=="m4a" || type=="m4p")
 
314
    else if(type=="aac" || type=="m4a" || (!m_supportsVideo && type=="mp4"))
275
315
    {
276
316
        track->filetype = g_strdup( "mp4" );
277
317
    }
283
323
#else
284
324
        track->flag3 |= 0x01; // remember current position in track
285
325
#endif
 
326
        track->unk208 = 0x08; // for audiobooks
286
327
    }
287
 
    else if(type=="m4v" || type=="mp4v" || type=="mov" || type=="mpg")
 
328
    else if(type=="m4v" || type=="mp4v" || type=="mov" || type=="mpg" || type=="mp4")
288
329
    {
289
330
        track->filetype = g_strdup( "m4v video" );
290
331
#ifdef HAVE_ITDB_SKIP_SHUFFLE_FLAG
300
341
#else
301
342
        track->flag3 |= 0x01; // remember current position in track
302
343
#endif
 
344
        track->unk208 = 0x08; // for audiobooks
303
345
 
304
 
        TagLib::Audible::File f( QFile::encodeName( bundle.url().path() ) );
 
346
        TagLib::Audible::File f( QFile::encodeName( propertiesBundle.url().path() ) );
305
347
        TagLib::Audible::Tag *t = f.getAudibleTag();
306
348
        if( t )
307
349
            track->drm_userid = t->userID();
314
356
        track->filetype = g_strdup( type.utf8() );
315
357
    }
316
358
 
317
 
    track->composer = g_strdup( bundle.composer()->utf8() );
318
 
    track->comment = g_strdup( bundle.comment()->utf8() );
319
 
    track->track_nr = bundle.track();
320
 
    track->cd_nr = bundle.discNumber();
321
 
    track->BPM = static_cast<int>( bundle.bpm() );
322
 
    track->year = bundle.year();
323
 
    track->size = bundle.filesize();
 
359
    track->composer = g_strdup( metaBundle.composer()->utf8() );
 
360
    track->comment = g_strdup( metaBundle.comment()->utf8() );
 
361
    track->track_nr = metaBundle.track();
 
362
    track->cd_nr = metaBundle.discNumber();
 
363
    track->BPM = static_cast<int>( metaBundle.bpm() );
 
364
    track->year = metaBundle.year();
 
365
    track->size = propertiesBundle.filesize();
324
366
    if( track->size == 0 )
325
367
    {
326
368
        debug() << "filesize is zero for " << track->ipod_path << ", expect strange problems with your ipod" << endl;
327
369
    }
328
 
    track->bitrate = bundle.bitrate();
329
 
    track->samplerate = bundle.sampleRate();
330
 
    track->tracklen = bundle.length()*1000;
 
370
    track->bitrate = propertiesBundle.bitrate();
 
371
    track->samplerate = propertiesBundle.sampleRate();
 
372
    track->tracklen = propertiesBundle.length()*1000;
331
373
 
332
374
    if(podcastInfo)
333
375
    {
334
376
#ifdef HAVE_ITDB_SKIP_SHUFFLE_FLAG
335
377
        track->skip_when_shuffling = 0x01; // skip  when shuffling
336
378
        track->remember_playback_position = 0x01; // remember playback position
337
 
        track->mark_unplayed = 0x02; // for podcasts
338
379
#else
339
380
        track->flag2 = 0x01; // skip  when shuffling
340
381
        track->flag3 = 0x01; // remember playback position
341
382
        // FIXME: track->unk176 = 0x00020000; // for podcasts
342
383
#endif
 
384
#ifdef HAVE_ITDB_MARK_UNPLAYED
 
385
        track->mark_unplayed = podcastInfo->listened ? 0x01 : 0x02;
 
386
#endif
 
387
        track->unk208 = track->unk208==0x02 ? 0x06 : 0x04; // video or audio podcast
343
388
        track->flag4 = 0x01; // also show description on iPod
344
389
        QString plaindesc = podcastInfo->description;
345
390
        plaindesc.replace( QRegExp("<[^>]*>"), "" );
355
400
    {
356
401
        // FIXME: track->unk176 = 0x00010000; // for non-podcasts
357
402
 
358
 
        if( bundle.compilation() == MetaBundle::CompilationYes )
 
403
        if( metaBundle.compilation() == MetaBundle::CompilationYes )
359
404
        {
360
405
            track->compilation = 0x01;
361
406
        }
371
416
    if( m_supportsArtwork )
372
417
    {
373
418
        QString image;
374
 
        if( bundle.podcastBundle() )
 
419
        if( metaBundle.podcastBundle() )
375
420
        {
376
421
            PodcastChannelBundle pcb;
377
 
            if( CollectionDB::instance()->getPodcastChannelBundle( bundle.podcastBundle()->parent(), &pcb ) )
 
422
            if( CollectionDB::instance()->getPodcastChannelBundle( metaBundle.podcastBundle()->parent(), &pcb ) )
378
423
                image = CollectionDB::instance()->podcastImage( pcb.imageURL().url(), 0 );
379
424
        }
380
425
        if( image.isEmpty() )
381
 
            image  = CollectionDB::instance()->albumImage(bundle.artist(), bundle.album(), false, 0);
 
426
            image  = CollectionDB::instance()->albumImage(metaBundle.artist(), metaBundle.album(), false, 0);
382
427
        if( !image.endsWith( "@nocover.png" ) )
383
428
        {
384
 
            debug() << "adding image " << image << " to " << bundle.artist() << ":" << bundle.album() << endl;
 
429
            debug() << "adding image " << image << " to " << metaBundle.artist() << ":" << metaBundle.album() << endl;
385
430
            itdb_track_set_thumbnails( track, g_strdup( QFile::encodeName(image) ) );
386
431
        }
387
432
    }
464
509
    }
465
510
    if ( !dir.exists() )
466
511
    {
467
 
        amaroK::StatusBar::instance()->longMessage(
 
512
        Amarok::StatusBar::instance()->longMessage(
468
513
                i18n( "Media Device: Creating directory for file %1 failed" ).arg( url.path() ),
469
514
                KDE::StatusBar::Error );
470
515
        return NULL;
485
530
        podcastInfo->author = peb->author();
486
531
        podcastInfo->rss = peb->parent().url();
487
532
        podcastInfo->date = peb->dateTime();
 
533
        podcastInfo->listened = !peb->isNew();
488
534
    }
489
535
 
490
 
    MetaBundle *newBundle = 0;
491
 
    if( bundle.url().isLocalFile() && !bundle.isValidMedia() )
492
 
        newBundle = new MetaBundle( url );
493
 
 
494
 
    MediaItem *ret = insertTrackIntoDB( url.path(), newBundle ? *newBundle : bundle, podcastInfo );
 
536
    MetaBundle propertiesBundle( url );
 
537
    MediaItem *ret = insertTrackIntoDB( url.path(), bundle, propertiesBundle, podcastInfo );
495
538
    delete podcastInfo;
496
539
    return ret;
497
540
}
499
542
MediaItem *
500
543
IpodMediaDevice::tagsChanged( MediaItem *item, const MetaBundle &bundle )
501
544
{
502
 
    return updateTrackInDB( dynamic_cast<IpodMediaItem *>(item), item->url().path(), bundle, NULL );
 
545
    return updateTrackInDB( dynamic_cast<IpodMediaItem *>(item), item->url().path(), bundle, bundle, NULL );
503
546
}
504
547
 
505
548
void
515
558
    IpodMediaItem *item = getTrack( bundle.artist(),
516
559
            bundle.album(),
517
560
            bundle.title(),
 
561
            bundle.discNumber(),
518
562
            bundle.track() );
519
563
 
520
564
    return item;
800
844
    m_lockFile = 0;
801
845
 
802
846
    if( !msg.isEmpty() )
803
 
        amaroK::StatusBar::instance()->longMessage( msg, KDE::StatusBar::Sorry );
 
847
        Amarok::StatusBar::instance()->longMessage( msg, KDE::StatusBar::Sorry );
804
848
    return false;
805
849
}
806
850
 
810
854
    QDir dir( mountPoint() );
811
855
    if( !dir.exists() )
812
856
    {
813
 
        amaroK::StatusBar::instance()->longMessage(
 
857
        Amarok::StatusBar::instance()->longMessage(
814
858
                i18n("Media device: Mount point %1 does not exist").arg(mountPoint()),
815
859
                KDE::StatusBar::Error );
816
860
        return false;
860
904
    if( !writeITunesDB( false ) )
861
905
        return false;
862
906
 
863
 
    amaroK::StatusBar::instance()->longMessage(
 
907
    Amarok::StatusBar::instance()->longMessage(
864
908
            i18n("Media Device: Initialized iPod mounted at %1").arg(mountPoint()),
865
909
            KDE::StatusBar::Information );
866
910
 
879
923
 
880
924
    if( m_itdb )
881
925
    {
882
 
        amaroK::StatusBar::instance()->longMessage(
 
926
        Amarok::StatusBar::instance()->longMessage(
883
927
                i18n("Media Device: iPod at %1 already opened").arg(mountPoint()),
884
928
                KDE::StatusBar::Sorry );
885
929
        return false;
887
931
 
888
932
    // try to find a mounted ipod
889
933
    bool ipodFound = false;
 
934
    bool canInitialize = false;
890
935
    KMountPoint::List currentmountpoints = KMountPoint::currentMountPoints();
891
936
    for( KMountPoint::List::Iterator mountiter = currentmountpoints.begin();
892
937
        mountiter != currentmountpoints.end();
893
938
        ++mountiter )
894
939
    {
 
940
        canInitialize = false;
895
941
        QString devicenode = (*mountiter)->mountedFrom();
896
942
        QString mountpoint = (*mountiter)->mountPoint();
897
943
 
 
944
        if( mountpoint.startsWith( "/proc" ) ||
 
945
            mountpoint.startsWith( "/sys" )  ||
 
946
            mountpoint.startsWith( "/dev" )  ||
 
947
            mountpoint.startsWith( "/boot" ) )
 
948
            continue;
 
949
 
898
950
        if( !mountPoint().isEmpty() )
899
951
        {
900
 
            if( mountPoint() != mountpoint )
 
952
            if( mountpoint != mountPoint() )
901
953
                continue;
 
954
            canInitialize = true;
902
955
        }
 
956
 
903
957
        else if( !deviceNode().isEmpty() )
904
958
        {
905
959
            if( devicenode != deviceNode() )
906
960
                continue;
 
961
            canInitialize = true;
907
962
        }
908
 
        else
 
963
 
 
964
        GError *err = 0;
 
965
        m_itdb = itdb_parse(QFile::encodeName(mountpoint), &err);
 
966
        if( err )
909
967
        {
910
 
            GError *err = 0;
911
 
            m_itdb = itdb_parse(QFile::encodeName(mountpoint), &err);
912
 
            if(err)
 
968
            g_error_free(err);
 
969
            if( m_itdb )
913
970
            {
914
 
                g_error_free(err);
915
 
                if( m_itdb )
916
 
                {
917
 
                    itdb_free( m_itdb );
918
 
                    m_itdb = 0;
919
 
                }
920
 
                continue;
 
971
                itdb_free( m_itdb );
 
972
                m_itdb = 0;
921
973
            }
922
 
            itdb_free( m_itdb );
923
 
            m_itdb = 0;
 
974
 
 
975
            if( !canInitialize )
 
976
                continue;
924
977
        }
925
978
 
926
979
        if( mountPoint().isEmpty() )
929
982
        break;
930
983
    }
931
984
 
932
 
    if( !ipodFound )
 
985
    if( !ipodFound && !canInitialize )
933
986
    {
934
987
        if( !silent )
935
988
        {
936
 
            amaroK::StatusBar::instance()->longMessage(
 
989
            Amarok::StatusBar::instance()->longMessage(
937
990
                    i18n("Media Device: No mounted iPod found" ),
938
991
                    KDE::StatusBar::Sorry );
939
992
        }
940
993
        return false;
941
994
    }
942
995
 
943
 
    GError *err = 0;
944
 
    m_itdb = itdb_parse( QFile::encodeName(mountPoint()), &err );
945
 
    if( err )
946
 
    {
947
 
        g_error_free( err );
948
 
        if( m_itdb )
949
 
        {
950
 
            itdb_free( m_itdb );
951
 
            m_itdb = 0;
952
 
        }
953
 
    }
954
 
 
955
 
    if( !m_itdb )
 
996
    if( !m_itdb && canInitialize )
956
997
    {
957
998
        QString msg = i18n( "Media Device: could not find iTunesDB on device mounted at %1. "
958
999
                "Should I try to initialize your iPod?" ).arg( mountPoint() );
969
1010
                    m_itdb = 0;
970
1011
                }
971
1012
 
972
 
                amaroK::StatusBar::instance()->longMessage(
 
1013
                Amarok::StatusBar::instance()->longMessage(
973
1014
                        i18n("Media Device: Failed to initialize iPod mounted at %1").arg(mountPoint()),
974
1015
                        KDE::StatusBar::Sorry );
975
1016
 
1021
1062
    else
1022
1063
    {
1023
1064
        debug() << "iPod type detection failed, no video support" << endl;
1024
 
        //amaroK::StatusBar::instance()->shortMessage( i18n("Media device: iPod type detection failed, no video support") );
 
1065
        //Amarok::StatusBar::instance()->shortMessage( i18n("Media device: iPod type detection failed, no video support") );
1025
1066
    }
1026
1067
#endif
1027
1068
 
1053
1094
            if( !dir.exists() )
1054
1095
            {
1055
1096
                debug() << "failed to create hash dir " << real << endl;
1056
 
                amaroK::StatusBar::instance()->longMessage(
 
1097
                Amarok::StatusBar::instance()->longMessage(
1057
1098
                        i18n("Media device: Failed to create directory %1").arg(real),
1058
1099
                        KDE::StatusBar::Error );
1059
1100
                return false;
1156
1197
        if(dir[i] == "." || dir[i] == "..")
1157
1198
            continue;
1158
1199
 
1159
 
        QString hashpath = musicpath + "/" + dir[i];
 
1200
        QString hashpath = musicpath + '/' + dir[i];
1160
1201
        QDir hashdir( hashpath, QString::null, QDir::Unsorted, QDir::Files );
1161
1202
        for(unsigned j=0; j<hashdir.count(); j++)
1162
1203
        {
1163
 
            QString filename = hashpath + "/" + hashdir[j];
1164
 
            QString ipodPath = itunesDir( "Music:" ) + dir[i] + ":" + hashdir[j];
 
1204
            QString filename = hashpath + '/' + hashdir[j];
 
1205
            QString ipodPath = itunesDir( "Music:" ) + dir[i] + ':' + hashdir[j];
1165
1206
            Itdb_Track *track = m_files[ipodPath.lower()];
1166
1207
            if(!track)
1167
1208
            {
1397
1438
 
1398
1439
    if( pl->is_spl )
1399
1440
    {
1400
 
        debug() << "playlist " << pl->name << " is a smart playlist, ignored" << endl;
1401
 
        return;
 
1441
        debug() << "playlist " << pl->name << " is a smart playlist" << endl;
1402
1442
    }
1403
1443
 
1404
1444
    QString name( QString::fromUtf8(pl->name) );
1439
1479
        base = ":iTunes:iTunes_Control";
1440
1480
 
1441
1481
    if( !p.startsWith( ":" ) )
1442
 
        base += ":";
 
1482
        base += ':';
1443
1483
    return base + p;
1444
1484
}
1445
1485
 
1606
1646
        }
1607
1647
        else
1608
1648
        {
1609
 
            amaroK::StatusBar::instance()->longMessage(
 
1649
            Amarok::StatusBar::instance()->longMessage(
1610
1650
                    i18n("Media device: failed to write iPod database"),
1611
1651
                    KDE::StatusBar::Error );
1612
1652
        }
1642
1682
}
1643
1683
 
1644
1684
IpodMediaItem *
1645
 
IpodMediaDevice::getTrack(const QString &artist, const QString &album, const QString &title, int trackNumber)
 
1685
IpodMediaDevice::getTrack(const QString &artist, const QString &album, const QString &title, int discNumber, int trackNumber)
1646
1686
{
1647
1687
    IpodMediaItem *item = getAlbum(artist, album);
1648
1688
    if(item)
1651
1691
                track;
1652
1692
                track = dynamic_cast<IpodMediaItem *>(item->findItem(title, track)) )
1653
1693
        {
1654
 
            if( trackNumber==-1 || track->bundle()->track() == trackNumber )
 
1694
            if( ( discNumber==-1 || track->bundle()->discNumber()==discNumber )
 
1695
                    && ( trackNumber==-1 || track->bundle()->track()==trackNumber ) )
1655
1696
                return track;
1656
1697
        }
1657
1698
    }
1664
1705
                track;
1665
1706
                track = dynamic_cast<IpodMediaItem *>(item->findItem(t, track)) )
1666
1707
        {
1667
 
            if( trackNumber==-1 || track->bundle()->track() == trackNumber )
 
1708
            if( ( discNumber==-1 || track->bundle()->discNumber()==discNumber )
 
1709
                    && ( trackNumber==-1 || track->bundle()->track()==trackNumber ) )
1668
1710
                return track;
1669
1711
        }
1670
1712
    }
1678
1720
                    track;
1679
1721
                    track = dynamic_cast<IpodMediaItem *>(item->findItem(title, track)) )
1680
1722
            {
1681
 
                if( trackNumber==-1 || track->bundle()->track() == trackNumber )
 
1723
                if( ( discNumber==-1 || track->bundle()->discNumber()==discNumber )
 
1724
                        && ( trackNumber==-1 || track->bundle()->track()==trackNumber ) )
1682
1725
                    return track;
1683
1726
            }
1684
1727
        }
1755
1798
    do
1756
1799
    {
1757
1800
        int num = std::rand() % 1000000;
1758
 
        int music_dirs = itdb_musicdirs_number(m_itdb) > 0 ? itdb_musicdirs_number(m_itdb) : 20;
 
1801
        int music_dirs = itdb_musicdirs_number(m_itdb) > 1 ? itdb_musicdirs_number(m_itdb) : 20;
1759
1802
        int dir = num % music_dirs;
1760
1803
        QString dirname;
1761
1804
        dirname.sprintf( "%s:Music:f%02d", itunesDir().latin1(), dir );
1860
1903
    KPopupMenu *playlistsMenu = 0;
1861
1904
    if ( item )
1862
1905
    {
1863
 
        menu.insertItem( SmallIconSet( amaroK::icon( "playlist" ) ), i18n( "&Load" ), LOAD );
1864
 
        menu.insertItem( SmallIconSet( amaroK::icon( "add_playlist" ) ), i18n( "&Append to Playlist" ), APPEND );
1865
 
        menu.insertItem( SmallIconSet( amaroK::icon( "fastforward" ) ), i18n( "&Queue Tracks" ), QUEUE );
 
1906
        menu.insertItem( SmallIconSet( Amarok::icon( "playlist" ) ), i18n( "&Load" ), LOAD );
 
1907
        menu.insertItem( SmallIconSet( Amarok::icon( "add_playlist" ) ), i18n( "&Append to Playlist" ), APPEND );
 
1908
        menu.insertItem( SmallIconSet( Amarok::icon( "fastforward" ) ), i18n( "&Queue Tracks" ), QUEUE );
1866
1909
        menu.insertSeparator();
1867
1910
 
1868
 
        menu.insertItem( SmallIconSet( amaroK::icon( "collection" ) ), i18n( "&Copy Files to Collection..." ), COPY_TO_COLLECTION );
 
1911
        menu.insertItem( SmallIconSet( Amarok::icon( "collection" ) ), i18n( "&Copy Files to Collection..." ), COPY_TO_COLLECTION );
1869
1912
        switch( item->type() )
1870
1913
        {
1871
1914
        case MediaItem::ARTIST:
1872
 
            menu.insertItem( SmallIconSet( amaroK::icon( "cdrom_unmount" ) ), i18n( "Burn All Tracks by This Artist" ), BURN_ARTIST );
 
1915
            menu.insertItem( SmallIconSet( Amarok::icon( "cdrom_unmount" ) ), i18n( "Burn All Tracks by This Artist" ), BURN_ARTIST );
1873
1916
            menu.setItemEnabled( BURN_ARTIST, K3bExporter::isAvailable() );
1874
1917
            break;
1875
1918
 
1876
1919
        case MediaItem::ALBUM:
1877
 
            menu.insertItem( SmallIconSet( amaroK::icon( "cdrom_unmount" ) ), i18n( "Burn This Album" ), BURN_ALBUM );
 
1920
            menu.insertItem( SmallIconSet( Amarok::icon( "cdrom_unmount" ) ), i18n( "Burn This Album" ), BURN_ALBUM );
1878
1921
            menu.setItemEnabled( BURN_ALBUM, K3bExporter::isAvailable() );
1879
1922
            break;
1880
1923
 
1881
1924
        default:
1882
 
            menu.insertItem( SmallIconSet( amaroK::icon( "cdrom_unmount" ) ), i18n( "Burn to CD as Data" ), BURN_DATACD );
 
1925
            menu.insertItem( SmallIconSet( Amarok::icon( "cdrom_unmount" ) ), i18n( "Burn to CD as Data" ), BURN_DATACD );
1883
1926
            menu.setItemEnabled( BURN_DATACD, K3bExporter::isAvailable() );
1884
 
            menu.insertItem( SmallIconSet( amaroK::icon( "cdaudio_unmount" ) ), i18n( "Burn to CD as Audio" ), BURN_AUDIOCD );
 
1927
            menu.insertItem( SmallIconSet( Amarok::icon( "cdaudio_unmount" ) ), i18n( "Burn to CD as Audio" ), BURN_AUDIOCD );
1885
1928
            menu.setItemEnabled( BURN_AUDIOCD, K3bExporter::isAvailable() );
1886
1929
            break;
1887
1930
        }
1892
1935
                 || item->type() == MediaItem::PODCASTCHANNEL) )
1893
1936
        {
1894
1937
            IpodMediaItem *it = static_cast<IpodMediaItem *>(item);
1895
 
            menu.insertItem( SmallIconSet( amaroK::icon( "podcast" ) ), i18n( "Subscribe to This Podcast" ), SUBSCRIBE );
 
1938
            menu.insertItem( SmallIconSet( Amarok::icon( "podcast" ) ), i18n( "Subscribe to This Podcast" ), SUBSCRIBE );
1896
1939
            //menu.setItemEnabled( SUBSCRIBE, item->bundle()->podcastBundle() && item->bundle()->podcastBundle()->parent().isValid() );
1897
1940
            menu.setItemEnabled( SUBSCRIBE, it->m_podcastInfo && !it->m_podcastInfo->rss.isEmpty() );
1898
1941
            menu.insertSeparator();
1908
1951
        case MediaItem::PODCASTITEM:
1909
1952
            if(m_playlistItem)
1910
1953
            {
1911
 
                menu.insertItem( SmallIconSet( amaroK::icon( "playlist" ) ), i18n( "Make Media Device Playlist" ), MAKE_PLAYLIST );
 
1954
                menu.insertItem( SmallIconSet( Amarok::icon( "playlist" ) ), i18n( "Make Media Device Playlist" ), MAKE_PLAYLIST );
1912
1955
                menu.setItemEnabled( MAKE_PLAYLIST, !locked );
1913
1956
 
1914
1957
                playlistsMenu = new KPopupMenu(&menu);
1917
1960
                        it;
1918
1961
                        it = dynamic_cast<MediaItem *>(it->nextSibling()))
1919
1962
                {
1920
 
                    playlistsMenu->insertItem( SmallIconSet( amaroK::icon( "playlist" ) ), it->text(0), FIRST_PLAYLIST+i );
 
1963
                    playlistsMenu->insertItem( SmallIconSet( Amarok::icon( "playlist" ) ), it->text(0), FIRST_PLAYLIST+i );
1921
1964
                    i++;
1922
1965
                }
1923
 
                menu.insertItem( SmallIconSet( amaroK::icon( "playlist" ) ), i18n("Add to Playlist"), playlistsMenu, ADD_TO_PLAYLIST );
 
1966
                menu.insertItem( SmallIconSet( Amarok::icon( "playlist" ) ), i18n("Add to Playlist"), playlistsMenu, ADD_TO_PLAYLIST );
1924
1967
                menu.setItemEnabled( ADD_TO_PLAYLIST, !locked && m_playlistItem->childCount()>0 );
1925
1968
                menu.insertSeparator();
1926
1969
            }
1927
1970
 
1928
1971
            if( item->type() == MediaItem::ARTIST ||
1929
1972
                    item->type() == MediaItem::ALBUM ||
1930
 
                    item->type() == MediaItem::TRACK )
 
1973
                    item->type() == MediaItem::TRACK ||
 
1974
                    item->type() == MediaItem::ORPHANED )
1931
1975
            {
1932
 
                menu.insertItem( SmallIconSet( amaroK::icon( "edit" ) ),
 
1976
                menu.insertItem( SmallIconSet( Amarok::icon( "edit" ) ),
1933
1977
                        i18n( "Edit &Information...", "Edit &Information for %n Tracks...", urls.count()),
1934
1978
                        RENAME );
1935
1979
            }
1937
1981
 
1938
1982
        case MediaItem::ORPHANED:
1939
1983
        case MediaItem::ORPHANEDROOT:
1940
 
            menu.insertItem( SmallIconSet( amaroK::icon( "edit" ) ), i18n( "Add to Database" ), ADD );
 
1984
            menu.insertItem( SmallIconSet( Amarok::icon( "edit" ) ), i18n( "Add to Database" ), ADD );
1941
1985
            menu.setItemEnabled( ADD, !locked );
1942
1986
            break;
1943
1987
 
1944
1988
        case MediaItem::PLAYLIST:
1945
 
            menu.insertItem( SmallIconSet( amaroK::icon( "edit" ) ), i18n( "Rename" ), RENAME );
 
1989
            menu.insertItem( SmallIconSet( Amarok::icon( "edit" ) ), i18n( "Rename" ), RENAME );
1946
1990
            menu.setItemEnabled( RENAME, !locked );
1947
1991
            break;
1948
1992
 
1952
1996
 
1953
1997
        if( item->type() == MediaItem::PLAYLIST || item->type() == MediaItem::PLAYLISTITEM )
1954
1998
        {
1955
 
            menu.insertItem( SmallIconSet( amaroK::icon( "remove_from_playlist" ) ),
 
1999
            menu.insertItem( SmallIconSet( Amarok::icon( "remove_from_playlist" ) ),
1956
2000
                    item->type()==MediaItem::PLAYLIST ? i18n( "Remove Playlist" ) : i18n( "Remove from Playlist" ),
1957
2001
                    REMOVE_FROM_PLAYLIST );
1958
2002
            menu.setItemEnabled( REMOVE_FROM_PLAYLIST, !locked );
1959
2003
        }
1960
2004
        if( item->type() == MediaItem::PODCASTSROOT || item->type() == MediaItem::PODCASTCHANNEL )
1961
2005
        {
1962
 
            menu.insertItem( SmallIconSet( amaroK::icon( "remove" ) ), i18n( "Delete Podcasts Already Played" ), DELETE_PLAYED );
 
2006
            menu.insertItem( SmallIconSet( Amarok::icon( "remove" ) ), i18n( "Delete Podcasts Already Played" ), DELETE_PLAYED );
1963
2007
            menu.setItemEnabled( DELETE_PLAYED, !locked );
1964
2008
        }
1965
 
        menu.insertItem( SmallIconSet( amaroK::icon( "remove" ) ),
 
2009
        menu.insertItem( SmallIconSet( Amarok::icon( "remove" ) ),
1966
2010
                i18n( "Delete Track from iPod", "Delete %n Tracks from iPod", urls.count() ),
1967
2011
                DELETE_FROM_IPOD );
1968
2012
        menu.setItemEnabled( DELETE_FROM_IPOD, !locked && urls.count() > 0 );
1969
2013
    }
1970
2014
 
1971
2015
    KPopupMenu repairMenu;
1972
 
    repairMenu.insertItem( SmallIconSet( amaroK::icon( "playlist_refresh" ) ), i18n( "Scan for Orphaned and Missing Files" ), REPAIR_SCAN );
1973
 
    repairMenu.insertItem( SmallIconSet( amaroK::icon( "covermanager" ) ), i18n( "Refresh Cover Images" ), REPAIR_COVERS );
 
2016
    repairMenu.insertItem( SmallIconSet( Amarok::icon( "playlist_refresh" ) ), i18n( "Scan for Orphaned and Missing Files" ), REPAIR_SCAN );
 
2017
    repairMenu.insertItem( SmallIconSet( Amarok::icon( "covermanager" ) ), i18n( "Refresh Cover Images" ), REPAIR_COVERS );
1974
2018
    repairMenu.setItemEnabled( REPAIR_COVERS, m_supportsArtwork );
1975
2019
    menu.insertItem( SmallIconSet( "folder" ), i18n("Repair iPod"), &repairMenu, REPAIR_MENU );
1976
2020
 
2052
2096
                    {
2053
2097
                        QString num;
2054
2098
                        num.setNum(i);
2055
 
                        name = base + " " + num;
 
2099
                        name = base + ' ' + num;
2056
2100
                        i++;
2057
2101
                    }
2058
2102
                    MediaItem *pl = newPlaylist(name, m_playlistItem, items);
2079
2123
                            }
2080
2124
 
2081
2125
                            item->takeItem(it);
2082
 
                            insertTrackIntoDB(it->url().path(), *it->bundle(), 0);
 
2126
                            insertTrackIntoDB(it->url().path(), *it->bundle(), *it->bundle(), 0);
2083
2127
                            delete it;
2084
2128
                        }
2085
2129
                    }
2102
2146
                            }
2103
2147
 
2104
2148
                            i->parent()->takeItem(i);
2105
 
                            insertTrackIntoDB(i->url().path(), *i->bundle(), 0);
2106
 
                            delete it;
 
2149
                            insertTrackIntoDB(i->url().path(), *i->bundle(), *i->bundle(), 0);
 
2150
                            delete i;
2107
2151
                        }
2108
2152
                    }
2109
2153
 
2110
2154
                    if( dupes > 0 )
2111
 
                        amaroK::StatusBar::instance()->shortMessage( i18n(
 
2155
                        Amarok::StatusBar::instance()->shortMessage( i18n(
2112
2156
                                    "One duplicate track not added to database",
2113
2157
                                    "%n duplicate tracks not added to database", dupes ) );
2114
2158
                }
2197
2241
    QStringList list;
2198
2242
    list << "m4a";
2199
2243
    list << "m4b";
2200
 
    list << "m4p";
2201
2244
    list << "mp3";
2202
2245
    list << "wav";
2203
2246
    list << "mp4";
2274
2317
        {
2275
2318
            if( curDir[i].lower() == (*it).lower())
2276
2319
            {
2277
 
                curPath += "/" + curDir[i];
 
2320
                curPath += '/' + curDir[i];
2278
2321
                curDir.cd( curPath );
2279
2322
                found = true;
2280
2323
                break;
2285
2328
    }
2286
2329
 
2287
2330
    for( ; it != components.end(); ++it )
2288
 
        curPath += "/" + *it;
 
2331
        curPath += '/' + *it;
2289
2332
 
2290
2333
    //debug() << ipodPath << ( found ? "" : " not" ) << " found, actually " << curPath << endl;
2291
2334