EQCurveReader Class Reference

Deserializer of curves from XML files. More...

#include <EqualizationCurves.h>

Inheritance diagram for EQCurveReader:

Collaboration diagram for EQCurveReader:

Public Member Functions
	EQCurveReader (EQCurveArray &curves, const TranslatableString &name, int options)
bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override
XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override
void	LoadCurves (const wxString &fileName={}, bool append=false)
Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()
virtual	~XMLTagHandler ()
virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0
virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))
virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))
virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0
void	ReadXMLEndTag (const char *tag)
void	ReadXMLContent (const char *s, int len)
XMLTagHandler *	ReadXMLChild (const char *tag)

Private Member Functions
bool	GetDefaultFileName (wxFileName &fileName)
wxString	GetPrefsPrefix ()
void	UpdateDefaultCurves (bool updateAll=false)

Private Attributes
EQCurveArray &	mCurves
const TranslatableString	mName
const int	mOptions

Detailed Description

Deserializer of curves from XML files.

Definition at line 66 of file EqualizationCurves.h.

Constructor & Destructor Documentation

EQCurveReader()

EQCurveReader::EQCurveReader ( EQCurveArray &  curves, const TranslatableString &  name, int  options  )

inline

Definition at line 68 of file EqualizationCurves.h.

      : mCurves{ curves }, mName{ name }, mOptions{ options } {}

Member Function Documentation

GetDefaultFileName()

bool EQCurveReader::GetDefaultFileName ( wxFileName &  fileName )

private

Definition at line 254 of file EqualizationCurves.cpp.

{
   // look in data dir first, in case the user has their own defaults (maybe downloaded ones)
   fileName = wxFileName( FileNames::DataDir(), wxT("EQDefaultCurves.xml") );
   if( !fileName.FileExists() )
   {  // Default file not found in the data dir.  Fall back to Resources dir.
      // See http://docs.wxwidgets.org/trunk/classwx_standard_paths.html#5514bf6288ee9f5a0acaf065762ad95d
      fileName = wxFileName( FileNames::ResourcesDir(), wxT("EQDefaultCurves.xml") );
   }
   if( !fileName.FileExists() )
   {
      // LLL:  Is there really a need for an error message at all???
      //auto errorMessage = XO("EQCurves.xml and EQDefaultCurves.xml were not found on your system.\nPlease press 'help' to visit the download page.\n\nSave the curves at %s")
      //   .Format( FileNames::DataDir() );
      //BasicUI::ShowErrorDialog( wxWidgetsWindowPlacement{ mUIParent },
      //   XO("EQCurves.xml and EQDefaultCurves.xml missing"),
      //   errorMessage, wxT("http://wiki.audacityteam.org/wiki/EQCurvesDownload"), false);
 
      // Have another go at finding EQCurves.xml in the data dir, in case 'help' helped
      fileName = wxFileName( FileNames::DataDir(), wxT("EQDefaultCurves.xml") );
   }
   return (fileName.FileExists());
}

References FileNames::DataDir(), FileNames::ResourcesDir(), and wxT().

Referenced by LoadCurves().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPrefsPrefix()

wxString EQCurveReader::GetPrefsPrefix ( )

private

Definition at line 27 of file EqualizationCurves.cpp.

{
   wxString base = wxT("/Effects/Equalization/");
   if( mOptions == kEqOptionGraphic )
      base = wxT("/Effects/GraphicEq/");
   else if( mOptions == kEqOptionCurve )
      base = wxT("/Effects/FilterCurve/");
   return base;
}

References kEqOptionCurve, kEqOptionGraphic, mOptions, and wxT().

Referenced by LoadCurves(), and UpdateDefaultCurves().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleXMLChild()

XMLTagHandler * EQCurveReader::HandleXMLChild ( const std::string_view &  tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 419 of file EqualizationCurves.cpp.

{
   if (tag == "equalizationeffect")
   {
      return this;
   }
 
   if (tag == "curve")
   {
      return this;
   }
 
   if (tag == "point")
   {
      return this;
   }
 
   return NULL;
}

HandleXMLTag()

bool EQCurveReader::HandleXMLTag ( const std::string_view &  tag, const AttributesList &  attrs  )

overridevirtual

Implements XMLTagHandler.

Definition at line 324 of file EqualizationCurves.cpp.

{
   // May want to add a version strings...
   if (tag == "equalizationeffect")
   {
      return true;
   }
 
   // Located a NEW curve
   if (tag == "curve")
   {
      // Process the attributes
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         // Create a NEW curve and name it
         if( attr == "name" )
         {
            const wxString strValue = value.ToWString();
            // check for a duplicate name and add (n) if there is one
            int n = 0;
            wxString strValueTemp = strValue;
            bool exists;
            do
            {
               exists = false;
               for(size_t i = 0; i < mCurves.size(); i++)
               {
                  if(n>0)
                     strValueTemp.Printf(wxT("%s (%d)"),strValue,n);
                  if(mCurves[i].Name == strValueTemp)
                  {
                     exists = true;
                     break;
                  }
               }
               n++;
            }
            while(exists == true);
 
            mCurves.push_back( EQCurve( strValueTemp ) );
         }
      }
 
      // Tell caller it was processed
      return true;
   }
 
   // Located a NEW point
   if(tag == "point")
   {
      // Set defaults in case attributes are missing
      double f = 0.0;
      double d = 0.0;
 
      // Process the attributes
      double dblValue;
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         // Get the frequency
         if( attr == "f" )
         {
            if (!value.TryGet(dblValue))
               return false;
            f = dblValue;
         }
         // Get the dB
         else if( attr == "d" )
         {
            if (!value.TryGet(dblValue))
               return false;
            d = dblValue;
         }
      }
 
      // Create a NEW point
      mCurves[ mCurves.size() - 1 ].points.push_back( EQPoint( f, d ) );
 
      // Tell caller it was processed
      return true;
   }
 
   // Tell caller we didn't understand the tag
   return false;
}

References mCurves, and wxT().

Here is the call graph for this function:

LoadCurves()

void EQCurveReader::LoadCurves	(	const wxString &	fileName = {},
		bool	append = false
	)

Definition at line 40 of file EqualizationCurves.cpp.

{
// We've disabled the XML management of curves.
// Just going via .cfg files now.
#ifndef LEGACY_EQ
   (void)fileName;
   (void)append;
   mCurves.clear();
   mCurves.push_back( wxT("unnamed") );   // we still need a default curve to use
#else
   // Construct normal curve filename
   //
   // LLL:  Wouldn't you know that as of WX 2.6.2, there is a conflict
   //       between wxStandardPaths and wxConfig under Linux.  The latter
   //       creates a normal file as "$HOME/.audacity", while the former
   //       expects the ".audacity" portion to be a directory.
   // MJS:  I don't know what the above means, or if I have broken it.
   wxFileName fn;
 
   if(fileName.empty()) {
      // Check if presets are up to date.
      wxString eqCurvesCurrentVersion = wxString::Format(wxT("%d.%d"), EQCURVES_VERSION, EQCURVES_REVISION);
      wxString eqCurvesInstalledVersion;
      gPrefs->Read(GetPrefsPrefix() + "PresetVersion", &eqCurvesInstalledVersion, wxT(""));
 
      bool needUpdate = (eqCurvesCurrentVersion != eqCurvesInstalledVersion);
 
      // UpdateDefaultCurves allows us to import NEW factory presets only,
      // or update all factory preset curves.
      if (needUpdate)
         UpdateDefaultCurves( UPDATE_ALL != 0 );
      fn = wxFileName( FileNames::DataDir(), wxT("EQCurves.xml") );
   }
   else
      fn = fileName; // user is loading a specific set of curves
 
   // If requested file doesn't exist...
   if( !fn.FileExists() && !GetDefaultFileName(fn) ) {
      mCurves.clear();
      /* i18n-hint: name of the 'unnamed' custom curve */
      mCurves.push_back( _("unnamed") );   // we still need a default curve to use
      return;
   }
 
   EQCurve tempCustom(wxT("temp"));
   if( append == false ) // Start from scratch
      mCurves.clear();
   else  // appending so copy and remove 'unnamed', to replace later
   {
      tempCustom.points = mCurves.back().points;
      mCurves.pop_back();
   }
 
   // Load the curves
   XMLFileReader reader;
   const wxString fullPath{ fn.GetFullPath() };
   if( !reader.Parse( this, fullPath ) )
   {
      /* i18n-hint: EQ stands for 'Equalization'.*/
      auto msg = XO("Error Loading EQ Curves from file:\n%s\nError message says:\n%s")
         .Format( fullPath, reader.GetErrorStr() );
      // Inform user of load failure
      using namespace BasicUI;
      ShowMessageBox(msg, MessageBoxOptions{}.IconStyle(Icon::Error));
      mCurves.push_back( _("unnamed") );  // we always need a default curve to use
      return;
   }
 
   // Move "unnamed" to end, if it exists in current language.
   int numCurves = mCurves.size();
   int curve;
   EQCurve tempUnnamed(wxT("tempUnnamed"));
   for( curve = 0; curve < numCurves-1; curve++ )
   {
      if( mCurves[curve].Name == _("unnamed") )
      {
         tempUnnamed.points = mCurves[curve].points;
         mCurves.erase(mCurves.begin() + curve);
         mCurves.push_back( _("unnamed") );   // add 'unnamed' back at the end
         mCurves.back().points = tempUnnamed.points;
      }
   }
 
   if( mCurves.back().Name != _("unnamed") )
      mCurves.push_back( _("unnamed") );   // we always need a default curve to use
   if( append == true )
   {
      mCurves.back().points = tempCustom.points;
   }
#endif
   return;
}

References _, audacity::cloud::audiocom::anonymous_namespace{OAuthService.cpp}::append(), FileNames::DataDir(), EQCURVES_REVISION, EQCURVES_VERSION, fn, GetDefaultFileName(), XMLFileReader::GetErrorStr(), GetPrefsPrefix(), gPrefs, BasicUI::MessageBoxOptions::IconStyle(), mCurves, XMLFileReader::Parse(), EQCurve::points, audacity::BasicSettings::Read(), BasicUI::ShowMessageBox(), UPDATE_ALL, UpdateDefaultCurves(), wxT(), and XO().

Here is the call graph for this function:

UpdateDefaultCurves()

void EQCurveReader::UpdateDefaultCurves ( bool  updateAll = false )

private

Definition at line 136 of file EqualizationCurves.cpp.

{
   if (mCurves.size() == 0)
      return;
 
   wxString unnamed = wxT("unnamed");
 
   // Save the "unnamed" curve and remove it so we can add it back as the final curve.
   EQCurve userUnnamed(wxT("temp"));
   userUnnamed = mCurves.back();
   mCurves.pop_back();
 
   EQCurveArray userCurves = mCurves;
   mCurves.clear();
   // We only wamt to look for the shipped EQDefaultCurves.xml
   wxFileName fn = wxFileName(FileNames::ResourcesDir(), wxT("EQDefaultCurves.xml"));
   wxLogDebug(wxT("Attempting to load EQDefaultCurves.xml from %s"),fn.GetFullPath());
   XMLFileReader reader;
 
   if(!reader.Parse(this, fn.GetFullPath())) {
      wxLogError(wxT("EQDefaultCurves.xml could not be read."));
      return;
   }
   else {
      wxLogDebug(wxT("Loading EQDefaultCurves.xml successful."));
   }
 
   EQCurveArray defaultCurves = mCurves;
   mCurves.clear(); // clear now so that we can sort then add back.
 
   // Remove "unnamed" if it exists.
   if (defaultCurves.back().Name == unnamed) {
      defaultCurves.pop_back();
   }
   else {
      wxLogError(wxT("Error in EQDefaultCurves.xml"));
   }
 
   int numUserCurves = userCurves.size();
   int numDefaultCurves = defaultCurves.size();
   EQCurve tempCurve(wxT("test"));
 
   if (updateAll) {
      // Update all factory preset curves.
      // Sort and add factory defaults first;
      mCurves = defaultCurves;
      std::sort(mCurves.begin(), mCurves.end());
      // then add remaining user curves:
      for (int curveCount = 0; curveCount < numUserCurves; curveCount++) {
         bool isCustom = true;
         tempCurve = userCurves[curveCount];
         // is the name in the default set?
         for (int defCurveCount = 0; defCurveCount < numDefaultCurves; defCurveCount++) {
            if (tempCurve.Name == mCurves[defCurveCount].Name) {
               isCustom = false;
               break;
            }
         }
         // if tempCurve is not in the default set, add it to mCurves.
         if (isCustom) {
            mCurves.push_back(tempCurve);
         }
      }
   }
   else {
      // Import NEW factory defaults but retain all user modified curves.
      for (int defCurveCount = 0; defCurveCount < numDefaultCurves; defCurveCount++) {
         bool isUserCurve = false;
         // Add if the curve is in the user's set (preserve user's copy)
         for (int userCurveCount = 0; userCurveCount < numUserCurves; userCurveCount++) {
            if (userCurves[userCurveCount].Name == defaultCurves[defCurveCount].Name) {
               isUserCurve = true;
               mCurves.push_back(userCurves[userCurveCount]);
               break;
            }
         }
         if (!isUserCurve) {
            mCurves.push_back(defaultCurves[defCurveCount]);
         }
      }
      std::sort(mCurves.begin(), mCurves.end());
      // now add the rest of the user's curves.
      for (int userCurveCount = 0; userCurveCount < numUserCurves; userCurveCount++) {
         bool isDefaultCurve = false;
         tempCurve = userCurves[userCurveCount];
         for (int defCurveCount = 0; defCurveCount < numDefaultCurves; defCurveCount++) {
            if (tempCurve.Name == defaultCurves[defCurveCount].Name) {
               isDefaultCurve = true;
               break;
            }
         }
         if (!isDefaultCurve) {
            mCurves.push_back(tempCurve);
         }
      }
   }
   defaultCurves.clear();
   userCurves.clear();
 
   // Add back old "unnamed"
   if(userUnnamed.Name == unnamed) {
      mCurves.push_back( userUnnamed );   // we always need a default curve to use
   }
 
   EQCurveWriter{ mCurves }.SaveCurves();
 
   // Write current EqCurve version number
   // TODO: Probably better if we used pluginregistry.cfg
   wxString eqCurvesCurrentVersion = wxString::Format(wxT("%d.%d"), EQCURVES_VERSION, EQCURVES_REVISION);
   gPrefs->Write(GetPrefsPrefix()+"PresetVersion", eqCurvesCurrentVersion);
   gPrefs->Flush();
 
   return;
}

References EQCURVES_REVISION, EQCURVES_VERSION, audacity::BasicSettings::Flush(), fn, GetPrefsPrefix(), gPrefs, mCurves, EQCurve::Name, XMLFileReader::Parse(), FileNames::ResourcesDir(), audacity::BasicSettings::Write(), and wxT().

Referenced by LoadCurves().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mCurves

EQCurveArray& EQCurveReader::mCurves

private

Definition at line 84 of file EqualizationCurves.h.

Referenced by HandleXMLTag(), LoadCurves(), and UpdateDefaultCurves().

mName

const TranslatableString EQCurveReader::mName

private

Definition at line 85 of file EqualizationCurves.h.

mOptions

const int EQCurveReader::mOptions

private

Definition at line 86 of file EqualizationCurves.h.

Referenced by GetPrefsPrefix().

---

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

• EqualizationCurves.h
• EqualizationCurves.cpp