Add missing WXK constants for the control keys

[wxWidgets.git] / src / common / cmdproc.cpp

diff --git a/src/common/cmdproc.cpp b/src/common/cmdproc.cpp
index 3dbefff13f1754a889e7d9f100a2c15c755c038c..5e8a253ccbbeea631ee1ebc20eebcab533c600f0 100644 (file)
--- a/src/common/cmdproc.cpp
+++ b/src/common/cmdproc.cpp
@@ -5,7 +5,7 @@
 // Modified by:
 // Created:     05.11.00
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     05.11.00
 // RCS-ID:      $Id$

-// Copyright:   (c) wxWindows team
+// Copyright:   (c) wxWidgets team

 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "cmdproc.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // 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/intl.h"
     #include "wx/string.h"
     #include "wx/menu.h"

+    #include "wx/accel.h"

 #endif //WX_PRECOMP
 
 #include "wx/cmdproc.h"
 #endif //WX_PRECOMP
 
 #include "wx/cmdproc.h"


@@ -53,10 +50,6 @@ wxCommand::wxCommand(bool canUndoIt, const wxString& name)
     m_commandName = name;
 }
 
     m_commandName = name;
 }
 

-wxCommand::~wxCommand()
-{
-}
-

 // ----------------------------------------------------------------------------
 // Command processor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // Command processor
 // ----------------------------------------------------------------------------


@@ -64,12 +57,17 @@ wxCommand::~wxCommand()
 wxCommandProcessor::wxCommandProcessor(int maxCommands)
 {
     m_maxNoCommands = maxCommands;
 wxCommandProcessor::wxCommandProcessor(int maxCommands)
 {
     m_maxNoCommands = maxCommands;

-    m_currentCommand = (wxNode *) NULL;

 #if wxUSE_MENUS
 #if wxUSE_MENUS

-    m_commandEditMenu = (wxMenu *) NULL;
+    m_commandEditMenu = NULL;

 #endif // wxUSE_MENUS
 #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()
 }
 
 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
 
 // 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)
 {
 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;
 
 
     if ( !DoCommand(*command) )
     {
         // the user code expects the command to be deleted anyhow
         delete command;
 

-        return FALSE;
+        return false;

     }
 
     if ( storeIt )
         Store(command);
     }
 
     if ( storeIt )
         Store(command);

+    else
+        delete command;

 
 

-    return TRUE;
+    return true;

 }
 
 void wxCommandProcessor::Store(wxCommand *command)
 {
 }
 
 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.
 
     // 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
     {
         ClearCommands();
     else
     {

-        wxNode *node = m_currentCommand->Next();
+        wxList::compatibility_iterator node = m_currentCommand->GetNext();

         while (node)
         {
         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;
         }
     }
 
             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_commands.Append(command);

-    m_currentCommand = m_commands.Last();
+    m_currentCommand = m_commands.GetLast();

     SetMenuStrings();
 }
 
     SetMenuStrings();
 }
 


@@ -148,35 +159,39 @@ bool wxCommandProcessor::Undo()
     {
         if ( UndoCommand(*command) )
         {
     {
         if ( UndoCommand(*command) )
         {

-            m_currentCommand = m_currentCommand->Previous();
+            m_currentCommand = m_currentCommand->GetPrevious();

             SetMenuStrings();
             SetMenuStrings();

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 bool wxCommandProcessor::Redo()
 {
 }
 
 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 )
     {
         // 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
     {
         }
     }
     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();
         {
             m_currentCommand = redoNode;
             SetMenuStrings();

-            return TRUE;
+            return true;

         }
     }
         }
     }

-    return FALSE;
+    return false;

 }
 
 bool wxCommandProcessor::CanUndo() const
 }
 
 bool wxCommandProcessor::CanUndo() const


@@ -202,21 +217,21 @@ bool wxCommandProcessor::CanUndo() const
 
 bool wxCommandProcessor::CanRedo() 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()
 {
 }
 
 void wxCommandProcessor::Initialize()
 {

-    m_currentCommand = m_commands.Last();
+    m_currentCommand = m_commands.GetLast();

     SetMenuStrings();
 }
 
     SetMenuStrings();
 }
 


@@ -227,7 +242,7 @@ void wxCommandProcessor::SetMenuStrings()
     {
         wxString undoLabel = GetUndoMenuLabel();
         wxString redoLabel = GetRedoMenuLabel();
     {
         wxString undoLabel = GetUndoMenuLabel();
         wxString redoLabel = GetRedoMenuLabel();

-        
+

         m_commandEditMenu->SetLabel(wxID_UNDO, undoLabel);
         m_commandEditMenu->Enable(wxID_UNDO, CanUndo());
 
         m_commandEditMenu->SetLabel(wxID_UNDO, undoLabel);
         m_commandEditMenu->Enable(wxID_UNDO, CanUndo());
 


@@ -243,9 +258,9 @@ wxString wxCommandProcessor::GetUndoMenuLabel() const
     wxString buf;
     if (m_currentCommand)
     {
     wxString buf;
     if (m_currentCommand)
     {

-        wxCommand *command = (wxCommand *)m_currentCommand->Data();
+        wxCommand *command = (wxCommand *)m_currentCommand->GetData();

         wxString commandName(command->GetName());
         wxString commandName(command->GetName());

-        if (commandName == wxT("")) commandName = _("Unnamed command");
+        if (commandName.empty()) commandName = _("Unnamed command");

         bool canUndo = command->CanUndo();
         if (canUndo)
             buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator;
         bool canUndo = command->CanUndo();
         if (canUndo)
             buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator;


@@ -256,7 +271,7 @@ wxString wxCommandProcessor::GetUndoMenuLabel() const
     {
         buf = _("&Undo") + m_undoAccelerator;
     }
     {
         buf = _("&Undo") + m_undoAccelerator;
     }

-    
+

     return buf;
 }
 
     return buf;
 }
 


@@ -267,11 +282,11 @@ wxString wxCommandProcessor::GetRedoMenuLabel() const
     if (m_currentCommand)
     {
         // We can redo, if we're not at the end of the history.
     if (m_currentCommand)
     {
         // We can redo, if we're not at the end of the history.

-        if (m_currentCommand->Next())
+        if (m_currentCommand->GetNext())

         {
         {

-            wxCommand *redoCommand = (wxCommand *)m_currentCommand->Next()->Data();
+            wxCommand *redoCommand = (wxCommand *)m_currentCommand->GetNext()->GetData();

             wxString redoCommandName(redoCommand->GetName());
             wxString redoCommandName(redoCommand->GetName());

-            if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command");
+            if (redoCommandName.empty()) redoCommandName = _("Unnamed command");

             buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
         }
         else
             buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
         }
         else


@@ -281,7 +296,7 @@ wxString wxCommandProcessor::GetRedoMenuLabel() const
     }
     else
     {
     }
     else
     {

-        if (m_commands.Number() == 0)
+        if (m_commands.GetCount() == 0)

         {
             buf = _("&Redo") + m_redoAccelerator;
         }
         {
             buf = _("&Redo") + m_redoAccelerator;
         }


@@ -289,9 +304,9 @@ wxString wxCommandProcessor::GetRedoMenuLabel() const
         {
             // currentCommand is NULL but there are commands: this means that
             // we've undone to the start of the list, but can redo the first.
         {
             // 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();
+            wxCommand *redoCommand = (wxCommand *)m_commands.GetFirst()->GetData();

             wxString redoCommandName(redoCommand->GetName());
             wxString redoCommandName(redoCommand->GetName());

-            if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command");
+            if (redoCommandName.empty()) redoCommandName = _("Unnamed command");

             buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
         }
     }
             buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
         }
     }


@@ -300,15 +315,41 @@ wxString wxCommandProcessor::GetRedoMenuLabel() const
 
 void wxCommandProcessor::ClearCommands()
 {
 
 void wxCommandProcessor::ClearCommands()
 {

-    wxNode *node = m_commands.First();
+    wxList::compatibility_iterator node = m_commands.GetFirst();

     while (node)
     {
     while (node)
     {

-        wxCommand *command = (wxCommand *)node->Data();
+        wxCommand *command = (wxCommand *)node->GetData();

         delete command;
         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();

 }
 
 }
 

+bool wxCommandProcessor::IsDirty() const
+{
+    if ( m_commands.empty() )
+    {
+        // If we have never been modified, we can't be dirty.
+        return false;
+    }
+
+    if ( !m_lastSavedCommand )
+    {
+        // If we have been modified but have never been saved, we're dirty.
+        return true;
+    }
+
+    if ( !m_currentCommand )
+    {
+        // This only happens if all commands were undone after saving the
+        // document: we're dirty then.
+        return true;
+    }
+
+    // Finally if both iterators are valid, we may just compare them.
+    return m_currentCommand != m_lastSavedCommand;
+}