File indexing completed on 2024-05-19 04:56:07

 /**
  * \file kid3application.h
  * Kid3 application logic, independent of GUI.
  *
  * \b Project: Kid3
  * \author Urs Fleisch
  * \date 10 Jul 2011
  *
  * Copyright (C) 2011-2024  Urs Fleisch
  *
  * This file is part of Kid3.
  *
  * Kid3 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.
  *
  * Kid3 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/>.
  */
 
 #pragma once
 
 #include <QObject>
 #include <QPersistentModelIndex>
 #include <QScopedPointer>
 #include <QItemSelectionModel>
 #include "frame.h"
 #include "framelist.h"
 #include "taggedfilesystemmodel.h"
 #include "fileproxymodel.h"
 #include "dirproxymodel.h"
 #include "frametablemodel.h"
 #include "genremodel.h"
 #include "downloadclient.h"
 #include "batchimporter.h"
 #include "dirrenamer.h"
 #include "frameeditorobject.h"
 #include "taggedfileselection.h"
 #include "trackdata.h"
 #include "tagsearcher.h"
 #include "generalconfig.h"
 #include "config.h"
 
 class QItemSelection;
 class QModelIndex;
 class QNetworkAccessManager;
 class QDir;
 class QUrl;
 class TaggedFileSystemModel;
 class FileProxyModelIterator;
 class TrackDataModel;
 class ConfigStore;
 class PlaylistConfig;
 class PlaylistModel;
 class TaggedFile;
 class IFrameEditor;
 class ServerImporter;
 class ServerTrackImporter;
 class ITaggedFileFactory;
 class TextExporter;
 class BatchImportProfile;
 class Kid3ApplicationTagContext;
 class IAbortable;
 class ICorePlatformTools;
 class IUserCommandProcessor;
 class ImageDataProvider;
 class FileFilter;
 
 /**
  * Kid3 application logic, independent of GUI.
  */
 class KID3_CORE_EXPORT Kid3Application : public QObject {
   Q_OBJECT
   /** File proxy model. */
   Q_PROPERTY(FileProxyModel* fileProxyModel READ getFileProxyModel CONSTANT)
   /** Directory proxy model. */
   Q_PROPERTY(DirProxyModel* dirProxyModel READ getDirProxyModel CONSTANT)
   /** File selection model. */
   Q_PROPERTY(QItemSelectionModel* fileSelectionModel READ getFileSelectionModel CONSTANT)
   /** Directory selection model. */
   Q_PROPERTY(QItemSelectionModel* dirSelectionModel READ getDirSelectionModel CONSTANT)
   /** Information about selected tagged files. */
   Q_PROPERTY(TaggedFileSelection* selectionInfo READ selectionInfo CONSTANT)
   /** Root index of opened directory in file proxy model. */
   Q_PROPERTY(QModelIndex fileRootIndex READ getRootIndex NOTIFY fileRootIndexChanged)
   /** Root index of opened directory in directory proxy model. */
   Q_PROPERTY(QModelIndex dirRootIndex READ getDirRootIndex NOTIFY dirRootIndexChanged)
   /** Directory name. */
   Q_PROPERTY(QString dirName READ getDirName NOTIFY dirNameChanged)
   /** Modification state. */
   Q_PROPERTY(bool modified READ isModified NOTIFY modifiedChanged)
   /** Filtered state. */
   Q_PROPERTY(bool filtered READ isFiltered WRITE setFiltered NOTIFY filteredChanged)
   /** Number of files which have passed the filter. */
   Q_PROPERTY(int filterPassedCount READ filterPassedCount NOTIFY fileFiltered)
   /** Total number of files checked by filter. */
   Q_PROPERTY(int filterTotalCount READ filterTotalCount NOTIFY fileFiltered)
   /** Frame editor. */
   Q_PROPERTY(FrameEditorObject* frameEditor READ frameEditor WRITE setFrameEditor
              NOTIFY frameEditorChanged)
   /** ID to get cover art image. */
   Q_PROPERTY(QString coverArtImageId READ coverArtImageId
              NOTIFY coverArtImageIdChanged)
   /** Directory renamer. */
   Q_PROPERTY(DirRenamer* dirRenamer READ getDirRenamer CONSTANT)
   /** Batch importer. */
   Q_PROPERTY(BatchImporter* batchImporter READ getBatchImporter CONSTANT)
   /** Download client */
   Q_PROPERTY(DownloadClient* downloadClient READ getDownloadClient CONSTANT)
   Q_FLAGS(NumberTrackOption NumberTrackOptions)
 public:
   /** Destination for downloadImage(). */
   enum DownloadImageDestination {
     ImageForSelectedFiles,         /**< only for current file */
     ImageForAllFilesInDirectory, /**< for all files in directory */
     ImageForImportTrackData      /**< for enabled files in m_trackDataModel */
   };
 
   /** Options for numberTracks(). */
   enum NumberTrackOption {
     NumberTracksEnabled = 1,                     /**< Enable track numbering */
     NumberTracksResetCounterForEachDirectory = 2 /**< Reset counter */
   };
   Q_DECLARE_FLAGS(NumberTrackOptions, NumberTrackOption)
 
   /**
    * Constructor.
    * @param platformTools platform tools
    * @param parent parent object
    */
   explicit Kid3Application(ICorePlatformTools* platformTools,
                            QObject* parent = nullptr);
 
   /**
    * Destructor.
    */
   ~Kid3Application() override;
 
 #ifdef HAVE_QTDBUS
   /**
    * Activate the D-Bus interface.
    * This method shall be called only once at initialization.
    */
   void activateDbusInterface();
 #endif
 
   /**
    * Get platform tools.
    * @return platform tools.
    */
   ICorePlatformTools* getPlatformTools() { return m_platformTools; }
 
  /**
   * Get file system model.
   * @return file system model.
   */
   TaggedFileSystemModel* getFileSystemModel() { return m_fileSystemModel; }
 
  /**
   * Get file proxy model.
   * @return file proxy model.
   */
   FileProxyModel* getFileProxyModel() { return m_fileProxyModel; }
 
   /**
   * Get file proxy model iterator.
   * @return file proxy model iterator.
    */
   FileProxyModelIterator* getFileProxyModelIterator() {
     return m_fileProxyModelIterator;
   }
 
  /**
   * Get directory proxy model.
   * @return directory proxy model.
   */
   DirProxyModel* getDirProxyModel() { return m_dirProxyModel; }
 
  /**
   * Get track data model.
   * @return track data model.
   */
   TrackDataModel* getTrackDataModel() { return m_trackDataModel; }
 
   /**
    * Get selection model of files.
    */
   QItemSelectionModel* getFileSelectionModel() { return m_fileSelectionModel; }
 
   /**
    * Get selection model of directories.
    */
   QItemSelectionModel* getDirSelectionModel() { return m_dirSelectionModel; }
 
   /**
    * Store index of directory from where "directory up" (..) is activated.
    * This directory will then be selected in the new (parent) directory.
    *
    * @param index model index of target directory entered when going up
    */
   void setDirUpIndex(const QPersistentModelIndex& index) {
     m_dirUpIndex = index;
   }
 
   /**
    * Get genre model.
    * @param tagNr tag number
    * @return genre model.
    */
   GenreModel*  genreModel(Frame::TagNumber tagNr) const { return m_genreModel[tagNr]; }
 
   /**
    * Get frame table model.
    * @param tagNr tag number
    * @return frame table.
    */
   FrameTableModel* frameModel(Frame::TagNumber tagNr) { return m_framesModel[tagNr]; }
 
   /**
    * Get selection model of frame table model.
    * @param tagNr tag number
    * @return selection model.
    */
   QItemSelectionModel* getFramesSelectionModel(Frame::TagNumber tagNr) {
     return m_framesSelectionModel[tagNr];
   }
 
   /**
    * Get frame list.
    * @param tagNr tag number
    * @return frame list.
    */
   FrameList* getFrameList(Frame::TagNumber tagNr) { return m_framelist[tagNr]; }
 
   /**
    * Get settings.
    * @return settings.
    */
   ISettings* getSettings() const;
 
   /**
    * Get download client.
    * @return download client.
    */
   DownloadClient* getDownloadClient() { return m_downloadClient; }
 
   /**
    * Get text exporter.
    * @return text exporter.
    */
   TextExporter* getTextExporter() { return m_textExporter; }
 
   /**
    * Get available server importers.
    * @return list of server importers.
    */
   QList<ServerImporter*> getServerImporters() { return m_importers; }
 
   /**
    * Get names of available server track importers.
    * @return list of server track importer names.
    */
   Q_INVOKABLE QStringList getServerImporterNames() const;
 
   /**
    * Get available server track importers.
    * @return list of server track importers.
    */
   QList<ServerTrackImporter*> getServerTrackImporters() {
     return m_trackImporters;
   }
 
   /**
    * Get available user command processors.
    * @return list of user command processors.
    */
   QList<IUserCommandProcessor*> getUserCommandProcessors() {
     return m_userCommandProcessors;
   }
 
   /**
    * Get tag searcher.
    * @return tag searcher.
    */
   TagSearcher* getTagSearcher() const { return m_tagSearcher; }
 
   /**
    * Get directory renamer.
    * @return directory renamer.
    */
   DirRenamer* getDirRenamer() { return m_dirRenamer; }
 
   /**
    * Get batch importer.
    * @return batch importer.
    */
   BatchImporter* getBatchImporter() { return m_batchImporter; }
 
   /**
    * Get audio player.
    * This method will create an audio player if it does not already exist.
    * The returned audio player can be deleted after this call, so objects which
    * hold a pointer must be deleted before deleteAudioPlayer() is called!
    * @return audio player.
    */
   Q_INVOKABLE QObject* getAudioPlayer();
 
   /**
    * Get context for tag.
    * @param tagNr tag number
    * @return tag context.
    */
   Q_INVOKABLE Kid3ApplicationTagContext* tag(Frame::TagNumber tagNr) const {
     return m_tagContext[tagNr];
   }
 
   /**
    * Get current index in file proxy model or root index if current index is
    * invalid.
    * @return current index, root index if not valid.
    */
   QModelIndex currentOrRootIndex() const;
 
   /**
    * Apply configuration changes.
    */
   Q_INVOKABLE void applyChangedConfiguration();
 
   /**
    * Save settings to the configuration.
    */
   Q_INVOKABLE void saveConfig();
 
   /**
    * Read settings from the configuration.
    */
   Q_INVOKABLE void readConfig();
 
   /**
    * Open directory.
    * When finished directoryOpened() is emitted, also if false is returned.
    *
    * @param paths file or directory paths, if multiple paths are given, the
    * common directory is opened and the files are selected
    * @param fileCheck if true, only open directory if paths exist
    *
    * @return true if ok.
    */
   Q_INVOKABLE bool openDirectory(const QStringList& paths, bool fileCheck = false);
 
   /**
    * Get root index of opened directory in file proxy model.
    * @return index of directory root.
    */
   QPersistentModelIndex getRootIndex() const {
     return m_fileProxyModelRootIndex;
   }
 
   /**
    * Get root index of opened directory in directory proxy model.
    * @return index of directory root.
    */
   QPersistentModelIndex getDirRootIndex() const {
     return m_dirProxyModelRootIndex;
   }
 
   /**
    * Get directory path of opened directory.
    * @return directory path.
    */
   QString getDirPath() const;
 
   /**
    * Handle drop of URLs.
    *
    * @param urlList picture, tagged file and folder URLs to handle (if local)
    * @param isInternal true if this is an internal drop
    */
   void dropUrls(const QList<QUrl>& urlList, bool isInternal);
 
   /**
    * Open directory after resetting the file system model.
    * When finished directoryOpened() is emitted, also if false is returned.
    *
    * @param paths file or directory paths, if multiple paths are given, the
    * common directory is opened and the files are selected, if empty, the
    * currently open directory is reopened
    *
    * @return true if ok.
    */
   bool openDirectoryAfterReset(const QStringList& paths = QStringList());
 
   /**
    * Save all changed files.
    * longRunningOperationProgress() is emitted while saving files.
    *
    * @param errorDescriptions if not NULL, a list with error descriptions
    * corresponding to the errored files in the returned file list
    * is returned here. Null strings are used where no error description
    * is available.
    *
    * @return list of files with error, empty if ok.
    */
   QStringList saveDirectory(QStringList* errorDescriptions);
 
   /**
    * Save all changed files.
    * longRunningOperationProgress() is emitted while saving files.
    *
    * @return list of files with error, empty if ok.
    */
   Q_INVOKABLE QStringList saveDirectory();
 
   /**
    * Merge entries of two string lists.
    *
    * Combine two string lists to a resulting list with all strings from
    * @a leftStrs having the corresponding string from @a rightStrs appended
    * if available. A @a separator can be given to join the two parts.
    * The @a rightStrs can contain fewer elements than @a leftStrs, the
    * resulting string will then be only the element from @a leftStrs.
    * This function can be used to add details to an error message, e.g.
    * mergeStringLists(errorMsgs, errorDescriptions, ": ").
    *
    * @param leftStrs strings for left part
    * @param rightStrs strings for right part
    * @param separator separator between left and right parts
    * @return string list with combined left and right parts.
    */
   static QStringList mergeStringLists(
       const QStringList& leftStrs, const QStringList& rightStrs,
       const QString& separator);
 
   /**
    * Update tags of selected files to contain contents of frame models.
    */
   Q_INVOKABLE void frameModelsToTags();
 
   /**
    * Update frame models to contain contents of selected files.
    * The properties starting with "selection" will be set by this method.
    */
   Q_INVOKABLE void tagsToFrameModels();
 
   /**
    * Update frame models to contain contents of item selection.
    * The properties starting with "selection" will be set by this method.
    * @param selected item selection
    */
   void selectedTagsToFrameModels(const QItemSelection& selected);
 
   /**
    * Access to information about selected tagged files.
    * @return selection information.
    */
   TaggedFileSelection* selectionInfo() const { return m_selection; }
 
   /**
    * Import.
    *
    * @param tagMask tag mask
    * @param path    path of file, "clipboard" for import from clipboard
    * @param fmtIdx  index of format
    *
    * @return true if ok.
    */
   Q_INVOKABLE bool importTags(Frame::TagVersion tagMask, const QString& path,
                               int fmtIdx);
 
   /**
    * Import from tags.
    *
    * @param tagMask tag mask
    * @param source format to get source text from tags
    * @param extraction regular expression with frame names and captures to
    * extract from source text
    */
   Q_INVOKABLE void importFromTags(Frame::TagVersion tagMask,
                                   const QString& source,
                                   const QString& extraction);
 
   /**
    * Import from tags on selected files.
    *
    * @param tagMask tag mask
    * @param source format to get source text from tags
    * @param extraction regular expression with frame names and captures to
    * extract from source text
    *
    * @return extracted values for "%{__return}(.+)", empty if not used.
    */
   Q_INVOKABLE QStringList importFromTagsToSelection(Frame::TagVersion tagMask,
                                                     const QString& source,
                                                     const QString& extraction);
 
   /**
    * Export.
    *
    * @param tagVersion tag version
    * @param path   path of file, "clipboard" for export to clipboard
    * @param fmtIdx index of format
    *
    * @return true if ok.
    */
   Q_INVOKABLE bool exportTags(Frame::TagVersion tagVersion,
                               const QString& path, int fmtIdx);
 
   /**
    * Write playlist according to playlist configuration.
    *
    * @param cfg playlist configuration to use
    *
    * @return true if ok.
    */
   bool writePlaylist(const PlaylistConfig& cfg);
 
   /**
    * Write empty playlist.
    * @param cfg playlist configuration to use
    * @param fileName file name for playlist
    * @return true if ok.
    */
   bool writeEmptyPlaylist(const PlaylistConfig& cfg, const QString& fileName);
 
   /**
    * Write playlist using current playlist configuration.
    *
    * @return true if ok.
    */
   Q_INVOKABLE bool writePlaylist();
 
   /**
    * Get items of a playlist.
    * @param path path to playlist file
    * @return list of absolute paths to playlist items.
    */
   Q_INVOKABLE QStringList getPlaylistItems(const QString& path);
 
   /**
    * Set items of a playlist.
    * @param path path to playlist file
    * @param items list of absolute paths to playlist items
    * @return true if ok, false if not all @a items were found and added or
    *         saving failed.
    */
   Q_INVOKABLE bool setPlaylistItems(const QString& path, const QStringList& items);
 
   /**
    * Get playlist model for a play list file.
    * @param path path to playlist file
    * @return playlist model.
    */
   PlaylistModel* playlistModel(const QString& path);
 
   /**
    * Check if any playlist model has unsaved modifications.
    * @return true if there is a modified playlist model.
    */
   bool hasModifiedPlaylistModel() const;
 
   /**
    * Save all modified playlist models.
    */
   void saveModifiedPlaylistModels();
 
   /**
    * Perform rename actions and change application directory afterwards if it
    * was renamed.
    *
    * @return error messages, null string if no error occurred.
    */
   Q_INVOKABLE QString performRenameActions();
 
   /**
    * Reset the file system model and then try to perform the rename actions.
    * On Windows, renaming directories fails when they have a subdirectory which
    * is open in the file system model. This method can be used to retry in such
    * a situation.
    */
   void tryRenameActionsAfterReset();
 
   /**
    * Reset the file system model and then try to rename a file.
    * On Windows, renaming directories fails when they have a subdirectory which
    * is open in the file system model. This method can be used to retry in such
    * a situation.
    *
    * @param oldName old file name
    * @param newName new file name
    */
   void tryRenameAfterReset(const QString& oldName, const QString& newName);
 
   /**
    * Set the directory name from the tags.
    * The directory must not have modified files.
    * renameActionsScheduled() is emitted when the rename actions have been
    * scheduled. Then performRenameActions() has to be called to effectively
    * rename the directory.
    *
    * @param tagMask tag mask
    * @param format  directory name format
    * @param create  true to create, false to rename
    *
    * @return true if ok.
    */
   Q_INVOKABLE bool renameDirectory(Frame::TagVersion tagMask,
                        const QString& format, bool create);
 
   /**
    * Number tracks in selected files of directory.
    *
    * @param nr start number
    * @param total total number of tracks, used if >0
    * @param tagVersion determines on which tags the numbers are set
    * @param options options for numbering operation
    */
   Q_INVOKABLE void numberTracks(int nr, int total, Frame::TagVersion tagVersion,
                                 Kid3Application::NumberTrackOptions options = {});
 
   /**
    * Set track data with tagged files of directory.
    *
    * @param tagVersion tag version
    * @param trackDataList is filled with track data
    */
   void filesToTrackData(Frame::TagVersion tagVersion,
                         ImportTrackDataVector& trackDataList);
 
   /**
    * Set track data model with tagged files of directory.
    *
    * @param tagVersion tag version
    */
   void filesToTrackDataModel(Frame::TagVersion tagVersion);
 
   /**
    * Set tagged files of directory from track data model.
    *
    * @param tagVersion tags to set
    */
   void trackDataModelToFiles(Frame::TagVersion tagVersion);
 
   /**
    * Download an image file.
    *
    * @param url  URL of image
    * @param dest specifies affected files
    */
   void downloadImage(const QUrl& url, DownloadImageDestination dest);
 
   /**
    * Download an image file.
    *
    * @param url URL of image
    * @param allFilesInDir true to add the image to all files in the directory
    */
   Q_INVOKABLE void downloadImage(const QString& url, bool allFilesInDir);
 
   /**
    * Get value of frame.
    * To get binary data like a picture, the name of a file to write can be
    * added after the @a name, e.g. "Picture:/path/to/file".
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    * @param name    name of frame (e.g. "artist")
    *
    * @return value of frame.
    */
   Q_INVOKABLE QString getFrame(Frame::TagVersion tagMask,
                                const QString& name) const;
 
   /**
    * Get names and values of all frames.
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    *
    * @return map containing frame values.
    */
   Q_INVOKABLE QVariantMap getAllFrames(Frame::TagVersion tagMask) const;
 
   /**
    * Set value of frame.
    * For tag 2 (@a tagMask 2), if no frame with @a name exists, a new frame
    * is added, if @a value is empty, the frame is deleted.
    * To add binary data like a picture, a file can be added after the
    * @a name, e.g. "Picture:/path/to/file".
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    * @param name    name of frame (e.g. "artist")
    * @param value   value of frame
    *
    * @return true if ok.
    */
   Q_INVOKABLE bool setFrame(Frame::TagVersion tagMask, const QString& name,
                             const QString& value);
 
   /**
    * Get data from picture frame.
    * @return picture data, empty if not found.
    */
   Q_INVOKABLE QByteArray getPictureData() const;
 
   /**
    * Set data in picture frame.
    * @param data picture data
    */
   Q_INVOKABLE void setPictureData(const QByteArray& data);
 
   /**
    * Format frames if format while editing is switched on.
    *
    * @param frames frames
    */
   void formatFramesIfEnabled(FrameCollection& frames) const;
 
   /**
    * Add picture on drop.
    *
    * @param frame dropped picture frame
    */
   void dropImage(Frame* frame);
 
   /**
    * Handle URL on drop.
    *
    * @param url dropped URL.
    */
   void dropUrl(const QUrl& url);
 
   /**
    * Get number of tracks in current directory.
    *
    * @return number of tracks, 0 if not found.
    */
   Q_INVOKABLE int getTotalNumberOfTracksInDir() const;
 
   /**
    * Get name of selected file.
    *
    * @return absolute file name, ends with "/" if it is a directory.
    */
   QString getFileNameOfSelectedFile();
 
   /**
    * Create a filter string for the file dialog.
    * The filter string contains entries for all supported types.
    *
    * @return filter string.
    */
   Q_INVOKABLE QString createFilterString() const;
 
 
   /**
    * Remove the file filter if necessary to open the files.
    * @param filePaths paths to files or directories
    */
   void resetFileFilterIfNotMatching(const QStringList& filePaths);
 
   /**
    * Get image destination set by downloadImage().
    * @return image destination.
    */
   DownloadImageDestination getDownloadImageDestination() const {
     return m_downloadImageDest;
   }
 
   /**
    * Check modification state.
    *
    * @return true if a file is modified.
    */
   bool isModified() const;
 
   /**
    * Set filter state.
    *
    * @param val true if list is filtered
    */
   void setFiltered(bool val);
 
   /**
    * Check filter state.
    *
    * @return true if list is filtered.
    */
   bool isFiltered() const { return m_filtered; }
 
   /**
    * Get number of files which have passed the filter.
    *
    * This number is only valid if isFiltered() is true.
    *
    * @return number of files which have passed the filter.
    */
   int filterPassedCount() const { return m_filterPassed; }
 
   /**
    * Get total number of files which have been checked by the filter.
    *
    * This number is only valid if isFiltered() is true.
    *
    * @return total number of files checked by filter.
    */
   int filterTotalCount() const { return m_filterTotal; }
 
   /**
    * Get the selected file.
    *
    * @return the selected file,
    *         0 if not exactly one file is selected
    */
   TaggedFile* getSelectedFile();
 
   /**
    * Get the stored current selection.
    * @return stored selection.
    */
   const QList<QPersistentModelIndex>& getCurrentSelection() const {
     return m_currentSelection;
   }
 
   /**
    * Update the stored current selection with the list of all selected items.
    */
   void updateCurrentSelection();
 
   /**
    * Get directory name.
    * @return directory.
    */
   QString getDirName() const { return m_dirName; }
 
   /**
    * Get frame editor set with setFrameEditor().
    * @return frame editor, null if no frame editor is set
    */
   FrameEditorObject* frameEditor() const { return m_frameEditor; }
 
   /**
    * Set a frame editor object to act as the frame editor.
    * @param frameEditor frame editor object, null to disable
    */
   void setFrameEditor(FrameEditorObject* frameEditor);
 
   /**
    * Remove frame editor.
    * Has to be called in the destructor of the frame editor to avoid a dangling
    * pointer to a deleted object.
    * @param frameEditor frame editor
    */
   void removeFrameEditor(const IFrameEditor* frameEditor);
 
   /**
    * Get ID to get cover art image.
    * @return ID for cover art image.
    */
   QString coverArtImageId() const { return m_coverArtImageId; }
 
   /**
    * Set the image provider.
    * @param imageProvider image provider
    */
   void setImageProvider(ImageDataProvider* imageProvider);
 
   /**
    * Get the numbers of the selected rows in a list suitable for scripting.
    * @return list with row numbers.
    */
   Q_INVOKABLE QVariantList getFileSelectionRows() const;
 
   /**
    * Set the file selection from a list of model indexes.
    * @param indexes list of model indexes suitable for scripting
    */
   Q_INVOKABLE void setFileSelectionIndexes(const QVariantList& indexes);
 
   /**
    * Get paths to all selected files.
    * @param onlyTaggedFiles only consider tagged files
    * @return list of absolute file paths.
    */
   Q_INVOKABLE QStringList getSelectedFilePaths(bool onlyTaggedFiles = true)
   const;
 
   /**
    * Set picture data for image provider.
    * @param picture picture data
    */
   Q_INVOKABLE void setCoverArtImageData(const QByteArray& picture);
 
   /**
    * Open a file select dialog to get a file name.
    * For script support, is only supported when a GUI is available.
    * @param caption dialog caption
    * @param dir working directory
    * @param filter file type filter
    * @param saveFile true to open a save file dialog
    * @return selected file, empty if canceled.
    */
   Q_INVOKABLE QString selectFileName(
       const QString& caption = QString(), const QString& dir = QString(),
       const QString& filter = QString(), bool saveFile = false);
 
   /**
    * Open a file select dialog to get a directory name.
    * For script support, is only supported when a GUI is available.
    * @param caption dialog caption
    * @param dir working directory
    * @return selected directory, empty if canceled.
    */
   Q_INVOKABLE QString selectDirName(
       const QString& caption = QString(), const QString& dir = QString());
 
   /**
    * Check if application is running with a graphical user interface.
    * @return true if application has a GUI.
    */
   Q_INVOKABLE bool hasGui() const;
 
   /**
    * Notify the tagged file factories about the changed configuration.
    */
   static void notifyConfigurationChange();
 
   /**
    * Find directory containing plugins.
    * @param pluginsDir the plugin directory is returned here
    * @return true if found.
    */
   static bool findPluginsDirectory(QDir& pluginsDir);
 
   /**
    * Set fallback path for directory containing plugins.
    * @param path path to be searched for plugins if they are not found at the
    * standard location relative to the application directory
    */
   static void setPluginsPathFallback(const QString& path);
 
   /**
    * Load plugins.
    * @return list of plugin instances.
    */
   static QObjectList loadPlugins();
 
 public slots:
   /**
    * Open directory or add pictures on drop.
    *
    * @param paths paths of directories or files in directory
    */
   void openDrop(const QStringList& paths);
 
   /**
    * Handle drop of URLs.
    *
    * @param urlList picture, tagged file and folder URLs to handle (if local)
    */
   void openDropUrls(const QList<QUrl>& urlList);
 
   /**
    * Unload all tags.
    * The tags of all files which are not modified or selected are freed to
    * reclaim their memory.
    */
   void unloadAllTags();
 
   /**
    * Revert file modifications.
    * Acts on selected files or all files if no file is selected.
    */
   void revertFileModifications();
 
   /**
    * Set name of selected file.
    * Exactly one file has to be selected.
    *
    * @param name file name.
    */
   void setFileNameOfSelectedFile(const QString& name);
 
   /**
    * Apply filename format.
    */
   void applyFilenameFormat();
 
   /**
    * Apply tag format.
    */
   void applyTagFormat();
 
   /**
    * Apply text encoding.
    * Set the text encoding selected in the settings Tags/ID3v2/Text encoding
    * for all selected files which have an ID3v2 tag.
    */
   void applyTextEncoding();
 
   /**
    * Convert ID3v2.3 to ID3v2.4 tags.
    */
   void convertToId3v24();
 
   /**
    * Convert ID3v2.4 to ID3v2.3 tags.
    */
   void convertToId3v23();
 
   /**
    * Copy tags into copy buffer.
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    */
   void copyTags(Frame::TagVersion tagMask);
 
   /**
    * Paste from copy buffer to tags.
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    */
   void pasteTags(Frame::TagVersion tagMask);
 
   /**
    * Set tag from other tag.
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    */
   void copyToOtherTag(Frame::TagVersion tagMask);
 
   /**
    * Copy from a tag to another tag.
    * @param srcTagNr source tag number
    * @param dstTagNr destination tag number
    */
   void copyTag(Frame::TagNumber srcTagNr, Frame::TagNumber dstTagNr);
 
   /**
    * Remove tags in selected files.
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    */
   void removeTags(Frame::TagVersion tagMask);
 
   /**
    * Set tags according to filename.
    *
    * @param tagMask tag bit (1 for tag 1, 2 for tag 2)
    */
   void getTagsFromFilename(Frame::TagVersion tagMask);
 
   /**
    * Set filename according to tags.
    * If a single file is selected the tags in the GUI controls
    * are used, else the tags in the multiple selected files.
    *
    * @param tagVersion tag version
    */
   void getFilenameFromTags(Frame::TagVersion tagVersion);
 
   /**
    * Edit selected frame.
    * @param tagNr tag number
    */
   void editFrame(Frame::TagNumber tagNr);
 
   /**
    * Delete selected frame.
    * @param tagNr tag number
    * @param frameName name of frame to delete, empty to delete selected frame
    * @param index 0 for first frame with @a frameName, 1 for second, etc.
    */
   void deleteFrame(Frame::TagNumber tagNr,
                    const QString& frameName = QString(), int index = 0);
 
   /**
    * Select a frame type and add such a frame to the frame list.
    * @param tagNr tag number
    */
   void selectAndAddFrame(Frame::TagNumber tagNr);
 
   /**
    * Edit a picture frame if one exists or add a new one.
    */
   void editOrAddPicture();
 
   /**
    * Add a downloaded image.
    *
    * @param data     HTTP response of download
    * @param mimeType MIME type of data
    * @param url      URL of downloaded data
    */
   void imageDownloaded(const QByteArray& data,
                        const QString& mimeType, const QString& url);
 
   /**
    * Set the first file as the current file.
    *
    * @param select true to select the file
    * @param onlyTaggedFiles only consider tagged files
    *
    * @return true if a file exists.
    */
   bool firstFile(bool select = true, bool onlyTaggedFiles = false);
 
   /**
    * Set the next file as the current file.
    *
    * @param select true to select the file
    * @param onlyTaggedFiles only consider tagged files
    *
    * @return true if a next file exists.
    */
   bool nextFile(bool select = true, bool onlyTaggedFiles = false);
 
   /**
    * Set the previous file as the current file.
    *
    * @param select true to select the file
    * @param onlyTaggedFiles only consider tagged files
    *
    * @return true if a previous file exists.
    */
   bool previousFile(bool select = true, bool onlyTaggedFiles = false);
 
   /**
    * Select or deselect the current file.
    *
    * @param select true to select the file, false to deselect it
    *
    * @return true if a current file exists.
    */
   bool selectCurrentFile(bool select = true);
 
   /**
    * Select all files.
    */
   void selectAllFiles();
 
   /**
    * Deselect all files.
    */
   void deselectAllFiles();
 
   /**
    * Select all files in the current directory.
    */
   void selectAllInDirectory();
 
   /**
    * Invert current selection.
    */
   void invertSelection();
 
   /**
    * Set a specific file as the current file.
    *
    * @param filePath path to file
    * @param select true to select the file
    *
    * @return true if file exists.
    */
   bool selectFile(const QString& filePath, bool select = true);
 
   /**
    * Fetch entries of directory if not already fetched.
    * This works like FileList::expand(), but without expanding tree view
    * items and independent of the GUI. The processing is done in the background
    * by FileSystemModel, so the fetched items are not immediately available
    * after calling this method.
    *
    * @param index index of directory item
    */
   void fetchDirectory(const QModelIndex& index);
 
   /**
    * Fetch entries of directory and toggle expanded state if GUI available.
    * @param index index of directory item
    */
   void expandDirectory(const QModelIndex& index);
 
   /**
    * Expand the whole file list if GUI available.
    */
   void requestExpandFileList();
 
   /**
    * Called when operation for requestExpandFileList() is finished.
    */
   void notifyExpandFileListFinished();
 
   /**
    * Process change of selection.
    * The GUI is signaled to update the current selection and the controls.
    * @param selected selected items
    * @param deselected deselected items
    */
   void fileSelected(const QItemSelection& selected,
                     const QItemSelection& deselected);
 
   /**
    * Search in tags for a given text.
    * @param params search parameters
    */
   void findText(const TagSearcher::Parameters& params);
 
   /**
    * Replace found text.
    * @param params search parameters
    */
   void replaceText(const TagSearcher::Parameters& params);
 
   /**
    * Replace all occurrences.
    * @param params search parameters
    */
   void replaceAll(const TagSearcher::Parameters& params);
 
   /**
    * Schedule actions to rename a directory.
    * When finished renameActionsScheduled() is emitted.
    */
   void scheduleRenameActions();
 
   /**
    * Apply a file filter.
    *
    * @param fileFilter filter to apply.
    */
   void applyFilter(FileFilter& fileFilter);
 
   /**
    * Apply a file filter.
    *
    * @param expression filter expression
    */
   void applyFilter(const QString& expression);
 
   /**
    * Abort expression file filter.
    */
   void abortFilter();
 
   /**
    * Perform a batch import for the selected directories.
    * @param profile batch import profile
    * @param tagVersion import destination tag versions
    */
   void batchImport(const BatchImportProfile& profile,
                    Frame::TagVersion tagVersion);
 
   /**
    * Perform a batch import for the selected directories.
    * @param profileName batch import profile name
    * @param tagVersion import destination tag versions
    * @return true if profile with @a profileName found.
    */
   bool batchImport(const QString& profileName, Frame::TagVersion tagVersion);
 
   /**
    * Play audio file.
    */
   void playAudio();
 
   /**
    * Show play tool bar.
    */
   void showAudioPlayer();
 
 #ifdef HAVE_QTDBUS
   /**
    * Activate the MPRIS D-Bus Interface if not already active.
    */
   void activateMprisInterface();
 
   /**
    * Deactivate the MPRIS D-Bus Interface if it is active.
    */
   void deactivateMprisInterface();
 #endif
 
   /**
    * Update state when file is about to be played.
    * @param filePath path to file
    */
   void onAboutToPlay(const QString& filePath);
 
   /**
    * Close the file handle of a tagged file.
    * @param filePath path to file
    */
   void closeFileHandle(const QString& filePath);
 
 signals:
   /**
    * Emitted when the file proxy model root index changes.
    * @param index new root index
    */
   void fileRootIndexChanged(const QModelIndex& index);
 
   /**
    * Emitted when the directory proxy model root index changes.
    * @param index new root index
    */
   void dirRootIndexChanged(const QModelIndex& index);
 
   /**
    * Emitted when the directory has been opened, the file and directory proxy
    * model root indexes changed and the selection updated.
    */
   void directoryOpened();
 
   /**
    * Emitted when a confirmed opening of a directory or file is requested.
    * @param paths directory or file paths
    */
   void confirmedOpenDirectoryRequested(const QStringList& paths);
 
   /**
    * Emitted before an operation on the selected files is performed.
    * The GUI should update the files of the current selection when
    * receiving this signal.
    */
   void fileSelectionUpdateRequested();
 
   /**
    * Emitted after an operation on the selected files has been performed.
    * The GUI should update its controls from the tags in the files when
    * receiving this signal.
    */
   void selectedFilesUpdated();
 
   /**
    * Emitted after the file selection is changed.
    * The GUI should update its controls from the tags of the new file selection
    * when receiving this signal.
    * @param selected selected items
    * @param deselected deselected items
    */
   void selectedFilesChanged(const QItemSelection& selected,
                             const QItemSelection& deselected);
 
   /**
    * Emitted after a frame of a tagged file has been modified.
    * The GUI should update the corresponding controls when receiving this
    * signal.
    *
    * @param taggedFile tagged file with modified frame
    * @param tagNr tag number
    */
   void frameModified(TaggedFile* taggedFile, Frame::TagNumber tagNr);
 
   /**
    * Emitted when modification state is changed.
    * @param modified true if any file is modified
    * @see isModified()
    */
   void modifiedChanged(bool modified);
 
   /**
    * Emitted when filtered state is changed.
    * @param filtered true if file list is filtered
    * @see isFiltered(), setFiltered()
    */
   void filteredChanged(bool filtered);
 
   /**
    * Emitted when the directory name is changed.
    * @param name current directory name
    */
   void dirNameChanged(const QString& name);
 
   /**
    * Emitted when a file is filtered.
    * @param type filter event type, enum FileFilter::FilterEventType
    * @param fileName name of filtered file
    * @param passed number of files which passed the filter
    * @param total total number of files checked
    */
   void fileFiltered(int type, const QString& fileName, int passed, int total);
 
   /**
    * Emitted before an audio file is played.
    * The GUI can display a player when receiving this signal.
    */
   void aboutToPlayAudio();
 
   /**
    * Emitted when all rename actions have been scheduled.
    * @see scheduleRenameActions()
    */
   void renameActionsScheduled();
 
   /**
    * Emitted to request toggling of the expanded state of a directory in the
    * file list.
    * @param index index of directory item
    */
   void toggleExpandedRequested(const QModelIndex& index);
 
   /**
    * Emitted to request expanding of all directories in the file list.
    */
   void expandFileListRequested();
 
   /**
    * Emitted when operation requested by requestExpandFileList()
    * (signal expandFileListRequested()) is finished.
    */
   void expandFileListFinished();
 
   /**
    * Emitted when the file selection is changed.
    * @see getFileSelectionRows()
    */
   void fileSelectionChanged();
 
   /**
    * Emitted when a new cover art image is available
    * @param id ID of image.
    */
   void coverArtImageIdChanged(const QString& id);
 
   /**
    * Emitted when the frame editor is changed.
    */
   void frameEditorChanged();
 
   /**
    * Emitted to report progress about a long running operation.
    *
    * This signal is used to report different states of a long running operation.
    * - Operation is started: done is -1,
    * - Operation is finished: done == total and total is not 0,
    * - Operation in progress: done < total or both done and total are 0
    *
    * @param name name of operation
    * @param done amount of work done
    * @param total total amount of work
    * @param abort if not 0, can be set to true to abort the operation
    */
   void longRunningOperationProgress(const QString& name, int done, int total,
                                     bool* abort);
 
 private slots:
   /**
    * Apply file filter after the file system model has been reset.
    */
   void applyFilterAfterReset();
 
   /**
    * Apply single file to file filter.
    *
    * @param index index of file in file proxy model
    */
   void filterNextFile(const QPersistentModelIndex& index);
 
   /**
    * Apply single file to batch import.
    *
    * @param index index of file in file proxy model
    */
   void batchImportNextFile(const QPersistentModelIndex& index);
 
   /**
    * Schedule rename action for a file.
    *
    * @param index index of file in file proxy model
    */
   void scheduleNextRenameAction(const QPersistentModelIndex& index);
 
   /**
    * Perform rename actions after the file system model has been reset.
    */
   void performRenameActionsAfterReset();
 
   /**
    * Rename after the file system model has been reset.
    */
   void renameAfterReset();
 
   /**
    * Update selection and emit signals when directory is opened.
    */
   void onDirectoryOpened();
 
   /**
    * Called when the gatherer thread has finished to load the directory.
    */
   void onDirectoryLoaded();
 
   /**
    * Called when a frame is edited.
    * @param frame edited frame, 0 if canceled
    */
   void onFrameEdited(const Frame* frame);
 
   /**
    * Called when a frame is added.
    * @param frame added frame, 0 if canceled
    * @param tagNr tag number used if slot is not invoked by framelist signal
    */
   void onFrameAdded(const Frame* frame, Frame::TagNumber tagNr = Frame::Tag_2);
 
   /**
    * Called by framelist when a frame is added.
    * Same as onFrameAdded() with default argument, provided for functor-based
    * connections.
    * @param frame added frame, 0 if canceled
    */
   void onTag2FrameAdded(const Frame* frame);
 
   /**
    * If an image provider is used, update its picture and change the
    * coverArtImageId property if the picture of the selection changed.
    * This can be used to change a QML image.
    */
   void updateCoverArtImageId();
 
   /**
    * Save config when suspended, check intents when activated.
    * @param state application state
    */
   void onApplicationStateChanged(Qt::ApplicationState state);
 
 private:
   /**
    * Load and initialize plugins depending on configuration.
    */
   void initPlugins();
 
   /**
    * Check type of a loaded plugin and register it.
    * @param plugin instance returned by plugin loader
    */
   void checkPlugin(QObject* plugin);
 
   /**
    * Update frame models to contain contents of selected files.
    * @param indexes tagged file indexes
    * @param startSelection true if a new selection is started, false to add to
    * the existing selection
    * @return true if ok, false if selection operation is already running.
    */
   bool addTaggedFilesToSelection(
       const QList<QPersistentModelIndex>& indexes, bool startSelection);
 
   /**
    * Select a frame type and add such a frame to frame list.
    * @param tagNr tag number
    * @param frame frame to add, if 0 the user has to select and edit the frame
    * @param edit if true and a frame is set, the user can edit the frame before
    * it is added
    */
   void addFrame(Frame::TagNumber tagNr, const Frame* frame, bool edit = false);
 
   /**
    * Open directory or add pictures on drop.
    *
    * @param paths paths of directories or files in directory
    * @param isInternal true if this is an internal drop
    */
   void dropLocalFiles(const QStringList& paths, bool isInternal);
 
   /**
    * Second stage for applyFilter().
    */
   void proceedApplyingFilter();
 
   /**
    * Set the coverArtImageId property to a new value.
    * This can be used to trigger an update of QML images.
    */
   void setNextCoverArtImageId();
 
   void setAllFilesFileFilter();
 
   ICorePlatformTools* m_platformTools;
   /** Configuration */
   QScopedPointer<ConfigStore> m_configStore;
   /** model of filesystem */
   TaggedFileSystemModel* m_fileSystemModel;
   FileProxyModel* m_fileProxyModel;
   FileProxyModelIterator* m_fileProxyModelIterator;
   DirProxyModel* m_dirProxyModel;
   QItemSelectionModel* m_fileSelectionModel;
   QItemSelectionModel* m_dirSelectionModel;
   /** Track data model */
   TrackDataModel* m_trackDataModel;
   GenreModel* m_genreModel[Frame::Tag_NumValues];
   FrameTableModel* m_framesModel[Frame::Tag_NumValues];
   QItemSelectionModel* m_framesSelectionModel[Frame::Tag_NumValues];
   QMap<QString, PlaylistModel*> m_playlistModels;
   /** Frame list */
   FrameList* m_framelist[Frame::Tag_NumValues];
   /** Tag context */
   Kid3ApplicationTagContext* m_tagContext[Frame::Tag_NumValues];
   /** Network access manager */
   QNetworkAccessManager* m_netMgr;
   /** Download client */
   DownloadClient* m_downloadClient;
   /** Text exporter */
   TextExporter* m_textExporter;
   /** Tag searcher */
   TagSearcher* m_tagSearcher;
   /** Directory renamer */
   DirRenamer* m_dirRenamer;
   /** Batch importer */
   BatchImporter* m_batchImporter;
   /** Audio player */
   QObject* m_player;
 #ifdef HAVE_QTDBUS
   QString m_mprisServiceName;
 #endif
   FileFilter* m_expressionFileFilter;
   /** Information about selected tagged files */
   TaggedFileSelection* m_selection;
   /** Affected files to add frame when downloading image */
   DownloadImageDestination m_downloadImageDest;
   /** Copy buffer */
   FrameCollection m_copyTags;
   /** Root index in file proxy model */
   QPersistentModelIndex m_fileProxyModelRootIndex;
   /** Root index in directory proxy model */
   QPersistentModelIndex m_dirProxyModelRootIndex;
   /** Indexes of opened file in file proxy model */
   QList<QPersistentModelIndex> m_fileProxyModelFileIndexes;
   /** Importers for different servers */
   QList<ServerImporter*> m_importers;
   /** Importer for MusicBrainz fingerprints */
   QList<ServerTrackImporter*> m_trackImporters;
   /** Processors for user commands */
   QList<IUserCommandProcessor*> m_userCommandProcessors;
   /** Current directory */
   QString m_dirName;
   /** Stored current selection with the list of all selected items */
   QList<QPersistentModelIndex> m_currentSelection;
   /** directory from where "directory up" (..) was activated. */
   QPersistentModelIndex m_dirUpIndex;
 
   /* Context for filterNextFile() */
   FileFilter* m_fileFilter;
   QString m_lastProcessedDirName;
   int m_filterPassed;
   int m_filterTotal;
   /* Context for batchImportNextFile() */
   QScopedPointer<BatchImportProfile> m_namedBatchImportProfile;
   const BatchImportProfile* m_batchImportProfile;
   Frame::TagVersion m_batchImportTagVersion;
   QList<ImportTrackDataVector> m_batchImportAlbums;
   ImportTrackDataVector m_batchImportTrackDataList;
 
   /* Context for renameAfterReset() */
   QString m_renameAfterResetOldName;
   QString m_renameAfterResetNewName;
 
   /* Context for editFrame() */
   TaggedFile* m_editFrameTaggedFile;
   QString m_editFrameName;
 
   /* Context for addFrame() */
   TaggedFile* m_addFrameTaggedFile;
 
   /* Support for frame editor object */
   FrameEditorObject* m_frameEditor;
   IFrameEditor* m_storedFrameEditor;
   /* Support for image provider */
   ImageDataProvider* m_imageProvider;
   QString m_coverArtImageId;
 
 #ifdef Q_OS_ANDROID
   bool m_pendingIntentsChecked;
 #endif
 #ifdef HAVE_QTDBUS
   /** true if D-Bus is enabled */
   bool m_dbusEnabled;
 #endif
   /** true if list is filtered */
   bool m_filtered;
   /** true if a selection operation is running */
   bool m_selectionOperationRunning;
 
   /** Fallback for path to search for plugins */
   static QString s_pluginsPathFallback;
 };
 
 /**
  * Facade to have a uniform interface for different tags.
  */
 class KID3_CORE_EXPORT Kid3ApplicationTagContext : public QObject {
   Q_OBJECT
   /** Genre model. */
   Q_PROPERTY(GenreModel* genreModel READ genreModel CONSTANT)
   /** Frame table model. */
   Q_PROPERTY(FrameTableModel* frameModel READ frameModel CONSTANT)
   /** Frame selection model. */
   Q_PROPERTY(QItemSelectionModel* frameSelectionModel READ frameSelectionModel CONSTANT)
   /** Frame list. */
   Q_PROPERTY(FrameList* frameList READ frameList CONSTANT)
 public:
   /**
    * Constructor.
    * @param app application
    * @param tagNr tag number
    */
   Kid3ApplicationTagContext(Kid3Application* app, Frame::TagNumber tagNr)
     : QObject(app), m_app(app), m_tagNr(tagNr),
       m_tagVersion(Frame::tagVersionFromNumber(tagNr)) {
   }
 
 public slots:
   /**
    * Copy tags into copy buffer.
    */
   void copyTags() { m_app->copyTags(m_tagVersion); }
 
   /**
    * Paste from copy buffer to tags.
    */
   void pasteTags() { m_app->pasteTags(m_tagVersion); }
 
   /**
    * Copy tags to other tags of selected files.
    */
   void copyToOtherTag() { m_app->copyToOtherTag(m_tagVersion); }
 
   /**
    * Remove tags in selected files.
    */
   void removeTags() { m_app->removeTags(m_tagVersion); }
 
   /**
    * Set tags from filename.
    */
   void getTagsFromFilename() { m_app->getTagsFromFilename(m_tagVersion); }
 
   /**
    * Set filename from tags.
    */
   void getFilenameFromTags() { m_app->getFilenameFromTags(m_tagVersion); }
 
   /**
    * Edit selected frame of tag.
    */
   void editFrame() { m_app->editFrame(m_tagNr); }
 
   /**
    * Delete selected frame from tag.
    */
   void deleteFrame() { m_app->deleteFrame(m_tagNr); }
 
   /**
    * Select a frame type and add such a frame to the frame list.
    */
   void addFrame() { m_app->selectAndAddFrame(m_tagNr); }
 
 private:
   /**
    * Get genre model.
    * @return genre model.
    */
   GenreModel* genreModel() const { return m_app->genreModel(m_tagNr); }
 
   /**
    * Get frame table model.
    * @return frame table.
    */
   FrameTableModel* frameModel() { return m_app->frameModel(m_tagNr); }
 
   /**
    * Get selection model of frame table model.
    */
   QItemSelectionModel* frameSelectionModel() {
     return m_app->getFramesSelectionModel(m_tagNr);
   }
 
   /**
    * Get frame list.
    */
   FrameList* frameList() { return m_app->getFrameList(m_tagNr); }
 
   Kid3Application* const m_app;
   const Frame::TagNumber m_tagNr;
   const Frame::TagVersion m_tagVersion;
 };