src/common/cmdproc.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/cmdproc.cpp
   3 // Purpose:     wxCommand and wxCommandProcessor classes
   4 // Author:      Julian Smart (extracted from docview.h by VZ)
   5 // Modified by:
   6 // Created:     05.11.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWindows team
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "cmdproc.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/intl.h"
  33     #include "wx/string.h"
  34     #include "wx/menu.h"
  35 #endif //WX_PRECOMP
  36
  37 #include "wx/cmdproc.h"
  38
  39 // ============================================================================
  40 // implementation
  41 // ============================================================================
  42
  43 IMPLEMENT_CLASS(wxCommand, wxObject)
  44 IMPLEMENT_DYNAMIC_CLASS(wxCommandProcessor, wxObject)
  45
  46 // ----------------------------------------------------------------------------
  47 // wxCommand
  48 // ----------------------------------------------------------------------------
  49
  50 wxCommand::wxCommand(bool canUndoIt, const wxString& name)
  51 {
  52     m_canUndo = canUndoIt;
  53     m_commandName = name;
  54 }
  55
  56 wxCommand::~wxCommand()
  57 {
  58 }
  59
  60 // ----------------------------------------------------------------------------
  61 // Command processor
  62 // ----------------------------------------------------------------------------
  63
  64 wxCommandProcessor::wxCommandProcessor(int maxCommands)
  65 {
  66     m_maxNoCommands = maxCommands;
  67     m_currentCommand = (wxNode *) NULL;
  68 #if wxUSE_MENUS
  69     m_commandEditMenu = (wxMenu *) NULL;
  70 #endif // wxUSE_MENUS
  71     m_undoAccelerator = wxT("\tCtrl+Z");
  72     m_redoAccelerator = wxT("\tCtrl+Y");
  73 }
  74
  75 wxCommandProcessor::~wxCommandProcessor()
  76 {
  77     ClearCommands();
  78 }
  79
  80 bool wxCommandProcessor::DoCommand(wxCommand& cmd)
  81 {
  82     return cmd.Do();
  83 }
  84
  85 bool wxCommandProcessor::UndoCommand(wxCommand& cmd)
  86 {
  87     return cmd.Undo();
  88 }
  89
  90 // Pass a command to the processor. The processor calls Do();
  91 // if successful, is appended to the command history unless
  92 // storeIt is FALSE.
  93 bool wxCommandProcessor::Submit(wxCommand *command, bool storeIt)
  94 {
  95     wxCHECK_MSG( command, FALSE, _T("no command in wxCommandProcessor::Submit") );
  96
  97     if ( !DoCommand(*command) )
  98     {
  99         // the user code expects the command to be deleted anyhow
 100         delete command;
 101
 102         return FALSE;
 103     }
 104
 105     if ( storeIt )
 106         Store(command);
 107
 108     return TRUE;
 109 }
 110
 111 void wxCommandProcessor::Store(wxCommand *command)
 112 {
 113     wxCHECK_RET( command, _T("no command in wxCommandProcessor::Store") );
 114
 115     if (m_commands.Number() == m_maxNoCommands)
 116     {
 117         wxNode *firstNode = m_commands.First();
 118         wxCommand *firstCommand = (wxCommand *)firstNode->Data();
 119         delete firstCommand;
 120         delete firstNode;
 121     }
 122
 123     // Correct a bug: we must chop off the current 'branch'
 124     // so that we're at the end of the command list.
 125     if (!m_currentCommand)
 126         ClearCommands();
 127     else
 128     {
 129         wxNode *node = m_currentCommand->Next();
 130         while (node)
 131         {
 132             wxNode *next = node->Next();
 133             delete (wxCommand *)node->Data();
 134             delete node;
 135             node = next;
 136         }
 137     }
 138
 139     m_commands.Append(command);
 140     m_currentCommand = m_commands.Last();
 141     SetMenuStrings();
 142 }
 143
 144 bool wxCommandProcessor::Undo()
 145 {
 146     wxCommand *command = GetCurrentCommand();
 147     if ( command && command->CanUndo() )
 148     {
 149         if ( UndoCommand(*command) )
 150         {
 151             m_currentCommand = m_currentCommand->Previous();
 152             SetMenuStrings();
 153             return TRUE;
 154         }
 155     }
 156
 157     return FALSE;
 158 }
 159
 160 bool wxCommandProcessor::Redo()
 161 {
 162     wxCommand *redoCommand = (wxCommand *) NULL;
 163     wxNode *redoNode = (wxNode *) NULL;
 164
 165     if ( m_currentCommand )
 166     {
 167         // is there anything to redo?
 168         if ( m_currentCommand->Next() )
 169         {
 170             redoCommand = (wxCommand *)m_currentCommand->Next()->Data();
 171             redoNode = m_currentCommand->Next();
 172         }
 173     }
 174     else // no current command, redo the first one
 175     {
 176         if (m_commands.Number() > 0)
 177         {
 178             redoCommand = (wxCommand *)m_commands.First()->Data();
 179             redoNode = m_commands.First();
 180         }
 181     }
 182
 183     if (redoCommand)
 184     {
 185         bool success = DoCommand(*redoCommand);
 186         if (success)
 187         {
 188             m_currentCommand = redoNode;
 189             SetMenuStrings();
 190             return TRUE;
 191         }
 192     }
 193     return FALSE;
 194 }
 195
 196 bool wxCommandProcessor::CanUndo() const
 197 {
 198     wxCommand *command = GetCurrentCommand();
 199
 200     return command && command->CanUndo();
 201 }
 202
 203 bool wxCommandProcessor::CanRedo() const
 204 {
 205     if ((m_currentCommand != (wxNode*) NULL) && (m_currentCommand->Next() == (wxNode*) NULL))
 206         return FALSE;
 207
 208     if ((m_currentCommand != (wxNode*) NULL) && (m_currentCommand->Next() != (wxNode*) NULL))
 209         return TRUE;
 210
 211     if ((m_currentCommand == (wxNode*) NULL) && (m_commands.Number() > 0))
 212         return TRUE;
 213
 214     return FALSE;
 215 }
 216
 217 void wxCommandProcessor::Initialize()
 218 {
 219     m_currentCommand = m_commands.Last();
 220     SetMenuStrings();
 221 }
 222
 223 void wxCommandProcessor::SetMenuStrings()
 224 {
 225 #if wxUSE_MENUS
 226     if (m_commandEditMenu)
 227     {
 228         wxString buf;
 229         if (m_currentCommand)
 230         {
 231             wxCommand *command = (wxCommand *)m_currentCommand->Data();
 232             wxString commandName(command->GetName());
 233             if (commandName == wxT("")) commandName = _("Unnamed command");
 234             bool canUndo = command->CanUndo();
 235             if (canUndo)
 236                 buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator;
 237             else
 238                 buf = wxString(_("Can't &Undo ")) + commandName + m_undoAccelerator;
 239
 240             m_commandEditMenu->SetLabel(wxID_UNDO, buf);
 241             m_commandEditMenu->Enable(wxID_UNDO, canUndo);
 242
 243             // We can redo, if we're not at the end of the history.
 244             if (m_currentCommand->Next())
 245             {
 246                 wxCommand *redoCommand = (wxCommand *)m_currentCommand->Next()->Data();
 247                 wxString redoCommandName(redoCommand->GetName());
 248                 if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command");
 249                 buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
 250                 m_commandEditMenu->SetLabel(wxID_REDO, buf);
 251                 m_commandEditMenu->Enable(wxID_REDO, TRUE);
 252             }
 253             else
 254             {
 255                 m_commandEditMenu->SetLabel(wxID_REDO, _("&Redo") + m_redoAccelerator);
 256                 m_commandEditMenu->Enable(wxID_REDO, FALSE);
 257             }
 258         }
 259         else
 260         {
 261             m_commandEditMenu->SetLabel(wxID_UNDO, _("&Undo") + m_undoAccelerator);
 262             m_commandEditMenu->Enable(wxID_UNDO, FALSE);
 263
 264             if (m_commands.Number() == 0)
 265             {
 266                 m_commandEditMenu->SetLabel(wxID_REDO, _("&Redo") + m_redoAccelerator);
 267                 m_commandEditMenu->Enable(wxID_REDO, FALSE);
 268             }
 269             else
 270             {
 271                 // currentCommand is NULL but there are commands: this means that
 272                 // we've undone to the start of the list, but can redo the first.
 273                 wxCommand *redoCommand = (wxCommand *)m_commands.First()->Data();
 274                 wxString redoCommandName(redoCommand->GetName());
 275                 if (redoCommandName == wxT("")) redoCommandName = _("Unnamed command");
 276                 buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
 277                 m_commandEditMenu->SetLabel(wxID_REDO, buf);
 278                 m_commandEditMenu->Enable(wxID_REDO, TRUE);
 279             }
 280         }
 281     }
 282 #endif // wxUSE_MENUS
 283 }
 284
 285 void wxCommandProcessor::ClearCommands()
 286 {
 287     wxNode *node = m_commands.First();
 288     while (node)
 289     {
 290         wxCommand *command = (wxCommand *)node->Data();
 291         delete command;
 292         delete node;
 293         node = m_commands.First();
 294     }
 295     m_currentCommand = (wxNode *) NULL;
 296 }
 297
 298