X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cf57855e9e45022928c50eda153c6d363bf01629..abd474ea63667f727940a009cc3e0b23ba9f418f:/src/common/cmdproc.cpp diff --git a/src/common/cmdproc.cpp b/src/common/cmdproc.cpp index 4326cda809..7de08c2790 100644 --- a/src/common/cmdproc.cpp +++ b/src/common/cmdproc.cpp @@ -5,7 +5,7 @@ // Modified by: // Created: 05.11.00 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team +// Copyright: (c) wxWidgets team // Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "cmdproc.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -32,6 +28,7 @@ #include "wx/intl.h" #include "wx/string.h" #include "wx/menu.h" + #include "wx/accel.h" #endif //WX_PRECOMP #include "wx/cmdproc.h" @@ -53,10 +50,6 @@ wxCommand::wxCommand(bool canUndoIt, const wxString& name) m_commandName = name; } -wxCommand::~wxCommand() -{ -} - // ---------------------------------------------------------------------------- // Command processor // ---------------------------------------------------------------------------- @@ -64,12 +57,17 @@ wxCommand::~wxCommand() wxCommandProcessor::wxCommandProcessor(int maxCommands) { m_maxNoCommands = maxCommands; - m_currentCommand = (wxNode *) NULL; #if wxUSE_MENUS - m_commandEditMenu = (wxMenu *) NULL; + m_commandEditMenu = NULL; #endif // wxUSE_MENUS - m_undoAccelerator = wxT("\tCtrl+Z"); - m_redoAccelerator = wxT("\tCtrl+Y"); + +#if wxUSE_ACCEL + m_undoAccelerator = '\t' + wxAcceleratorEntry(wxACCEL_CTRL, 'Z').ToString(); + m_redoAccelerator = '\t' + wxAcceleratorEntry(wxACCEL_CTRL, 'Y').ToString(); +#endif // wxUSE_ACCEL + + m_lastSavedCommand = + m_currentCommand = wxList::compatibility_iterator(); } wxCommandProcessor::~wxCommandProcessor() @@ -89,36 +87,30 @@ bool wxCommandProcessor::UndoCommand(wxCommand& cmd) // Pass a command to the processor. The processor calls Do(); // if successful, is appended to the command history unless -// storeIt is FALSE. +// storeIt is false. bool wxCommandProcessor::Submit(wxCommand *command, bool storeIt) { - wxCHECK_MSG( command, FALSE, _T("no command in wxCommandProcessor::Submit") ); + wxCHECK_MSG( command, false, wxT("no command in wxCommandProcessor::Submit") ); if ( !DoCommand(*command) ) { // the user code expects the command to be deleted anyhow delete command; - return FALSE; + return false; } if ( storeIt ) Store(command); + else + delete command; - return TRUE; + return true; } void wxCommandProcessor::Store(wxCommand *command) { - wxCHECK_RET( command, _T("no command in wxCommandProcessor::Store") ); - - if (m_commands.Number() == m_maxNoCommands) - { - wxNode *firstNode = m_commands.First(); - wxCommand *firstCommand = (wxCommand *)firstNode->Data(); - delete firstCommand; - delete firstNode; - } + wxCHECK_RET( command, wxT("no command in wxCommandProcessor::Store") ); // Correct a bug: we must chop off the current 'branch' // so that we're at the end of the command list. @@ -126,18 +118,37 @@ void wxCommandProcessor::Store(wxCommand *command) ClearCommands(); else { - wxNode *node = m_currentCommand->Next(); + wxList::compatibility_iterator node = m_currentCommand->GetNext(); while (node) { - wxNode *next = node->Next(); - delete (wxCommand *)node->Data(); - delete node; + wxList::compatibility_iterator next = node->GetNext(); + + // Make sure m_lastSavedCommand won't point to freed memory + if ( m_lastSavedCommand && m_lastSavedCommand == node ) + m_lastSavedCommand = wxList::compatibility_iterator(); + + delete (wxCommand *)node->GetData(); + m_commands.Erase(node); + node = next; } } + if ( (int)m_commands.GetCount() == m_maxNoCommands ) + { + wxList::compatibility_iterator firstNode = m_commands.GetFirst(); + + // Make sure m_lastSavedCommand won't point to freed memory + if ( m_lastSavedCommand && m_lastSavedCommand == firstNode ) + m_lastSavedCommand = wxList::compatibility_iterator(); + + wxCommand *firstCommand = (wxCommand *)firstNode->GetData(); + delete firstCommand; + m_commands.Erase(firstNode); + } + m_commands.Append(command); - m_currentCommand = m_commands.Last(); + m_currentCommand = m_commands.GetLast(); SetMenuStrings(); } @@ -148,35 +159,39 @@ bool wxCommandProcessor::Undo() { if ( UndoCommand(*command) ) { - m_currentCommand = m_currentCommand->Previous(); + m_currentCommand = m_currentCommand->GetPrevious(); SetMenuStrings(); - return TRUE; + return true; } } - return FALSE; + return false; } bool wxCommandProcessor::Redo() { - wxCommand *redoCommand = (wxCommand *) NULL; - wxNode *redoNode = (wxNode *) NULL; + wxCommand *redoCommand = NULL; + wxList::compatibility_iterator redoNode +#if !wxUSE_STD_CONTAINERS + = NULL // just to avoid warnings +#endif // !wxUSE_STD_CONTAINERS + ; if ( m_currentCommand ) { // is there anything to redo? - if ( m_currentCommand->Next() ) + if ( m_currentCommand->GetNext() ) { - redoCommand = (wxCommand *)m_currentCommand->Next()->Data(); - redoNode = m_currentCommand->Next(); + redoCommand = (wxCommand *)m_currentCommand->GetNext()->GetData(); + redoNode = m_currentCommand->GetNext(); } } else // no current command, redo the first one { - if (m_commands.Number() > 0) + if (m_commands.GetCount() > 0) { - redoCommand = (wxCommand *)m_commands.First()->Data(); - redoNode = m_commands.First(); + redoCommand = (wxCommand *)m_commands.GetFirst()->GetData(); + redoNode = m_commands.GetFirst(); } } @@ -187,10 +202,10 @@ bool wxCommandProcessor::Redo() { m_currentCommand = redoNode; SetMenuStrings(); - return TRUE; + return true; } } - return FALSE; + return false; } bool wxCommandProcessor::CanUndo() const @@ -202,112 +217,115 @@ bool wxCommandProcessor::CanUndo() const bool wxCommandProcessor::CanRedo() const { - if ((m_currentCommand != (wxNode*) NULL) && (m_currentCommand->Next() == (wxNode*) NULL)) - return FALSE; + if (m_currentCommand && !m_currentCommand->GetNext()) + return false; - if ((m_currentCommand != (wxNode*) NULL) && (m_currentCommand->Next() != (wxNode*) NULL)) - return TRUE; + if (m_currentCommand && m_currentCommand->GetNext()) + return true; - if ((m_currentCommand == (wxNode*) NULL) && (m_commands.Number() > 0)) - return TRUE; + if (!m_currentCommand && (m_commands.GetCount() > 0)) + return true; - return FALSE; + return false; } void wxCommandProcessor::Initialize() { - m_currentCommand = m_commands.Last(); + m_currentCommand = m_commands.GetLast(); SetMenuStrings(); } -// This reduces flicker in wxGTK+ -static void wxSetMenuLabelOptimally(wxMenu* menu, int id, const wxString& label) -{ - wxString oldLabel = menu->GetLabel(id); - oldLabel = wxStripMenuCodes(oldLabel.BeforeFirst('\t')); -#ifdef __WXGTK__ - oldLabel.Replace(wxT("_"), wxT("")); // GTK+ only -#endif - wxString label1 = wxStripMenuCodes(label.BeforeFirst('\t')); - if (oldLabel != label1) - menu->SetLabel(id, label); -} - void wxCommandProcessor::SetMenuStrings() { #if wxUSE_MENUS if (m_commandEditMenu) { - wxString buf; - if (m_currentCommand) + wxString undoLabel = GetUndoMenuLabel(); + wxString redoLabel = GetRedoMenuLabel(); + + m_commandEditMenu->SetLabel(wxID_UNDO, undoLabel); + m_commandEditMenu->Enable(wxID_UNDO, CanUndo()); + + m_commandEditMenu->SetLabel(wxID_REDO, redoLabel); + m_commandEditMenu->Enable(wxID_REDO, CanRedo()); + } +#endif // wxUSE_MENUS +} + +// Gets the current Undo menu label. +wxString wxCommandProcessor::GetUndoMenuLabel() const +{ + wxString buf; + if (m_currentCommand) + { + wxCommand *command = (wxCommand *)m_currentCommand->GetData(); + wxString commandName(command->GetName()); + if (commandName.empty()) commandName = _("Unnamed command"); + bool canUndo = command->CanUndo(); + if (canUndo) + buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator; + else + buf = wxString(_("Can't &Undo ")) + commandName + m_undoAccelerator; + } + else + { + buf = _("&Undo") + m_undoAccelerator; + } + + return buf; +} + +// Gets the current Undo menu label. +wxString wxCommandProcessor::GetRedoMenuLabel() const +{ + wxString buf; + if (m_currentCommand) + { + // We can redo, if we're not at the end of the history. + if (m_currentCommand->GetNext()) { - wxCommand *command = (wxCommand *)m_currentCommand->Data(); - wxString commandName(command->GetName()); - if (commandName == wxT("")) commandName = _("Unnamed command"); - bool canUndo = command->CanUndo(); - if (canUndo) - buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator; - else - buf = wxString(_("Can't &Undo ")) + commandName + m_undoAccelerator; - - //m_commandEditMenu->SetLabel(wxID_UNDO, buf); - wxSetMenuLabelOptimally(m_commandEditMenu, wxID_UNDO, buf); - - m_commandEditMenu->Enable(wxID_UNDO, canUndo); - - // We can redo, if we're not at the end of the history. - if (m_currentCommand->Next()) - { - wxCommand *redoCommand = (wxCommand *)m_currentCommand->Next()->Data(); - wxString redoCommandName(redoCommand->GetName()); - if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command"); - buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator; - wxSetMenuLabelOptimally(m_commandEditMenu, wxID_REDO, buf); - m_commandEditMenu->Enable(wxID_REDO, TRUE); - } - else - { - wxSetMenuLabelOptimally(m_commandEditMenu, wxID_REDO, _("&Redo") + m_redoAccelerator); - m_commandEditMenu->Enable(wxID_REDO, FALSE); - } + wxCommand *redoCommand = (wxCommand *)m_currentCommand->GetNext()->GetData(); + wxString redoCommandName(redoCommand->GetName()); + if (redoCommandName.empty()) redoCommandName = _("Unnamed command"); + buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator; } else { - wxSetMenuLabelOptimally(m_commandEditMenu, wxID_UNDO, _("&Undo") + m_undoAccelerator); - m_commandEditMenu->Enable(wxID_UNDO, FALSE); - - if (m_commands.Number() == 0) - { - wxSetMenuLabelOptimally(m_commandEditMenu, wxID_REDO, _("&Redo") + m_redoAccelerator); - m_commandEditMenu->Enable(wxID_REDO, FALSE); - } - else - { - // currentCommand is NULL but there are commands: this means that - // we've undone to the start of the list, but can redo the first. - wxCommand *redoCommand = (wxCommand *)m_commands.First()->Data(); - wxString redoCommandName(redoCommand->GetName()); - if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command"); - buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator; - wxSetMenuLabelOptimally(m_commandEditMenu, wxID_REDO, buf); - m_commandEditMenu->Enable(wxID_REDO, TRUE); - } + buf = _("&Redo") + m_redoAccelerator; } } -#endif // wxUSE_MENUS + else + { + if (m_commands.GetCount() == 0) + { + buf = _("&Redo") + m_redoAccelerator; + } + else + { + // currentCommand is NULL but there are commands: this means that + // we've undone to the start of the list, but can redo the first. + wxCommand *redoCommand = (wxCommand *)m_commands.GetFirst()->GetData(); + wxString redoCommandName(redoCommand->GetName()); + if (redoCommandName.empty()) redoCommandName = _("Unnamed command"); + buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator; + } + } + return buf; } void wxCommandProcessor::ClearCommands() { - wxNode *node = m_commands.First(); + wxList::compatibility_iterator node = m_commands.GetFirst(); while (node) { - wxCommand *command = (wxCommand *)node->Data(); + wxCommand *command = (wxCommand *)node->GetData(); delete command; - delete node; - node = m_commands.First(); + m_commands.Erase(node); + node = m_commands.GetFirst(); } - m_currentCommand = (wxNode *) NULL; + + m_currentCommand = wxList::compatibility_iterator(); + m_lastSavedCommand = wxList::compatibility_iterator(); }