Importer Class Reference

Class which actually imports the auido, using functions defined in ImportPCM.cpp, ImportMP3_*.cpp, ImportOGG.cpp, ImportRawData.cpp, ImportLOF.cpp, and ImportAUP.cpp. More...

#include <Import.h>

Collaboration diagram for Importer:

Classes
struct	ImporterItem
struct	RegisteredImportPlugin
struct	RegisteredUnusableImportPlugin

Public Member Functions
	Importer ()
	~Importer ()
	Importer (const Importer &)=delete
Importer &	operator= (Importer &)=delete
bool	Initialize ()
bool	Terminate ()
FileNames::FileTypes	GetFileTypes (const FileNames::FileType &extraType={})
void	ReadImportItems ()
void	WriteImportItems ()
void	StringToList (wxString &str, wxString &delims, wxArrayString &list, wxStringTokenizerMode mod=wxTOKEN_RET_EMPTY_ALL)
ExtImportItems &	GetImportItems ()
std::unique_ptr< ExtImportItem >	CreateDefaultImportItem ()
bool	Import (AudacityProject &project, const FilePath &fName, ImportProgressListener *importProgressListener, WaveTrackFactory *trackFactory, TrackHolders &tracks, Tags *tags, TranslatableString &errorMessage)

Static Public Member Functions
static Importer &	Get ()
static void	SetLastOpenType (const FileNames::FileType &type)
static void	SetDefaultOpenType (const FileNames::FileType &type)
static size_t	SelectDefaultOpenType (const FileNames::FileTypes &fileTypes)

Static Private Member Functions
static ImportPluginList &	sImportPluginList ()
static UnusableImportPluginList &	sUnusableImportPluginList ()

Private Attributes
ExtImportItems	mExtImportItems

Static Private Attributes
static Importer	mInstance

Detailed Description

Class which actually imports the auido, using functions defined in ImportPCM.cpp, ImportMP3_*.cpp, ImportOGG.cpp, ImportRawData.cpp, ImportLOF.cpp, and ImportAUP.cpp.

Definition at line 79 of file Import.h.

Constructor & Destructor Documentation

Importer() [1/2]

Importer::Importer

(

)

Definition at line 108 of file Import.cpp.

{
}

~Importer()

Importer::~Importer

(

)

Definition at line 112 of file Import.cpp.

{
}

Importer() [2/2]

Importer::Importer ( const Importer &  )

delete

Member Function Documentation

CreateDefaultImportItem()

std::unique_ptr< ExtImportItem > Importer::CreateDefaultImportItem

(

)

Allocates NEW ExtImportItem, fills it with default data and returns a pointer to it.

Definition at line 476 of file Import.cpp.

{
   auto new_item = std::make_unique<ExtImportItem>();
   new_item->extensions.push_back(wxT("*"));
   new_item->mime_types.push_back(wxT("*"));
 
   for (const auto &importPlugin : sImportPluginList())
   {
      new_item->filters.push_back(importPlugin->GetPluginStringID());
      new_item->filter_objects.push_back(importPlugin);
   }
   new_item->divider = -1;
   return new_item;
}

References sImportPluginList(), and wxT().

Referenced by ExtImportPrefs::OnAddRule().

Here is the call graph for this function:

Here is the caller graph for this function:

Get()

Importer & Importer::Get ( )

static

Return instance reference

Definition at line 103 of file Import.cpp.

{
   return mInstance;
}

References mInstance.

Referenced by ExtImportPrefs::Commit(), ExtImportPrefs::DoOnPluginKeyDown(), ExtImportPrefs::DoOnRuleTableSelect(), ProjectFileManager::Import(), AudacityApp::InitPart2(), ExtImportPrefs::OnAddRule(), ApplyMacroDialog::OnApplyToFiles(), ExtImportPrefs::OnDelRule(), AudacityApp::OnExit(), ExtImportPrefs::OnRuleTableEdit(), ExtImportPrefs::Populate(), ExtImportPrefs::PopulateOrExchange(), ProjectFileManager::ShowOpenDialog(), ExtImportPrefs::SwapPluginRows(), and ExtImportPrefs::SwapRows().

Here is the caller graph for this function:

GetFileTypes()

FileNames::FileTypes Importer::GetFileTypes

(

const FileNames::FileType &

extraType = {}

)

Constructs a list of types, for use by file opening dialogs, that includes all supported file types

Definition at line 214 of file Import.cpp.

{
   // Construct the filter
   FileNames::FileTypes fileTypes{
      FileNames::AllFiles,
      // Will fill in the list of extensions later:
      { XO("All supported files"), {} },
      FileNames::AudacityProjects
   };
 
   if ( !extraType.extensions.empty() )
      fileTypes.push_back( extraType );
 
   FileNames::FileTypes l;
   for(const auto &importPlugin : sImportPluginList())
   {
      l.emplace_back(importPlugin->GetPluginFormatDescription(),
                               importPlugin->GetSupportedExtensions());
   }
 
   FileExtensions extraExtensions = FileNames::AudacityProjects.extensions;
   extraExtensions.insert(extraExtensions.end(),
                          extraType.extensions.begin(),
                          extraType.extensions.end());
 
   using ExtensionSet = std::unordered_set< FileExtension >;
   FileExtensions allList = FileNames::AudacityProjects.extensions, newList;
   allList.insert(allList.end(), extraType.extensions.begin(), extraType.extensions.end());
   ExtensionSet allSet{ allList.begin(), allList.end() }, newSet;
   for ( const auto &format : l ) {
      newList.clear();
      newSet.clear();
      for ( const auto &extension : format.extensions ) {
         if ( newSet.insert( extension ).second )
            newList.push_back( extension );
         if ( allSet.insert( extension ).second )
            allList.push_back( extension );
      }
      fileTypes.push_back( { format.description, newList } );
   }
 
   fileTypes[1].extensions = allList;
   return fileTypes;
}

References FileNames::AllFiles, FileNames::AudacityProjects, FileNames::FileType::extensions, anonymous_namespace{ExportPCM.cpp}::format, wxArrayStringEx::insert(), sImportPluginList(), and XO().

Referenced by ApplyMacroDialog::OnApplyToFiles(), and ProjectFileManager::ShowOpenDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

GetImportItems()

ExtImportItems & Importer::GetImportItems ( )

inline

Returns a pointer to internal items array. External objects are allowed to change the array contents.

Definition at line 164 of file Import.h.

{ return mExtImportItems; }

Referenced by ExtImportPrefs::DoOnPluginKeyDown(), ExtImportPrefs::DoOnRuleTableSelect(), ExtImportPrefs::OnAddRule(), ExtImportPrefs::OnDelRule(), ExtImportPrefs::OnRuleTableEdit(), ExtImportPrefs::PopulateOrExchange(), ExtImportPrefs::SwapPluginRows(), and ExtImportPrefs::SwapRows().

Here is the caller graph for this function:

Import()

bool Importer::Import	(	AudacityProject &	project,
		const FilePath &	fName,
		ImportProgressListener *	importProgressListener,
		WaveTrackFactory *	trackFactory,
		TrackHolders &	tracks,
		Tags *	tags,
		TranslatableString &	errorMessage
	)

Definition at line 492 of file Import.cpp.

{
   AudacityProject *pProj = &project;
   auto cleanup = valueRestorer( pProj->mbBusyImporting, true );
 
   const FileExtension extension{ fName.AfterLast(wxT('.')) };
 
   // Always refuse to import MIDI, even though the FFmpeg plugin pretends to know how (but makes very bad renderings)
#ifdef USE_MIDI
   // MIDI files must be imported, not opened
   if (FileNames::IsMidi(fName)) {
      errorMessage = XO(
"\"%s\" \nis a MIDI file, not an audio file. \nAudacity cannot open this type of file for playing, but you can\nedit it by clicking File > Import > MIDI.")
         .Format( fName );
      return false;
   }
#endif
 
   // Bug #2647: Peter has a Word 2000 .doc file that is recognized and imported by FFmpeg.
   if (wxFileName(fName).GetExt() == wxT("doc")) {
      errorMessage =
         XO("\"%s\" \nis a not an audio file. \nAudacity cannot open this type of file.")
         .Format( fName );
      return false;
   }
 
   using ImportPluginPtrs = std::vector< ImportPlugin* >;
 
   // This list is used to call plugins in correct order
   ImportPluginPtrs importPlugins;
 
   // This list is used to remember plugins that should have been compatible with the file.
   ImportPluginPtrs compatiblePlugins;
 
   // Not implemented (yet?)
   wxString mime_type = wxT("*");
 
   // First, add user-selected filter
   bool usersSelectionOverrides;
   gPrefs->Read(wxT("/ExtendedImport/OverrideExtendedImportByOpenFileDialogChoice"), &usersSelectionOverrides, false);
 
   if (usersSelectionOverrides)
   {
      // If user explicitly selected a filter,
      // then we should try importing via corresponding plugin first
      wxString type = gPrefs->Read(wxT("/LastOpenType"),wxT(""));
 
      wxLogDebug(wxT("LastOpenType is %s"),type);
      wxLogDebug(wxT("OverrideExtendedImportByOpenFileDialogChoice is %i"),usersSelectionOverrides);
 
      for (const auto &plugin : sImportPluginList())
      {
         if (plugin->GetPluginFormatDescription().Translation() == type )
         {
            // This plugin corresponds to user-selected filter, try it first.
            wxLogDebug(wxT("Inserting %s"),plugin->GetPluginStringID());
            importPlugins.insert(importPlugins.begin(), plugin);
         }
      }
   }
 
   wxLogMessage(wxT("File name is %s"), fName);
   wxLogMessage(wxT("Mime type is %s"), mime_type.Lower());
 
   for (const auto &uItem : mExtImportItems)
   {
      ExtImportItem *item = uItem.get();
      bool matches_ext = false, matches_mime = false;
      wxLogDebug(wxT("Testing extensions"));
      for (size_t j = 0; j < item->extensions.size(); j++)
      {
         wxLogDebug(wxT("%s"), item->extensions[j].Lower());
         if (wxMatchWild (item->extensions[j].Lower(),fName.Lower(), false))
         {
            wxLogDebug(wxT("Match!"));
            matches_ext = true;
            break;
         }
      }
      if (item->extensions.size() == 0)
      {
         wxLogDebug(wxT("Match! (empty list)"));
         matches_ext = true;
      }
      if (matches_ext)
         wxLogDebug(wxT("Testing mime types"));
      else
         wxLogDebug(wxT("Not testing mime types"));
      for (size_t j = 0; matches_ext && j < item->mime_types.size(); j++)
      {
         if (wxMatchWild (item->mime_types[j].Lower(),mime_type.Lower(), false))
         {
            wxLogDebug(wxT("Match!"));
            matches_mime = true;
            break;
         }
      }
      if (item->mime_types.size() == 0)
      {
         wxLogDebug(wxT("Match! (empty list)"));
         matches_mime = true;
      }
      if (matches_ext && matches_mime)
      {
         wxLogDebug(wxT("Complete match!"));
         for (size_t j = 0; j < item->filter_objects.size() && (item->divider < 0 || (int) j < item->divider); j++)
         {
            // the filter_object can be NULL if a suitable importer was not found
            // this happens when we recompile with --without-ffmpeg and there
            // is still ffmpeg in prefs from previous --with-ffmpeg builds
            if (!(item->filter_objects[j]))
               continue;
            wxLogDebug(wxT("Inserting %s"),item->filter_objects[j]->GetPluginStringID());
            importPlugins.push_back(item->filter_objects[j]);
         }
      }
   }
 
   // Add all plugins that support the extension
   for (const auto &plugin : sImportPluginList())
   {
      // Make sure its not already in the list
      if (importPlugins.end() ==
          std::find(importPlugins.begin(), importPlugins.end(), plugin))
      {
         if (plugin->SupportsExtension(extension))
         {
            wxLogDebug(wxT("Appending %s"),plugin->GetPluginStringID());
            importPlugins.push_back(plugin);
         }
      }
   }
 
   // Add remaining plugins
   for (const auto &plugin : sImportPluginList())
   {
      // Make sure its not already in the list
      if (importPlugins.end() ==
            std::find(importPlugins.begin(), importPlugins.end(), plugin))
      {
         wxLogDebug(wxT("Appending %s"),plugin->GetPluginStringID());
         importPlugins.push_back(plugin);
      }
   }
 
   ImportProgressResultProxy importResultProxy(importProgressListener);
   
   // Try the import plugins, in the permuted sequences just determined
   for (const auto plugin : importPlugins)
   {
      // Try to open the file with this plugin (probe it)
      wxLogMessage(wxT("Opening with %s"),plugin->GetPluginStringID());
      auto inFile = plugin->Open(fName, pProj);
      if ( (inFile != NULL) && (inFile->GetStreamCount() > 0) )
      {
         wxLogMessage(wxT("Open(%s) succeeded"), fName);
         if(!importResultProxy.OnImportFileOpened(*inFile))
            return false;
         
         inFile->Import(importResultProxy, trackFactory, tracks, tags);
         const auto importResult = importResultProxy.GetResult();
         if (importResult == ImportProgressListener::ImportResult::Success ||
             importResult == ImportProgressListener::ImportResult::Stopped)
         {
            // LOF ("list-of-files") has different semantics
            if (extension.IsSameAs(wxT("lof"), false))
            {
               return true;
            }
 
            // AUP ("legacy projects") have different semantics
            if (extension.IsSameAs(wxT("aup"), false))
            {
               return true;
            }
 
            auto end = tracks.end();
            auto iter = std::remove_if(tracks.begin(), end,
               [](auto &pList){ return pList->empty(); });
            if (iter != end) {
               // importer shouldn't give us empty groups of channels!
               assert(false);
               // But correct that and proceed anyway
               tracks.erase(iter, end);
            }
            if (tracks.size() > 0)
               // success!
               return true;
         }
 
         if (importResultProxy.GetResult() == ImportProgressListener::ImportResult::Cancelled)
            return false;
 
         // We could exit here since we had a match on the file extension,
         // but there may be another plug-in that can import the file and
         // that may recognize the extension, so we allow the loop to
         // continue.
      }
   }
   wxLogError(wxT("Importer::Import: Opening failed."));
 
   // None of our plugins can handle this file.  It might be that
   // Audacity supports this format, but support was not compiled in.
   // If so, notify the user of this fact
   for (const auto &unusableImportPlugin : sUnusableImportPluginList())
   {
      if( unusableImportPlugin->SupportsExtension(extension) )
      {
         errorMessage = XO("This version of Audacity was not compiled with %s support.")
            .Format( unusableImportPlugin->GetPluginFormatDescription() );
         return false;
      }
   }
 
   /* warnings for unsupported data types */
 
   if (compatiblePlugins.empty())
   {
      // if someone has sent us a .cda file, send them away
      if (extension.IsSameAs(wxT("cda"), false)) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is an audio CD track. \nAudacity cannot open audio CDs directly. \nExtract (rip) the CD tracks to an audio format that \nAudacity can import, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      // playlist type files
      if ((extension.IsSameAs(wxT("m3u"), false))||(extension.IsSameAs(wxT("ram"), false))||(extension.IsSameAs(wxT("pls"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a playlist file. \nAudacity cannot open this file because it only contains links to other files. \nYou may be able to open it in a text editor and download the actual audio files.")
            .Format( fName );
         return false;
      }
      //WMA files of various forms
      if ((extension.IsSameAs(wxT("wma"), false))||(extension.IsSameAs(wxT("asf"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a Windows Media Audio file. \nAudacity cannot open this type of file due to patent restrictions. \nYou need to convert it to a supported audio format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
      //AAC files of various forms (probably not encrypted)
      if ((extension.IsSameAs(wxT("aac"), false))||(extension.IsSameAs(wxT("m4a"), false))||(extension.IsSameAs(wxT("m4r"), false))||(extension.IsSameAs(wxT("mp4"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is an Advanced Audio Coding file.\nWithout the optional FFmpeg library, Audacity cannot open this type of file.\nOtherwise, you need to convert it to a supported audio format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
      // encrypted itunes files
      if ((extension.IsSameAs(wxT("m4p"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is an encrypted audio file. \nThese typically are from an online music store. \nAudacity cannot open this type of file due to the encryption. \nTry recording the file into Audacity, or burn it to audio CD then \nextract the CD track to a supported audio format such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
      // Real Inc. files of various sorts
      if ((extension.IsSameAs(wxT("ra"), false))||(extension.IsSameAs(wxT("rm"), false))||(extension.IsSameAs(wxT("rpm"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a RealPlayer media file. \nAudacity cannot open this proprietary format. \nYou need to convert it to a supported audio format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      // Other notes-based formats
      if ((extension.IsSameAs(wxT("kar"), false))||(extension.IsSameAs(wxT("mod"), false))||(extension.IsSameAs(wxT("rmi"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a notes-based file, not an audio file. \nAudacity cannot open this type of file. \nTry converting it to an audio file such as WAV or AIFF and \nthen import it, or record it into Audacity.")
            .Format( fName );
         return false;
      }
 
      // MusePack files
      if ((extension.IsSameAs(wxT("mp+"), false))||(extension.IsSameAs(wxT("mpc"), false))||(extension.IsSameAs(wxT("mpp"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a Musepack audio file. \nAudacity cannot open this type of file. \nIf you think it might be an mp3 file, rename it to end with \".mp3\" \nand try importing it again. Otherwise you need to convert it to a supported audio \nformat, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      // WavPack files
      if ((extension.IsSameAs(wxT("wv"), false))||(extension.IsSameAs(wxT("wvc"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a Wavpack audio file. \nAudacity cannot open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      // AC3 files
      if ((extension.IsSameAs(wxT("ac3"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a Dolby Digital audio file. \nAudacity cannot currently open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      // Speex files
      if ((extension.IsSameAs(wxT("spx"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is an Ogg Speex audio file. \nAudacity cannot currently open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      // Video files of various forms
      if ((extension.IsSameAs(wxT("mpg"), false))||(extension.IsSameAs(wxT("mpeg"), false))||(extension.IsSameAs(wxT("avi"), false))||(extension.IsSameAs(wxT("wmv"), false))||(extension.IsSameAs(wxT("rv"), false))) {
         errorMessage = XO(
/* i18n-hint: %s will be the filename */
"\"%s\" is a video file. \nAudacity cannot currently open this type of file. \nYou need to extract the audio to a supported format, such as WAV or AIFF.")
            .Format( fName );
         return false;
      }
 
      if( !wxFileExists(fName)){
         errorMessage = XO( "File \"%s\" not found.").Format( fName );
         return false;
      }
 
      // we were not able to recognize the file type
      TranslatableString extraMessages;
      for(const auto &importPlugin : sImportPluginList()) {
         auto message = importPlugin->FailureHint();
         if (!message.empty()) {
            extraMessages += message;
            extraMessages += Verbatim("\n");
         }
      }
 
      errorMessage = XO(
/* i18n-hint: %s will be the filename */
"Audacity did not recognize the type of the file '%s'.\n\n%sFor uncompressed files, also try File > Import > Raw Data.")
         .Format( fName, extraMessages );
   }
   else
   {
      // We DO have a plugin for this file, but import failed.
      TranslatableString pluglist;
 
      for (const auto &plugin : compatiblePlugins)
      {
         if (pluglist.empty())
           pluglist = plugin->GetPluginFormatDescription();
         else
           pluglist = XO("%s, %s")
               .Format( pluglist, plugin->GetPluginFormatDescription() );
      }
 
      errorMessage = XO(
/* i18n-hint: %s will be the filename */
"Audacity recognized the type of the file '%s'.\nImporters supposedly supporting such files are:\n%s,\nbut none of them understood this file format.")
         .Format( fName, pluglist );
   }
 
   return false;
}

References ImportProgressListener::Cancelled, ExtImportItem::divider, TranslatableString::empty(), PackedArray::end(), ExtImportItem::extensions, ExtImportItem::filter_objects, gPrefs, FileNames::IsMidi(), AudacityProject::mbBusyImporting, mExtImportItems, ExtImportItem::mime_types, project, audacity::BasicSettings::Read(), sImportPluginList(), ImportProgressListener::Stopped, ImportProgressListener::Success, sUnusableImportPluginList(), tracks, valueRestorer(), Verbatim(), wxT(), and XO().

Referenced by ProjectFileManager::Import().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

bool Importer::Initialize

(

)

Initialization/Termination

Definition at line 167 of file Import.cpp.

{
   // build the list of import plugin and/or unusableImporters.
   // order is significant.  If none match, they will all be tried
   // in the order defined here.
 
   using namespace Registry;
   static OrderingPreferenceInitializer init{
      PathStart,
      { {wxT(""), wxT("AUP,PCM,OGG,FLAC,MP3,LOF,WavPack,FFmpeg") } }
      // QT and GStreamer are only conditionally compiled and would get
      // placed at the end if present
   };
 
   static struct MyVisitor final : Visitor {
      MyVisitor()
      {
         // Once only, visit the registry to collect the plug-ins properly
         // sorted
         GroupItem<Registry::DefaultTraits> top{ PathStart };
         Registry::Visit( *this, &top, &ImporterItem::Registry() );
      }
 
      void Visit( SingleItem &item, const Path &path ) override
      {
         sImportPluginList().push_back(
            static_cast<ImporterItem&>( item ).mpPlugin.get() );
      }
   } visitor;
 
   // Ordering of the unusable plugin list is not important.
 
   ExtImportItems{}.swap(mExtImportItems);
 
   ReadImportItems();
 
   return true;
}

References mExtImportItems, anonymous_namespace{Import.cpp}::PathStart, ReadImportItems(), Importer::ImporterItem::Registry(), sImportPluginList(), Registry::Visit(), and wxT().

Referenced by AudacityApp::InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

Importer & Importer::operator= ( Importer &  )

delete

ReadImportItems()

void Importer::ReadImportItems

(

)

Reads extended import filters from gPrefs into internal list mExtImportItems

Definition at line 304 of file Import.cpp.

{
   int item_counter = 0;
   wxStringTokenizer toker;
   wxString item_name;
   wxString item_value;
 
   ExtImportItems{}.swap(mExtImportItems);
   /* Rule string format is:
    * extension1:extension2:extension3\mime_type1:mime_type2:mime_type3|filter1:filter2:filter3\unusedfilter1:unusedfilter2
    * backslashes are escaped and unescaped internally
    */
   for (item_counter = 0; true; item_counter++)
   {
      wxString condition, filters, used_filters, unused_filters, extensions, mime_types;
      item_name.Printf (wxT("/ExtImportItems/Item%d"), item_counter);
      /* Break at first non-existent item */
      if (!gPrefs->Read(item_name, &item_value))
        break;
 
      toker.SetString(item_value, wxT("|"), wxTOKEN_RET_EMPTY_ALL);
      /* Break at first broken item */
      if (toker.CountTokens() != 2)
        break;
 
      auto new_item = std::make_unique<ExtImportItem>();
 
      /* First token is the filtering condition, second - the filter list */
      condition = toker.GetNextToken();
      filters = toker.GetNextToken();
 
      /* Condition token consists of extension list and mime type list
       * mime type list can be omitted entirely (complete with '\' separator)*/
      toker.SetString(condition, wxT("\\"), wxTOKEN_RET_EMPTY_ALL);
      extensions = toker.GetNextToken();
      if (toker.HasMoreTokens())
        mime_types = toker.GetNextToken();
 
      wxString delims(wxT(":"));
      StringToList (extensions, delims, new_item->extensions);
 
      if (!mime_types.empty())
         StringToList (mime_types, delims, new_item->mime_types);
 
      /* Filter token consists of used and unused filter lists */
      toker.SetString(filters, wxT("\\"), wxTOKEN_RET_EMPTY_ALL);
      used_filters = toker.GetNextToken();
      if (toker.HasMoreTokens())
        unused_filters = toker.GetNextToken();
 
      StringToList (used_filters, delims, new_item->filters);
 
      if (!unused_filters.empty())
      {
         /* Filters are stored in one list, but the position at which
          * unused filters start is remembered
          */
         new_item->divider = new_item->filters.size();
         StringToList (unused_filters, delims, new_item->filters);
      }
      else
         new_item->divider = -1;
 
      /* Find corresponding filter object for each filter ID */
      for (size_t i = 0; i < new_item->filters.size(); i++)
      {
         bool found = false;
         for (const auto &importPlugin : sImportPluginList())
         {
            if (importPlugin->GetPluginStringID() == new_item->filters[i])
            {
               new_item->filter_objects.push_back(importPlugin);
               found = true;
               break;
            }
         }
         /* IDs that do not have corresponding filters, will be shown as-is */
         if (!found)
           new_item->filter_objects.push_back(nullptr);
      }
      /* Find all filter objects that are not present in the filter list */
      for (const auto &importPlugin : sImportPluginList())
      {
         bool found = false;
         for (size_t i = 0; i < new_item->filter_objects.size(); i++)
         {
            if (importPlugin == new_item->filter_objects[i])
            {
               found = true;
               break;
            }
         }
         /* Add these filters at the bottom of used filter list */
         if (!found)
         {
            int index = new_item->divider;
            if (new_item->divider < 0)
               index = new_item->filters.size();
            new_item->filters.insert(
               new_item->filters.begin() + index,
               importPlugin->GetPluginStringID());
            new_item->filter_objects.insert(
               new_item->filter_objects.begin() + index, importPlugin);
            if (new_item->divider >= 0)
               new_item->divider++;
         }
      }
      this->mExtImportItems.push_back( std::move(new_item) );
   }
}

References gPrefs, mExtImportItems, audacity::BasicSettings::Read(), sImportPluginList(), StringToList(), and wxT().

Referenced by Initialize(), and ExtImportPrefs::Populate().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectDefaultOpenType()

size_t Importer::SelectDefaultOpenType ( const FileNames::FileTypes &  fileTypes )

static

Choose index of preferred type

Definition at line 279 of file Import.cpp.

{
   wxString defaultValue;
   if ( !fileTypes.empty() )
      defaultValue = fileTypes[0].description.Translation();
 
   wxString type = gPrefs->Read(wxT("/DefaultOpenType"), defaultValue);
   // Convert the type to the filter index
   auto begin = fileTypes.begin();
   auto index = std::distance(
      begin,
      std::find_if( begin, fileTypes.end(),
         [&type](const FileNames::FileType &fileType){
            return fileType.description.Translation() == type; } ) );
   return (index == fileTypes.size()) ? 0 : index;
}

References PackedArray::begin(), gPrefs, audacity::BasicSettings::Read(), and wxT().

Referenced by ApplyMacroDialog::OnApplyToFiles(), and ProjectFileManager::ShowOpenDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

SetDefaultOpenType()

void Importer::SetDefaultOpenType ( const FileNames::FileType &  type )

static

Remember a file type in preferences

Definition at line 269 of file Import.cpp.

{
   // PRL:  Preference key /DefaultOpenType, unusually, stores a localized
   // string!
   // The bad consequences of a change of locale are not severe -- only that
   // a default choice of file type for an open dialog is not remembered
   gPrefs->Write(wxT("/DefaultOpenType"), type.description.Translation());
   gPrefs->Flush();
}

References FileNames::FileType::description, audacity::BasicSettings::Flush(), gPrefs, TranslatableString::Translation(), audacity::BasicSettings::Write(), and wxT().

Referenced by ProjectFileManager::ShowOpenDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastOpenType()

void Importer::SetLastOpenType ( const FileNames::FileType &  type )

static

Remember a file type in preferences

Definition at line 259 of file Import.cpp.

{
   // PRL:  Preference key /LastOpenType, unusually, stores a localized
   // string!
   // The bad consequences of a change of locale are not severe -- only that
   // a default choice of file type for an open dialog is not remembered
   gPrefs->Write(wxT("/LastOpenType"), type.description.Translation());
   gPrefs->Flush();
}

References FileNames::FileType::description, audacity::BasicSettings::Flush(), gPrefs, TranslatableString::Translation(), audacity::BasicSettings::Write(), and wxT().

Referenced by anonymous_namespace{FileMenus.cpp}::DoImport(), ProjectManager::OpenFiles(), and ProjectFileManager::ShowOpenDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

sImportPluginList()

ImportPluginList & Importer::sImportPluginList ( )

staticprivate

Definition at line 116 of file Import.cpp.

{
   static ImportPluginList theList;
   return theList;
}

Referenced by CreateDefaultImportItem(), GetFileTypes(), Import(), Initialize(), and ReadImportItems().

Here is the caller graph for this function:

StringToList()

void Importer::StringToList	(	wxString &	str,
		wxString &	delims,
		wxArrayString &	list,
		wxStringTokenizerMode	mod = wxTOKEN_RET_EMPTY_ALL
	)

Helper function - uses wxStringTokenizer to tokenize @str string and appends string-tokens to a list @list. @mod defines tokenizer's behaviour.

Definition at line 296 of file Import.cpp.

{
   wxStringTokenizer toker;
 
   for (toker.SetString(str, delims, mod);
      toker.HasMoreTokens(); list.push_back(toker.GetNextToken()));
}

References str.

Referenced by ExtImportPrefs::OnRuleTableEdit(), and ReadImportItems().

Here is the caller graph for this function:

sUnusableImportPluginList()

UnusableImportPluginList & Importer::sUnusableImportPluginList ( )

staticprivate

Definition at line 154 of file Import.cpp.

{
   static UnusableImportPluginList theList;
   return theList;
}

Referenced by Import(), and Importer::RegisteredUnusableImportPlugin::RegisteredUnusableImportPlugin().

Here is the caller graph for this function:

Terminate()

bool Importer::Terminate

(

)

Definition at line 206 of file Import.cpp.

{
   WriteImportItems();
 
   return true;
}

References WriteImportItems().

Referenced by AudacityApp::OnExit().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteImportItems()

void Importer::WriteImportItems

(

)

Writes mExtImportItems into gPrefs

Definition at line 415 of file Import.cpp.

{
   size_t i;
   wxString val, name;
   for (i = 0; i < this->mExtImportItems.size(); i++)
   {
      ExtImportItem *item = mExtImportItems[i].get();
      val.clear();
 
      for (size_t j = 0; j < item->extensions.size(); j++)
      {
         val.Append (item->extensions[j]);
         if (j < item->extensions.size() - 1)
            val.Append (wxT(":"));
      }
      val.Append (wxT("\\"));
      for (size_t j = 0; j < item->mime_types.size(); j++)
      {
         val.Append (item->mime_types[j]);
         if (j < item->mime_types.size() - 1)
            val.Append (wxT(":"));
      }
      val.Append (wxT("|"));
      for (size_t j = 0; j < item->filters.size() && ((int) j < item->divider || item->divider < 0); j++)
      {
         val.Append (item->filters[j]);
         if (j < item->filters.size() - 1 && ((int) j < item->divider - 1 || item->divider < 0))
            val.Append (wxT(":"));
      }
      if (item->divider >= 0)
      {
         val.Append (wxT("\\"));
         for (size_t j = item->divider; j < item->filters.size(); j++)
         {
            val.Append (item->filters[j]);
            if (j < item->filters.size() - 1)
               val.Append (wxT(":"));
         }
      }
      name.Printf (wxT("/ExtImportItems/Item%d"), (int)i);
      gPrefs->Write (name, val);
      gPrefs->Flush();
   }
   /* If we used to have more items than we have now, DELETE the excess items.
   We just keep deleting items and incrementing until we find there aren't any
   more to DELETE.*/
   i = this->mExtImportItems.size();
   do {
     name.Printf (wxT("/ExtImportItems/Item%d"), (int)i);
     // No item to DELETE?  Then it's time to finish.
     if (!gPrefs->Read(name, &val))
        break;
     // Failure to DELETE probably means a read-only config file.
     // no point continuing.
     // TODO: Possibly report (once).
     if( !gPrefs->DeleteEntry (name))
        break;
     i++;
   } while( true );
}

References audacity::BasicSettings::DeleteEntry(), ExtImportItem::divider, ExtImportItem::extensions, ExtImportItem::filters, audacity::BasicSettings::Flush(), gPrefs, mExtImportItems, ExtImportItem::mime_types, name, audacity::BasicSettings::Read(), audacity::BasicSettings::Write(), and wxT().

Referenced by ExtImportPrefs::Commit(), and Terminate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mExtImportItems

ExtImportItems Importer::mExtImportItems

private

Definition at line 192 of file Import.h.

Referenced by Import(), Initialize(), ReadImportItems(), and WriteImportItems().

mInstance

Importer Importer::mInstance

staticprivate

Definition at line 190 of file Import.h.

Referenced by Get().

---

The documentation for this class was generated from the following files:

• Import.h
• Import.cpp