TagsEditorDialog Class Reference

Derived from ExpandingToolBar, this dialog allows editing of Tags. More...

#include <TagsEditor.h>

Inheritance diagram for TagsEditorDialog:

Collaboration diagram for TagsEditorDialog:

Public Member Functions
	TagsEditorDialog (wxWindow *parent, const TranslatableString &title, std::vector< Tags * > tags, std::vector< wxString > names, bool editTitle, bool editTrack)
virtual	~TagsEditorDialog ()
void	PopulateOrExchange (ShuttleGui &S)
void	OnHelp (wxCommandEvent &Evt)
bool	TransferDataToWindow () override
bool	TransferDataFromWindow () 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

Static Public Member Functions
static AUDACITY_DLL_API bool	ShowEditDialog (Tags &tags, wxWindow *parent, const TranslatableString &title)
static AUDACITY_DLL_API bool	EditProjectMetadata (AudacityProject &project, const TranslatableString &title, const TranslatableString &shortUndoDescription)

Private Member Functions
void	PopulateGenres ()
void	SetEditors ()
void	OnNext (wxCommandEvent &)
void	OnPrev (wxCommandEvent &)
void	OnChange (wxGridEvent &event)
void	OnEdit (wxCommandEvent &event)
void	OnReset (wxCommandEvent &event)
void	OnClear (wxCommandEvent &event)
void	OnLoad (wxCommandEvent &event)
void	OnSave (wxCommandEvent &event)
void	OnSaveDefaults (wxCommandEvent &event)
void	OnAdd (wxCommandEvent &event)
void	OnRemove (wxCommandEvent &event)
void	OnOk (wxCommandEvent &event)
void	DoCancel (bool escKey)
void	OnCancel (wxCommandEvent &event)
void	OnKeyDown (wxKeyEvent &event)
bool	IsWindowRectValid (const wxRect *windowRect) const

Private Attributes
std::vector< Tags * >	mTags
std::vector< wxString >	mNames
int	mSelectedIndex {0}
bool	mEditTitle
bool	mEditTrack
std::vector< std::unique_ptr< Tags > >	mEditTags
Grid *	mGrid
wxStaticText *	mName {}
wxButton *	mNext {}
wxButton *	mPrev {}
ComboEditor *	mComboEditor
wxGridCellStringRenderer *	mStringRenderer

Detailed Description

Derived from ExpandingToolBar, this dialog allows editing of Tags.

Definition at line 21 of file TagsEditor.h.

Constructor & Destructor Documentation

TagsEditorDialog()

TagsEditorDialog::TagsEditorDialog	(	wxWindow *	parent,
		const TranslatableString &	title,
		std::vector< Tags * >	tags,
		std::vector< wxString >	names,
		bool	editTitle,
		bool	editTrack
	)

Definition at line 212 of file TagsEditor.cpp.

:  wxDialogWrapper(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize,
            wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER),
   mTags(std::move(tags)),
   mNames(std::move(names)),
   mEditTitle(editTitle),
   mEditTrack(editTrack)
{
   assert(mTags.size() == 1 || (mTags.size() > 1 && mTags.size() == mNames.size()));
 
   SetName();
 
   mGrid = NULL;
 
   // Make a local copy of the passed in tags
   mEditTags.reserve(mTags.size());
   for(auto ptr : mTags)
      mEditTags.push_back(std::make_unique<Tags>(*ptr));
 
   // Build, size, and position the dialog
   ShuttleGui S(this, eIsCreating);
   PopulateOrExchange(S);
 
   TransferDataToWindow();
 
   Layout();
   Fit();
   Center();
   wxSize sz = GetSize();
   SetSizeHints(sz.x, std::min(sz.y, 600));
 
   // Restore the original tags because TransferDataToWindow() will be called again
   for(unsigned i = 0; i < mEditTags.size(); ++i)
   {
      mEditTags[i]->Clear();
      *mEditTags[i] = *mTags[i];
   }
   // Override size and position with last saved
   wxRect r = GetRect();
   gPrefs->Read(wxT("/TagsEditorDialog/x"), &r.x, r.x);
   gPrefs->Read(wxT("/TagsEditorDialog/y"), &r.y, r.y);
   gPrefs->Read(wxT("/TagsEditorDialog/width"), &r.width, r.width);
   gPrefs->Read(wxT("/TagsEditorDialog/height"), &r.height, r.height);
   //On multi-monitor systems, there's a chance the last saved window position is
   //on a monitor that has been removed or is unavailable.
   if (IsWindowRectValid(&r))
      Move(r.GetPosition());
 
   SetSize(r.GetSize());
   Layout();
 
   // Resize value column width based on width of columns and the vertical scrollbar
   wxScrollBar sb(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL);
   r = mGrid->GetClientRect();
   r.width -= mGrid->GetColSize(0);
   r.width -= sb.GetSize().GetWidth();
   r.width -= 10;
   r.width -= r.x;
   mGrid->SetColSize(1, r.width);
   //Bug 2038
   mGrid->SetFocus();
 
   // Load the genres
   PopulateGenres();
}

References eIsCreating, gPrefs, min(), audacity::BasicSettings::Read(), S, and wxT().

Here is the call graph for this function:

~TagsEditorDialog()

TagsEditorDialog::~TagsEditorDialog ( )

virtual

Definition at line 283 of file TagsEditor.cpp.

{
   // This DELETE is not needed because wxWidgets owns the grid.
// DELETE mGrid;
 
// TODO:  Need to figure out if these should be deleted.  Looks like the wxGrid
//        code takes ownership and uses reference counting, but there's been
//        cases where they show up as memory leaks.
//  PRL: Fixed the leaks, see commit c87eb0804bc5f40659b133cab6e2ade061959645
//   DELETE mStringRenderer;
//   DELETE mComboEditor;
}

Member Function Documentation

DoCancel()

void TagsEditorDialog::DoCancel ( bool  escKey )

private

Definition at line 889 of file TagsEditor.cpp.

{
   if (mGrid->IsCellEditControlShown()) {
      auto editor = mGrid->GetCellEditor(mGrid->GetGridCursorRow(),
         mGrid->GetGridCursorCol());
      editor->Reset();
      // To avoid memory leak, don't forget DecRef()!
      editor->DecRef();
      mGrid->HideCellEditControl();
#if defined(__WXMSW__)
      return;
#endif
   }
 
   auto focus = wxWindow::FindFocus();
   if (escKey && focus == mGrid)
      return;
 
   EndModal(wxID_CANCEL);
}

References BasicUI::FindFocus(), and mGrid.

Referenced by OnCancel(), and OnKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

EditProjectMetadata()

bool TagsEditorDialog::EditProjectMetadata ( AudacityProject &  project, const TranslatableString &  title, const TranslatableString &  shortUndoDescription  )

static

Invoke ShowEditDialog on project's tags; commit change in undo history, return true if not cancelled

Definition at line 1001 of file TagsEditor.cpp.

{
   auto &tags = Tags::Get( project );
 
   // Back up my tags
   // Tags (artist name, song properties, MP3 ID3 info, etc.)
   // The structure may be shared with undo history entries
   // To keep undo working correctly, always replace this with a NEW duplicate
   // BEFORE doing any editing of it!
   auto newTags = tags.Duplicate();
 
   if (ShowEditDialog(*newTags, &GetProjectFrame( project ), title)) {
      if (tags != *newTags) {
         // Commit the change to project state only now.
         Tags::Set( project, newTags );
         ProjectHistory::Get( project ).PushState( title, shortUndoDescription);
      }
      return true;
   }
 
   return false;
}

References ProjectHistory::Get(), Tags::Get(), GetProjectFrame(), project, ProjectHistory::PushState(), Tags::Set(), ShowEditDialog(), and title.

Referenced by anonymous_namespace{TagsEditor.cpp}::OnEditMetadata(), TimerRecordExportDialog::OnEditMetadata(), and ExportAudioDialog::OnEditMetadata().

Here is the call graph for this function:

Here is the caller graph for this function:

IsWindowRectValid()

bool TagsEditorDialog::IsWindowRectValid ( const wxRect *  windowRect ) const

private

Definition at line 979 of file TagsEditor.cpp.

{
   wxDisplay display;
   wxPoint topLeft(windowRect->GetTopLeft().x, windowRect->GetTopLeft().y);
   wxPoint topRight(windowRect->GetTopRight().x, windowRect->GetTopRight().y);
   wxPoint bottomLeft(windowRect->GetBottomLeft().x, windowRect->GetBottomLeft().y);
   wxPoint bottomRight(windowRect->GetBottomRight().x, windowRect->GetBottomRight().y);
   display.GetFromPoint(topLeft);
   if (display.GetFromPoint(topLeft) == -1 &&
       display.GetFromPoint(topRight) == -1 &&
       display.GetFromPoint(bottomLeft) == -1 &&
       display.GetFromPoint(bottomRight) == -1) {
      return false;
   }
 
   return true;
}

OnAdd()

void TagsEditorDialog::OnAdd ( wxCommandEvent &  event )

private

Definition at line 828 of file TagsEditor.cpp.

{
   mGrid->AppendRows();
}

References mGrid.

OnCancel()

void TagsEditorDialog::OnCancel ( wxCommandEvent &  event )

private

Definition at line 884 of file TagsEditor.cpp.

{
   DoCancel(false);
}

References DoCancel().

Here is the call graph for this function:

OnChange()

void TagsEditorDialog::OnChange ( wxGridEvent &  event )

private

Definition at line 522 of file TagsEditor.cpp.

{
   static bool ischanging = false;
 
   // Prevent recursion
   if (ischanging) {
      return;
   }
 
   event.Skip();
 
   if (event.GetCol() != 0) {
      return;
   }
 
   // Do not permit duplication of any of the tags.
   // Tags differing only in case are nondistinct.
   auto row = event.GetRow();
   const wxString key0 = mGrid->GetCellValue(row, 0).Upper();
   auto nn = mGrid->GetNumberRows();
   for (decltype(nn) ii = 0; ii < nn; ++ii) {
      if (ii == row)
         continue;
      auto key = mGrid->GetCellValue(ii, 0).Upper();
      if (key0.CmpNoCase(key) == 0) {
         ischanging = true;
         wxBell();
         mGrid->SetGridCursor(ii, 0);
         event.Veto();
         ischanging = false;
         break;
      }
   }
 
   return;
}

References key, anonymous_namespace{TracksPrefs.cpp}::key0, and mGrid.

OnClear()

void TagsEditorDialog::OnClear ( wxCommandEvent &  event )

private

Definition at line 661 of file TagsEditor.cpp.

{
   mEditTags[mSelectedIndex]->Clear();
 
   TransferDataToWindow();
}

References mEditTags, mSelectedIndex, and TransferDataToWindow().

Here is the call graph for this function:

OnEdit()

void TagsEditorDialog::OnEdit ( wxCommandEvent &  event )

private

Definition at line 559 of file TagsEditor.cpp.

{
   if (mGrid->IsCellEditControlShown()) {
      mGrid->SaveEditControlValue();
      mGrid->HideCellEditControl();
   }
 
   wxDialogWrapper dlg(this, wxID_ANY, XO("Edit Genres"),
                wxDefaultPosition, wxDefaultSize,
                wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER);
   dlg.SetName();
   wxTextCtrl *tc;
 
   ShuttleGui S(&dlg, eIsCreating);
 
   S.StartVerticalLay(true);
   {
      tc = S.AddTextWindow(wxT(""));
   }
   S.EndVerticalLay();
 
   S.AddStandardButtons();
 
   auto& local = *mEditTags[mSelectedIndex];
 
   wxArrayString g;
   int cnt = local.GetNumUserGenres();
   for (int i = 0; i < cnt; i++) {
      g.push_back(local.GetUserGenre(i));
   }
   std::sort( g.begin(), g.end() );
 
   for (int i = 0; i < cnt; i++) {
      tc->AppendText(g[i] + wxT("\n"));
   }
 
   dlg.Center();
   if (dlg.ShowModal() == wxID_CANCEL) {
      return;
   }
 
   wxFileName fn(FileNames::DataDir(), wxT("genres.txt"));
   wxFile f(fn.GetFullPath(), wxFile::write);
   if (!f.IsOpened() || !f.Write(tc->GetValue())) {
      AudacityMessageBox(
         XO("Unable to save genre file."),
         XO("Reset Genres") );
      return;
   }
 
   local.LoadGenres();
 
   PopulateGenres();
}

References AudacityMessageBox(), FileNames::DataDir(), eIsCreating, fn, mEditTags, mGrid, mSelectedIndex, PopulateGenres(), S, wxDialogWrapper::SetName(), wxT(), and XO().

Here is the call graph for this function:

OnHelp()

void TagsEditorDialog::OnHelp

(

wxCommandEvent &

Evt

)

Definition at line 390 of file TagsEditor.cpp.

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

References HelpSystem::ShowHelp().

Here is the call graph for this function:

OnKeyDown()

void TagsEditorDialog::OnKeyDown ( wxKeyEvent &  event )

private

Definition at line 910 of file TagsEditor.cpp.

{
   if (event.GetKeyCode() == WXK_ESCAPE)
      DoCancel(true);
   else
      event.Skip();
}

References DoCancel().

Here is the call graph for this function:

OnLoad()

void TagsEditorDialog::OnLoad ( wxCommandEvent &  event )

private

Definition at line 668 of file TagsEditor.cpp.

{
   wxString fn;
 
   auto& local = *mEditTags[mSelectedIndex];
 
   // Ask the user for the real name
   fn = SelectFile(FileNames::Operation::_None,
      XO("Load Metadata As:"),
      FileNames::DataDir(),
      wxT("Tags.xml"),
      wxT("xml"),
      { FileNames::XMLFiles },
      wxFD_OPEN | wxRESIZE_BORDER,
      this);
 
   // User canceled...
   if (fn.empty()) {
      return;
   }
 
   // Load the metadata
   Tags temp;
   XMLFileReader reader;
   if (!reader.Parse(&temp, fn)) {
      // Inform user of load failure
      AudacityMessageBox(
         reader.GetErrorStr(),
         XO("Error Loading Metadata"),
         wxOK | wxCENTRE,
         this);
      return;
   }
 
   // Remember title and track in case they're read only
   wxString title = local.GetTag(TAG_TITLE);
   wxString track = local.GetTag(TAG_TRACK);
 
   // Replace existing tags with loaded ones
   local = temp;
 
   // Restore title
   if (!mEditTitle) {
      local.SetTag(TAG_TITLE, title);
   }
 
   // Restore track
   if (!mEditTrack) {
      local.SetTag(TAG_TRACK, track);
   }
 
   // Go fill up the window
   TransferDataToWindow();
 
   return;
}

References AudacityMessageBox(), FileNames::DataDir(), fn, XMLFileReader::GetErrorStr(), mEditTags, mEditTitle, mEditTrack, mSelectedIndex, XMLFileReader::Parse(), SelectFile(), Tags::SetTag(), TAG_TITLE, TAG_TRACK, title, TransferDataToWindow(), wxT(), FileNames::XMLFiles, and XO().

Here is the call graph for this function:

OnNext()

void TagsEditorDialog::OnNext ( wxCommandEvent &  )

private

Definition at line 934 of file TagsEditor.cpp.

{
   if(mSelectedIndex == static_cast<int>(mEditTags.size() - 1))
      return;
 
   TransferDataFromWindow();
   ++mSelectedIndex;
   TransferDataToWindow();
}

References mEditTags, mSelectedIndex, TransferDataFromWindow(), and TransferDataToWindow().

Here is the call graph for this function:

OnOk()

void TagsEditorDialog::OnOk ( wxCommandEvent &  event )

private

Definition at line 854 of file TagsEditor.cpp.

{
   if (mGrid->IsCellEditControlShown()) {
      mGrid->SaveEditControlValue();
      mGrid->HideCellEditControl();
#if defined(__WXMAC__)
      // The cell editors do not capture the ENTER key, so it invokes
      // the default button ("Ok") when it should just close the
      // editor. So, cancel the "Ok" action.
      return;
#endif
   }
 
   if (!Validate() || !TransferDataFromWindow()) {
      return;
   }
 
   for(unsigned i = 0; i < mEditTags.size(); ++i)
      *mTags[i] = *mEditTags[i];
 
   wxRect r = GetRect();
   gPrefs->Write(wxT("/TagsEditorDialog/x"), r.x);
   gPrefs->Write(wxT("/TagsEditorDialog/y"), r.y);
   gPrefs->Write(wxT("/TagsEditorDialog/width"), r.width);
   gPrefs->Write(wxT("/TagsEditorDialog/height"), r.height);
   gPrefs->Flush();
 
   EndModal(wxID_OK);
}

References audacity::BasicSettings::Flush(), gPrefs, mEditTags, mGrid, mTags, TransferDataFromWindow(), audacity::BasicSettings::Write(), and wxT().

Here is the call graph for this function:

OnPrev()

void TagsEditorDialog::OnPrev ( wxCommandEvent &  )

private

Definition at line 944 of file TagsEditor.cpp.

{
   if(mSelectedIndex == 0)
      return;
 
   TransferDataFromWindow();
   --mSelectedIndex;
   TransferDataToWindow();
}

References mSelectedIndex, TransferDataFromWindow(), and TransferDataToWindow().

Here is the call graph for this function:

OnRemove()

void TagsEditorDialog::OnRemove ( wxCommandEvent &  event )

private

Definition at line 833 of file TagsEditor.cpp.

{
   size_t row = mGrid->GetGridCursorRow();
 
   if (!mEditTitle &&
       mGrid->GetCellValue(row, 0).CmpNoCase(LABEL_TITLE.Translation()) == 0) {
      return;
   }
   else if (!mEditTrack &&
            mGrid->GetCellValue(row, 0)
               .CmpNoCase(LABEL_TRACK.Translation()) == 0) {
      return;
   }
   else if (row < STATICCNT) {
      mGrid->SetCellValue(row, 1, wxEmptyString);
   }
   else if (row >= STATICCNT) {
      mGrid->DeleteRows(row, 1);
   }
}

References LABEL_TITLE, LABEL_TRACK, mEditTitle, mEditTrack, mGrid, and STATICCNT.

OnReset()

void TagsEditorDialog::OnReset ( wxCommandEvent &  event )

private

Definition at line 614 of file TagsEditor.cpp.

{
   int id = AudacityMessageBox(
      XO("Are you sure you want to reset the genre list to defaults?"),
      XO("Reset Genres"),
      wxYES_NO);
 
   if (id == wxNO) {
      return;
   }
   auto& local = *mEditTags[mSelectedIndex];
 
   local.LoadDefaultGenres();
 
   wxFileName fn(FileNames::DataDir(), wxT("genres.txt"));
   wxTextFile tf(fn.GetFullPath());
 
   bool open = (tf.Exists() && tf.Open()) ||
               (!tf.Exists() && tf.Create());
 
   if (!open) {
      AudacityMessageBox(
         XO("Unable to open genre file."),
         XO("Reset Genres") );
      local.LoadGenres();
      return;
   }
 
   tf.Clear();
   int cnt = local.GetNumUserGenres();
   for (int i = 0; i < cnt; i++) {
      tf.AddLine(local.GetUserGenre(i));
   }
 
   if (!tf.Write()) {
      AudacityMessageBox(
         XO("Unable to save genre file."),
         XO("Reset Genres") );
      local.LoadGenres();
      return;
   }
 
   local.LoadGenres();
 
   PopulateGenres();
}

References AudacityMessageBox(), FileNames::DataDir(), fn, mEditTags, mSelectedIndex, PopulateGenres(), wxT(), and XO().

Here is the call graph for this function:

OnSave()

void TagsEditorDialog::OnSave ( wxCommandEvent &  event )

private

Definition at line 725 of file TagsEditor.cpp.

{
   wxString fn;
 
   auto& local = *mEditTags[mSelectedIndex];
 
   // Refresh tags
   TransferDataFromWindow();
 
   // Ask the user for the real name
   fn = SelectFile(FileNames::Operation::_None,
      XO("Save Metadata As:"),
      FileNames::DataDir(),
      wxT("Tags.xml"),
      wxT("xml"),
      { FileNames::XMLFiles },
      wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxRESIZE_BORDER,
      this);
 
   // User canceled...
   if (fn.empty()) {
      return;
   }
 
   GuardedCall( [&] {
      // Create/Open the file
      XMLFileWriter writer{ fn, XO("Error Saving Tags File") };
 
      // Remember title and track in case they're read only
      wxString title = local.GetTag(TAG_TITLE);
      wxString track = local.GetTag(TAG_TRACK);
 
      // Clear title
      if (!mEditTitle) {
         local.SetTag(TAG_TITLE, wxEmptyString);
      }
 
      // Clear track
      if (!mEditTrack) {
         local.SetTag(TAG_TRACK, wxEmptyString);
      }
 
      auto cleanup = finally( [&] {
         // Restore title
         if (!mEditTitle) {
            local.SetTag(TAG_TITLE, title);
         }
 
         // Restore track
         if (!mEditTrack) {
            local.SetTag(TAG_TRACK, track);
         }
      } );
 
      // Write the metadata
      local.WriteXML(writer);
 
      writer.Commit();
   } );
}

References FileNames::DataDir(), fn, GuardedCall(), mEditTags, mEditTitle, mEditTrack, mSelectedIndex, SelectFile(), TAG_TITLE, TAG_TRACK, title, TransferDataFromWindow(), wxT(), FileNames::XMLFiles, and XO().

Here is the call graph for this function:

OnSaveDefaults()

void TagsEditorDialog::OnSaveDefaults ( wxCommandEvent &  event )

private

Definition at line 786 of file TagsEditor.cpp.

{
   auto& local = *mEditTags[mSelectedIndex];
   // Refresh tags
   TransferDataFromWindow();
 
   // Remember title and track in case they're read only
   wxString title = local.GetTag(TAG_TITLE);
   wxString track = local.GetTag(TAG_TRACK);
 
   // Clear title
   if (!mEditTitle) {
      local.SetTag(TAG_TITLE, wxEmptyString);
   }
 
   // Clear track
   if (!mEditTrack) {
      local.SetTag(TAG_TRACK, wxEmptyString);
   }
 
   // Remove any previous defaults
   gPrefs->DeleteGroup(wxT("/Tags"));
 
   // Write out each tag
   for (const auto &pair : local.GetRange()) {
      const auto &n = pair.first;
      const auto &v = pair.second;
      gPrefs->Write(wxT("/Tags/") + n, v);
   }
   gPrefs->Flush();
 
   // Restore title
   if (!mEditTitle) {
      local.SetTag(TAG_TITLE, title);
   }
 
   // Restore track
   if (!mEditTrack) {
      local.SetTag(TAG_TRACK, track);
   }
}

References audacity::BasicSettings::DeleteGroup(), audacity::BasicSettings::Flush(), gPrefs, mEditTags, mEditTitle, mEditTrack, mSelectedIndex, TAG_TITLE, TAG_TRACK, title, TransferDataFromWindow(), audacity::BasicSettings::Write(), and wxT().

Here is the call graph for this function:

PopulateGenres()

void TagsEditorDialog::PopulateGenres ( )

private

Definition at line 954 of file TagsEditor.cpp.

{
   auto local = *mEditTags[mSelectedIndex];
 
   int cnt = local.GetNumUserGenres();
   int i;
   wxString parm;
   wxArrayString g;
 
   for (i = 0; i < cnt; i++) {
      g.push_back(local.GetUserGenre(i));
   }
   std::sort( g.begin(), g.end() );
 
   for (i = 0; i < cnt; i++) {
      parm = parm + (i == 0 ? wxT("") : wxT(",")) + g[i];
   }
 
   // Here was a memory leak!  wxWidgets docs for wxGrid::GetDefaultEditorForType() say:
   // "The caller must call DecRef() on the returned pointer."
   auto editor = mGrid->GetDefaultEditorForType(wxT("Combo"));
   editor->SetParameters(parm);
   editor->DecRef();
}

References mEditTags, mGrid, mSelectedIndex, and wxT().

Referenced by OnEdit(), and OnReset().

Here is the call graph for this function:

Here is the caller graph for this function:

PopulateOrExchange()

void TagsEditorDialog::PopulateOrExchange

(

ShuttleGui &

S

)

Definition at line 296 of file TagsEditor.cpp.

{
   S.StartVerticalLay();
   {
      S.StartHorizontalLay(wxALIGN_LEFT, 0);
      {
         S.AddUnits(XO("Use arrow keys (or ENTER key after editing) to navigate fields."));
      }
      S.EndHorizontalLay();
 
      if(mTags.size() > 1)
      {
         S.StartHorizontalLay(wxEXPAND, 0);
         {
            mPrev = S.Id(PrevID).Style(wxBU_EXACTFIT).AddButton(TranslatableString("<", {}));
            mName = S.Style(wxALIGN_CENTER).AddVariableText({}, true, wxEXPAND);
            mNext = S.Id(NextID).Style(wxBU_EXACTFIT).AddButton(TranslatableString(">", {}));
         }
         S.EndHorizontalLay();
      }
 
      if (mGrid == NULL) {
         mGrid = safenew Grid(FormatterContext::EmptyContext(), S.GetParent(),
                          wxID_ANY,
                          wxDefaultPosition,
                          wxDefaultSize,
                          wxSUNKEN_BORDER);
 
         mGrid->RegisterDataType(wxT("Combo"),
            (mStringRenderer = safenew wxGridCellStringRenderer),
            (mComboEditor = safenew ComboEditor(wxArrayString(), true)));
 
         mGrid->SetColLabelSize(mGrid->GetDefaultRowSize());
 
         auto  cs = transform_container<wxArrayStringEx>(
            names, std::mem_fn( &TranslatableString::Translation ) );
 
         // Build the initial (empty) grid
         mGrid->CreateGrid(0, 2, wxGrid::wxGridSelectRows);
         mGrid->SetRowLabelSize(0);
         mGrid->SetDefaultCellAlignment(wxALIGN_LEFT, wxALIGN_CENTER);
         mGrid->SetColLabelValue(0, _("Tag"));
         mGrid->SetColLabelValue(1, _("Value"));
 
         // Resize the name column and set default row height.
         wxComboBox tc(this, wxID_ANY, wxT(""), wxDefaultPosition, wxDefaultSize, cs);
         mGrid->SetColSize(0, tc.GetSize().x);
         mGrid->SetColMinimalWidth(0, tc.GetSize().x);
      }
      S.Prop(1)
         .Position(wxEXPAND | wxALL)
         .AddWindow(mGrid);
 
      S.StartMultiColumn(4, wxALIGN_CENTER);
      {
         S.Id(AddID).AddButton(XXO("&Add"));
         S.Id(RemoveID).AddButton(XXO("&Remove"));
         S.AddTitle( {} );
         S.Id(ClearID).AddButton(XXO("Cl&ear"));
      }
      S.EndMultiColumn();
 
      S.StartHorizontalLay(wxALIGN_CENTRE, 0);
      {
         S.StartStatic(XO("Genres"));
         {
            S.StartMultiColumn(4, wxALIGN_CENTER);
            {
               S.Id(EditID).AddButton(XXO("E&dit..."));
               S.Id(ResetID).AddButton(XXO("Rese&t..."));
            }
            S.EndMultiColumn();
         }
         S.EndStatic();
         S.StartStatic(XO("Template"));
         {
            S.StartMultiColumn(4, wxALIGN_CENTER);
            {
               S.Id(LoadID).AddButton(XXO("&Load..."));
               S.Id(SaveID).AddButton(XXO("&Save..."));
               S.AddTitle( {} );
               S.Id(SaveDefaultsID).AddButton(XXO("Set De&fault"));
            }
            S.EndMultiColumn();
         }
         S.EndStatic();
      }
      S.EndHorizontalLay();
   }
   S.EndVerticalLay();
 
   S.AddStandardButtons(eOkButton | eCancelButton | eHelpButton);
}

References _, AddID, ClearID, eCancelButton, EditID, eHelpButton, FormatterContext::EmptyContext(), eOkButton, LoadID, mComboEditor, mGrid, mName, mNext, mPrev, mStringRenderer, mTags, names, NextID, PrevID, RemoveID, ResetID, S, safenew, SaveDefaultsID, SaveID, TranslatableString::Translation(), wxT(), XO(), and XXO().

Here is the call graph for this function:

SetEditors()

void TagsEditorDialog::SetEditors ( )

private

Definition at line 918 of file TagsEditor.cpp.

{
   int cnt = mGrid->GetNumberRows();
 
   for (int i = 0; i < cnt; i++) {
      wxString label = mGrid->GetCellValue(i, 0);
      if (label.CmpNoCase(LABEL_GENRE.Translation()) == 0) {
         // This use of GetDefaultEditorForType does not require DecRef.
         mGrid->SetCellEditor(i, 1, mGrid->GetDefaultEditorForType(wxT("Combo")));
      }
      else {
         mGrid->SetCellEditor(i, 1, NULL); //mGrid->GetDefaultEditor());
      }
   }
}

References label, LABEL_GENRE, mGrid, and wxT().

Referenced by TransferDataToWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowEditDialog()

bool TagsEditorDialog::ShowEditDialog ( Tags &  tags, wxWindow *  parent, const TranslatableString &  title  )

static

Definition at line 30 of file TagsEditor.cpp.

{
   TagsEditorDialog dlg(parent, title, { &tags }, {}, true, true);
   return dlg.ShowModal() == wxID_OK;
}

References title.

Referenced by EditProjectMetadata().

Here is the caller graph for this function:

TransferDataFromWindow()

bool TagsEditorDialog::TransferDataFromWindow ( )

override

Definition at line 395 of file TagsEditor.cpp.

{
   int i, cnt = mGrid->GetNumberRows();
 
   if (mGrid->IsCellEditControlShown()) {
      mGrid->SaveEditControlValue();
      mGrid->HideCellEditControl();
   }
 
   auto& local = *mEditTags[mSelectedIndex];
 
   local.Clear();
   for (i = 0; i < cnt; i++) {
      // Get tag name from the grid
 
      auto n = mGrid->GetCellValue(i, 0);
      wxString v = mGrid->GetCellValue(i, 1);
 
      if (n.empty()) {
         continue;
      }
 
      bool bSpecialTag = true;
 
      // Map special tag names back to internal keys
      if (n.CmpNoCase(LABEL_ARTIST.Translation()) == 0) {
         n = TAG_ARTIST;
      }
      else if (n.CmpNoCase(LABEL_TITLE.Translation()) == 0) {
         n = TAG_TITLE;
      }
      else if (n.CmpNoCase(LABEL_ALBUM.Translation()) == 0) {
         n = TAG_ALBUM;
      }
      else if (n.CmpNoCase(LABEL_TRACK.Translation()) == 0) {
         n = TAG_TRACK;
      }
      else if (n.CmpNoCase(LABEL_YEAR.Translation()) == 0) {
         n = TAG_YEAR;
      }
      else if (n.CmpNoCase(LABEL_GENRE.Translation()) == 0) {
         n = TAG_GENRE;
      }
      else if (n.CmpNoCase(LABEL_COMMENTS.Translation()) == 0) {
         n = TAG_COMMENTS;
      }
      else {
         bSpecialTag = false;
      }
 
      local.SetTag(n, v, bSpecialTag);
   }
 
   return true;
}

References LABEL_ALBUM, LABEL_ARTIST, LABEL_COMMENTS, LABEL_GENRE, LABEL_TITLE, LABEL_TRACK, LABEL_YEAR, mEditTags, mGrid, mSelectedIndex, TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, and TAG_YEAR.

Referenced by OnNext(), OnOk(), OnPrev(), OnSave(), and OnSaveDefaults().

Here is the caller graph for this function:

TransferDataToWindow()

bool TagsEditorDialog::TransferDataToWindow ( )

override

Definition at line 451 of file TagsEditor.cpp.

{
   size_t i;
   TagMap popTagMap;
 
   auto& local = *mEditTags[mSelectedIndex];
 
   if(mName)
   {
      mPrev->Enable(mSelectedIndex > 0);
      mName->SetLabel(mNames[mSelectedIndex]);
      mNext->Enable(mSelectedIndex < mNames.size() - 1);
   }
 
   // Disable redrawing until we're done
   mGrid->BeginBatch();
 
   // Delete all rows
   if (mGrid->GetNumberRows()) {
      mGrid->DeleteRows(0, mGrid->GetNumberRows());
   }
 
   // Populate the static rows
   for (i = 0; i < STATICCNT; i++) {
      mGrid->AppendRows();
 
      mGrid->SetReadOnly(i, 0);
      // The special tag name that's displayed and translated may not match
      // the key string used for internal lookup.
      mGrid->SetCellValue(i, 0, labelmap[i].label.Translation() );
      mGrid->SetCellValue(i, 1, local.GetTag(labelmap[i].name));
 
      if (!mEditTitle &&
          mGrid->GetCellValue(i, 0).CmpNoCase(LABEL_TITLE.Translation()) == 0) {
         mGrid->SetReadOnly(i, 1);
      }
 
      if (!mEditTrack &&
          mGrid->GetCellValue(i, 0).CmpNoCase(LABEL_TRACK.Translation()) == 0) {
         mGrid->SetReadOnly(i, 1);
      }
 
      popTagMap[ labelmap[i].name ] = mGrid->GetCellValue(i, 1);
   }
 
   // Populate the rest
   for (const auto &pair : local.GetRange()) {
      const auto &n = pair.first;
      const auto &v = pair.second;
      if (popTagMap.find(n) == popTagMap.end()) {
         mGrid->AppendRows();
         mGrid->SetCellValue(i, 0, n);
         mGrid->SetCellValue(i, 1, v);
         i++;
      }
   }
 
   // Add an extra one to help with initial sizing and to show it can be done
   mGrid->AppendRows(1);
 
   // We're done, so allow the grid to redraw
   mGrid->EndBatch();
 
   // Set the editors
   SetEditors();
   Layout();
   Fit();
 
   return true;
}

References label, LABEL_TITLE, LABEL_TRACK, labelmap, mEditTags, mEditTitle, mEditTrack, mGrid, mName, mNames, mNext, mPrev, mSelectedIndex, SetEditors(), STATICCNT, and TranslatableString::Translation().

Referenced by OnClear(), OnLoad(), OnNext(), and OnPrev().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mComboEditor

ComboEditor* TagsEditorDialog::mComboEditor

private

Definition at line 96 of file TagsEditor.h.

Referenced by PopulateOrExchange().

mEditTags

std::vector<std::unique_ptr<Tags> > TagsEditorDialog::mEditTags

private

Definition at line 90 of file TagsEditor.h.

Referenced by OnClear(), OnEdit(), OnLoad(), OnNext(), OnOk(), OnReset(), OnSave(), OnSaveDefaults(), PopulateGenres(), TransferDataFromWindow(), and TransferDataToWindow().

mEditTitle

bool TagsEditorDialog::mEditTitle

private

Definition at line 87 of file TagsEditor.h.

Referenced by OnLoad(), OnRemove(), OnSave(), OnSaveDefaults(), and TransferDataToWindow().

mEditTrack

bool TagsEditorDialog::mEditTrack

private

Definition at line 88 of file TagsEditor.h.

Referenced by OnLoad(), OnRemove(), OnSave(), OnSaveDefaults(), and TransferDataToWindow().

mGrid

Grid* TagsEditorDialog::mGrid

private

Definition at line 92 of file TagsEditor.h.

Referenced by DoCancel(), OnAdd(), OnChange(), OnEdit(), OnOk(), OnRemove(), PopulateGenres(), PopulateOrExchange(), SetEditors(), TransferDataFromWindow(), and TransferDataToWindow().

mName

wxStaticText* TagsEditorDialog::mName {}

private

Definition at line 93 of file TagsEditor.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

mNames

std::vector<wxString> TagsEditorDialog::mNames

private

Definition at line 84 of file TagsEditor.h.

Referenced by TransferDataToWindow().

mNext

wxButton* TagsEditorDialog::mNext {}

private

Definition at line 94 of file TagsEditor.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

mPrev

wxButton* TagsEditorDialog::mPrev {}

private

Definition at line 95 of file TagsEditor.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

mSelectedIndex

int TagsEditorDialog::mSelectedIndex {0}

private

Definition at line 85 of file TagsEditor.h.

Referenced by OnClear(), OnEdit(), OnLoad(), OnNext(), OnPrev(), OnReset(), OnSave(), OnSaveDefaults(), PopulateGenres(), TransferDataFromWindow(), and TransferDataToWindow().

mStringRenderer

wxGridCellStringRenderer* TagsEditorDialog::mStringRenderer

private

Definition at line 97 of file TagsEditor.h.

Referenced by PopulateOrExchange().

mTags

std::vector<Tags*> TagsEditorDialog::mTags

private

Definition at line 83 of file TagsEditor.h.

Referenced by OnOk(), and PopulateOrExchange().

---

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

• TagsEditor.h
• TagsEditor.cpp