/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/cmdproc.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/cmdproc.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 2 months ago) by william
File size: 9041 byte(s)
committing r3113 initial commit again...
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: cmdproc.cpp 35650 2005-09-23 12:56:45Z MR $
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #ifndef WX_PRECOMP
28 #include "wx/intl.h"
29 #include "wx/string.h"
30 #include "wx/menu.h"
31 #endif //WX_PRECOMP
32
33 #include "wx/cmdproc.h"
34
35 // ============================================================================
36 // implementation
37 // ============================================================================
38
39 IMPLEMENT_CLASS(wxCommand, wxObject)
40 IMPLEMENT_DYNAMIC_CLASS(wxCommandProcessor, wxObject)
41
42 // ----------------------------------------------------------------------------
43 // wxCommand
44 // ----------------------------------------------------------------------------
45
46 wxCommand::wxCommand(bool canUndoIt, const wxString& name)
47 {
48 m_canUndo = canUndoIt;
49 m_commandName = name;
50 }
51
52 // ----------------------------------------------------------------------------
53 // Command processor
54 // ----------------------------------------------------------------------------
55
56 wxCommandProcessor::wxCommandProcessor(int maxCommands)
57 {
58 m_maxNoCommands = maxCommands;
59 #if wxUSE_MENUS
60 m_commandEditMenu = (wxMenu *) NULL;
61 #endif // wxUSE_MENUS
62 m_undoAccelerator = wxT("\tCtrl+Z");
63 m_redoAccelerator = wxT("\tCtrl+Y");
64
65 m_lastSavedCommand =
66 m_currentCommand = wxList::compatibility_iterator();
67 }
68
69 wxCommandProcessor::~wxCommandProcessor()
70 {
71 ClearCommands();
72 }
73
74 bool wxCommandProcessor::DoCommand(wxCommand& cmd)
75 {
76 return cmd.Do();
77 }
78
79 bool wxCommandProcessor::UndoCommand(wxCommand& cmd)
80 {
81 return cmd.Undo();
82 }
83
84 // Pass a command to the processor. The processor calls Do();
85 // if successful, is appended to the command history unless
86 // storeIt is false.
87 bool wxCommandProcessor::Submit(wxCommand *command, bool storeIt)
88 {
89 wxCHECK_MSG( command, false, _T("no command in wxCommandProcessor::Submit") );
90
91 if ( !DoCommand(*command) )
92 {
93 // the user code expects the command to be deleted anyhow
94 delete command;
95
96 return false;
97 }
98
99 if ( storeIt )
100 Store(command);
101 else
102 delete command;
103
104 return true;
105 }
106
107 void wxCommandProcessor::Store(wxCommand *command)
108 {
109 wxCHECK_RET( command, _T("no command in wxCommandProcessor::Store") );
110
111 if ( (int)m_commands.GetCount() == m_maxNoCommands )
112 {
113 wxList::compatibility_iterator firstNode = m_commands.GetFirst();
114 wxCommand *firstCommand = (wxCommand *)firstNode->GetData();
115 delete firstCommand;
116 m_commands.Erase(firstNode);
117
118 // Make sure m_lastSavedCommand won't point to freed memory
119 if ( m_lastSavedCommand == firstNode )
120 m_lastSavedCommand = wxList::compatibility_iterator();
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 wxList::compatibility_iterator node = m_currentCommand->GetNext();
130 while (node)
131 {
132 wxList::compatibility_iterator next = node->GetNext();
133 delete (wxCommand *)node->GetData();
134 m_commands.Erase(node);
135
136 // Make sure m_lastSavedCommand won't point to freed memory
137 if ( m_lastSavedCommand == node )
138 m_lastSavedCommand = wxList::compatibility_iterator();
139
140 node = next;
141 }
142 }
143
144 m_commands.Append(command);
145 m_currentCommand = m_commands.GetLast();
146 SetMenuStrings();
147 }
148
149 bool wxCommandProcessor::Undo()
150 {
151 wxCommand *command = GetCurrentCommand();
152 if ( command && command->CanUndo() )
153 {
154 if ( UndoCommand(*command) )
155 {
156 m_currentCommand = m_currentCommand->GetPrevious();
157 SetMenuStrings();
158 return true;
159 }
160 }
161
162 return false;
163 }
164
165 bool wxCommandProcessor::Redo()
166 {
167 wxCommand *redoCommand = (wxCommand *) NULL;
168 wxList::compatibility_iterator redoNode
169 #if !wxUSE_STL
170 = NULL // just to avoid warnings
171 #endif // !wxUSE_STL
172 ;
173
174 if ( m_currentCommand )
175 {
176 // is there anything to redo?
177 if ( m_currentCommand->GetNext() )
178 {
179 redoCommand = (wxCommand *)m_currentCommand->GetNext()->GetData();
180 redoNode = m_currentCommand->GetNext();
181 }
182 }
183 else // no current command, redo the first one
184 {
185 if (m_commands.GetCount() > 0)
186 {
187 redoCommand = (wxCommand *)m_commands.GetFirst()->GetData();
188 redoNode = m_commands.GetFirst();
189 }
190 }
191
192 if (redoCommand)
193 {
194 bool success = DoCommand(*redoCommand);
195 if (success)
196 {
197 m_currentCommand = redoNode;
198 SetMenuStrings();
199 return true;
200 }
201 }
202 return false;
203 }
204
205 bool wxCommandProcessor::CanUndo() const
206 {
207 wxCommand *command = GetCurrentCommand();
208
209 return command && command->CanUndo();
210 }
211
212 bool wxCommandProcessor::CanRedo() const
213 {
214 if (m_currentCommand && !m_currentCommand->GetNext())
215 return false;
216
217 if (m_currentCommand && m_currentCommand->GetNext())
218 return true;
219
220 if (!m_currentCommand && (m_commands.GetCount() > 0))
221 return true;
222
223 return false;
224 }
225
226 void wxCommandProcessor::Initialize()
227 {
228 m_currentCommand = m_commands.GetLast();
229 SetMenuStrings();
230 }
231
232 void wxCommandProcessor::SetMenuStrings()
233 {
234 #if wxUSE_MENUS
235 if (m_commandEditMenu)
236 {
237 wxString undoLabel = GetUndoMenuLabel();
238 wxString redoLabel = GetRedoMenuLabel();
239
240 m_commandEditMenu->SetLabel(wxID_UNDO, undoLabel);
241 m_commandEditMenu->Enable(wxID_UNDO, CanUndo());
242
243 m_commandEditMenu->SetLabel(wxID_REDO, redoLabel);
244 m_commandEditMenu->Enable(wxID_REDO, CanRedo());
245 }
246 #endif // wxUSE_MENUS
247 }
248
249 // Gets the current Undo menu label.
250 wxString wxCommandProcessor::GetUndoMenuLabel() const
251 {
252 wxString buf;
253 if (m_currentCommand)
254 {
255 wxCommand *command = (wxCommand *)m_currentCommand->GetData();
256 wxString commandName(command->GetName());
257 if (commandName.empty()) commandName = _("Unnamed command");
258 bool canUndo = command->CanUndo();
259 if (canUndo)
260 buf = wxString(_("&Undo ")) + commandName + m_undoAccelerator;
261 else
262 buf = wxString(_("Can't &Undo ")) + commandName + m_undoAccelerator;
263 }
264 else
265 {
266 buf = _("&Undo") + m_undoAccelerator;
267 }
268
269 return buf;
270 }
271
272 // Gets the current Undo menu label.
273 wxString wxCommandProcessor::GetRedoMenuLabel() const
274 {
275 wxString buf;
276 if (m_currentCommand)
277 {
278 // We can redo, if we're not at the end of the history.
279 if (m_currentCommand->GetNext())
280 {
281 wxCommand *redoCommand = (wxCommand *)m_currentCommand->GetNext()->GetData();
282 wxString redoCommandName(redoCommand->GetName());
283 if (redoCommandName.empty()) redoCommandName = _("Unnamed command");
284 buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
285 }
286 else
287 {
288 buf = _("&Redo") + m_redoAccelerator;
289 }
290 }
291 else
292 {
293 if (m_commands.GetCount() == 0)
294 {
295 buf = _("&Redo") + m_redoAccelerator;
296 }
297 else
298 {
299 // currentCommand is NULL but there are commands: this means that
300 // we've undone to the start of the list, but can redo the first.
301 wxCommand *redoCommand = (wxCommand *)m_commands.GetFirst()->GetData();
302 wxString redoCommandName(redoCommand->GetName());
303 if (redoCommandName.empty()) redoCommandName = _("Unnamed command");
304 buf = wxString(_("&Redo ")) + redoCommandName + m_redoAccelerator;
305 }
306 }
307 return buf;
308 }
309
310 void wxCommandProcessor::ClearCommands()
311 {
312 wxList::compatibility_iterator node = m_commands.GetFirst();
313 while (node)
314 {
315 wxCommand *command = (wxCommand *)node->GetData();
316 delete command;
317 m_commands.Erase(node);
318 node = m_commands.GetFirst();
319 }
320
321 m_currentCommand = wxList::compatibility_iterator();
322 m_lastSavedCommand = wxList::compatibility_iterator();
323 }
324
325

  ViewVC Help
Powered by ViewVC 1.1.22