File indexing completed on 2024-05-19 04:50:25

 /****************************************************************************************
  * Copyright (c) 2007-2009 Nikolaj Hald Nielsen <nhn@kde.org>                           *
  *                                                                                      *
  * This program 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 2 of the License, or (at your option) any later           *
  * version.                                                                             *
  *                                                                                      *
  * This program 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         *
  * this program.  If not, see <http://www.gnu.org/licenses/>.                           *
  ****************************************************************************************/
 
 #include "ScriptableServiceMeta.h"
 #include "ScriptableServiceMeta_p.h"
 
 #include "core/meta/support/PrivateMetaRegistry.h"
 #include "core-impl/meta/multi/MultiTrack.h"
 #include "core-impl/playlists/types/file/PlaylistFileSupport.h"
 #include "services/scriptable/ScriptableService.h"
 #include "services/scriptable/ScriptableServiceManager.h"
 
 using namespace Meta;
 
 ScriptableServiceMetaItem::ScriptableServiceMetaItem( int level )
     : m_callbackString( QString() )
     , m_level( level )
     , m_serviceName( QString() )
     , m_serviceDescription( QString() )
     , m_serviceEmblem( QPixmap() )
 {}
 
 void Meta::ScriptableServiceMetaItem::setCallbackString( const QString &callbackString )
 { 
     m_callbackString = callbackString;
 }
 
 QString Meta::ScriptableServiceMetaItem::callbackString() const
 {
     return m_callbackString;
 }
 
 int Meta::ScriptableServiceMetaItem::level() const
 {
     return m_level;
 }
 
 void Meta::ScriptableServiceMetaItem::setServiceName( const QString & name )
 {
     m_serviceName = name;
 }
 
 void Meta::ScriptableServiceMetaItem::setServiceDescription( const QString & description )
 {
     m_serviceDescription = description;
 }
 
 void Meta::ScriptableServiceMetaItem::setServiceEmblem( const QPixmap & emblem )
 {
     m_serviceEmblem = emblem;
 }
 
 void Meta::ScriptableServiceMetaItem::setServiceScalableEmblem ( const QString& emblemPath )
 {
     m_serviceScalableEmblem = emblemPath;
 }
 
 
 /* ScriptableServiceTrack */
 ScriptableServiceTrack::ScriptableServiceTrack( const QString & name )
     : ServiceTrack( name )
     , ScriptableServiceMetaItem( 0 )
 {}
 
 ScriptableServiceTrack::ScriptableServiceTrack( const QStringList & resultRow )
     : ServiceTrack( resultRow )
     , ScriptableServiceMetaItem( 0 )
 {}
 
 
 void Meta::ScriptableServiceTrack::setAlbumName( const QString &newAlbum )
 {
     Meta::AlbumPtr albumPtr = Meta::PrivateMetaRegistry::instance()->album( m_serviceName, newAlbum );
     if ( !albumPtr ) {
         ScriptableServiceInternalAlbum * intAlbum = new ScriptableServiceInternalAlbum( newAlbum );
         intAlbum->setServiceName( m_serviceName );
         intAlbum->setServiceDescription( m_serviceDescription );
         intAlbum->setServiceEmblem( m_serviceEmblem );
         intAlbum->setServiceScalableEmblem( m_serviceScalableEmblem );
         albumPtr = Meta::AlbumPtr( intAlbum );
         Meta::PrivateMetaRegistry::instance()->insertAlbum( m_serviceName, newAlbum, albumPtr );
     }
 
     setAlbumPtr( albumPtr );
 }
 
 void Meta::ScriptableServiceTrack::setArtistName( const QString &newArtist )
 {
     Meta::ArtistPtr artistPtr = Meta::PrivateMetaRegistry::instance()->artist( m_serviceName, newArtist );
     if ( !artistPtr ) {
         ScriptableServiceInternalArtist * intArtist = new ScriptableServiceInternalArtist( newArtist );
         intArtist->setServiceName( m_serviceName );
         intArtist->setServiceDescription( m_serviceDescription );
         intArtist->setServiceEmblem( m_serviceEmblem );
         intArtist->setServiceScalableEmblem( m_serviceScalableEmblem );
         artistPtr = Meta::ArtistPtr( intArtist );
         Meta::PrivateMetaRegistry::instance()->insertArtist( m_serviceName, newArtist, artistPtr );
     }
 
     setArtist( artistPtr );
 }
 
 void Meta::ScriptableServiceTrack::setGenreName( const QString &newGenre )
 {
     Meta::GenrePtr genrePtr = Meta::PrivateMetaRegistry::instance()->genre( m_serviceName, newGenre );
     if ( !genrePtr ) {
         ScriptableServiceInternalGenre * intGenre = new ScriptableServiceInternalGenre( newGenre );
         intGenre->setServiceName( m_serviceName );
         intGenre->setServiceDescription( m_serviceDescription );
         intGenre->setServiceEmblem( m_serviceEmblem );
         intGenre->setServiceScalableEmblem( m_serviceScalableEmblem );
         genrePtr = Meta::GenrePtr( intGenre );
         Meta::PrivateMetaRegistry::instance()->insertGenre( m_serviceName, newGenre, genrePtr );
     }
 
     setGenre( genrePtr );
 }
 
 void Meta::ScriptableServiceTrack::setComposerName( const QString &newComposer )
 {
     Meta::ComposerPtr composerPtr = Meta::PrivateMetaRegistry::instance()->composer( m_serviceName, newComposer );
     if ( !composerPtr ) {
         ScriptableServiceInternalComposer * intComposer = new ScriptableServiceInternalComposer( newComposer);
         intComposer->setServiceName( m_serviceName );
         intComposer->setServiceDescription( m_serviceDescription );
         intComposer->setServiceEmblem( m_serviceEmblem );
         intComposer->setServiceScalableEmblem( m_serviceScalableEmblem );
         composerPtr = Meta::ComposerPtr( intComposer );
         Meta::PrivateMetaRegistry::instance()->insertComposer( m_serviceName, newComposer, composerPtr );
     }
 
     setComposer( composerPtr );
 }
 
 void Meta::ScriptableServiceTrack::setYearNumber( int newYear )
 {
     const QString yearString = QString::number( newYear );
     
     Meta::YearPtr yearPtr = Meta::PrivateMetaRegistry::instance()->year( m_serviceName, yearString );
     if ( !yearPtr ) {
         ScriptableServiceInternalYear * intYear = new ScriptableServiceInternalYear( yearString );
         intYear->setServiceName( m_serviceName );
         intYear->setServiceDescription( m_serviceDescription );
         intYear->setServiceEmblem( m_serviceEmblem );
         intYear->setServiceScalableEmblem( m_serviceScalableEmblem );
         yearPtr = Meta::YearPtr( intYear );
         Meta::PrivateMetaRegistry::instance()->insertYear( m_serviceName, yearString, yearPtr );
     }
 
     setYear( yearPtr );
 }
 
 void Meta::ScriptableServiceTrack::setCustomAlbumCoverUrl( const QString & coverurl )
 {
     DEBUG_BLOCK
     if ( album() ) {
         debug() << "one";
         ServiceAlbumWithCoverPtr albumWithCover = ServiceAlbumWithCoverPtr::dynamicCast( album() );
         if ( albumWithCover ) {
             debug() << "two";
             albumWithCover->setCoverUrl( coverurl );
         }
     }
 }
 
 
 QString Meta::ScriptableServiceTrack::sourceName()
 {
     return m_serviceName;
 }
 
 QString Meta::ScriptableServiceTrack::sourceDescription()
 {
     return m_serviceDescription;
 }
 
 QPixmap Meta::ScriptableServiceTrack::emblem()
 {
     return m_serviceEmblem;
 }
 
 QString Meta::ScriptableServiceTrack::scalableEmblem()
 {
     return  m_serviceScalableEmblem;
 }
 
 void ScriptableServiceTrack::setUidUrl( const QString &url )
 {
     Meta::ServiceTrack::setUidUrl( url );
 
     using namespace Playlists;
     Meta::TrackPtr track( this );
     PlaylistPtr playlist = canExpand( track ) ? expand( track ) : PlaylistPtr();
     if( playlist )
         // since this is a playlist masqueurading as a single track, make a MultiTrack out of it:
         m_playableTrack = Meta::TrackPtr( new Meta::MultiTrack( playlist ) );
     else
         m_playableTrack = TrackPtr();
 }
 
 TrackPtr ScriptableServiceTrack::playableTrack() const
 {
     return m_playableTrack ? m_playableTrack : TrackPtr( const_cast<ScriptableServiceTrack *>( this ) );
 }
 
 
 /* DynamicScriptableAlbum */
 ScriptableServiceAlbum::ScriptableServiceAlbum( const QString & name )
     : ServiceAlbumWithCover( name )
     , ScriptableServiceMetaItem( 1 )
 {}
 
 ScriptableServiceAlbum::ScriptableServiceAlbum( const QStringList & resultRow )
     : ServiceAlbumWithCover( resultRow )
     , ScriptableServiceMetaItem( 1 )
 {}
 
 QString Meta::ScriptableServiceAlbum::sourceName()
 {
     return m_serviceName;
 }
 
 QString Meta::ScriptableServiceAlbum::sourceDescription()
 {
     return m_serviceDescription;
 }
 
 QPixmap Meta::ScriptableServiceAlbum::emblem()
 {
     return m_serviceEmblem;
 }
 
 QString Meta::ScriptableServiceAlbum::scalableEmblem()
 {
     return  m_serviceScalableEmblem;
 }
 
 bool Meta::ScriptableServiceAlbum::isBookmarkable() const
 {
     ScriptableService * service = The::scriptableServiceManager()->service( m_serviceName );
     if ( service )
         return service->hasSearchBar();
     else
         return false;
 }
 
 
 
 /* ScriptableServiceArtist */
 ScriptableServiceArtist::ScriptableServiceArtist( const QString & name )
     : ServiceArtist( name )
     , ScriptableServiceMetaItem( 2 )
     , m_genreId( 0 )
 {}
 
 ScriptableServiceArtist::ScriptableServiceArtist( const QStringList & resultRow )
     : ServiceArtist( resultRow )
     , ScriptableServiceMetaItem( 2 )
     , m_genreId( 0 )
 {}
 
 
 void Meta::ScriptableServiceArtist::setGenreId(int genreId)
 {
     m_genreId = genreId;
 }
 
 
 int Meta::ScriptableServiceArtist::genreId() const
 {
     return m_genreId;
 }
 
 QString Meta::ScriptableServiceArtist::sourceName()
 {
     return m_serviceName;
 }
 
 QString Meta::ScriptableServiceArtist::sourceDescription()
 {
     return m_serviceDescription;
 }
 
 QPixmap Meta::ScriptableServiceArtist::emblem()
 {
     return m_serviceEmblem;
 }
 
 QString Meta::ScriptableServiceArtist::scalableEmblem()
 {
     return  m_serviceScalableEmblem;
 }
 
 bool Meta::ScriptableServiceArtist::isBookmarkable()  const
 {
     ScriptableService * service = The::scriptableServiceManager()->service( m_serviceName );
     if ( service )
         return service->hasSearchBar();
     else
         return false;
 }
 
 
 /* ScriptableServiceGenre */
 ScriptableServiceGenre::ScriptableServiceGenre( const QString & name )
     : ServiceGenre( name )
     , ScriptableServiceMetaItem( 3 )
 {}
 
 ScriptableServiceGenre::ScriptableServiceGenre( const QStringList & resultRow )
     : ServiceGenre( resultRow )
     , ScriptableServiceMetaItem( 3 )
 {}
 
 
 void Meta::ScriptableServiceGenre::setDescription(const QString & description)
 {
     m_description = description;
 }
 
 QString Meta::ScriptableServiceGenre::description()
 {
     return m_description;
 }
 
 QString Meta::ScriptableServiceGenre::sourceName()
 {
     return m_serviceName;
 }
 
 QString Meta::ScriptableServiceGenre::sourceDescription()
 {
     return m_serviceDescription;
 }
 
 QPixmap Meta::ScriptableServiceGenre::emblem()
 {
     return m_serviceEmblem;
 }
 
 QString Meta::ScriptableServiceGenre::scalableEmblem()
 {
     return  m_serviceScalableEmblem;
 }