// Author: Julian Smart (extracted from docview.h by VZ)
// Modified by:
// Created: 05.11.00
-// RCS-ID: $Id$
-// Copyright: (c) wxWindows team
+// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "cmdproc.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/intl.h"
#include "wx/string.h"
#include "wx/menu.h"
+ #include "wx/accel.h"
#endif //WX_PRECOMP
#include "wx/cmdproc.h"
m_commandName = name;
}
-wxCommand::~wxCommand()
-{
-}
-
// ----------------------------------------------------------------------------
// Command processor
// ----------------------------------------------------------------------------
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()
// 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.
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();
}
{
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();
}
}
{
m_currentCommand = redoNode;
SetMenuStrings();
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
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();
}
#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);
- 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;
- m_commandEditMenu->SetLabel(wxID_REDO, buf);
- m_commandEditMenu->Enable(wxID_REDO, TRUE);
- }
- else
- {
- m_commandEditMenu->SetLabel(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
{
- m_commandEditMenu->SetLabel(wxID_UNDO, _("&Undo") + m_undoAccelerator);
- m_commandEditMenu->Enable(wxID_UNDO, FALSE);
-
- if (m_commands.Number() == 0)
- {
- m_commandEditMenu->SetLabel(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;
- m_commandEditMenu->SetLabel(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();
}
+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;
+}
projects / wxWidgets.git / blobdiff