MacroCommands Class Reference

Maintains the list of commands for batch/macro processing. See also MacrosWindow and ApplyMacroDialog. More...

#include <BatchCommands.h>

Collaboration diagram for MacroCommands:

Public Member Functions
	MacroCommands (AudacityProject &project)
AudacityProject &	GetProject ()
bool	ApplyMacro (const MacroCommandsCatalog &catalog, const wxString &filename={})
bool	ApplyCommand (const TranslatableString &friendlyCommand, const CommandID &command, const wxString &params, CommandContext const *pContext=nullptr)
bool	ApplyCommandInBatchMode (const TranslatableString &friendlyCommand, const CommandID &command, const wxString &params, CommandContext const *pContext=nullptr)
bool	ApplyEffectCommand (const PluginID &ID, const TranslatableString &friendlyCommand, const CommandID &command, const wxString &params, const CommandContext &Context)
bool	ReportAndSkip (const TranslatableString &friendlyCommand, const wxString &params)
void	AbortBatch ()
void	ResetMacro ()
void	RestoreMacro (const wxString &name)
wxString	ReadMacro (const wxString &macro, wxWindow *parent=nullptr)
wxString	WriteMacro (const wxString &macro, wxWindow *parent=nullptr)
bool	AddMacro (const wxString &macro)
bool	DeleteMacro (const wxString &name)
bool	RenameMacro (const wxString &oldmacro, const wxString &newmacro)
void	AddToMacro (const CommandID &command, int before=-1)
void	AddToMacro (const CommandID &command, const wxString &params, int before=-1)
void	DeleteFromMacro (int index)
CommandID	GetCommand (int index)
wxString	GetParams (int index)
int	GetCount ()
wxString	GetMessage ()
void	AddToMessage (const wxString &msgIn)
bool	IsFixed (const wxString &name)
void	Split (const wxString &str, wxString &command, wxString &param)
wxString	Join (const wxString &command, const wxString &param)

Static Public Member Functions
static void	MigrateLegacyChains ()
static wxArrayString	GetNames ()
static wxArrayStringEx	GetNamesOfDefaultMacros ()
static wxString	GetCurrentParamsFor (const CommandID &command)
static wxString	PromptForParamsFor (const CommandID &command, const wxString &params, AudacityProject &project)
static wxString	PromptForPresetFor (const CommandID &command, const wxString &params, wxWindow *parent)

Private Attributes
AudacityProject &	mProject
CommandIDs	mCommandMacro
wxArrayString	mParamsMacro
bool	mAbort
wxString	mMessage
wxString	mFileName

Detailed Description

Maintains the list of commands for batch/macro processing. See also MacrosWindow and ApplyMacroDialog.

Definition at line 60 of file BatchCommands.h.

Constructor & Destructor Documentation

MacroCommands()

MacroCommands::MacroCommands

(

AudacityProject &

project

)

Definition at line 57 of file BatchCommands.cpp.

: mProject{ project }
{
   ResetMacro();
 
   auto names = GetNames();
   auto defaults = GetNamesOfDefaultMacros();
 
   for( size_t i = 0;i<defaults.size();i++){
      wxString name = defaults[i];
      if ( ! make_iterator_range( names ).contains(name) ) {
         AddMacro(name);
         RestoreMacro(name);
         WriteMacro(name);
      }
   }
}

References AddMacro(), GetNames(), GetNamesOfDefaultMacros(), make_iterator_range(), name, names, ResetMacro(), RestoreMacro(), and WriteMacro().

Here is the call graph for this function:

Member Function Documentation

AbortBatch()

void MacroCommands::AbortBatch

(

)

Definition at line 770 of file BatchCommands.cpp.

{
   mAbort = true;
}

References mAbort.

AddMacro()

bool MacroCommands::AddMacro

(

const wxString &

macro

)

Definition at line 267 of file BatchCommands.cpp.

{
   // Build the filename
   wxFileName name(FileNames::MacroDir(), macro, wxT("txt"));
 
   // Set the file name
   wxTextFile tf(name.GetFullPath());
 
   // Create it..Create will display errors
   return tf.Create();
}

References FileNames::MacroDir(), name, and wxT().

Referenced by MacroCommands(), and MacrosWindow::OnAdd().

Here is the call graph for this function:

Here is the caller graph for this function:

AddToMacro() [1/2]

void MacroCommands::AddToMacro	(	const CommandID &	command,
		const wxString &	params,
		int	before = -1
	)

Definition at line 780 of file BatchCommands.cpp.

{
   if (before == -1) {
      before = (int)mCommandMacro.size();
   }
 
   mCommandMacro.insert(mCommandMacro.begin() + before, command);
   mParamsMacro.insert(mParamsMacro.begin() + before, params);
}

References mCommandMacro, mParamsMacro, and params.

AddToMacro() [2/2]

void MacroCommands::AddToMacro	(	const CommandID &	command,
		int	before = -1
	)

Definition at line 775 of file BatchCommands.cpp.

{
   AddToMacro(command, GetCurrentParamsFor(command), before);
}

References AddToMacro(), and GetCurrentParamsFor().

Referenced by AddToMacro(), MacrosWindow::InsertCommandAt(), MacrosWindow::OnDown(), MacrosWindow::OnEditCommandParams(), MacrosWindow::OnUp(), and RestoreMacro().

Here is the call graph for this function:

Here is the caller graph for this function:

AddToMessage()

void MacroCommands::AddToMessage ( const wxString &  msgIn )

inline

Definition at line 116 of file BatchCommands.h.

{ mMessage += msgIn;};

References mMessage.

ApplyCommand()

bool MacroCommands::ApplyCommand	(	const TranslatableString &	friendlyCommand,
		const CommandID &	command,
		const wxString &	params,
		CommandContext const *	pContext = nullptr
	)

Precondition

!pContext || &pContext->project == &GetProject()

Definition at line 579 of file BatchCommands.cpp.

{
   // Test for an effect.
   const PluginID& ID = PluginManager::Get().GetByCommandIdentifier(command);
   if (!ID.empty())
   {
      if( pContext )
         return ApplyEffectCommand(
            ID, friendlyCommand, command, params, *pContext);
      const CommandContext context( mProject );
      return ApplyEffectCommand(
         ID, friendlyCommand, command, params, context);
   }
 
   if (pContext) {
      assert(&pContext->project == &GetProject());
      if( CommandDispatch::HandleTextualCommand(
         command, *pContext, AlwaysEnabledFlag, true ) )
         return true;
      pContext->Status( wxString::Format(
         _("Your batch command of %s was not recognized."), friendlyCommand.Translation() ));
      return false;
   }
   else
   {
      const CommandContext context(  mProject );
      if( CommandDispatch::HandleTextualCommand(
         command, context, AlwaysEnabledFlag, true ) )
         return true;
   }
 
   AudacityMessageBox(
      XO("Your batch command of %s was not recognized.")
         .Format( friendlyCommand ) );
 
   return false;
}

References _, AlwaysEnabledFlag, ApplyEffectCommand(), AudacityMessageBox(), PluginManager::Get(), PluginManager::GetByCommandIdentifier(), GetProject(), CommandDispatch::HandleTextualCommand(), mProject, params, CommandContext::project, CommandContext::Status(), TranslatableString::Translation(), and XO().

Referenced by ApplyCommandInBatchMode().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyCommandInBatchMode()

bool MacroCommands::ApplyCommandInBatchMode	(	const TranslatableString &	friendlyCommand,
		const CommandID &	command,
		const wxString &	params,
		CommandContext const *	pContext = nullptr
	)

Precondition

!pContext || &pContext->project == &GetProject()

Definition at line 619 of file BatchCommands.cpp.

{
   assert(!pContext || &pContext->project == &GetProject());
   AudacityProject *project = &mProject;
   auto &settings = ProjectSettings::Get( *project );
   // Recalc flags and enable items that may have become enabled.
   CommandManager::Get(*project).UpdateMenus(false);
   // enter batch mode...
   project->mBatchMode++;
   auto cleanup = finally( [&] {
      // exit batch mode...
      project->mBatchMode--;
   } );
 
   return ApplyCommand( friendlyCommand, command, params, pContext );
}

References ApplyCommand(), CommandManager::Get(), ProjectSettings::Get(), GetProject(), mProject, params, CommandContext::project, project, settings(), and CommandManager::UpdateMenus().

Referenced by ApplyMacro().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyEffectCommand()

bool MacroCommands::ApplyEffectCommand	(	const PluginID &	ID,
		const TranslatableString &	friendlyCommand,
		const CommandID &	command,
		const wxString &	params,
		const CommandContext &	Context
	)

Definition at line 523 of file BatchCommands.cpp.

{
   static_cast<void>(command);//compiler food.
 
   //Possibly end processing here, if in batch-debug
   if( ReportAndSkip(friendlyCommand, params))
      return true;
 
   const PluginDescriptor *plug = PluginManager::Get().GetPlugin(ID);
   if (!plug)
      return false;
 
   AudacityProject *project = &mProject;
 
   // IF nothing selected, THEN select everything depending
   // on preferences setting.
   // (most effects require that you have something selected).
   if( plug->GetPluginType() != PluginTypeAudacityCommand )
   {
      if( !SelectUtilities::SelectAllIfNoneAndAllowed( *project ) )
      {
         AudacityMessageBox(
            // i18n-hint: %s will be replaced by the name of an action, such as "Remove Tracks".
            XO("\"%s\" requires one or more tracks to be selected.").Format(friendlyCommand));
         return false;
      }
   }
 
   bool res = false;
 
   auto cleanup = EffectAndCommandPluginManager::Get().SetBatchProcessing(ID);
 
   // transfer the parameters to the effect...
   if (EffectAndCommandPluginManager::Get().SetEffectParameters(ID, params))
   {
      if( plug->GetPluginType() == PluginTypeAudacityCommand )
         // and apply the effect...
         res = CommandDispatch::DoAudacityCommand(ID,
            Context,
            EffectManager::kConfigured |
            EffectManager::kSkipState |
            EffectManager::kDontRepeatLast);
      else
         // and apply the effect...
         res = EffectUI::DoEffect(
            ID, Context.project,
            EffectManager::kConfigured | EffectManager::kSkipState |
               EffectManager::kDontRepeatLast);
   }
 
   return res;
}

References AudacityMessageBox(), CommandDispatch::DoAudacityCommand(), EffectUI::DoEffect(), PluginManager::Get(), EffectAndCommandPluginManager::Get(), PluginManager::GetPlugin(), PluginDescriptor::GetPluginType(), EffectManager::kConfigured, EffectManager::kDontRepeatLast, EffectManager::kSkipState, mProject, params, PluginTypeAudacityCommand, CommandContext::project, project, ReportAndSkip(), SelectUtilities::SelectAllIfNoneAndAllowed(), EffectAndCommandPluginManager::SetBatchProcessing(), and XO().

Referenced by ApplyCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyMacro()

bool MacroCommands::ApplyMacro	(	const MacroCommandsCatalog &	catalog,
		const wxString &	filename = {}
	)

Definition at line 643 of file BatchCommands.cpp.

{
   // Check for reentrant ApplyMacro commands.
   // We'll allow 1 level of reentry, but not more.
   // And we treat ignoring deeper levels as a success.
   if (MacroReentryCount > 1) {
      return true;
   }
 
   // Restore the reentry counter (to zero) when we exit.
   auto cleanup1 = valueRestorer(MacroReentryCount);
   MacroReentryCount++;
 
   AudacityProject *proj = &mProject;
   bool res = false;
 
   // Only perform this group on initial entry.  They should not be done
   // while recursing.
   if (MacroReentryCount == 1) {
      mFileName = filename;
 
      TranslatableString longDesc, shortDesc;
      wxString name = gPrefs->Read(wxT("/Batch/ActiveMacro"), wxEmptyString);
      if (name.empty()) {
         /* i18n-hint: active verb in past tense */
         longDesc = XO("Applied Macro");
         shortDesc = XO("Apply Macro");
      }
      else {
         /* i18n-hint: active verb in past tense */
         longDesc = XO("Applied Macro '%s'").Format(name);
         shortDesc = XO("Apply '%s'").Format(name);
      }
 
      // Save the project state before making any changes.  It will be rolled
      // back if an error occurs.
      // It also causes any calls to ModifyState (such as by simple
      // view-changing commands) to append changes to this state, not to the
      // previous state in history.  See Bug 2076
      if (proj) {
         ProjectHistory::Get(*proj).PushState(longDesc, shortDesc);
      }
   }
 
   // Upon exit of the top level apply, roll back the state if an error occurs.
   auto cleanup2 = finally([&, macroReentryCount = MacroReentryCount] {
      if (macroReentryCount == 1 && !res && proj) {
         // Be sure that exceptions do not escape this destructor
         GuardedCall([&]{
            // Macro failed or was cancelled; revert to the previous state
            auto &history = ProjectHistory::Get(*proj);
            history.RollbackState();
            // The added undo state is now vacuous.  Remove it (Bug 2759)
            auto &undoManager = UndoManager::Get(*proj);
            undoManager.Undo(
               [&]( const UndoStackElem &elem ){
                  history.PopState( elem.state ); } );
            undoManager.AbandonRedo();
         });
      }
   });
 
   mAbort = false;
 
   // Is tracing enabled?
   bool trace;
   gPrefs->Read(wxT("/EnableMacroTracing"), &trace, false);
 
   // If so, then block most other messages while running the macro
   wxLogLevel prevLevel = wxLog::GetComponentLevel("");
   if (trace) {
      wxLog::SetComponentLevel("",  wxLOG_FatalError);
      wxLog::SetComponentLevel(wxLOG_COMPONENT,  wxLOG_Info);
   }
 
   size_t i = 0;
   for (; i < mCommandMacro.size(); i++) {
      const auto &command = mCommandMacro[i];
      auto iter = catalog.ByCommandId(command);
      const auto friendly = (iter == catalog.end())
         ?
           // uh oh, using GET to expose an internal name to the user!
           // in default of any better friendly name
           Verbatim( command.GET() )
         : iter->name.Msgid().Stripped();
 
      wxTimeSpan before;
      if (trace) {
         before = wxTimeSpan(0, 0, 0, wxGetUTCTimeMillis());
      }
 
      bool success = ApplyCommandInBatchMode(friendly, command, mParamsMacro[i]);
 
      if (trace) {
         auto after = wxTimeSpan(0, 0, 0, wxGetUTCTimeMillis());
         wxLogMessage(wxT("Macro line #%ld took %s : %s:%s"),
            i + 1,
            (after - before).Format(wxT("%H:%M:%S.%l")),
            command.GET(),
            mParamsMacro[i]);
      }
 
      if (!success || mAbort)
         break;
   }
 
   // Restore message level
   if (trace) {
      wxLog::SetComponentLevel("", prevLevel);
   }
 
   res = (i == mCommandMacro.size());
   if (!res)
      return false;
 
   if (MacroReentryCount == 1) {
      mFileName.Empty();
 
      if (proj)
         ProjectHistory::Get(*proj).ModifyState(true);
   }
 
   return true;
}

References ApplyCommandInBatchMode(), MacroCommandsCatalog::ByCommandId(), MacroCommandsCatalog::end(), ProjectHistory::Get(), UndoManager::Get(), gPrefs, GuardedCall(), mAbort, MacroReentryCount, mCommandMacro, mFileName, ProjectHistory::ModifyState(), mParamsMacro, mProject, name, ProjectHistory::PushState(), audacity::BasicSettings::Read(), UndoStackElem::state, TranslatableString::Stripped(), valueRestorer(), Verbatim(), wxLOG_COMPONENT, wxT(), and XO().

Referenced by ApplyMacroDialog::ApplyMacroToProject(), and ApplyMacroDialog::OnApplyToFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteFromMacro()

void MacroCommands::DeleteFromMacro

(

int

index

)

Definition at line 790 of file BatchCommands.cpp.

{
   if (index < 0 || index >= (int)mCommandMacro.size()) {
      return;
   }
 
   mCommandMacro.erase( mCommandMacro.begin() + index );
   mParamsMacro.erase( mParamsMacro.begin() + index );
}

References mCommandMacro, and mParamsMacro.

Referenced by MacrosWindow::OnDelete(), MacrosWindow::OnDown(), MacrosWindow::OnEditCommandParams(), and MacrosWindow::OnUp().

Here is the caller graph for this function:

DeleteMacro()

bool MacroCommands::DeleteMacro

(

const wxString &

name

)

Definition at line 279 of file BatchCommands.cpp.

{
   // Build the filename
   wxFileName name(FileNames::MacroDir(), macro, wxT("txt"));
 
   // Delete it...wxRemoveFile will display errors
   auto result = wxRemoveFile(name.GetFullPath());
 
   // Delete any legacy chain that it shadowed
   auto oldPath = wxFileName{ FileNames::LegacyChainDir(), macro, wxT("txt") };
   wxRemoveFile(oldPath.GetFullPath()); // Don't care about this return value
 
   return result;
}

References FileNames::LegacyChainDir(), FileNames::MacroDir(), name, and wxT().

Referenced by MacrosWindow::OnRemove().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCommand()

CommandID MacroCommands::GetCommand

(

int

index

)

Definition at line 103 of file BatchCommands.cpp.

{
   if (index < 0 || index >= (int)mCommandMacro.size()) {
      return wxT("");
   }
 
   return mCommandMacro[index];
}

References mCommandMacro, and wxT().

Referenced by MacrosWindow::OnDown(), MacrosWindow::OnEditCommandParams(), MacrosWindow::OnUp(), and MacrosWindow::PopulateList().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCount()

int MacroCommands::GetCount

(

)

Definition at line 121 of file BatchCommands.cpp.

{
   return (int)mCommandMacro.size();
}

References mCommandMacro.

Referenced by MacrosWindow::PopulateList().

Here is the caller graph for this function:

GetCurrentParamsFor()

wxString MacroCommands::GetCurrentParamsFor ( const CommandID &  command )

static

Definition at line 446 of file BatchCommands.cpp.

{
   const PluginID& ID = PluginManager::Get().GetByCommandIdentifier(command);
   if (ID.empty())
   {
      return wxEmptyString;   // effect not found.
   }
 
   return EffectAndCommandPluginManager::Get().GetEffectParameters(ID);
}

References PluginManager::Get(), EffectAndCommandPluginManager::Get(), PluginManager::GetByCommandIdentifier(), and EffectAndCommandPluginManager::GetEffectParameters().

Referenced by AddToMacro(), and MacroCommandDialog::OnItemSelected().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMessage()

wxString MacroCommands::GetMessage ( )

inline

Definition at line 115 of file BatchCommands.h.

{ return mMessage;};

References mMessage.

GetNames()

wxArrayString MacroCommands::GetNames ( )

static

Definition at line 866 of file BatchCommands.cpp.

{
   MigrateLegacyChains();
 
   wxArrayString names;
   FilePaths files;
   wxDir::GetAllFiles(FileNames::MacroDir(), &files, wxT("*.txt"), wxDIR_FILES);
   size_t i;
 
   wxFileName ff;
   for (i = 0; i < files.size(); i++) {
      ff = (files[i]);
      names.push_back(ff.GetName());
   }
 
   std::sort( names.begin(), names.end() );
 
   return names;
}

References FileNames::MacroDir(), MigrateLegacyChains(), names, and wxT().

Referenced by MacroCommands(), ApplyMacroDialog::PopulateMacros(), and anonymous_namespace{BatchProcessDialog.cpp}::PopulateMacrosMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNamesOfDefaultMacros()

wxArrayStringEx MacroCommands::GetNamesOfDefaultMacros ( )

static

Definition at line 78 of file BatchCommands.cpp.

{
   return {
      MP3Conversion.Translation() ,
      FadeEnds.Translation() ,
   };
}

References FadeEnds, and MP3Conversion.

Referenced by IsFixed(), and MacroCommands().

Here is the caller graph for this function:

GetParams()

wxString MacroCommands::GetParams

(

int

index

)

Definition at line 112 of file BatchCommands.cpp.

{
   if (index < 0 || index >= (int)mParamsMacro.size()) {
      return wxT("");
   }
 
   return mParamsMacro[index];
}

References mParamsMacro, and wxT().

Referenced by MacrosWindow::OnDown(), MacrosWindow::OnEditCommandParams(), MacrosWindow::OnUp(), and MacrosWindow::PopulateList().

Here is the call graph for this function:

Here is the caller graph for this function:

GetProject()

AudacityProject & MacroCommands::GetProject ( )

inline

Definition at line 64 of file BatchCommands.h.

{ return mProject; }

References mProject.

Referenced by ApplyCommand(), and ApplyCommandInBatchMode().

Here is the caller graph for this function:

IsFixed()

bool MacroCommands::IsFixed

(

const wxString &

name

)

Definition at line 886 of file BatchCommands.cpp.

{
   auto defaults = GetNamesOfDefaultMacros();
   if( make_iterator_range( defaults ).contains( name ) )
      return true;
   return false;
}

References GetNamesOfDefaultMacros(), make_iterator_range(), and name.

Referenced by MacrosWindow::OnMacrosBeginEdit(), and MacrosWindow::ShowActiveMacro().

Here is the call graph for this function:

Here is the caller graph for this function:

Join()

wxString MacroCommands::Join	(	const wxString &	command,
		const wxString &	param
	)

Definition at line 916 of file BatchCommands.cpp.

{
   return command + wxT(": ") + param;
}

References wxT().

Here is the call graph for this function:

MigrateLegacyChains()

void MacroCommands::MigrateLegacyChains ( )

static

Definition at line 833 of file BatchCommands.cpp.

{
   static bool done = false;
   if (!done) {
      // Check once per session at most
 
      // Copy chain files from the old Chains into the new Macros directory,
      // but only if like-named files are not already present in Macros.
 
      // Leave the old copies in place, in case a user wants to go back to
      // an old Audacity version.  They will have their old chains intact, but
      // won't have any edits they made to the copy that now lives in Macros
      // which old Audacity will not read.
 
      const auto oldDir = FileNames::LegacyChainDir();
      FilePaths files;
      wxDir::GetAllFiles(oldDir, &files, wxT("*.txt"), wxDIR_FILES);
 
      // add a dummy path component to be overwritten by SetFullName
      wxFileName newDir{ FileNames::MacroDir(), wxT("x") };
 
      for (const auto &file : files) {
         auto name = wxFileName{file}.GetFullName();
         newDir.SetFullName(name);
         const auto newPath = newDir.GetFullPath();
         if (!wxFileExists(newPath))
            FileNames::DoCopyFile(file, newPath);
      }
      done = true;
   }
   // To do:  use std::once
}

References FileNames::DoCopyFile(), FileNames::LegacyChainDir(), FileNames::MacroDir(), name, and wxT().

Referenced by GetNames().

Here is the call graph for this function:

Here is the caller graph for this function:

PromptForParamsFor()

wxString MacroCommands::PromptForParamsFor ( const CommandID &  command, const wxString &  params, AudacityProject &  project  )

static

Definition at line 457 of file BatchCommands.cpp.

{
   const PluginID& ID = PluginManager::Get().GetByCommandIdentifier(command);
   if (ID.empty())
      return wxEmptyString;   // effect not found
 
   wxString res = params;
   auto cleanup = EffectAndCommandPluginManager::Get().SetBatchProcessing(ID);
   if (EffectAndCommandPluginManager::Get().SetEffectParameters(ID, params))
   {
      auto dialogInvoker =
         [&](
            Effect& effect, EffectSettings& settings,
            std::shared_ptr<EffectInstance>& pInstance) -> bool {
         const auto pServices = dynamic_cast<EffectUIServices*>(&effect);
         return pServices && pServices->ShowHostInterface(effect,
            GetProjectFrame(project), EffectUI::DialogFactory,
            pInstance,
            *std::make_shared<SimpleEffectSettingsAccess>(settings),
            effect.IsBatchProcessing() ) != 0;
      };
      if (EffectAndCommandPluginManager::Get().PromptUser(
             ID, project, std::move(dialogInvoker)))
         res = EffectAndCommandPluginManager::Get().GetEffectParameters(ID);
   }
   return res;
}

References EffectUI::DialogFactory(), PluginManager::Get(), EffectAndCommandPluginManager::Get(), PluginManager::GetByCommandIdentifier(), EffectAndCommandPluginManager::GetEffectParameters(), GetProjectFrame(), Effect::IsBatchProcessing(), params, project, EffectAndCommandPluginManager::PromptUser(), EffectAndCommandPluginManager::SetBatchProcessing(), settings(), and EffectUIServices::ShowHostInterface().

Referenced by MacrosWindow::OnEditCommandParams(), and MacroCommandDialog::OnEditParams().

Here is the call graph for this function:

Here is the caller graph for this function:

PromptForPresetFor()

wxString MacroCommands::PromptForPresetFor ( const CommandID &  command, const wxString &  params, wxWindow *  parent  )

static

Definition at line 486 of file BatchCommands.cpp.

{
   const PluginID& ID = PluginManager::Get().GetByCommandIdentifier(command);
   if (ID.empty())
   {
      return wxEmptyString;   // effect not found.
   }
 
   EffectManager::EffectPresetDialog dialog =
      [parent](
         EffectPlugin& effect,
         const wxString& preset) -> std::optional<wxString> {
      EffectPresetsDialog dlg(parent, &effect);
      dlg.Layout();
      dlg.Fit();
      dlg.SetSize(dlg.GetMinSize());
      dlg.CenterOnParent();
      dlg.SetSelected(preset);
 
      if (dlg.ShowModal())
         return std::make_optional(dlg.GetSelected());
      else
         return {};
   };
   wxString preset =
      EffectManager::Get().GetPreset(ID, params, std::move(dialog));
 
   // Preset will be empty if the user cancelled the dialog, so return the original
   // parameter value.
   if (preset.empty())
   {
      return params;
   }
 
   return preset;
}

References EffectManager::Get(), PluginManager::Get(), PluginManager::GetByCommandIdentifier(), EffectManager::GetPreset(), EffectPresetsDialog::GetSelected(), params, preset, and EffectPresetsDialog::SetSelected().

Referenced by MacroCommandDialog::OnUsePreset().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadMacro()

wxString MacroCommands::ReadMacro	(	const wxString &	macro,
		wxWindow *	parent = nullptr
	)

Definition at line 126 of file BatchCommands.cpp.

{
   // Clear any previous macro
   ResetMacro();
 
   // Build the filename
   wxFileName name(FileNames::MacroDir(), macro, wxT("txt"));
 
   // But, ask the user for the real name if we're importing
   if (parent) {
      FilePath fn = SelectFile(FileNames::Operation::_None,
         XO("Import Macro"),
         wxEmptyString,
         name.GetName(),
         wxT("txt"),
         { FileNames::TextFiles },
         wxFD_OPEN | wxRESIZE_BORDER,
         parent);
 
      // User canceled...
      if (fn.empty()) {
         return wxEmptyString;
      }
 
      wxFileName check(fn);
      check.SetPath(name.GetPath());
      if (check.FileExists())
      {
         int id = AudacityMessageBox(
            XO("Macro %s already exists. Would you like to replace it?").Format(check.GetName()),
            XO("Import Macro"),
            wxYES_NO);
         if (id == wxNO) {
            return wxEmptyString;
         }
      }
 
      name.Assign(fn);
   }
 
   // Set the file name
   wxTextFile tf(name.GetFullPath());
 
   // Open and check
   tf.Open();
   if (!tf.IsOpened()) {
      // wxTextFile will display any errors
      return wxEmptyString;
   }
 
   // Load commands from the file
   int lines = tf.GetLineCount();
   if (lines > 0) {
      for (int i = 0; i < lines; i++) {
 
         // Find the command name terminator...ignore line if not found
         int splitAt = tf[i].Find(wxT(':'));
         if (splitAt < 0) {
            continue;
         }
 
         // Parse and clean
         wxString cmd = tf[i].Left(splitAt).Strip(wxString::both);
         wxString parm = tf[i].Mid(splitAt + 1).Strip(wxString::trailing);
 
         // Add to lists
         mCommandMacro.push_back(cmd);
         mParamsMacro.push_back(parm);
      }
   }
 
   // Done with the file
   tf.Close();
 
   // Write to macro directory if importing
   if (parent) {
      return WriteMacro(name.GetName());
   }
 
   return name.GetName();
}

References AudacityMessageBox(), fn, FileNames::MacroDir(), mCommandMacro, mParamsMacro, name, ResetMacro(), SelectFile(), FileNames::TextFiles, WriteMacro(), wxT(), and XO().

Referenced by ApplyMacroDialog::ApplyMacroToProject(), ApplyMacroDialog::OnApplyToFiles(), MacrosWindow::OnImport(), and MacrosWindow::ShowActiveMacro().

Here is the call graph for this function:

Here is the caller graph for this function:

RenameMacro()

bool MacroCommands::RenameMacro	(	const wxString &	oldmacro,
		const wxString &	newmacro
	)

Definition at line 294 of file BatchCommands.cpp.

{
   // Build the filenames
   wxFileName oname(FileNames::MacroDir(), oldmacro, wxT("txt"));
   wxFileName nname(FileNames::MacroDir(), newmacro, wxT("txt"));
 
   // Rename it...wxRenameFile will display errors
   return wxRenameFile(oname.GetFullPath(), nname.GetFullPath());
}

References FileNames::MacroDir(), and wxT().

Referenced by MacrosWindow::OnMacrosEndEdit().

Here is the call graph for this function:

Here is the caller graph for this function:

ReportAndSkip()

bool MacroCommands::ReportAndSkip	(	const TranslatableString &	friendlyCommand,
		const wxString &	params
	)

Definition at line 808 of file BatchCommands.cpp.

{
   int bDebug;
   gPrefs->Read(wxT("/Batch/Debug"), &bDebug, 0);
   if( bDebug == 0 )
      return false;
 
   //TODO: Add a cancel button to these, and add the logic so that we can abort.
   if( !params.empty() )
   {
      AudacityMessageBox(
         XO("Apply %s with parameter(s)\n\n%s")
            .Format( friendlyCommand, params ),
         XO("Test Mode"));
   }
   else
   {
      AudacityMessageBox(
         XO("Apply %s").Format( friendlyCommand ),
         XO("Test Mode"));
   }
   return true;
}

References AudacityMessageBox(), gPrefs, params, audacity::BasicSettings::Read(), wxT(), and XO().

Referenced by ApplyEffectCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetMacro()

void MacroCommands::ResetMacro

(

)

Definition at line 800 of file BatchCommands.cpp.

{
   mCommandMacro.clear();
   mParamsMacro.clear();
}

References mCommandMacro, and mParamsMacro.

Referenced by MacroCommands(), ReadMacro(), and RestoreMacro().

Here is the caller graph for this function:

RestoreMacro()

void MacroCommands::RestoreMacro

(

const wxString &

name

)

Definition at line 86 of file BatchCommands.cpp.

{
// TIDY-ME: Effects change their name with localisation.
// Commands (at least currently) don't.  Messy.
   ResetMacro();
   if (name == MP3Conversion.Translation() ){
        AddToMacro( wxT("Normalize") );
        AddToMacro( wxT("ExportMP3") );
   } else if (name == FadeEnds.Translation() ){
        AddToMacro( wxT("Select"), wxT("Start=\"0\" End=\"1\"") );
        AddToMacro( wxT("FadeIn") );
        AddToMacro( wxT("Select"), wxT("Start=\"0\" End=\"1\" RelativeTo=\"ProjectEnd\"") );
        AddToMacro( wxT("FadeOut") );
        AddToMacro( wxT("Select"), wxT("Start=\"0\" End=\"0\"") );
   }
}

References AddToMacro(), FadeEnds, MP3Conversion, name, ResetMacro(), and wxT().

Referenced by MacroCommands(), and MacrosWindow::OnRestore().

Here is the call graph for this function:

Here is the caller graph for this function:

Split()

void MacroCommands::Split	(	const wxString &	str,
		wxString &	command,
		wxString &	param
	)

Definition at line 894 of file BatchCommands.cpp.

{
   int splitAt;
 
   command.Empty();
   param.Empty();
 
   if (str.empty()) {
      return;
   }
 
   splitAt = str.Find(wxT(':'));
   if (splitAt < 0) {
      return;
   }
 
   command = str.Mid(0, splitAt);
   param = str.Mid(splitAt + 1);
 
   return;
}

References str, and wxT().

Here is the call graph for this function:

WriteMacro()

wxString MacroCommands::WriteMacro	(	const wxString &	macro,
		wxWindow *	parent = nullptr
	)

Definition at line 208 of file BatchCommands.cpp.

{
   // Build the default filename
   wxFileName name(FileNames::MacroDir(), macro, wxT("txt"));
 
   // But, ask the user for the real name if we're exporting
   if (parent) {
      FilePath fn = SelectFile(FileNames::Operation::_None,
         XO("Export Macro"),
         wxEmptyString,
         name.GetName(),
         wxT("txt"),
         { FileNames::TextFiles },
         wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxRESIZE_BORDER,
         parent);
 
      // User canceled...
      if (fn.empty()) {
         return wxEmptyString;
      }
 
      name.Assign(fn);
   }
 
   // Set the file name
   wxTextFile tf(name.GetFullPath());
 
   // Create the file (Create() doesn't leave the file open)
   if (!tf.Exists()) {
      tf.Create();
   }
 
   // Open it
   tf.Open();
 
   if (!tf.IsOpened()) {
      // wxTextFile will display any errors
      return wxEmptyString;
   }
 
   // Start with a clean slate
   tf.Clear();
 
   // Copy over the commands
   int lines = mCommandMacro.size();
   for (int i = 0; i < lines; i++) {
      // using GET to serialize macro definition to a text file
      tf.AddLine(mCommandMacro[i].GET() + wxT(":") + mParamsMacro[ i ]);
   }
 
   // Write the macro
   tf.Write();
 
   // Done with the file
   tf.Close();
 
   return name.GetName();
}

References fn, FileNames::MacroDir(), mCommandMacro, mParamsMacro, name, SelectFile(), FileNames::TextFiles, wxT(), and XO().

Referenced by MacrosWindow::ChangeOK(), MacroCommands(), MacrosWindow::OnExport(), ReadMacro(), and MacrosWindow::SaveChanges().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mAbort

bool MacroCommands::mAbort

private

Definition at line 128 of file BatchCommands.h.

Referenced by AbortBatch(), and ApplyMacro().

mCommandMacro

CommandIDs MacroCommands::mCommandMacro

private

Definition at line 126 of file BatchCommands.h.

Referenced by AddToMacro(), ApplyMacro(), DeleteFromMacro(), GetCommand(), GetCount(), ReadMacro(), ResetMacro(), and WriteMacro().

mFileName

wxString MacroCommands::mFileName

private

Definition at line 131 of file BatchCommands.h.

Referenced by ApplyMacro().

mMessage

wxString MacroCommands::mMessage

private

Definition at line 129 of file BatchCommands.h.

Referenced by AddToMessage(), and GetMessage().

mParamsMacro

wxArrayString MacroCommands::mParamsMacro

private

Definition at line 127 of file BatchCommands.h.

Referenced by AddToMacro(), ApplyMacro(), DeleteFromMacro(), GetParams(), ReadMacro(), ResetMacro(), and WriteMacro().

mProject

AudacityProject& MacroCommands::mProject

private

Definition at line 124 of file BatchCommands.h.

Referenced by ApplyCommand(), ApplyCommandInBatchMode(), ApplyEffectCommand(), ApplyMacro(), and GetProject().

---

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

• BatchCommands.h
• BatchCommands.cpp