aa75d950e27e61f415963dbfa624c0b5bbeef581
[xonotic/netradiant.git] / radiant / undo.cpp
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #include "undo.h"
23
24 #include "debugging/debugging.h"
25 #include "warnings.h"
26
27 #include "iundo.h"
28 #include "preferencesystem.h"
29 #include "string/string.h"
30 #include "generic/callback.h"
31 #include "preferences.h"
32 #include "stringio.h"
33
34 #include <list>
35 #include <map>
36 #include <set>
37
38 #include "timer.h"
39
40 class DebugScopeTimer
41 {
42   Timer m_timer;
43   const char* m_operation;
44 public:
45   DebugScopeTimer(const char* operation)
46     : m_operation(operation)
47   {
48     m_timer.start();
49   }
50   ~DebugScopeTimer()
51   {
52     unsigned int elapsed = m_timer.elapsed_msec();
53     if(elapsed > 0)
54     {
55       globalOutputStream() << m_operation << ": " << elapsed << " msec\n";
56     }
57   }
58 };
59
60
61 class RadiantUndoSystem : public UndoSystem
62 {
63   INTEGER_CONSTANT(MAX_UNDO_LEVELS, 1024);
64
65   class Snapshot
66   {
67     class StateApplicator
68     {
69     public:
70       Undoable* m_undoable;
71     private:
72       UndoMemento* m_data;
73     public:
74
75       StateApplicator(Undoable* undoable, UndoMemento* data)
76         : m_undoable(undoable), m_data(data)
77       {
78       }
79       void restore()
80       {
81         m_undoable->importState(m_data);
82       }
83       void release()
84       {
85         m_data->release();
86       }
87     };
88   
89     typedef std::list<StateApplicator> states_t;
90     states_t m_states;
91
92   public:
93     bool empty() const
94     {
95       return m_states.empty();
96     }
97     std::size_t size() const
98     {
99       return m_states.size();
100     }
101     void save(Undoable* undoable)
102     {
103       m_states.push_front(StateApplicator(undoable, undoable->exportState()));
104     }
105     void restore()
106     {
107       for(states_t::iterator i = m_states.begin(); i != m_states.end(); ++i)
108       {
109         (*i).restore();
110       }
111     }
112     void release()
113     {
114       for(states_t::iterator i = m_states.begin(); i != m_states.end(); ++i)
115       {
116         (*i).release();
117       }
118     }
119   };
120
121   struct Operation
122   {
123     Snapshot m_snapshot;
124     CopiedString m_command;
125
126     Operation(const char* command)
127       : m_command(command)
128     {
129     }
130     ~Operation()
131     {
132       m_snapshot.release();
133     }
134   };
135
136
137   class UndoStack
138   {
139     //! Note: using std::list instead of vector/deque, to avoid copying of undos
140     typedef std::list<Operation*> Operations;
141
142     Operations m_stack;
143     Operation* m_pending;
144
145   public:
146     UndoStack() : m_pending(0)
147     {
148     }
149     ~UndoStack()
150     {
151       clear();
152     }
153     bool empty() const
154     {
155       return m_stack.empty();
156     }
157     std::size_t size() const
158     {
159       return m_stack.size();
160     }
161     Operation* back()
162     {
163       return m_stack.back();
164     }
165     const Operation* back() const
166     {
167       return m_stack.back();
168     }
169     Operation* front()
170     {
171       return m_stack.front();
172     }
173     const Operation* front() const
174     {
175       return m_stack.front();
176     }
177     void pop_front()
178     {
179       delete m_stack.front();
180       m_stack.pop_front();
181     }
182     void pop_back()
183     {
184       delete m_stack.back();
185       m_stack.pop_back();
186     }
187     void clear()
188     {
189       if(!m_stack.empty())
190       {
191         for(Operations::iterator i = m_stack.begin(); i != m_stack.end(); ++i)
192         {
193           delete *i;
194         }
195         m_stack.clear();
196       }
197     }
198     void start(const char* command)
199     {
200       if(m_pending != 0)
201       {
202         delete m_pending;
203       }
204       m_pending = new Operation(command);
205     }
206     bool finish(const char* command)
207     {
208       if(m_pending != 0)
209       {
210         delete m_pending;
211         m_pending = 0;
212         return false;
213       }
214       else
215       {
216         ASSERT_MESSAGE(!m_stack.empty(), "undo stack empty");
217         m_stack.back()->m_command = command;
218         return true;
219       }
220     }
221     void save(Undoable* undoable)
222     {
223       if(m_pending != 0)
224       {
225         m_stack.push_back(m_pending);
226         m_pending = 0;
227       }
228       back()->m_snapshot.save(undoable);
229     }
230   };
231
232   UndoStack m_undo_stack;
233   UndoStack m_redo_stack;
234
235   class UndoStackFiller : public UndoObserver
236   {
237     UndoStack* m_stack;
238   public:
239
240     UndoStackFiller()
241       : m_stack(0)
242     {
243     }
244     void save(Undoable* undoable)
245     {
246       ASSERT_NOTNULL(undoable);
247
248       if(m_stack != 0)
249       {
250         m_stack->save(undoable);
251         m_stack = 0;
252       }
253     }
254     void setStack(UndoStack* stack)
255     {
256       m_stack = stack;
257     }
258   };
259
260   typedef std::map<Undoable*, UndoStackFiller> undoables_t;
261   undoables_t m_undoables;
262
263   void mark_undoables(UndoStack* stack)
264   {
265     for(undoables_t::iterator i = m_undoables.begin(); i != m_undoables.end(); ++i)
266     {
267       (*i).second.setStack(stack);
268     }
269   }
270
271   std::size_t m_undo_levels;
272
273   typedef std::set<UndoTracker*> Trackers;
274   Trackers m_trackers;
275 public:
276   RadiantUndoSystem()
277     : m_undo_levels(64)
278   {
279   }
280   ~RadiantUndoSystem()
281   {
282     clear();
283   }
284   UndoObserver* observer(Undoable* undoable)
285   {
286     ASSERT_NOTNULL(undoable);
287
288     return &m_undoables[undoable];
289   }
290   void release(Undoable* undoable)
291   {
292     ASSERT_NOTNULL(undoable);
293
294     m_undoables.erase(undoable);
295   }
296   void setLevels(std::size_t levels)
297   {
298     if(levels > MAX_UNDO_LEVELS())
299     {
300       levels = MAX_UNDO_LEVELS();
301     }
302
303     while(m_undo_stack.size() > levels)
304     {
305       m_undo_stack.pop_front();
306     }
307     m_undo_levels = levels;
308   }
309   std::size_t getLevels() const
310   {
311     return m_undo_levels;
312   }
313   std::size_t size() const
314   {
315     return m_undo_stack.size();
316   }
317   void startUndo()
318   {
319     m_undo_stack.start("unnamedCommand");
320     mark_undoables(&m_undo_stack);
321   }
322   bool finishUndo(const char* command)
323   {
324     bool changed = m_undo_stack.finish(command);
325     mark_undoables(0);
326     return changed;
327   }
328   void startRedo()
329   {
330     m_redo_stack.start("unnamedCommand");
331     mark_undoables(&m_redo_stack);
332   }
333   bool finishRedo(const char* command)
334   {
335     bool changed = m_redo_stack.finish(command);
336     mark_undoables(0);
337     return changed;
338   }
339   void start()
340   {
341     m_redo_stack.clear();
342     if(m_undo_stack.size() == m_undo_levels)
343     {
344       m_undo_stack.pop_front();
345     }
346     startUndo();
347     trackersBegin();
348   }
349   void finish(const char* command)
350   {
351     if(finishUndo(command))
352     {
353       globalOutputStream() << command << '\n';
354     }
355   }
356   void undo()
357   {
358     if(m_undo_stack.empty())
359     {
360       globalOutputStream() << "Undo: no undo available\n";
361     }
362     else
363     {
364       Operation* operation = m_undo_stack.back();
365       globalOutputStream() << "Undo: " << operation->m_command.c_str() << "\n";
366
367       startRedo();
368       trackersUndo();
369       operation->m_snapshot.restore();
370       finishRedo(operation->m_command.c_str());
371       m_undo_stack.pop_back();
372     }
373   }
374   void redo()
375   {
376     if(m_redo_stack.empty())
377     {
378       globalOutputStream() << "Redo: no redo available\n";
379     }
380     else
381     {
382       Operation* operation = m_redo_stack.back();
383       globalOutputStream() << "Redo: " << operation->m_command.c_str() << "\n";
384
385       startUndo();
386       trackersRedo();
387       operation->m_snapshot.restore();
388       finishUndo(operation->m_command.c_str());
389       m_redo_stack.pop_back();
390     }
391   }
392   void clear()
393   {
394     mark_undoables(0);
395     m_undo_stack.clear();
396     m_redo_stack.clear();
397     trackersClear();
398   }
399   void trackerAttach(UndoTracker& tracker)
400   {
401     ASSERT_MESSAGE(m_trackers.find(&tracker) == m_trackers.end(), "undo tracker already attached");
402     m_trackers.insert(&tracker);
403   }
404   void trackerDetach(UndoTracker& tracker)
405   {
406     ASSERT_MESSAGE(m_trackers.find(&tracker) != m_trackers.end(), "undo tracker cannot be detached");
407     m_trackers.erase(&tracker);
408   }
409   void trackersClear() const
410   {
411     for(Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i)
412     {
413       (*i)->clear();
414     }
415   }
416   void trackersBegin() const
417   {
418     for(Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i)
419     {
420       (*i)->begin();
421     }
422   }
423   void trackersUndo() const
424   {
425     for(Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i)
426     {
427       (*i)->undo();
428     }
429   }
430   void trackersRedo() const
431   {
432     for(Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i)
433     {
434       (*i)->redo();
435     }
436   }
437 };
438
439
440
441 void UndoLevels_importString(RadiantUndoSystem& undo, const char* value)
442 {
443   int levels;
444   Int_importString(levels, value);
445   undo.setLevels(levels);
446 }
447 typedef ReferenceCaller1<RadiantUndoSystem, const char*, UndoLevels_importString> UndoLevelsImportStringCaller;
448 void UndoLevels_exportString(const RadiantUndoSystem& undo, const StringImportCallback& importer)
449 {
450   Int_exportString(static_cast<int>(undo.getLevels()), importer);
451 }
452 typedef ConstReferenceCaller1<RadiantUndoSystem, const StringImportCallback&, UndoLevels_exportString> UndoLevelsExportStringCaller;
453
454 #include "generic/callback.h"
455
456 void UndoLevelsImport(RadiantUndoSystem& self, int value)
457 {
458   self.setLevels(value);
459 }
460 typedef ReferenceCaller1<RadiantUndoSystem, int, UndoLevelsImport> UndoLevelsImportCaller;
461 void UndoLevelsExport(const RadiantUndoSystem& self, const IntImportCallback& importCallback)
462 {
463   importCallback(static_cast<int>(self.getLevels()));
464 }
465 typedef ConstReferenceCaller1<RadiantUndoSystem, const IntImportCallback&, UndoLevelsExport> UndoLevelsExportCaller;
466
467
468 void Undo_constructPreferences(RadiantUndoSystem& undo, PreferencesPage& page)
469 {
470   page.appendSpinner("Undo Queue Size", 64, 0, 1024, IntImportCallback(UndoLevelsImportCaller(undo)), IntExportCallback(UndoLevelsExportCaller(undo)));
471 }
472 void Undo_constructPage(RadiantUndoSystem& undo, PreferenceGroup& group)
473 {
474   PreferencesPage page(group.createPage("Undo", "Undo Queue Settings"));
475   Undo_constructPreferences(undo, page);
476 }
477 void Undo_registerPreferencesPage(RadiantUndoSystem& undo)
478 {
479   PreferencesDialog_addSettingsPage(ReferenceCaller1<RadiantUndoSystem, PreferenceGroup&, Undo_constructPage>(undo));
480 }
481
482 class UndoSystemDependencies : public GlobalPreferenceSystemModuleRef
483 {
484 };
485
486 class UndoSystemAPI
487 {
488   RadiantUndoSystem m_undosystem;
489 public:
490   typedef UndoSystem Type;
491   STRING_CONSTANT(Name, "*");
492
493   UndoSystemAPI()
494   {
495     GlobalPreferenceSystem().registerPreference("UndoLevels", makeIntStringImportCallback(UndoLevelsImportCaller(m_undosystem)), makeIntStringExportCallback(UndoLevelsExportCaller(m_undosystem)));
496
497     Undo_registerPreferencesPage(m_undosystem);
498   }
499   UndoSystem* getTable()
500   {
501     return &m_undosystem;
502   }
503 };
504
505 #include "modulesystem/singletonmodule.h"
506 #include "modulesystem/moduleregistry.h"
507
508 typedef SingletonModule<UndoSystemAPI, UndoSystemDependencies> UndoSystemModule;
509 typedef Static<UndoSystemModule> StaticUndoSystemModule;
510 StaticRegisterModule staticRegisterUndoSystem(StaticUndoSystemModule::instance());
511
512
513
514
515
516
517
518
519
520
521 class undoable_test : public Undoable
522 {
523   struct state_type : public UndoMemento
524   {
525     state_type() : test_data(0)
526     {
527     }
528     state_type(const state_type& other) : UndoMemento(other), test_data(other.test_data)
529     {
530     }
531     void release()
532     {
533       delete this;
534     }
535
536     int test_data;
537   };
538   state_type m_state;
539   UndoObserver* m_observer;
540 public:
541   undoable_test()
542     : m_observer(GlobalUndoSystem().observer(this))
543   {
544   }
545   ~undoable_test()
546   {
547     GlobalUndoSystem().release(this);
548   }
549   UndoMemento* exportState() const
550   {
551     return new state_type(m_state);
552   }
553   void importState(const UndoMemento* state)
554   {
555     ASSERT_NOTNULL(state);
556
557     m_observer->save(this);
558     m_state = *(static_cast<const state_type*>(state));
559   }
560
561   void mutate(unsigned int data)
562   {
563     m_observer->save(this);
564     m_state.test_data = data;
565   }
566 };
567
568 #if 0
569
570 class TestUndo
571 {
572 public:
573   TestUndo()
574   {
575     undoable_test test;
576     GlobalUndoSystem().begin("bleh");
577     test.mutate(3);
578     GlobalUndoSystem().begin("blah");
579     test.mutate(4);
580     GlobalUndoSystem().undo();
581     GlobalUndoSystem().undo();
582     GlobalUndoSystem().redo();
583     GlobalUndoSystem().redo();
584   }
585 };
586
587 TestUndo g_TestUndo;
588
589 #endif
590