X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cf57855e9e45022928c50eda153c6d363bf01629..97e324eff05f010ce59985c670bbe501edfa75c2:/src/common/cmdproc.cpp

diff --git a/src/common/cmdproc.cpp b/src/common/cmdproc.cpp
index 4326cda809..08f414c171 100644
--- a/src/common/cmdproc.cpp
+++ b/src/common/cmdproc.cpp
@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #pragma implementation "cmdproc.h"
 #endif
 
@@ -64,12 +64,14 @@ wxCommand::~wxCommand()
 wxCommandProcessor::wxCommandProcessor(int maxCommands)
 {
     m_maxNoCommands = maxCommands;
-    m_currentCommand = (wxNode *) NULL;
 #if wxUSE_MENUS
     m_commandEditMenu = (wxMenu *) NULL;
 #endif // wxUSE_MENUS
     m_undoAccelerator = wxT("\tCtrl+Z");
     m_redoAccelerator = wxT("\tCtrl+Y");
+#if !wxUSE_STL
+    m_currentCommand = NULL;
+#endif
 }
 
 wxCommandProcessor::~wxCommandProcessor()
@@ -112,12 +114,12 @@ void wxCommandProcessor::Store(wxCommand *command)
 {
     wxCHECK_RET( command, _T("no command in wxCommandProcessor::Store") );
 
-    if (m_commands.Number() == m_maxNoCommands)
+    if ( (int)m_commands.GetCount() == m_maxNoCommands )
     {
-        wxNode *firstNode = m_commands.First();
-        wxCommand *firstCommand = (wxCommand *)firstNode->Data();
+        wxList::compatibility_iterator firstNode = m_commands.GetFirst();
+        wxCommand *firstCommand = (wxCommand *)firstNode->GetData();
         delete firstCommand;
-        delete firstNode;
+        m_commands.Erase(firstNode);
     }
 
     // Correct a bug: we must chop off the current 'branch'
@@ -126,18 +128,18 @@ 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();
+            delete (wxCommand *)node->GetData();
+            m_commands.Erase(node);
             node = next;
         }
     }
 
     m_commands.Append(command);
-    m_currentCommand = m_commands.Last();
+    m_currentCommand = m_commands.GetLast();
     SetMenuStrings();
 }
 
@@ -148,7 +150,7 @@ bool wxCommandProcessor::Undo()
     {
         if ( UndoCommand(*command) )
         {
-            m_currentCommand = m_currentCommand->Previous();
+            m_currentCommand = m_currentCommand->GetPrevious();
             SetMenuStrings();
             return TRUE;
         }
@@ -160,23 +162,27 @@ bool wxCommandProcessor::Undo()
 bool wxCommandProcessor::Redo()
 {
     wxCommand *redoCommand = (wxCommand *) NULL;
-    wxNode *redoNode = (wxNode *) NULL;
+    wxList::compatibility_iterator redoNode
+#if !wxUSE_STL
+        = NULL          // just to avoid warnings
+#endif // !wxUSE_STL
+        ;
 
     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();
         }
     }
 
@@ -202,13 +208,13 @@ bool wxCommandProcessor::CanUndo() const
 
 bool wxCommandProcessor::CanRedo() const
 {
-    if ((m_currentCommand != (wxNode*) NULL) && (m_currentCommand->Next() == (wxNode*) NULL))
+    if (m_currentCommand && !m_currentCommand->GetNext())
         return FALSE;
 
-    if ((m_currentCommand != (wxNode*) NULL) && (m_currentCommand->Next() != (wxNode*) NULL))
+    if (m_currentCommand && m_currentCommand->GetNext())
         return TRUE;
 
-    if ((m_currentCommand == (wxNode*) NULL) && (m_commands.Number() > 0))
+    if (!m_currentCommand && (m_commands.GetCount() > 0))
         return TRUE;
 
     return FALSE;
@@ -216,98 +222,99 @@ bool wxCommandProcessor::CanRedo() const
 
 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 == 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;
+    }
+    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 == wxT("")) 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 == wxT("")) 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();
 }