From 048114dba920afecf758120e72a40cc1729f4eb5 Mon Sep 17 00:00:00 2001 From: "Uwe L. Korn" Date: Tue, 16 Jul 2013 00:45:43 +0200 Subject: [PATCH] Pimple Track --- src/libtomahawk/PlaybackLog.h | 37 ++++++ src/libtomahawk/SocialAction.h | 38 ++++++ src/libtomahawk/Track.cpp | 236 ++++++++++++++++++++++++--------- src/libtomahawk/Track.h | 72 +++++----- src/libtomahawk/TrackData.h | 27 +--- src/libtomahawk/Track_p.h | 67 ++++++++++ 6 files changed, 350 insertions(+), 127 deletions(-) create mode 100644 src/libtomahawk/PlaybackLog.h create mode 100644 src/libtomahawk/SocialAction.h create mode 100644 src/libtomahawk/Track_p.h diff --git a/src/libtomahawk/PlaybackLog.h b/src/libtomahawk/PlaybackLog.h new file mode 100644 index 000000000..becf7cb30 --- /dev/null +++ b/src/libtomahawk/PlaybackLog.h @@ -0,0 +1,37 @@ +/* === This file is part of Tomahawk Player - === + * + * Copyright 2013, Christian Muehlhaeuser + * + * Tomahawk is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Tomahawk is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Tomahawk. If not, see . + */ + +#pragma once +#ifndef PLAYBACKLOG_H +#define PLAYBACKLOG_H + +#include "Typedefs.h" + +namespace Tomahawk +{ + +struct PlaybackLog +{ + Tomahawk::source_ptr source; + unsigned int timestamp; + unsigned int secsPlayed; +}; + +} // namespace Tomahawk + +#endif // PLAYBACKLOG_H diff --git a/src/libtomahawk/SocialAction.h b/src/libtomahawk/SocialAction.h new file mode 100644 index 000000000..9994a06c4 --- /dev/null +++ b/src/libtomahawk/SocialAction.h @@ -0,0 +1,38 @@ +/* === This file is part of Tomahawk Player - === + * + * Copyright 2013, Christian Muehlhaeuser + * + * Tomahawk is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Tomahawk is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Tomahawk. If not, see . + */ + +#pragma once +#ifndef SOCIALACTION_H +#define SOCIALACTION_H + +#include "Typedefs.h" + +namespace Tomahawk +{ + +struct SocialAction +{ + QVariant action; + QVariant value; + QVariant timestamp; + Tomahawk::source_ptr source; +}; + +} // namespace Tomahawk + +#endif // SOCIALACTION_H diff --git a/src/libtomahawk/Track.cpp b/src/libtomahawk/Track.cpp index c457c5669..c00f4d578 100644 --- a/src/libtomahawk/Track.cpp +++ b/src/libtomahawk/Track.cpp @@ -2,6 +2,7 @@ * * Copyright 2013, Christian Muehlhaeuser * Copyright 2013, Teo Mrnjavac + * Copyright 2013, Uwe L. Korn * * Tomahawk is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,7 +18,7 @@ * along with Tomahawk. If not, see . */ -#include "Track.h" +#include "Track_p.h" #include "audio/AudioEngine.h" #include "collection/Collection.h" @@ -102,26 +103,20 @@ Track::get( unsigned int id, const QString& artist, const QString& track, const Track::Track( unsigned int id, const QString& artist, const QString& track, const QString& album, int duration, const QString& composer, unsigned int albumpos, unsigned int discnumber ) - : m_composer( composer ) - , m_album( album ) - , m_duration( duration ) - , m_albumpos( albumpos ) - , m_discnumber( discnumber ) + : d_ptr( new TrackPrivate( this, album, duration, composer, albumpos, discnumber ) ) { - m_trackData = TrackData::get( id, artist, track ); + Q_D( Track ); + d->trackData = TrackData::get( id, artist, track ); init(); } Track::Track( const QString& artist, const QString& track, const QString& album, int duration, const QString& composer, unsigned int albumpos, unsigned int discnumber ) - : m_composer( composer ) - , m_album( album ) - , m_duration( duration ) - , m_albumpos( albumpos ) - , m_discnumber( discnumber ) + : d_ptr( new TrackPrivate( this, album, duration, composer, albumpos, discnumber ) ) { - m_trackData = TrackData::get( 0, artist, track ); + Q_D( Track ); + d->trackData = TrackData::get( 0, artist, track ); init(); } @@ -133,25 +128,36 @@ Track::~Track() } +void +Track::setAlbum( const QString& album ) +{ + Q_D( Track ); + d->album = album; + updateSortNames(); +} + + void Track::init() { + Q_D( Track ); updateSortNames(); - connect( m_trackData.data(), SIGNAL( attributesLoaded() ), SIGNAL( attributesLoaded() ) ); - connect( m_trackData.data(), SIGNAL( socialActionsLoaded() ), SIGNAL( socialActionsLoaded() ) ); - connect( m_trackData.data(), SIGNAL( statsLoaded() ), SIGNAL( statsLoaded() ) ); - connect( m_trackData.data(), SIGNAL( similarTracksLoaded() ), SIGNAL( similarTracksLoaded() ) ); - connect( m_trackData.data(), SIGNAL( lyricsLoaded() ), SIGNAL( lyricsLoaded() ) ); + connect( d->trackData.data(), SIGNAL( attributesLoaded() ), SIGNAL( attributesLoaded() ) ); + connect( d->trackData.data(), SIGNAL( socialActionsLoaded() ), SIGNAL( socialActionsLoaded() ) ); + connect( d->trackData.data(), SIGNAL( statsLoaded() ), SIGNAL( statsLoaded() ) ); + connect( d->trackData.data(), SIGNAL( similarTracksLoaded() ), SIGNAL( similarTracksLoaded() ) ); + connect( d->trackData.data(), SIGNAL( lyricsLoaded() ), SIGNAL( lyricsLoaded() ) ); } void Track::deleteLater() { + Q_D( Track ); QMutexLocker lock( &s_nameCacheMutex ); - const QString key = cacheKey( artist(), track(), m_album, m_duration, m_composer, m_albumpos, m_discnumber ); + const QString key = cacheKey( artist(), track(), d->album, d->duration, d->composer, d->albumpos, d->discnumber ); if ( s_tracksByName.contains( key ) ) { s_tracksByName.remove( key ); @@ -164,7 +170,24 @@ Track::deleteLater() unsigned int Track::trackId() const { - return m_trackData->trackId(); + Q_D( const Track ); + return d->trackData->trackId(); +} + + +QWeakPointer +Track::weakRef() +{ + Q_D( Track ); + return d->ownRef; +} + + +void +Track::setWeakRef( QWeakPointer weakRef ) +{ + Q_D( Track ); + d->ownRef = weakRef; } @@ -192,6 +215,7 @@ Track::finishPlaying( int timeElapsed ) void Track::markAsListened() { + Q_D( Track ); if ( !isListened() ) { DatabaseCommand_ModifyInboxEntry* cmd = new DatabaseCommand_ModifyInboxEntry( toQuery(), false ); @@ -207,9 +231,9 @@ Track::markAsListened() it->value = false; //listened! } } - m_trackData->blockSignals( true ); - m_trackData->setAllSocialActions( actions ); //emits socialActionsLoaded which gets propagated here - m_trackData->blockSignals( false ); + d->trackData->blockSignals( true ); + d->trackData->setAllSocialActions( actions ); //emits socialActionsLoaded which gets propagated here + d->trackData->blockSignals( false ); } } @@ -233,15 +257,17 @@ Track::isListened() const void Track::updateSortNames() { - m_composerSortname = DatabaseImpl::sortname( m_composer, true ); - m_albumSortname = DatabaseImpl::sortname( m_album ); + Q_D( Track ); + d->composerSortname = DatabaseImpl::sortname( d->composer, true ); + d->albumSortname = DatabaseImpl::sortname( d->album ); } void Track::setAllSocialActions( const QList< SocialAction >& socialActions ) { - m_trackData->setAllSocialActions( socialActions ); + Q_D( Track ); + d->trackData->setAllSocialActions( socialActions ); } @@ -288,87 +314,114 @@ Track::toString() const query_ptr Track::toQuery() { - if ( m_query.isNull() ) + Q_D( Track ); + if ( d->query.isNull() ) { query_ptr query = Tomahawk::Query::get( weakRef().toStrongRef() ); if ( !query ) return query_ptr(); - m_query = query->weakRef(); + d->query = query->weakRef(); return query; } - return m_query.toStrongRef(); + return d->query.toStrongRef(); +} + + +QString +Track::composerSortname() const +{ + Q_D( const Track ); + return d->composerSortname; +} + + +QString +Track::albumSortname() const +{ + Q_D( const Track ); + return d->albumSortname; } void Track::loadStats() { - m_trackData->loadStats(); + Q_D( Track ); + d->trackData->loadStats(); } QList< Tomahawk::PlaybackLog > Track::playbackHistory( const Tomahawk::source_ptr& source ) const { - return m_trackData->playbackHistory( source ); + Q_D( const Track ); + return d->trackData->playbackHistory( source ); } unsigned int Track::playbackCount( const source_ptr& source ) { - return m_trackData->playbackCount( source ); + Q_D( Track ); + return d->trackData->playbackCount( source ); } unsigned int Track::chartPosition() const { - return m_trackData->chartPosition(); + Q_D( const Track ); + return d->trackData->chartPosition(); } unsigned int Track::chartCount() const { - return m_trackData->chartCount(); + Q_D( const Track ); + return d->trackData->chartCount(); } void Track::loadAttributes() { - m_trackData->loadAttributes(); + Q_D( Track ); + d->trackData->loadAttributes(); } void Track::loadSocialActions() { - m_trackData->loadSocialActions(); + Q_D( Track ); + d->trackData->loadSocialActions(); } QList< SocialAction > Track::allSocialActions() const { - return m_trackData->allSocialActions(); + Q_D( const Track ); + return d->trackData->allSocialActions(); } bool Track::loved() { - return m_trackData->loved(); + Q_D( Track ); + return d->trackData->loved(); } void Track::setLoved( bool loved, bool postToInfoSystem ) { - m_trackData->setLoved( loved ); + Q_D( Track ); + d->trackData->setLoved( loved ); if ( postToInfoSystem ) { @@ -380,7 +433,7 @@ Track::setLoved( bool loved, bool postToInfoSystem ) loveInfo[ "trackinfo" ] = QVariant::fromValue< Tomahawk::InfoSystem::InfoStringHash >( trackInfo ); - Tomahawk::InfoSystem::InfoPushData pushData ( m_trackData->id(), + Tomahawk::InfoSystem::InfoPushData pushData ( d->trackData->id(), ( loved ? Tomahawk::InfoSystem::InfoLove : Tomahawk::InfoSystem::InfoUnLove ), loveInfo, Tomahawk::InfoSystem::PushShortUrlFlag ); @@ -468,38 +521,41 @@ Track::socialActionDescription( const QString& action, DescriptionMode mode ) co artist_ptr Track::artistPtr() const { - if ( !m_artistPtr ) + Q_D( const Track ); + if ( !d->artistPtr ) { - m_artistPtr = Artist::get( artist(), false ); - connect( m_artistPtr.data(), SIGNAL( updated() ), SIGNAL( updated() ), Qt::UniqueConnection ); - connect( m_artistPtr.data(), SIGNAL( coverChanged() ), SIGNAL( coverChanged() ), Qt::UniqueConnection ); + d->artistPtr = Artist::get( artist(), false ); + connect( d->artistPtr.data(), SIGNAL( updated() ), SIGNAL( updated() ), Qt::UniqueConnection ); + connect( d->artistPtr.data(), SIGNAL( coverChanged() ), SIGNAL( coverChanged() ), Qt::UniqueConnection ); } - return m_artistPtr; + return d->artistPtr; } album_ptr Track::albumPtr() const { - if ( !m_albumPtr ) + Q_D( const Track ); + if ( !d->albumPtr ) { - m_albumPtr = Album::get( artistPtr(), album(), false ); - connect( m_albumPtr.data(), SIGNAL( updated() ), SIGNAL( updated() ), Qt::UniqueConnection ); - connect( m_albumPtr.data(), SIGNAL( coverChanged() ), SIGNAL( coverChanged() ), Qt::UniqueConnection ); + d->albumPtr = Album::get( artistPtr(), album(), false ); + connect( d->albumPtr.data(), SIGNAL( updated() ), SIGNAL( updated() ), Qt::UniqueConnection ); + connect( d->albumPtr.data(), SIGNAL( coverChanged() ), SIGNAL( coverChanged() ), Qt::UniqueConnection ); } - return m_albumPtr; + return d->albumPtr; } artist_ptr Track::composerPtr() const { - if ( !m_composerPtr ) - m_composerPtr = Artist::get( composer(), false ); + Q_D( const Track ); + if ( !d->composerPtr ) + d->composerPtr = Artist::get( composer(), false ); - return m_composerPtr; + return d->composerPtr; } @@ -523,13 +579,14 @@ Track::cover( const QSize& size, bool forceLoad ) const bool Track::coverLoaded() const { - if ( m_albumPtr.isNull() ) + Q_D( const Track ); + if ( d->albumPtr.isNull() ) return false; - if ( m_albumPtr->coverLoaded() && !m_albumPtr->cover( QSize( 0, 0 ) ).isNull() ) + if ( d->albumPtr->coverLoaded() && !d->albumPtr->cover( QSize( 0, 0 ) ).isNull() ) return true; - return m_artistPtr->coverLoaded(); + return d->artistPtr->coverLoaded(); } #endif @@ -538,61 +595,110 @@ Track::coverLoaded() const QList Track::similarTracks() const { - return m_trackData->similarTracks(); + Q_D( const Track ); + return d->trackData->similarTracks(); } QStringList Track::lyrics() const { - return m_trackData->lyrics(); + Q_D( const Track ); + return d->trackData->lyrics(); } QString Track::artist() const { - return m_trackData->artist(); + Q_D( const Track ); + return d->trackData->artist(); } QString Track::track() const { - return m_trackData->track(); + Q_D( const Track ); + return d->trackData->track(); +} + + +QString +Track::composer() const +{ + Q_D( const Track ); + return d->composer; +} + + +QString +Track::album() const +{ + Q_D( const Track ); + return d->album; +} + + +int +Track::duration() const +{ + Q_D( const Track ); + return d->duration; } QVariantMap Track::attributes() const { - return m_trackData->attributes(); + Q_D( const Track ); + return d->trackData->attributes(); } int Track::year() const { - return m_trackData->year(); + Q_D( const Track ); + return d->trackData->year(); +} + + +unsigned int +Track::albumpos() const +{ + Q_D( const Track ); + return d->albumpos; +} + + +unsigned int +Track::discnumber() const +{ + Q_D( const Track ); + return d->discnumber; } void Track::share( const Tomahawk::source_ptr& source ) { - m_trackData->share( source ); + Q_D( Track ); + d->trackData->share( source ); } QString Track::artistSortname() const { - return m_trackData->artistSortname(); + Q_D( const Track ); + return d->trackData->artistSortname(); } QString Track::trackSortname() const { - return m_trackData->trackSortname(); + Q_D( const Track ); + return d->trackData->trackSortname(); } diff --git a/src/libtomahawk/Track.h b/src/libtomahawk/Track.h index 22dcfb76c..b3415d936 100644 --- a/src/libtomahawk/Track.h +++ b/src/libtomahawk/Track.h @@ -2,6 +2,7 @@ * * Copyright 2013, Christian Muehlhaeuser * Copyright 2013, Teo Mrnjavac + * Copyright 2013, Uwe L. Korn * * Tomahawk is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,23 +18,24 @@ * along with Tomahawk. If not, see . */ +#pragma once #ifndef TRACK_H #define TRACK_H -#include +#include "DllMacro.h" +#include "PlaybackLog.h" +#include "SocialAction.h" +#include "Typedefs.h" + #include #include -#include "Typedefs.h" -#include "TrackData.h" - -#include "DllMacro.h" - namespace Tomahawk { class DatabaseCommand_LoadInboxEntries; +class TrackPrivate; class DLLEXPORT Track : public QObject { @@ -51,13 +53,13 @@ public: virtual ~Track(); -// void setArtist( const QString& artist ) { m_artist = artist; updateSortNames(); } - void setAlbum( const QString& album ) { m_album = album; updateSortNames(); } -// void setTrack( const QString& track ) { m_track = track; updateSortNames(); } -/* void setDuration( int duration ) { m_duration = duration; } - void setAlbumPos( unsigned int albumpos ) { m_albumpos = albumpos; } - void setDiscNumber( unsigned int discnumber ) { m_discnumber = discnumber; } - void setComposer( const QString& composer ) { m_composer = composer; updateSortNames(); }*/ + // void setArtist( const QString& artist ) { m_artist = artist; updateSortNames(); } + void setAlbum( const QString& album ); + // void setTrack( const QString& track ) { m_track = track; updateSortNames(); } + // void setDuration( int duration ) { m_duration = duration; } + // void setAlbumPos( unsigned int albumpos ) { m_albumpos = albumpos; } + // void setDiscNumber( unsigned int discnumber ) { m_discnumber = discnumber; } + // void setComposer( const QString& composer ) { m_composer = composer; updateSortNames(); } bool equals( const Tomahawk::track_ptr& other, bool ignoreCase = false ) const; @@ -65,19 +67,19 @@ public: QString toString() const; Tomahawk::query_ptr toQuery(); - QString composerSortname() const { return m_composerSortname; } - QString albumSortname() const { return m_albumSortname; } + QString composerSortname() const; + QString albumSortname() const; QString artistSortname() const; QString trackSortname() const; QString artist() const; QString track() const; - QString composer() const { return m_composer; } - QString album() const { return m_album; } - int duration() const { return m_duration; } + QString composer() const; + QString album() const; + int duration() const; int year() const; - unsigned int albumpos() const { return m_albumpos; } - unsigned int discnumber() const { return m_discnumber; } + unsigned int albumpos() const; + unsigned int discnumber() const; Tomahawk::artist_ptr artistPtr() const; Tomahawk::album_ptr albumPtr() const; @@ -112,8 +114,8 @@ public: unsigned int trackId() const; - QWeakPointer< Tomahawk::Track > weakRef() { return m_ownRef; } - void setWeakRef( QWeakPointer< Tomahawk::Track > weakRef ) { m_ownRef = weakRef; } + QWeakPointer< Tomahawk::Track > weakRef(); + void setWeakRef( QWeakPointer< Tomahawk::Track > weakRef ); void startPlaying(); void finishPlaying( int timeElapsed ); @@ -134,7 +136,11 @@ signals: public slots: void deleteLater(); +protected: + QScopedPointer d_ptr; + private: + Q_DECLARE_PRIVATE( Track ) explicit Track( unsigned int id, const QString& artist, const QString& track, const QString& album, int duration, const QString& composer, unsigned int albumpos, unsigned int discnumber ); explicit Track( const QString& artist, const QString& track, const QString& album, int duration, const QString& composer, unsigned int albumpos, unsigned int discnumber ); @@ -144,29 +150,11 @@ private: void setAllSocialActions( const QList< SocialAction >& socialActions ); - QString m_composer; - QString m_album; - QString m_composerSortname; - QString m_albumSortname; - - int m_duration; - unsigned int m_albumpos; - unsigned int m_discnumber; - - mutable Tomahawk::artist_ptr m_artistPtr; - mutable Tomahawk::album_ptr m_albumPtr; - mutable Tomahawk::artist_ptr m_composerPtr; - - mutable trackdata_ptr m_trackData; - - query_wptr m_query; - QWeakPointer< Tomahawk::Track > m_ownRef; - static QHash< QString, track_wptr > s_tracksByName; }; -}; //ns +} // namespace Tomahawk -Q_DECLARE_METATYPE( Tomahawk::track_ptr ); +Q_DECLARE_METATYPE( Tomahawk::track_ptr ) #endif // TRACK_H diff --git a/src/libtomahawk/TrackData.h b/src/libtomahawk/TrackData.h index 2a3b9bfe2..4cdff9a7c 100644 --- a/src/libtomahawk/TrackData.h +++ b/src/libtomahawk/TrackData.h @@ -24,10 +24,12 @@ #include #include -#include "Typedefs.h" #include "infosystem/InfoSystem.h" - #include "DllMacro.h" +#include "PlaybackLog.h" +#include "SocialAction.h" +#include "Typedefs.h" + namespace Tomahawk { @@ -36,21 +38,6 @@ class DatabaseCommand_LogPlayback; class DatabaseCommand_PlaybackHistory; class IdThreadWorker; -struct SocialAction -{ - QVariant action; - QVariant value; - QVariant timestamp; - Tomahawk::source_ptr source; -}; - -struct PlaybackLog -{ - Tomahawk::source_ptr source; - unsigned int timestamp; - unsigned int secsPlayed; -}; - class DLLEXPORT TrackData : public QObject { Q_OBJECT @@ -173,9 +160,9 @@ private: friend class DatabaseCommand_PlaybackHistory; }; -}; //ns +} // namespace Tomahawk -Q_DECLARE_METATYPE( QList ); -Q_DECLARE_METATYPE( Tomahawk::trackdata_ptr ); +Q_DECLARE_METATYPE( QList ) +Q_DECLARE_METATYPE( Tomahawk::trackdata_ptr ) #endif // TRACKDATA_H diff --git a/src/libtomahawk/Track_p.h b/src/libtomahawk/Track_p.h new file mode 100644 index 000000000..bdaa0ebda --- /dev/null +++ b/src/libtomahawk/Track_p.h @@ -0,0 +1,67 @@ +/* === This file is part of Tomahawk Player - === + * + * Copyright 2013, Christian Muehlhaeuser + * Copyright 2013, Teo Mrnjavac + * Copyright 2013, Uwe L. Korn + * + * Tomahawk is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Tomahawk is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Tomahawk. If not, see . + */ + +#pragma once +#ifndef TRACK_P_H +#define TRACK_P_H + +#include "Track.h" + +namespace Tomahawk { + +class TrackPrivate +{ +public: + TrackPrivate( Track* q, const QString& _album, int _duration, const QString& _composer, unsigned int _albumpos, unsigned int _discnumber ) + : q_ptr( q ) + , composer( _composer ) + , album( _album ) + , duration( _duration ) + , albumpos( _albumpos ) + , discnumber( _discnumber ) + { + } + + Track* q_ptr; + Q_DECLARE_PUBLIC( Track ) + +private: + QString composer; + QString album; + QString composerSortname; + QString albumSortname; + + int duration; + uint albumpos; + uint discnumber; + + mutable Tomahawk::artist_ptr artistPtr; + mutable Tomahawk::album_ptr albumPtr; + mutable Tomahawk::artist_ptr composerPtr; + + mutable trackdata_ptr trackData; + + query_wptr query; + QWeakPointer< Tomahawk::Track > ownRef; +}; + +} // namespace Tomahawk + +#endif // TRACK_P_H