File indexing completed on 2024-05-12 04:51:00

 /*
     SPDX-FileCopyrightText: 2003-2008 Sebastian Trueg <trueg@k3b.org>
     SPDX-FileCopyrightText: 2009 Gustavo Pichorim Boiko <gustavo.boiko@kdemail.net>
     SPDX-FileCopyrightText: 2010 Michal Malek <michalm@jabster.pl>
     SPDX-FileCopyrightText: 1998-2009 Sebastian Trueg <trueg@k3b.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 
 #ifndef K3BAUDIODOC_H
 #define K3BAUDIODOC_H
 
 #include "k3bdoc.h"
 #include "k3bcdtext.h"
 #include "k3btoc.h"
 
 #include "k3b_export.h"
 
 class QDomElement;
 
 namespace K3b {
     class AudioTrack;
     class AudioDataSource;
     class AudioDecoder;
     class AudioFile;
 
     /**
      * Document class for an audio project.
      * @author Sebastian Trueg
      */
     class LIBK3B_EXPORT AudioDoc : public Doc
     {
         Q_OBJECT
 
         friend class MixedDoc;
         friend class AudioTrack;
         friend class AudioFile;
 
     public:
         explicit AudioDoc( QObject* );
         ~AudioDoc() override;
 
         Type type() const override { return AudioProject; }
         QString typeString() const override { return QString::fromLatin1("audio"); }
 
         QString name() const override;
 
         bool newDocument() override;
 
         void clear() override;
 
         Device::MediaTypes supportedMediaTypes() const override;
 
         bool hideFirstTrack() const;
         int numOfTracks() const override;
 
         bool normalize() const;
 
         AudioTrack* firstTrack() const;
         AudioTrack* lastTrack() const;
 
         /**
          * Slow.
          * \return the AudioTrack with track number trackNum (starting at 1) or 0 if trackNum > numOfTracks()
          */
         AudioTrack* getTrack( int trackNum );
 
         /**
          * Creates a new audiofile inside this doc which has no track yet.
          */
         AudioFile* createAudioFile( const QUrl& url );
 
         /** get the current size of the project */
         KIO::filesize_t size() const override;
         Msf length() const override;
 
         // CD-Text
         bool cdText() const;
         QString title() const;
         QString artist() const;
         QString disc_id() const;
         QString arranger() const;
         QString songwriter() const;
         QString composer() const;
         QString upc_ean() const;
         QString cdTextMessage() const;
 
         /**
          * Create complete CD-Text including the tracks' data.
          */
         Device::CdText cdTextData() const;
 
         int audioRippingParanoiaMode() const;
         int audioRippingRetries() const;
         bool audioRippingIgnoreReadErrors() const;
 
         /**
          * Represent the structure of the doc as CD Table of Contents.
          */
         Device::Toc toToc() const;
 
         BurnJob* newBurnJob( JobHandler*, QObject* parent = 0 ) override;
 
         /**
          * returns the new after track, ie. the last added track or null if
          * the import failed.
          *
          * This is a blocking method.
          *
          * \param cuefile The Cuefile to be imported
          * \param after   The track after which the new tracks should be inserted
          * \param decoder The decoder to be used for the new tracks. If 0 a new one will be created.
          *
          * BE AWARE THAT THE DECODER HAS TO FIT THE AUDIO FILE IN THE CUE.
          */
         AudioTrack* importCueFile( const QString& cuefile, AudioTrack* after, AudioDecoder* decoder = 0 );
 
         /**
          * Create a decoder for a specific url. If another AudioFileSource with this
          * url is already part of this project the associated decoder is returned.
          *
          * In the first case the decoder will not be initialized yet (AudioDecoder::analyseFile
          * is not called yet).
          *
          * \param url The url for which a decoder is requested.
          * \param reused If not null this variable is set to true if the decoder is already in
          *               use and AudioDecoder::analyseFile() does not have to be called anymore.
          */
         AudioDecoder* getDecoderForUrl( const QUrl& url, bool* reused = 0 );
 
         /**
          * Transforms given url list into flat file list.
          * Each directory and M3U playlist is expanded into the files.
          * Note: directories are not expanded recursively.
          */
         static QList<QUrl> extractUrlList( const QList<QUrl>& urls );
 
         static bool readPlaylistFile( const QUrl& url, QList<QUrl>& playlist );
 
     public Q_SLOTS:
         void addUrls( const QList<QUrl>& ) override;
         void addTrack( const QUrl&, int );
         void addTracks( const QList<QUrl>&, int );
         /**
          * Adds a track without any testing
          *
          * Slow because it uses getTrack.
          */
         void addTrack( AudioTrack* track, int position = 0 );
 
         void addSources( AudioTrack* parent, const QList<QUrl>& urls, AudioDataSource* sourceAfter = 0 );
 
         void removeTrack( AudioTrack* );
         void moveTrack( AudioTrack* track, AudioTrack* after );
 
         void setHideFirstTrack( bool b );
         void setNormalize( bool b );
 
         // CD-Text
         void writeCdText( bool b );
         void setTitle( const QString& v );
         void setArtist( const QString& v );
         void setPerformer( const QString& v );
         void setDisc_id( const QString& v );
         void setArranger( const QString& v );
         void setSongwriter( const QString& v );
         void setComposer( const QString& v );
         void setUpc_ean( const QString& v );
         void setCdTextMessage( const QString& v );
 
         // Audio-CD Ripping
         void setAudioRippingParanoiaMode( int i );
         void setAudioRippingRetries( int r );
         void setAudioRippingIgnoreReadErrors( bool b );
 
     private Q_SLOTS:
         void slotTrackChanged( K3b::AudioTrack* track );
         void slotTrackRemoved( int position );
 
     Q_SIGNALS:
         void trackChanged( K3b::AudioTrack* track );
 
         // signals for the model
         void trackAboutToBeAdded( int position );
         void trackAdded( int position );
         void trackAboutToBeRemoved( int position );
         void trackRemoved( int position );
         void sourceAboutToBeAdded( K3b::AudioTrack* parent, int position );
         void sourceAdded( K3b::AudioTrack* parent, int position );
         void sourceAboutToBeRemoved( K3b::AudioTrack* parent, int position );
         void sourceRemoved( K3b::AudioTrack* parent, int position );
 
     protected:
         /** reimplemented from Doc */
         bool loadDocumentData( QDomElement* ) override;
         /** reimplemented from Doc */
         bool saveDocumentData( QDomElement* ) override;
 
     private:
         // the stuff for adding files
         // ---------------------------------------------------------
         AudioTrack* createTrack( const QUrl& url );
 
         /**
          * Used by AudioTrack to update the track list
          */
         void setFirstTrack( AudioTrack* track );
         /**
          * Used by AudioTrack to update the track list
          */
         void setLastTrack( AudioTrack* track );
 
         /**
          * Used by AudioFile to tell the doc that it does not need the decoder anymore.
          */
         void decreaseDecoderUsage( AudioDecoder* );
         void increaseDecoderUsage( AudioDecoder* );
 
         class Private;
         Private* d;
     };
 }
 
 #endif