#include <ExportAudioDialog.h>

Inheritance diagram for ExportAudioDialog:

Collaboration diagram for ExportAudioDialog:

Classes
struct	ExportSetting
	A private class used to store the information needed to do an export. More...

Public Types
enum class	ExportMode { Auto , SelectedOnly }

Public Member Functions
	ExportAudioDialog (wxWindow *parent, AudacityProject &project, const wxString &defaultName, const wxString &defaultFormat, ExportMode mode=ExportMode::Auto)

	~ExportAudioDialog () override

bool	Show (bool show=true) override

Public Member Functions inherited from wxDialogWrapper
	wxDialogWrapper ()

	wxDialogWrapper (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))

bool	Create (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))

void	SetTitle (const TranslatableString &title)

void	SetLabel (const TranslatableString &title)

void	SetName (const TranslatableString &title)

void	SetName ()

Public Member Functions inherited from wxTabTraversalWrapper< wxDialog >
	wxTabTraversalWrapper (Args &&... args)

	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete

	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete

wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete

wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

Private Member Functions
void	PopulateOrExchange (ShuttleGui &S)

void	OnExportRangeChange (wxCommandEvent &event)

void	OnSplitModeChange (wxCommandEvent &event)

void	OnSplitNamePolicyChange (wxCommandEvent &event)

void	OnTrimBlankSpaceBeforeFirstClip (wxCommandEvent &)

void	OnIncludeAudioBeforeFirstLabelChange (wxCommandEvent &)

void	OnFileNamePrefixChange (wxCommandEvent &)

void	OnEditMetadata (wxCommandEvent &event)

void	OnHelp (wxCommandEvent &event)

void	OnExport (wxCommandEvent &event)

void	OnFormatChange (wxCommandEvent &event)

void	UpdateExportSettings ()

void	UpdateLabelExportSettings (const ExportPlugin &plugin, int formatIndex, bool byName, bool addNumber, const wxString &prefix)

void	UpdateTrackExportSettings (const ExportPlugin &plugin, int formatIndex, bool byName, bool addNumber, const wxString &prefix)

ExportResult	DoExportSplitByLabels (const ExportPlugin &plugin, int formatIndex, const ExportProcessor::Parameters &parameters, FilePaths &exporterFiles)

ExportResult	DoExportSplitByTracks (const ExportPlugin &plugin, int formatIndex, const ExportProcessor::Parameters &parameters, FilePaths &exporterFiles)

ExportResult	DoExport (const ExportPlugin &plugin, int formatIndex, const ExportProcessor::Parameters &parameters, const wxFileName &filename, int channels, double t0, double t1, bool selectedOnly, const Tags &tags, FilePaths &exportedFiles)

Private Attributes
AudacityProject &	mProject

ExportFilePanel *	mExportOptionsPanel {}

wxWindow *	mSplitsPanel {}

wxCheckBox *	mIncludeAudioBeforeFirstLabel {}

wxTextCtrl *	mSplitFileNamePrefix {}

wxButton *	mEditMetadata {}

wxRadioButton *	mRangeProject

wxRadioButton *	mRangeSelection {}

wxRadioButton *	mRangeSplit {}

wxRadioButton *	mSplitByLabels {}

wxRadioButton *	mSplitByTracks {}

wxRadioButton *	mExportRangeSelection {}

wxRadioButton *	mSplitModeTracks {}

wxRadioButton *	mSplitModeLabels {}

wxRadioButton *	mSplitUseName {}

wxRadioButton *	mSplitUseNumAndName {}

wxRadioButton *	mSplitUseNumAndPrefix {}

wxCheckBox *	mOverwriteExisting {}

wxCheckBox *	mSkipSilenceAtBeginning {}

std::vector< ExportSetting >	mExportSettings

bool	mExportSettingsDirty {true}

Detailed Description

Definition at line 42 of file ExportAudioDialog.h.

Member Enumeration Documentation

◆ ExportMode

enum class ExportAudioDialog::ExportMode

strong

Enumerator
Auto
SelectedOnly

Definition at line 55 of file ExportAudioDialog.h.

   {
      Auto,
      SelectedOnly
   };

Constructor & Destructor Documentation

◆ ExportAudioDialog()

ExportAudioDialog::ExportAudioDialog	(	wxWindow *	parent,
		AudacityProject &	project,
		const wxString &	defaultName,
		const wxString &	defaultFormat,
		ExportMode	mode = `ExportMode::Auto`
	)

Definition at line 160 of file ExportAudioDialog.cpp.

   : wxDialogWrapper(parent, wxID_ANY, XO("Export Audio"))
   , mProject(project)
{
   assert(!ExportUtils::FindExportWaveTracks(TrackList::Get(project), false).empty());
 
   ShuttleGui S(this, eIsCreatingFromPrefs);
   PopulateOrExchange(S);
 
   SetMinSize({GetBestSize().GetWidth(), -1});
 
   wxFileName filename;
   auto exportPath = ExportAudioDefaultPath.Read();
   if(exportPath.empty())
      exportPath = FileNames::FindDefaultPath(FileNames::Operation::Export);
   filename.SetPath(exportPath);
 
   //extension will be set in `ChangeFormat`
   filename.SetEmptyExt();
   if(defaultName.empty())
      //i18n-hint: default exported file name when exporting from unsaved project
      filename.SetName(_("untitled"));
   else
      filename.SetName(defaultName);
 
   auto sampleRate = ImportExport::Get(project).GetPreferredExportRate();
   if(sampleRate == ImportExport::InvalidRate)
   {
      auto& tracks = TrackList::Get(project);
      for(const auto track : tracks.Any<WaveTrack>())
         sampleRate = std::max(sampleRate, track->GetRate());
   }
 
   wxString format = defaultFormat;
   if(format.empty())
      ExportAudioDefaultFormat.Read(&format);
 
   mExportOptionsPanel->Init(filename, sampleRate, format);
 
   auto& tracks = TrackList::Get(mProject);
   const auto labelTracks = tracks.Any<LabelTrack>();
   const auto hasLabels = !labelTracks.empty() &&
      (*labelTracks.begin())->GetNumLabels() > 0;
   const auto hasMultipleWaveTracks = tracks.Any<WaveTrack>().size() > 1;
   const auto hasSelectedAudio = ExportUtils::HasSelectedAudio(mProject);
 
   mRangeSelection->Enable(hasSelectedAudio);
   mRangeSplit->Enable(hasLabels || hasMultipleWaveTracks);
 
   mSplitByLabels->Enable(hasLabels);
   mSplitByTracks->Enable(hasMultipleWaveTracks);
 
   if(mRangeSelection->IsEnabled() && mode == ExportMode::SelectedOnly)
   {
      mRangeSelection->SetValue(true);
   }
   else
   {
      if(!mRangeSelection->IsEnabled() && ExportAudioExportRange.Read() == "selection")
         mRangeProject->SetValue(true);
 
      if(!mRangeSplit->IsEnabled() && ExportAudioExportRange.Read() == "split")
         mRangeProject->SetValue(true);
 
      if(!hasLabels && hasMultipleWaveTracks)
         mSplitByTracks->SetValue(true);
      if (!hasMultipleWaveTracks && hasLabels)
         mSplitByLabels->SetValue(true);
   }
 
   if (mRangeSelection->IsEnabled() && !hasLabels && !hasMultipleWaveTracks)
      mRangeSelection->MoveAfterInTabOrder(mRangeProject);
 
   if (ExportAudioExportRange.Read() != "split" || (!hasLabels && !hasMultipleWaveTracks))
      mSplitsPanel->Hide();
 
   mExportOptionsPanel->SetCustomMappingEnabled(!mRangeSplit->GetValue());
 
   mIncludeAudioBeforeFirstLabel->Enable(mSplitByLabels->GetValue());
 
   if(ExportAudioSplitNamePolicy.Read() != "num_and_prefix")
      mSplitFileNamePrefix->Disable();
 
   Layout();
   Fit();
   Center();
}

References _, eIsCreatingFromPrefs, anonymous_namespace{ExportAudioDialog.cpp}::ExportAudioDefaultFormat, anonymous_namespace{ExportAudioDialog.cpp}::ExportAudioDefaultPath, anonymous_namespace{ExportAudioDialog.cpp}::ExportAudioExportRange, anonymous_namespace{ExportAudioDialog.cpp}::ExportAudioSplitNamePolicy, FileNames::FindDefaultPath(), ExportUtils::FindExportWaveTracks(), anonymous_namespace{ExportPCM.cpp}::format, ImportExport::Get(), TrackList::Get(), ImportExport::GetPreferredExportRate(), ExportUtils::HasSelectedAudio(), ImportExport::InvalidRate, project, ChoiceSetting::Read(), Setting< T >::Read(), S, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, size, and tracks.

Here is the call graph for this function:

◆ ~ExportAudioDialog()

ExportAudioDialog::~ExportAudioDialog ( )

overridedefault

Member Function Documentation

◆ DoExport()

ExportResult ExportAudioDialog::DoExport	(	const ExportPlugin &	plugin,
		int	formatIndex,
		const ExportProcessor::Parameters &	parameters,
		const wxFileName &	filename,
		int	channels,
		double	t0,
		double	t1,
		bool	selectedOnly,
		const Tags &	tags,
		FilePaths &	exportedFiles
	)

private

Definition at line 969 of file ExportAudioDialog.cpp.

{
   wxFileName name;
 
   wxLogDebug(wxT("Doing multiple Export: File name \"%s\""), (filename.GetFullName()));
   wxLogDebug(wxT("Channels: %i, Start: %lf, End: %lf "), channels, t0, t1);
   if (selectedOnly)
      wxLogDebug(wxT("Selected Region Only"));
   else
      wxLogDebug(wxT("Whole Project"));
 
   wxFileName backup;
   if (mOverwriteExisting->GetValue()) {
      name = filename;
      backup.Assign(name);
 
      int suffix = 0;
      do {
         backup.SetName(name.GetName() +
                           wxString::Format(wxT("%d"), suffix));
         ++suffix;
      }
      while (backup.FileExists());
      ::wxRenameFile(filename.GetFullPath(), backup.GetFullPath());
   }
   else {
      name = filename;
      int i = 2;
      wxString base(name.GetName());
      while (name.FileExists()) {
         name.SetName(wxString::Format(wxT("%s-%d"), base, i++));
      }
   }
 
   bool success{false};
   const wxString fullPath{name.GetFullPath()};
 
   auto cleanup = finally( [&] {
      if (backup.IsOk()) {
         if ( success )
            // Remove backup
            ::wxRemoveFile(backup.GetFullPath());
         else {
            // Restore original
            ::wxRemoveFile(fullPath);
            ::wxRenameFile(backup.GetFullPath(), fullPath);
         }
      }
      else {
         if ( ! success )
            // Remove any new, and only partially written, file.
            ::wxRemoveFile(fullPath);
      }
   } );
 
   auto result = ExportResult::Error;
   ExportProgressUI::ExceptionWrappedCall([&]
   {
      result = ExportProgressUI::Show(ExportTaskBuilder{}.SetPlugin(&plugin, formatIndex)
                                    .SetParameters(parameters)
                                    .SetRange(t0, t1, selectedOnly)
                                    .SetTags(&tags)
                                    .SetNumChannels(channels)
                                    .SetFileName(fullPath)
                                    .SetSampleRate(mExportOptionsPanel->GetSampleRate())
                                    .Build(mProject));
   });
 
   success = result == ExportResult::Success || result == ExportResult::Stopped;
 
   if(success)
      exportedFiles.push_back(fullPath);
 
   return result;
}

References mOverwriteExisting, name, and wxT().

Referenced by DoExportSplitByLabels(), and DoExportSplitByTracks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoExportSplitByLabels()

ExportResult ExportAudioDialog::DoExportSplitByLabels	(	const ExportPlugin &	plugin,
		int	formatIndex,
		const ExportProcessor::Parameters &	parameters,
		FilePaths &	exporterFiles
	)

private

Definition at line 867 of file ExportAudioDialog.cpp.

{
   auto ok = ExportResult::Success;   // did it work?
   /* Go round again and do the exporting (so this run is slow but
    * non-interactive) */
   for(auto& activeSetting : mExportSettings)
   {
      /* get the settings to use for the export from the array */
      // Bug 1440 fix.
      if( activeSetting.filename.GetName().empty() )
         continue;
 
      // Export it
      ok = DoExport(plugin, formatIndex, parameters, activeSetting.filename, activeSetting.channels,
         activeSetting.t0, activeSetting.t1, false, activeSetting.tags, exporterFiles);
 
      if (ok == ExportResult::Stopped) {
         AudacityMessageDialog dlgMessage(
            nullptr,
            XO("Continue to export remaining files?"),
            XO("Export"),
            wxYES_NO | wxNO_DEFAULT | wxICON_WARNING);
         if (dlgMessage.ShowModal() != wxID_YES ) {
            // User decided not to continue - bail out!
            break;
         }
      }
      else if (ok != ExportResult::Success) {
         break;
      }
   }
 
   return ok;
}

References DoExport(), mExportSettings, Stopped, Success, and XO().

Referenced by OnExport().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoExportSplitByTracks()

ExportResult ExportAudioDialog::DoExportSplitByTracks	(	const ExportPlugin &	plugin,
		int	formatIndex,
		const ExportProcessor::Parameters &	parameters,
		FilePaths &	exporterFiles
	)

private

Definition at line 905 of file ExportAudioDialog.cpp.

{
   auto& tracks = TrackList::Get(mProject);
 
   bool anySolo =
      !((tracks.Any<const WaveTrack>() + &WaveTrack::GetSolo).empty());
 
   auto waveTracks = tracks.Any<WaveTrack>() -
      (anySolo ? &WaveTrack::GetNotSolo : &WaveTrack::GetMute);
 
   auto& selectionState = SelectionState::Get( mProject );
 
   /* Remember which tracks were selected, and set them to deselected */
   SelectionStateChanger changer{ selectionState, tracks };
   for (auto tr : tracks.Selected<WaveTrack>())
      tr->SetSelected(false);
 
   auto ok = ExportResult::Success;
 
   int count = 0;
   for (auto tr : waveTracks) {
 
      wxLogDebug( "Get setting %i", count );
      /* get the settings to use for the export from the array */
      auto& activeSetting = mExportSettings[count];
      if( activeSetting.filename.GetName().empty() ){
         count++;
         continue;
      }
 
      /* Select the track */
      SelectionStateChanger changer2{ selectionState, tracks };
      tr->SetSelected(true);
 
      // Export the data. "channels" are per track.
      ok = DoExport(plugin, formatIndex, parameters, activeSetting.filename, activeSetting.channels,
         activeSetting.t0, activeSetting.t1, true, activeSetting.tags, exporterFiles);
 
      if (ok == ExportResult::Stopped) {
         AudacityMessageDialog dlgMessage(
            nullptr,
            XO("Continue to export remaining files?"),
            XO("Export"),
            wxYES_NO | wxNO_DEFAULT | wxICON_WARNING);
         if (dlgMessage.ShowModal() != wxID_YES ) {
            // User decided not to continue - bail out!
            break;
         }
      }
 
      else if (ok != ExportResult::Success) {
         break;
      }
      // increment export counter
      count++;
   }
 
 
   return ok ;
}

References DoExport(), SelectionState::Get(), TrackList::Get(), WaveTrack::GetMute(), PlayableTrack::GetNotSolo(), WaveTrack::GetSolo(), mExportSettings, mProject, Stopped, Success, tracks, and XO().

Referenced by OnExport().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnEditMetadata()

void ExportAudioDialog::OnEditMetadata ( wxCommandEvent & event )

private

Definition at line 447 of file ExportAudioDialog.cpp.

{
   if(mRangeSplit->GetValue())
   {
      UpdateExportSettings();
 
      std::vector<Tags*> tags;
      std::vector<wxString> names;
      tags.reserve(mExportSettings.size());
      names.reserve(mExportSettings.size());
      for(auto& spec : mExportSettings)
      {
         tags.push_back(&spec.tags);
         names.push_back(spec.filename.GetFullName());
      }
      TagsEditorDialog dialog(this, XO("Edit Metadata Tags"), tags, names, true, true);
      dialog.ShowModal();
   }
   else
   {
      TagsEditorDialog::EditProjectMetadata(mProject,
         XO("Edit Metadata Tags"), XO("Exported Tags"));
   }
}

References TagsEditorDialog::EditProjectMetadata(), mExportSettings, mProject, mRangeSplit, names, UpdateExportSettings(), and XO().

Here is the call graph for this function:

◆ OnExport()

void ExportAudioDialog::OnExport ( wxCommandEvent & event )

private

Definition at line 477 of file ExportAudioDialog.cpp.

{
   auto selectedPlugin = mExportOptionsPanel->GetPlugin();
   if(selectedPlugin == nullptr)
      return;
   auto selectedFormat = mExportOptionsPanel->GetFormat();
   auto parameters = mExportOptionsPanel->GetParameters();
   if(!parameters.has_value())
      return;
 
   const auto path = mExportOptionsPanel->GetPath();
 
   if(!wxDirExists(path))
      wxFileName::Mkdir(path, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
 
   if(!wxDirExists(path))
   {
      AudacityMessageBox(XO("Unable to create destination folder"),
                         XO("Export Audio"),
                         wxOK | wxCENTER,
                         this);
      return;
   }
 
   auto result = ExportResult::Error;
 
   if(mRangeSplit->GetValue())
   {
      FilePaths exportedFiles;
 
      UpdateExportSettings();
 
      if(mSplitByLabels->GetValue())
         result = DoExportSplitByLabels(*selectedPlugin, selectedFormat, *parameters, exportedFiles);
      else if(mSplitByTracks->GetValue())
         result = DoExportSplitByTracks(*selectedPlugin, selectedFormat, *parameters, exportedFiles);
 
      auto msg = (result == ExportResult::Success
         ? XO("Successfully exported the following %lld file(s).")
         : result == ExportResult::Error
            ? XO("Something went wrong after exporting the following %lld file(s).")
            : result == ExportResult::Cancelled
               ? XO("Export canceled after exporting the following %lld file(s).")
               : result == ExportResult::Stopped
                  ? XO("Export stopped after exporting the following %lld file(s).")
                  : XO("Something went really wrong after exporting the following %lld file(s).")
         ).Format((long long) exportedFiles.size());
 
      wxString fileList;
      for (auto& path : exportedFiles)
         fileList += path + '\n';
 
      // TODO: give some warning dialog first, when only some files exported
      // successfully.
 
      HelpSystem::ShowInfoDialog( this,
                                 XO("Export Audio"),
                                 msg,
                                 fileList,
                                 450,400);
   }
   else
   {
      wxFileName filename(path, mExportOptionsPanel->GetFullName());
 
      if (filename.FileExists()) {
         auto result = AudacityMessageBox(
            XO("A file named \"%s\" already exists. Replace?")
              .Format( filename.GetFullPath() ),
            XO("Export Audio"),
            wxYES_NO | wxICON_EXCLAMATION);
         if (result != wxYES) {
            return;
         }
      }
 
      ExportTaskBuilder builder;
      builder.SetFileName(filename)
         .SetPlugin(selectedPlugin, selectedFormat)
         .SetParameters(*parameters)
         .SetSampleRate(mExportOptionsPanel->GetSampleRate());
 
      const auto& viewInfo = ViewInfo::Get(mProject);
 
      const auto selectedOnly = mRangeSelection->GetValue();
 
      auto t0 = selectedOnly
         ? std::max(.0, viewInfo.selectedRegion.t0())
         : .0;
 
      auto t1 = selectedOnly
         ? std::min(TrackList::Get(mProject).GetEndTime(), viewInfo.selectedRegion.t1())
         : TrackList::Get(mProject).GetEndTime();
 
      auto exportedTracks = ExportUtils::FindExportWaveTracks(TrackList::Get(mProject), selectedOnly);
      if(exportedTracks.empty())
      {
         ShowExportErrorDialog(
            selectedOnly ? XO("All selected audio is muted.") : XO("All audio is muted."), //":576"
            XO("Warning"),
            false);
         return;
      }
 
      if(mSkipSilenceAtBeginning->GetValue())
         t0 = std::max(t0, exportedTracks.min(&Track::GetStartTime));
 
      builder.SetRange(t0, t1, selectedOnly);
 
      std::unique_ptr<MixerOptions::Downmix> tempMixerSpec;
      const auto channels = mExportOptionsPanel->GetChannels();
      if(channels == 0)
      {
         //Figure out the final channel mapping: mixer dialog shows
         //all tracks regardless of their mute/solo state, but
         //muted channels should not be present in exported file -
         //apply channel mask to exclude them
         auto tracks = TrackList::Get(mProject).Any<WaveTrack>();
         std::vector<bool> channelMask(
            tracks.sum([](const auto track) { return track->NChannels(); }),
            false);
         unsigned trackIndex = 0;
         for(const auto track : tracks)
         {
            if(track->GetSolo())
            {
               channelMask.assign(channelMask.size(), false);
               for(unsigned i = 0; i < track->NChannels(); ++i)
                  channelMask[trackIndex++] = true;
               break;
            }
            if(!track->GetMute() && (!selectedOnly || track->GetSelected()))
            {
               for(unsigned i = 0; i < track->NChannels(); ++i)
                  channelMask[trackIndex++] = true;
            }
            else
               trackIndex += track->NChannels();
         }
 
         tempMixerSpec = std::make_unique<MixerOptions::Downmix>(*mExportOptionsPanel->GetMixerSpec(), channelMask);
         builder.SetMixerSpec(tempMixerSpec.get());
      }
      else
         builder.SetNumChannels(channels);
 
      ExportProgressUI::ExceptionWrappedCall([&]
      {
         result = ExportProgressUI::Show(builder.Build(mProject));
      });
   }
 
   if(result == ExportResult::Success || result == ExportResult::Stopped)
   {
      ImportExport::Get(mProject).SetPreferredExportRate(mExportOptionsPanel->GetSampleRate());
 
      ExportAudioDefaultFormat.Write(selectedPlugin->GetFormatInfo(selectedFormat).format);
      ExportAudioDefaultPath.Write(mExportOptionsPanel->GetPath());
 
      ShuttleGui S(this, eIsSavingToPrefs);
      PopulateOrExchange(S);
      event.Skip();
   }
}

Here is the call graph for this function:

◆ OnExportRangeChange()

void ExportAudioDialog::OnExportRangeChange ( wxCommandEvent & event )

private

Definition at line 407 of file ExportAudioDialog.cpp.

{
   const auto enableSplits = event.GetId() == ExportRangeSplitID;
   mExportOptionsPanel->SetCustomMappingEnabled(!enableSplits);
   if(mSplitsPanel->IsShown() != enableSplits)
   {
      mExportSettingsDirty = true;
      mSplitsPanel->Show(enableSplits);
 
      Layout();
      Fit();
   }
}

References anonymous_namespace{ExportAudioDialog.cpp}::ExportRangeSplitID, mExportOptionsPanel, mExportSettingsDirty, mSplitsPanel, and ExportFilePanel::SetCustomMappingEnabled().

Here is the call graph for this function:

◆ OnFileNamePrefixChange()

void ExportAudioDialog::OnFileNamePrefixChange ( wxCommandEvent & )

private

Definition at line 442 of file ExportAudioDialog.cpp.

{
   mExportSettingsDirty = true;
}

References mExportSettingsDirty.

◆ OnFormatChange()

void ExportAudioDialog::OnFormatChange ( wxCommandEvent & event )

private

Definition at line 642 of file ExportAudioDialog.cpp.

{
   Layout();
   Fit();
 
   auto enableMeta = false;
   if(auto plugin = mExportOptionsPanel->GetPlugin())
      enableMeta = plugin->GetFormatInfo(mExportOptionsPanel->GetFormat()).canMetaData;
   mEditMetadata->Enable(enableMeta);
   mExportSettingsDirty = true;
}

References ExportFilePanel::GetFormat(), ExportFilePanel::GetPlugin(), mEditMetadata, mExportOptionsPanel, and mExportSettingsDirty.

Here is the call graph for this function:

◆ OnHelp()

void ExportAudioDialog::OnHelp ( wxCommandEvent & event )

private

Definition at line 472 of file ExportAudioDialog.cpp.

{
   HelpSystem::ShowHelp(wxGetTopLevelParent(this), L"File_Export_Dialog", true);
}

References HelpSystem::ShowHelp().

Here is the call graph for this function:

◆ OnIncludeAudioBeforeFirstLabelChange()

void ExportAudioDialog::OnIncludeAudioBeforeFirstLabelChange ( wxCommandEvent & event )

private

Definition at line 437 of file ExportAudioDialog.cpp.

{
   mExportSettingsDirty = true;
}

References mExportSettingsDirty.

◆ OnSplitModeChange()

void ExportAudioDialog::OnSplitModeChange ( wxCommandEvent & event )

private

Definition at line 420 of file ExportAudioDialog.cpp.

{
   mIncludeAudioBeforeFirstLabel->Enable(event.GetId() == ExportModeLabelsID);
   mExportSettingsDirty = true;
}

References anonymous_namespace{ExportAudioDialog.cpp}::ExportModeLabelsID, mExportSettingsDirty, and mIncludeAudioBeforeFirstLabel.

◆ OnSplitNamePolicyChange()

void ExportAudioDialog::OnSplitNamePolicyChange ( wxCommandEvent & event )

private

Definition at line 426 of file ExportAudioDialog.cpp.

{
   mSplitFileNamePrefix->Enable(event.GetId() == ExportSplitNamePolicyNumberingAfterPrefixID);
   mExportSettingsDirty = true;
}

References anonymous_namespace{ExportAudioDialog.cpp}::ExportSplitNamePolicyNumberingAfterPrefixID, mExportSettingsDirty, and mSplitFileNamePrefix.

◆ OnTrimBlankSpaceBeforeFirstClip()

void ExportAudioDialog::OnTrimBlankSpaceBeforeFirstClip ( wxCommandEvent & )

private

Definition at line 432 of file ExportAudioDialog.cpp.

{
   mExportSettingsDirty = true;
}

References mExportSettingsDirty.

◆ PopulateOrExchange()

void ExportAudioDialog::PopulateOrExchange ( ShuttleGui & S )

private

Definition at line 267 of file ExportAudioDialog.cpp.

{
   S.SetBorder(5);
   S.StartVerticalLay();
   {
      if(S.GetMode() == eIsCreating)
      {
         mExportOptionsPanel = safenew ExportFilePanel(mProject, false, this, ExportFilePanelID);
         S.Id(ExportFilePanelID).AddWindow(mExportOptionsPanel, wxEXPAND);
      }
 
      S.StartPanel();
      {
         S.SetBorder(5);
         S.StartTwoColumn();
         {
            S.StartHorizontalLay(wxSHRINK | wxALIGN_TOP);
            {
               if(auto prompt = S.AddPrompt(XO("Export Range:")))
                  prompt->SetMinSize({145, -1});
            }
            S.EndHorizontalLay();
 
            S.StartVerticalLay();
            {
               S.StartRadioButtonGroup(ExportAudioExportRange);
               {
                  mRangeProject = S.Id(ExportRangeProjectID)
                     .Name(XO("Export entire project"))
                     .TieRadioButton();
                  mRangeSplit = S.Id(ExportRangeSplitID)
                     .Name(XO("Export multiple files"))
                     .TieRadioButton();
                  mRangeSelection = S.Id(ExportRangeSelectionID)
                     .Name(XO("Export current selection"))
                     .TieRadioButton();
#if wxUSE_ACCESSIBILITY
                  safenew WindowAccessible(mRangeProject);
                  safenew WindowAccessible(mRangeSelection);
                  safenew WindowAccessible(mRangeSplit);
#endif
               }
               S.EndRadioButtonGroup();
            }
            S.EndVerticalLay();
         }
         S.EndTwoColumn();
 
         S.AddSpace(10);
 
         S.StartTwoColumn();
         {
            S.AddSpace(155, 1);
            mSkipSilenceAtBeginning = S
               .Id(TrimBlankSpaceBeforeFirstClipID)
               .TieCheckBox(XO("Trim blank space before first clip"), ExportAudioSkipSilenceAtBeginning);
         }
         S.EndTwoColumn();
      }
      S.EndPanel();
 
      S.SetBorder(5);
      mSplitsPanel = S.StartPanel();
      {
         S.StartMultiColumn(2);
         {
            S.StartStatic(XO("Split files based on:"));
            {
               S.StartVerticalLay();
               {
                  S.StartRadioButtonGroup(ExportAudioSplitMode);
                  {
                     mSplitByTracks = S.Id(ExportModeTracksID).TieRadioButton();
                     mSplitByLabels = S.Id(ExportModeLabelsID).TieRadioButton();
                  }
                  S.EndRadioButtonGroup();
 
                  S.StartHorizontalLay(wxALIGN_TOP);
                  {
                     S.AddSpace(10, 1);
                     mIncludeAudioBeforeFirstLabel = S
                        .Id(IncludeAudioBeforeFirstLabelID)
                        .TieCheckBox(XO("Include audio before first label"), ExportAudioIncludeAudioBeforeFirstLabel);
                  }
                  S.EndHorizontalLay();
               }
               S.EndVerticalLay();
            }
            S.EndStatic();
 
            S.StartStatic(XO("Name files:"));
            {
               S.StartVerticalLay();
               {
                  S.StartRadioButtonGroup(ExportAudioSplitNamePolicy);
                  {
                     mSplitUseName = S.Id(ExportSplitNamePolicyTrackNameID).TieRadioButton();
                     mSplitUseNumAndName = S.Id(ExportSplitNamePolicyNumberingBeforeNameID).TieRadioButton();
                     mSplitUseNumAndPrefix = S.Id(ExportSplitNamePolicyNumberingAfterPrefixID).TieRadioButton();
                  }
                  S.EndRadioButtonGroup();
                  S.StartHorizontalLay(wxALIGN_TOP);
                  {
                     S.AddSpace(10, 1);
                     mSplitFileNamePrefix = S
                        .Id(FileNamePrefixID)
                        .AddTextBox(XO("File name prefix:"), {}, 0);
                  }
                  S.EndHorizontalLay();
               }
               S.EndVerticalLay();
            }
            S.EndStatic();
         }
         S.EndMultiColumn();
 
         mOverwriteExisting = S
            .Id(OverwriteExistingFilesID)
            .TieCheckBox(XO("Overwrite existing files"), ExportAudioOverwriteExisting);
      }
      S.EndPanel();
 
      S.AddSpace(1, 10);
 
      S.SetBorder(5);
 
      S.SetBorder(5);
      S.StartHorizontalLay(wxEXPAND);
      {
         mEditMetadata = S.Id(EditMetadataID).AddButton(XO("Edit &Metadata..."), wxLEFT | wxBOTTOM);
         S.AddSpace(1, 1, wxEXPAND);
         S.Id(wxID_CANCEL).AddButton(XO("&Cancel"), wxBOTTOM);
         S.Id(wxID_OK).AddButton(XO("&Export"), wxRIGHT | wxBOTTOM, true);
      }
      S.EndHorizontalLay();
   }
   S.EndVerticalLay();
}

Referenced by OnExport().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Show()

bool ExportAudioDialog::Show ( bool show = true )

override

Definition at line 255 of file ExportAudioDialog.cpp.

{
   bool ret = wxDialogWrapper::Show(show);
 
#if defined(__WXMSW__)
   if (show)
      mExportOptionsPanel->SetInitialFocus();
#endif
 
   return ret;
}

References mExportOptionsPanel, ExportFilePanel::SetInitialFocus(), and ExportProgressUI::Show().

Here is the call graph for this function:

◆ UpdateExportSettings()

void ExportAudioDialog::UpdateExportSettings ( )

private

Definition at line 654 of file ExportAudioDialog.cpp.

{
   if(!mExportSettingsDirty)
      return;
 
   const auto selectedPlugin = mExportOptionsPanel->GetPlugin();
   if(selectedPlugin == nullptr)
      return;
 
   const auto selectedFormat = mExportOptionsPanel->GetFormat();
 
   if(mRangeSplit->GetValue())
   {
      const auto byName = mSplitUseName->GetValue() || mSplitUseNumAndName->GetValue();
      const auto addNumber = mSplitUseNumAndName->GetValue();
      const auto prefix = mSplitFileNamePrefix->GetValue();
 
      if(mSplitByLabels->GetValue())
         UpdateLabelExportSettings(*selectedPlugin, selectedFormat, byName, addNumber, prefix);
      else if(mSplitByTracks->GetValue())
         UpdateTrackExportSettings(*selectedPlugin, selectedFormat, byName, addNumber, prefix);
 
      mExportSettingsDirty = false;
   }
}

References ExportFilePanel::GetFormat(), ExportFilePanel::GetPlugin(), mExportOptionsPanel, mExportSettingsDirty, mRangeSplit, mSplitByLabels, mSplitByTracks, mSplitFileNamePrefix, mSplitUseName, mSplitUseNumAndName, UpdateLabelExportSettings(), and UpdateTrackExportSettings().

Referenced by OnEditMetadata(), and OnExport().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateLabelExportSettings()

void ExportAudioDialog::UpdateLabelExportSettings	(	const ExportPlugin &	plugin,
		int	formatIndex,
		bool	byName,
		bool	addNumber,
		const wxString &	prefix
	)

private

Definition at line 680 of file ExportAudioDialog.cpp.

{
   const auto& tracks = TrackList::Get(mProject);
   const auto& labels = (*tracks.Any<const LabelTrack>().begin());
   const auto numLabels = labels->GetNumLabels();
 
   auto numFiles = numLabels;
   auto fileIndex = 0;        // counter for files done
   std::vector<ExportSetting> exportSettings; // dynamic array for settings.
   exportSettings.reserve(numFiles); // Allocate some guessed space to use.
 
   // Account for exporting before first label
   if( mIncludeAudioBeforeFirstLabel->GetValue() ) {
      fileIndex = -1;
      numFiles++;
   }
 
   const auto formatInfo = plugin.GetFormatInfo(formatIndex);
 
   FilePaths otherNames;  // keep track of file names we will use, so we
   // don't duplicate them
   ExportSetting setting;   // the current batch of settings
   setting.filename.SetPath(mExportOptionsPanel->GetPath());
   setting.channels = mExportOptionsPanel->GetChannels();
   setting.filename.SetFullName(mExportOptionsPanel->GetFullName());
 
   wxString name;    // used to hold file name whilst we mess with it
   wxString title;   // un-messed-with title of file for tagging with
 
   const LabelStruct *info = NULL;
   /* Examine all labels a first time, sort out all data but don't do any
    * exporting yet (so this run is quick but interactive) */
   while( fileIndex < numLabels ) {
 
      // Get file name and starting time
      if( fileIndex < 0 ) {
         // create wxFileName for output file
         name = setting.filename.GetName();
         setting.t0 = 0.0;
      } else {
         info = labels->GetLabel(fileIndex);
         name = (info->title);
         setting.t0 = info->selectedRegion.t0();
      }
 
      // Figure out the ending time
      if( info && !info->selectedRegion.isPoint() ) {
         setting.t1 = info->selectedRegion.t1();
      } else if( fileIndex < numLabels - 1 ) {
         // Use start of next label as end
         const LabelStruct *info1 = labels->GetLabel(fileIndex+1);
         setting.t1 = info1->selectedRegion.t0();
      } else {
         setting.t1 = tracks.GetEndTime();
      }
 
      if( name.empty() )
         name = _("untitled");
 
      // store title of label to use in tags
      title = name;
 
      // Numbering files...
      if( !byName ) {
         name.Printf(wxT("%s-%02d"), prefix, fileIndex + 1);
      } else if( addNumber ) {
         // Following discussion with GA, always have 2 digits
         // for easy file-name sorting (on Windows)
         name.Prepend(wxString::Format(wxT("%02d-"), fileIndex + 1));
      }
      Internat::SanitiseFilename(name, wxT("_"));
 
      setting.filename.SetName(name);
      {
         // FIXME: TRAP_ERR User could have given an illegal filename prefix.
         // in that case we should tell them, not fail silently.
         wxASSERT(setting.filename.IsOk());     // burp if file name is broke
 
         // Make sure the (final) file name is unique within the set of exports
         FileNames::MakeNameUnique(otherNames, setting.filename);
 
         /* do the metadata for this file */
         // copy project metadata to start with
         if (exportSettings.empty())
         {
            setting.tags = Tags::Get( mProject );
            setting.tags.LoadDefaults();
         }
         else
            setting.tags = exportSettings.back().tags;
         // over-ride with values
         setting.tags.SetTag(TAG_TITLE, title);
         setting.tags.SetTag(TAG_TRACK, fileIndex+1);
      }
 
      /* add the settings to the array of settings to be used for export */
      exportSettings.push_back(setting);
 
      fileIndex++;  // next label, count up one
   }
   std::swap(mExportSettings, exportSettings);
}

References _, details::begin(), ExportAudioDialog::ExportSetting::channels, TranslatableString::empty(), ExportAudioDialog::ExportSetting::filename, Tags::Get(), TrackList::Get(), ExportFilePanel::GetChannels(), ExportPlugin::GetFormatInfo(), ExportFilePanel::GetFullName(), ExportFilePanel::GetPath(), SelectedRegion::isPoint(), Tags::LoadDefaults(), FileNames::MakeNameUnique(), mExportOptionsPanel, mExportSettings, mIncludeAudioBeforeFirstLabel, mProject, name, Internat::SanitiseFilename(), LabelStruct::selectedRegion, Tags::SetTag(), anonymous_namespace{NoteTrack.cpp}::swap(), SelectedRegion::t0(), ExportAudioDialog::ExportSetting::t0, SelectedRegion::t1(), ExportAudioDialog::ExportSetting::t1, TAG_TITLE, TAG_TRACK, ExportAudioDialog::ExportSetting::tags, LabelStruct::title, title, tracks, and wxT().

Referenced by UpdateExportSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTrackExportSettings()

void ExportAudioDialog::UpdateTrackExportSettings	(	const ExportPlugin &	plugin,
		int	formatIndex,
		bool	byName,
		bool	addNumber,
		const wxString &	prefix
	)

private

Definition at line 783 of file ExportAudioDialog.cpp.

{
   auto& tracks = TrackList::Get(mProject);
 
   bool anySolo = !(( tracks.Any<const WaveTrack>() + &WaveTrack::GetSolo ).empty());
 
   auto waveTracks = tracks.Any<WaveTrack>() -
      (anySolo ? &WaveTrack::GetNotSolo : &WaveTrack::GetMute);
 
   const auto numWaveTracks = waveTracks.size();
 
   auto fileIndex = 0;     // track counter
   FilePaths otherNames;
   auto formatInfo = plugin.GetFormatInfo(formatIndex);
   std::vector<ExportSetting> exportSettings; // dynamic array we will use to store the
                                  // settings needed to do the exports with in
   exportSettings.reserve(numWaveTracks);   // Allocate some guessed space to use.
   ExportSetting setting;   // the current batch of settings
   setting.filename.SetPath(mExportOptionsPanel->GetPath());
   setting.filename.SetExt(wxFileName{mExportOptionsPanel->GetFullName()}.GetExt());
 
   wxString name;    // used to hold file name whilst we mess with it
   wxString title;   // un-messed-with title of file for tagging with
 
   const auto skipSilenceAtBeginning = mSkipSilenceAtBeginning->GetValue();
 
   /* Examine all tracks in turn, collecting export information */
   for (auto tr : waveTracks) {
 
      // Get the times for the track
      setting.t0 = skipSilenceAtBeginning ? tr->GetStartTime() : 0;
      setting.t1 = tr->GetEndTime();
 
      setting.channels = mExportOptionsPanel->GetChannels();
      // Get name and title
      title = tr->GetName();
      if( title.empty() )
         title = _("untitled");
 
      if (byName) {
         name = title;
         if (addNumber) {
            name.Prepend(
               wxString::Format(wxT("%02d-"), fileIndex+1));
         }
      }
      else {
         name = (wxString::Format(wxT("%s-%02d"), prefix, fileIndex+1));
      }
 
      Internat::SanitiseFilename(name, wxT("_"));
      // store sanitised and user checked name in object
      setting.filename.SetName(name);
 
      // FIXME: TRAP_ERR User could have given an illegal track name.
      // in that case we should tell them, not fail silently.
      wxASSERT(setting.filename.IsOk());     // burp if file name is broke
 
      // Make sure the (final) file name is unique within the set of exports
      FileNames::MakeNameUnique(otherNames, setting.filename);
 
      /* do the metadata for this file */
      // copy project metadata to start with
 
      if(exportSettings.empty())
      {
         setting.tags = Tags::Get( mProject );
         setting.tags.LoadDefaults();
      }
      else
         setting.tags = exportSettings.back().tags;
 
      // over-ride with values
      setting.tags.SetTag(TAG_TITLE, title);
      setting.tags.SetTag(TAG_TRACK, fileIndex + 1);
 
      exportSettings.push_back(setting);
 
      fileIndex++;  // next track, count up one
   }
   std::swap(mExportSettings, exportSettings);
}

References _, ExportAudioDialog::ExportSetting::channels, ExportAudioDialog::ExportSetting::filename, Tags::Get(), TrackList::Get(), ExportFilePanel::GetChannels(), ExportPlugin::GetFormatInfo(), ExportFilePanel::GetFullName(), WaveTrack::GetMute(), PlayableTrack::GetNotSolo(), ExportFilePanel::GetPath(), WaveTrack::GetSolo(), Tags::LoadDefaults(), FileNames::MakeNameUnique(), mExportOptionsPanel, mExportSettings, mProject, mSkipSilenceAtBeginning, name, Internat::SanitiseFilename(), Tags::SetTag(), anonymous_namespace{NoteTrack.cpp}::swap(), ExportAudioDialog::ExportSetting::t0, ExportAudioDialog::ExportSetting::t1, TAG_TITLE, TAG_TRACK, ExportAudioDialog::ExportSetting::tags, title, tracks, and wxT().

Referenced by UpdateExportSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mEditMetadata

wxButton* ExportAudioDialog::mEditMetadata {}

private

Definition at line 121 of file ExportAudioDialog.h.

Referenced by OnFormatChange(), and PopulateOrExchange().

◆ mExportOptionsPanel

ExportFilePanel* ExportAudioDialog::mExportOptionsPanel {}

private

Definition at line 116 of file ExportAudioDialog.h.

Referenced by OnExport(), OnExportRangeChange(), OnFormatChange(), PopulateOrExchange(), Show(), UpdateExportSettings(), UpdateLabelExportSettings(), and UpdateTrackExportSettings().

◆ mExportRangeSelection

wxRadioButton* ExportAudioDialog::mExportRangeSelection {}

private

Definition at line 127 of file ExportAudioDialog.h.

◆ mExportSettings

std::vector<ExportSetting> ExportAudioDialog::mExportSettings

private

Definition at line 136 of file ExportAudioDialog.h.

Referenced by DoExportSplitByLabels(), DoExportSplitByTracks(), OnEditMetadata(), UpdateLabelExportSettings(), and UpdateTrackExportSettings().

◆ mExportSettingsDirty

bool ExportAudioDialog::mExportSettingsDirty {true}

private

Definition at line 137 of file ExportAudioDialog.h.

Referenced by OnExportRangeChange(), OnFileNamePrefixChange(), OnFormatChange(), OnIncludeAudioBeforeFirstLabelChange(), OnSplitModeChange(), OnSplitNamePolicyChange(), OnTrimBlankSpaceBeforeFirstClip(), and UpdateExportSettings().

◆ mIncludeAudioBeforeFirstLabel

wxCheckBox* ExportAudioDialog::mIncludeAudioBeforeFirstLabel {}

private

Definition at line 119 of file ExportAudioDialog.h.

Referenced by OnSplitModeChange(), PopulateOrExchange(), and UpdateLabelExportSettings().

◆ mOverwriteExisting

wxCheckBox* ExportAudioDialog::mOverwriteExisting {}

private

Definition at line 133 of file ExportAudioDialog.h.

Referenced by DoExport(), and PopulateOrExchange().

◆ mProject

AudacityProject& ExportAudioDialog::mProject

private

Definition at line 114 of file ExportAudioDialog.h.

Referenced by DoExportSplitByTracks(), OnEditMetadata(), OnExport(), PopulateOrExchange(), UpdateLabelExportSettings(), and UpdateTrackExportSettings().

◆ mRangeProject

wxRadioButton* ExportAudioDialog::mRangeProject

private

Definition at line 122 of file ExportAudioDialog.h.

Referenced by PopulateOrExchange().

◆ mRangeSelection

wxRadioButton* ExportAudioDialog::mRangeSelection {}

private

Definition at line 123 of file ExportAudioDialog.h.

Referenced by OnExport(), and PopulateOrExchange().

◆ mRangeSplit

wxRadioButton* ExportAudioDialog::mRangeSplit {}

private

Definition at line 124 of file ExportAudioDialog.h.

Referenced by OnEditMetadata(), OnExport(), PopulateOrExchange(), and UpdateExportSettings().

◆ mSkipSilenceAtBeginning

wxCheckBox* ExportAudioDialog::mSkipSilenceAtBeginning {}

private

Definition at line 134 of file ExportAudioDialog.h.

Referenced by OnExport(), PopulateOrExchange(), and UpdateTrackExportSettings().

◆ mSplitByLabels

wxRadioButton* ExportAudioDialog::mSplitByLabels {}

private

Definition at line 125 of file ExportAudioDialog.h.

Referenced by OnExport(), PopulateOrExchange(), and UpdateExportSettings().

◆ mSplitByTracks

wxRadioButton* ExportAudioDialog::mSplitByTracks {}

private

Definition at line 126 of file ExportAudioDialog.h.

Referenced by OnExport(), PopulateOrExchange(), and UpdateExportSettings().

◆ mSplitFileNamePrefix

wxTextCtrl* ExportAudioDialog::mSplitFileNamePrefix {}

private

Definition at line 120 of file ExportAudioDialog.h.

Referenced by OnSplitNamePolicyChange(), PopulateOrExchange(), and UpdateExportSettings().

◆ mSplitModeLabels

wxRadioButton* ExportAudioDialog::mSplitModeLabels {}

private

Definition at line 129 of file ExportAudioDialog.h.

◆ mSplitModeTracks

wxRadioButton* ExportAudioDialog::mSplitModeTracks {}

private

Definition at line 128 of file ExportAudioDialog.h.

◆ mSplitsPanel

wxWindow* ExportAudioDialog::mSplitsPanel {}

private

Definition at line 118 of file ExportAudioDialog.h.

Referenced by OnExportRangeChange(), and PopulateOrExchange().

◆ mSplitUseName

wxRadioButton* ExportAudioDialog::mSplitUseName {}

private

Definition at line 130 of file ExportAudioDialog.h.

Referenced by PopulateOrExchange(), and UpdateExportSettings().

◆ mSplitUseNumAndName

wxRadioButton* ExportAudioDialog::mSplitUseNumAndName {}

private

Definition at line 131 of file ExportAudioDialog.h.

Referenced by PopulateOrExchange(), and UpdateExportSettings().

◆ mSplitUseNumAndPrefix

wxRadioButton* ExportAudioDialog::mSplitUseNumAndPrefix {}

private

Definition at line 132 of file ExportAudioDialog.h.

Referenced by PopulateOrExchange().

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

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ExportMode

Constructor & Destructor Documentation

◆ ExportAudioDialog()

◆ ~ExportAudioDialog()

Member Function Documentation

◆ DoExport()

◆ DoExportSplitByLabels()

◆ DoExportSplitByTracks()

◆ OnEditMetadata()

◆ OnExport()

◆ OnExportRangeChange()

◆ OnFileNamePrefixChange()

◆ OnFormatChange()

◆ OnHelp()

◆ OnIncludeAudioBeforeFirstLabelChange()

◆ OnSplitModeChange()

◆ OnSplitNamePolicyChange()

◆ OnTrimBlankSpaceBeforeFirstClip()

◆ PopulateOrExchange()

◆ Show()

◆ UpdateExportSettings()

◆ UpdateLabelExportSettings()

◆ UpdateTrackExportSettings()

Member Data Documentation

◆ mEditMetadata

◆ mExportOptionsPanel

◆ mExportRangeSelection

◆ mExportSettings

◆ mExportSettingsDirty

◆ mIncludeAudioBeforeFirstLabel

◆ mOverwriteExisting

◆ mProject

◆ mRangeProject

◆ mRangeSelection

◆ mRangeSplit

◆ mSkipSilenceAtBeginning

◆ mSplitByLabels

◆ mSplitByTracks

◆ mSplitFileNamePrefix

◆ mSplitModeLabels

◆ mSplitModeTracks

◆ mSplitsPanel

◆ mSplitUseName

◆ mSplitUseNumAndName

◆ mSplitUseNumAndPrefix