Import.h

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  Import.h
 
  Dominic Mazzoni
 
**********************************************************************/
 
#ifndef _IMPORT_
#define _IMPORT_
 
#include "ImportForwards.h"
#include "Identifier.h"
#include <vector>
#include <wx/tokenzr.h> // for enum wxStringTokenizerMode
 
#include "FileNames.h" // for FileType
 
#include "Registry.h"
 
class wxArrayString;
class AudacityProject;
class Tags;
class WaveTrackFactory;
class Track;
class TrackList;
class ImportPlugin;
class ImportProgressListener;
class UnusableImportPlugin;
typedef bool (*progress_callback_t)( void *userData, float percent );
 
class ExtImportItem;
class WaveTrack;
 
using ExtImportItems = std::vector<std::unique_ptr<ExtImportItem>>;
using TrackHolders = std::vector<std::shared_ptr<TrackList>>;
 
class ExtImportItem
{
  public:
  wxArrayString filters;
 
  int divider;
 
  std::vector<ImportPlugin*> filter_objects;
 
  wxArrayString extensions;
 
  wxArrayString mime_types;
};
 
class IMPORT_EXPORT_API Importer {
   struct ImporterItem;
public:
 
   // Objects of this type are statically constructed in files implementing
   // subclasses of ImportPlugin
   struct IMPORT_EXPORT_API RegisteredImportPlugin final
      : Registry::RegisteredItem<ImporterItem>
   {
      RegisteredImportPlugin(
         const Identifier &id, // an internal string naming the plug-in
         std::unique_ptr<ImportPlugin>,
         const Registry::Placement &placement = { wxEmptyString, {} } );
   };
 
   // Objects of this type are statically constructed in files, to identify
   // unsupported import formats; typically in a conditional compilation
   struct RegisteredUnusableImportPlugin{
      RegisteredUnusableImportPlugin( std::unique_ptr<UnusableImportPlugin> );
   };
 
   Importer();
   ~Importer();
 
   Importer( const Importer& ) = delete;
   Importer &operator=( Importer& ) = delete;
 
   static Importer & Get();
 
   bool Initialize();
   bool Terminate();
 
   FileNames::FileTypes
   GetFileTypes( const FileNames::FileType &extraType = {} );
 
   static void
   SetLastOpenType( const FileNames::FileType &type );
 
   static void
   SetDefaultOpenType( const FileNames::FileType &type );
 
   static size_t
   SelectDefaultOpenType( const FileNames::FileTypes &fileTypes );
 
   void ReadImportItems();
 
   void WriteImportItems();
 
   void StringToList(wxString &str, wxString &delims, wxArrayString &list, wxStringTokenizerMode mod = wxTOKEN_RET_EMPTY_ALL);
 
   ExtImportItems &GetImportItems() { return mExtImportItems; }
 
    std::unique_ptr<ExtImportItem> CreateDefaultImportItem();
 
   // if false, the import failed and errorMessage will be set.
   bool Import( AudacityProject &project,
              const FilePath &fName,
              ImportProgressListener* importProgressListener,
              WaveTrackFactory *trackFactory,
              TrackHolders &tracks,
              Tags *tags,
              TranslatableString &errorMessage);
 
private:
   struct Traits : Registry::DefaultTraits {
      using LeafTypes = List<ImporterItem>;
   };
   struct IMPORT_EXPORT_API ImporterItem final : Registry::SingleItem {
      static Registry::GroupItem<Traits> &Registry();
 
      ImporterItem( const Identifier &id, std::unique_ptr<ImportPlugin> pPlugin );
      ~ImporterItem();
      std::unique_ptr<ImportPlugin> mpPlugin;
   };
 
   static Importer mInstance;
 
   ExtImportItems mExtImportItems;
   static ImportPluginList &sImportPluginList();
   static UnusableImportPluginList &sUnusableImportPluginList();
};
 
extern IMPORT_EXPORT_API BoolSetting NewImportingSession;
 
#endif