{

public:

Tags filetags; /**< The set of metadata to use for the export */

wxFileNameWrapper destfile; /**< The file to export to */

double t0; /**< Start time for the export */

double t1; /**< End time for the export */

unsigned channels; /**< Number of channels for ExportMultipleByTrack */

: wxDialogWrapper( &GetProjectFrame( *project ),

wxID_ANY, XO("Export Multiple") )

, mExporter{ *project }

, mSelectionState{ SelectionState::Get( *project ) }

{

SetName();

mProject = project;

mTracks = &TrackList::Get( *project );

// Construct an array of non-owning pointers

for (const auto &plugin : mExporter.GetPlugins())

mPlugins.push_back(plugin.get());

this->CountTracksAndLabels();

mBook = NULL;

ShuttleGui S(this, eIsCreatingFromPrefs);

// Creating some of the widgets cause events to fire

// and we don't want that until after we're completely

// created. (Observed on Windows)

mInitialized = false;

PopulateOrExchange(S);

mInitialized = true;

Layout();

Fit();

SetMinSize(GetSize());

Center();

EnableControls();

{

bool anySolo = !(( mTracks->Any<const WaveTrack>() + &WaveTrack::GetSolo ).empty());

mNumWaveTracks =

(mTracks->Leaders< const WaveTrack >() -

(anySolo ? &WaveTrack::GetNotSolo : &WaveTrack::GetMute)).size();

// only the first label track

mLabels = *mTracks->Any< const LabelTrack >().begin();

mNumLabels = mLabels ? mLabels->GetNumLabels() : 0;

{

// Cannot export if all audio tracks are muted.

if (mNumWaveTracks == 0)

{

::AudacityMessageBox(

XO("All audio is muted."),

XO("Cannot Export Multiple"),

wxOK | wxCENTRE,

this);

return wxID_CANCEL;

}

if ((mNumWaveTracks < 1) && (mNumLabels < 1))

{

::AudacityMessageBox(

XO(

\nlabels, so you cannot export to separate audio files."),

XO("Cannot Export Multiple"),

wxOK | wxCENTRE,

this);

return wxID_CANCEL;

}

bool bHasLabels = (mNumLabels > 0);

bool bHasTracks = (mNumWaveTracks > 0);

mLabel->Enable(bHasLabels && bHasTracks);

mTrack->Enable(bHasTracks);

// If you have 2 or more tracks, then it is export by tracks.

// If you have no labels, then it is export by tracks.

// Otherwise it is export by labels, by default.

bool bPreferByLabels = bHasLabels && (mNumWaveTracks < 2);

mLabel->SetValue(bPreferByLabels);

mTrack->SetValue(!bPreferByLabels);

EnableControls();

return wxDialogWrapper::ShowModal();

{

wxString name = mProject->GetProjectName();

wxString defaultFormat = gPrefs->Read(wxT("/Export/Format"), wxT("WAV"));

TranslatableStrings visibleFormats;

wxArrayStringEx formats;

mPluginIndex = -1;

mFilterIndex = 0;

{

int i = -1;

for (const auto &pPlugin : mPlugins)

{

++i;

for (int j = 0; j < pPlugin->GetFormatCount(); j++)

{

auto format = mPlugins[i]->GetDescription(j);

visibleFormats.push_back( format );

// use MSGID of description as a value too, written into config file

// This is questionable. A change in the msgid can make the

// preference stored in old config files inapplicable

formats.push_back( format.MSGID().GET() );

if (mPlugins[i]->GetFormat(j) == defaultFormat) {

mPluginIndex = i;

mSubFormatIndex = j;

}

if (mPluginIndex == -1) mFilterIndex++;

}

}

}

// Bug 1304: Set the default file path. It's used if none stored in config.

auto DefaultPath = FileNames::FindDefaultPath(FileNames::Operation::Export);

if (mPluginIndex == -1)

{

mPluginIndex = 0;

mFilterIndex = 0;

mSubFormatIndex = 0;

}

S.SetBorder(5);

S.StartHorizontalLay(wxEXPAND, true);

{

S.SetBorder(5);

S.StartStatic(XO("Export files to:"), true);

{

S.StartMultiColumn(4, true);

{

mDir = S.Id(DirID)

.AddTextBox(XXO("Folder:"),

DefaultPath,

64);

S.Id(ChooseID).AddButton(XXO("Choose..."));

S.Id(CreateID).AddButton(XXO("Create"));

mFormat = S.Id(FormatID)

.TieChoice( XXO("Format:"),

{

wxT("/Export/MultipleFormat"),

{

ByColumns,

visibleFormats,

formats

},

mFilterIndex

}

);

S.AddVariableText( {}, false);

S.AddVariableText( {}, false);

S.AddPrompt(XXO("Options:"));

mBook = S.Id(OptionsID)

.Style(wxBORDER_STATIC)

.StartSimplebook();

if (S.GetMode() == eIsCreating)

{

for (const auto &pPlugin : mPlugins)

{

for (int j = 0; j < pPlugin->GetFormatCount(); j++)

{

// Name of simple book page is not displayed

S.StartNotebookPage( {} );

pPlugin->OptionsCreate(S, j);

S.EndNotebookPage();

}

}

mBook->ChangeSelection(mFormat->GetSelection());

}

S.EndSimplebook();

S.AddVariableText( {}, false);

S.AddVariableText( {}, false);

}

S.EndMultiColumn();

}

S.EndStatic();

}

S.EndHorizontalLay();

S.StartHorizontalLay(wxEXPAND, false);

{

S.SetBorder(5);

S.StartStatic(XO("Split files based on:"), 1);

{

// Row 1

S.SetBorder(1);

// Bug 2692: Place button group in panel so tabbing will work and,

// on the Mac, VoiceOver will announce as radio buttons.

S.StartPanel();

{

mTrack = S.Id(TrackID)

.AddRadioButton(XXO("Tracks"));

// Row 2

S.SetBorder(1);

mLabel = S.Id(LabelID)

.AddRadioButtonToGroup(XXO("Labels"));

}

S.EndPanel();

S.SetBorder(3);

S.StartMultiColumn(2, wxEXPAND);

S.SetStretchyCol(1);

{

// Row 3 (indented)

S.AddVariableText(Verbatim(" "), false);

mFirst = S.Id(FirstID)

.AddCheckBox(XXO("Include audio before first label"), false);

// Row 4

S.AddVariableText( {}, false);

S.StartMultiColumn(2, wxEXPAND);

S.SetStretchyCol(1);

{

mFirstFileLabel =

S.AddVariableText(XO("First file name:"), false);

mFirstFileName = S.Id(FirstFileNameID)

.Prop(1)

.Name(XO("First file name"))

.TieTextBox( {},

name,

30);

}

S.EndMultiColumn();

}

S.EndMultiColumn();

S.SetBorder(3);

}

S.EndStatic();

S.SetBorder(5);

S.StartStatic(XO("Name files:"), 1);

{

S.SetBorder(2);

// Bug 2692: Place button group in panel so tabbing will work and,

// on the Mac, VoiceOver will announce as radio buttons.

S.StartPanel();

{

S.StartRadioButtonGroup({

wxT("/Export/TrackNameWithOrWithoutNumbers"),

{

{ wxT("labelTrack"), XXO("Using Label/Track Name") },

{ wxT("numberBefore"), XXO("Numbering before Label/Track Name") },

{ wxT("numberAfter"), XXO("Numbering after File name prefix") },

},

0 // labelTrack

});

{

mByName = S.Id(ByNameID).TieRadioButton();

mByNumberAndName = S.Id(ByNameAndNumberID).TieRadioButton();

mByNumber = S.Id(ByNumberID).TieRadioButton();

}

S.EndRadioButtonGroup();

}

S.EndPanel();

S.StartMultiColumn(3, wxEXPAND);

S.SetStretchyCol(2);

{

// Row 3 (indented)

S.AddVariableText(Verbatim(" "), false);

mPrefixLabel = S.AddVariableText(XO("File name prefix:"), false);

mPrefix = S.Id(PrefixID)

.Name(XO("File name prefix"))

.TieTextBox( {},

name,

30);

}

S.EndMultiColumn();

}

S.EndStatic();

}

S.EndHorizontalLay();

S.SetBorder(5);

S.StartHorizontalLay(wxEXPAND, false);

{

mOverwrite = S.Id(OverwriteID).TieCheckBox(XXO("Overwrite existing files"),

{wxT("/Export/OverwriteExisting"),

false});

}

S.EndHorizontalLay();

S.AddStandardButtons(eOkButton | eCancelButton | eHelpButton);

mExport = (wxButton *)wxWindow::FindWindowById(wxID_OK, this);

mExport->SetLabel(_("Export"));

{

bool enable;

if (!mInitialized) {

return;

}

mFirst->Enable(mLabel->GetValue());

enable = mLabel->GetValue() &&

(mByName->GetValue() || mByNumberAndName->GetValue()) &&

mFirst->GetValue();

mFirstFileLabel->Enable(enable);

mFirstFileName->Enable(enable);

enable = mByNumber->GetValue();

mPrefixLabel->Enable(enable);

mPrefix->Enable(enable);

bool ok = true;

if (mLabel->GetValue() && mFirst->GetValue() &&

mFirstFileName->GetValue().empty() &&

mPrefix->GetValue().empty())

ok = false;

if (mByNumber->GetValue() &&

mPrefix->GetValue().empty())

ok = false;

mExport->Enable(ok);

{

mBook->ChangeSelection(mFormat->GetSelection());

EnableControls();

{

const int sel = mFormat->GetSelection();

if (sel != wxNOT_FOUND)

{

size_t c = 0;

int i = -1;

for (const auto &pPlugin : mPlugins)

{

++i;

for (int j = 0; j < pPlugin->GetFormatCount(); j++)

{

if ((size_t)sel == c)

{

mPluginIndex = i;

mSubFormatIndex = j;

}

c++;

}

}

}

mPlugins[mPluginIndex]->DisplayOptions(this,mSubFormatIndex);

{

wxFileName fn;

fn.AssignDir(mDir->GetValue());

bool ok = fn.Mkdir(0777, wxPATH_MKDIR_FULL);

if (!ok) {

// Mkdir will produce an error dialog

return;

}

::AudacityMessageBox(

XO("\"%s\" successfully created.").Format( fn.GetPath() ),

XO("Export Multiple"),

wxOK | wxCENTRE,

this);

{

wxDirDialogWrapper dlog(this,

XO("Choose a location to save the exported files"),

mDir->GetValue());

dlog.ShowModal();

if (!dlog.GetPath().empty())

mDir->SetValue(dlog.GetPath());

{

ShuttleGui S(this, eIsSavingToPrefs);

PopulateOrExchange(S);

gPrefs->Flush();

FileNames::UpdateDefaultPath(FileNames::Operation::Export, mDir->GetValue());

// Make sure the output directory is in good shape

if (!DirOk()) {

return;

}

mFilterIndex = mFormat->GetSelection();

if (mFilterIndex != wxNOT_FOUND)

{

size_t c = 0;

int i = -1;

for (const auto &pPlugin : mPlugins)

{

++i;

for (int j = 0; j < pPlugin->GetFormatCount(); j++, c++)

{

if ((size_t)mFilterIndex == c)

{ // this is the selected format. Store the plug-in and sub-format

// needed to achieve it.

mPluginIndex = i;

mSubFormatIndex = j;

mBook->GetPage(mFilterIndex)->TransferDataFromWindow();

}

}

}

}

ProgressResult ok = ProgressResult::Failed;

mExported.clear();

// Give 'em the result

auto cleanup = finally( [&]

{

auto msg = (ok == ProgressResult::Success

? XO("Successfully exported the following %lld file(s).")

: ok == ProgressResult::Failed

? XO("Something went wrong after exporting the following %lld file(s).")

: ok == ProgressResult::Cancelled

? XO("Export canceled after exporting the following %lld file(s).")

: ok == ProgressResult::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) mExported.size());

wxString FileList;

for (size_t i = 0; i < mExported.size(); i++) {

FileList += mExported[i];

FileList += '\n';

}

// TODO: give some warning dialog first, when only some files exported

// successfully.

GuardedCall( [&] {

// This results dialog is a child of this dialog.

HelpSystem::ShowInfoDialog( this,

XO("Export Multiple"),

msg,

FileList,

450,400);

} );

} );

if (mLabel->GetValue()) {

ok = ExportMultipleByLabel(mByName->GetValue() || mByNumberAndName->GetValue(),

mPrefix->GetValue(),

mByNumberAndName->GetValue());

}

else {

ok = ExportMultipleByTrack(mByName->GetValue() || mByNumberAndName->GetValue(),

mPrefix->GetValue(),

mByNumberAndName->GetValue());

}

if (ok == ProgressResult::Success || ok == ProgressResult::Stopped) {

EndModal(1);

}

{

wxFileName fn;

fn.AssignDir(mDir->GetValue());

if (fn.DirExists()) {

return true;

}

auto prompt = XO("\"%s\" doesn't exist.\n\nWould you like to create it?")

.Format( fn.GetFullPath() );

int action = AudacityMessageBox(

prompt,

XO("Warning"),

wxYES_NO | wxICON_EXCLAMATION);

if (action != wxYES) {

return false;

}

return fn.Mkdir(0777, wxPATH_MKDIR_FULL);

{

/* counters for tracks panned different places */

int numLeft = 0;

int numRight = 0;

//int numMono = 0;

/* track iteration kit */

bool anySolo = !(( tracks.Any<const WaveTrack>() + &WaveTrack::GetSolo ).empty());

// Want only unmuted wave tracks.

for (auto tr :

tracks.Any< const WaveTrack >() -

(anySolo ? &WaveTrack::GetNotSolo : &WaveTrack::GetMute)

) {

// Found a left channel

if (tr->GetChannel() == Track::LeftChannel) {

numLeft++;

}

// Found a right channel

else if (tr->GetChannel() == Track::RightChannel) {

numRight++;

}

// Found a mono channel, but it may be panned

else if (tr->GetChannel() == Track::MonoChannel) {

float pan = tr->GetPan();

// Figure out what kind of channel it should be

if (pan == -1.0) { // panned hard left

numLeft++;

}

else if (pan == 1.0) { // panned hard right

numRight++;

}

else if (pan == 0) { // panned dead center

// numMono++;

}

else { // panned somewhere else

numLeft++;

numRight++;

}

}

}

// if there is stereo content, report 2, else report 1

if (numRight > 0 || numLeft > 0) {

return 2;

}

return 1;

const wxString &prefix, bool addNumber)

{

wxASSERT(mProject);

int numFiles = mNumLabels;

int l = 0; // counter for files done

std::vector<ExportKit> exportSettings; // dynamic array for settings.

exportSettings.reserve(numFiles); // Allocate some guessed space to use.

// Account for exporting before first label

if( mFirst->GetValue() ) {

l--;

numFiles++;

}

// Figure out how many channels we should export.

auto channels = GetNumExportChannels( *mTracks );

FilePaths otherNames; // keep track of file names we will use, so we

// don't duplicate them

ExportKit setting; // the current batch of settings

setting.destfile.SetPath(mDir->GetValue());

setting.destfile.SetExt(mPlugins[mPluginIndex]->GetExtension(mSubFormatIndex));

wxLogDebug(wxT("Plug-in index = %d, Sub-format = %d"), mPluginIndex, mSubFormatIndex);

wxLogDebug(wxT("File extension is %s"), setting.destfile.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 LabelStruct *info = NULL;

/* Examine all labels a first time, sort out all data but don't do any

while( l < mNumLabels ) {

// Get file name and starting time

if( l < 0 ) {

// create wxFileName for output file

name = (mFirstFileName->GetValue());

setting.t0 = 0.0;

} else {

info = mLabels->GetLabel(l);

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( l < mNumLabels-1 ) {

// Use start of next label as end

const LabelStruct *info1 = mLabels->GetLabel(l+1);

setting.t1 = info1->selectedRegion.t0();

} else {

setting.t1 = mTracks->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, l+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-"), l+1));

}

// store sanitised and user checked name in object

setting.destfile.SetName(MakeFileName(name));

if( setting.destfile.GetName().empty() )

{ // user cancelled dialogue, or deleted everything in field.

// or maybe the label was empty??

// So we ignore this one and keep going.

}

else

{

// FIXME: TRAP_ERR User could have given an illegal filename prefix.

// in that case we should tell them, not fail silently.

wxASSERT(setting.destfile.IsOk()); // burp if file name is broke

// Make sure the (final) file name is unique within the set of exports

FileNames::MakeNameUnique(otherNames, setting.destfile);

/* do the metadata for this file */

// copy project metadata to start with

setting.filetags = Tags::Get( *mProject );

setting.filetags.LoadDefaults();

if (exportSettings.size()) {

setting.filetags = exportSettings.back().filetags;

}

// over-ride with values

setting.filetags.SetTag(TAG_TITLE, title);

setting.filetags.SetTag(TAG_TRACK, l+1);

// let the user have a crack at editing it, exit if cancelled

auto &settings = ProjectSettings::Get( *mProject );

bool bShowTagsDialog = settings.GetShowId3Dialog();

bShowTagsDialog = bShowTagsDialog && mPlugins[mPluginIndex]->GetCanMetaData(mSubFormatIndex);

if( bShowTagsDialog ){

bool bCancelled = !setting.filetags.ShowEditDialog(

ProjectWindow::Find( mProject ),

XO("Edit Metadata Tags"), bShowTagsDialog);

gPrefs->Read(wxT("/AudioFiles/ShowId3Dialog"), &bShowTagsDialog, true);

settings.SetShowId3Dialog( bShowTagsDialog );

if( bCancelled )

return ProgressResult::Cancelled;

}

}

/* add the settings to the array of settings to be used for export */

exportSettings.push_back(setting);

l++; // next label, count up one

}

auto ok = ProgressResult::Success; // did it work?

int count = 0; // count the number of successful runs

ExportKit activeSetting; // pointer to the settings in use for this export

/* Go round again and do the exporting (so this run is slow but

std::unique_ptr<ProgressDialog> pDialog;

for (count = 0; count < numFiles; count++) {

/* get the settings to use for the export from the array */

activeSetting = exportSettings[count];

// Bug 1440 fix.

if( activeSetting.destfile.GetName().empty() )

continue;

// Export it

ok = DoExport(pDialog, channels, activeSetting.destfile, false,

activeSetting.t0, activeSetting.t1, activeSetting.filetags);

if (ok == ProgressResult::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 != ProgressResult::Success) {

break;

}

}

return ok;

const wxString &prefix, bool addNumber)

{

wxASSERT(mProject);

int l = 0; // track counter

auto ok = ProgressResult::Success;

FilePaths otherNames;

std::vector<ExportKit> exportSettings; // dynamic array we will use to store the

// settings needed to do the exports with in

exportSettings.reserve(mNumWaveTracks); // Allocate some guessed space to use.

ExportKit setting; // the current batch of settings

setting.destfile.SetPath(mDir->GetValue());

setting.destfile.SetExt(mPlugins[mPluginIndex]->GetExtension(mSubFormatIndex));

wxString name; // used to hold file name whilst we mess with it

wxString title; // un-messed-with title of file for tagging with

/* Remember which tracks were selected, and set them to deselected */

SelectionStateChanger changer{ mSelectionState, *mTracks };

for (auto tr : mTracks->Selected<WaveTrack>())

tr->SetSelected(false);

bool anySolo = !(( mTracks->Any<const WaveTrack>() + &WaveTrack::GetSolo ).empty());

bool skipSilenceAtBeginning;

gPrefs->Read(wxT("/AudioFiles/SkipSilenceAtBeginning"), &skipSilenceAtBeginning, false);

/* Examine all tracks in turn, collecting export information */

for (auto tr : mTracks->Leaders<WaveTrack>() -

(anySolo ? &WaveTrack::GetNotSolo : &WaveTrack::GetMute)) {

// Get the times for the track

auto channels = TrackList::Channels(tr);

setting.t0 = skipSilenceAtBeginning ? channels.min(&Track::GetStartTime) : 0;

setting.t1 = channels.max( &Track::GetEndTime );

// number of export channels?

setting.channels = channels.size();

if (setting.channels == 1 &&

!(tr->GetChannel() == WaveTrack::MonoChannel &&

tr->GetPan() == 0.0))

setting.channels = 2;

// Get name and title

title = tr->GetName();

if( title.empty() )

title = _("untitled");

if (byName) {

name = title;

if (addNumber) {

name.Prepend(

wxString::Format(wxT("%02d-"), l+1));

}

}

else {

name = (wxString::Format(wxT("%s-%02d"), prefix, l+1));

}

// store sanitised and user checked name in object

setting.destfile.SetName(MakeFileName(name));

if (setting.destfile.GetName().empty())

{ // user cancelled dialogue, or deleted everything in field.

// So we ignore this one and keep going.

}

else

{

// FIXME: TRAP_ERR User could have given an illegal track name.

// in that case we should tell them, not fail silently.

wxASSERT(setting.destfile.IsOk()); // burp if file name is broke

// Make sure the (final) file name is unique within the set of exports

FileNames::MakeNameUnique(otherNames, setting.destfile);

/* do the metadata for this file */

// copy project metadata to start with

setting.filetags = Tags::Get( *mProject );

setting.filetags.LoadDefaults();

if (exportSettings.size()) {

setting.filetags = exportSettings.back().filetags;

}

// over-ride with values

setting.filetags.SetTag(TAG_TITLE, title);

setting.filetags.SetTag(TAG_TRACK, l+1);

// let the user have a crack at editing it, exit if cancelled

auto &settings = ProjectSettings::Get( *mProject );

bool bShowTagsDialog = settings.GetShowId3Dialog();

bShowTagsDialog = bShowTagsDialog && mPlugins[mPluginIndex]->GetCanMetaData(mSubFormatIndex);

if( bShowTagsDialog ){

bool bCancelled = !setting.filetags.ShowEditDialog(

ProjectWindow::Find( mProject ),

XO("Edit Metadata Tags"), bShowTagsDialog);

gPrefs->Read(wxT("/AudioFiles/ShowId3Dialog"), &bShowTagsDialog, true);

settings.SetShowId3Dialog( bShowTagsDialog );

if( bCancelled )