]> Shamusworld >> Repos - architektonas/blob - src/base/rs_undo.cpp
Removed more QC_ madness...
[architektonas] / src / base / rs_undo.cpp
1 // rs_undo.cpp
2 //
3 // Part of the Architektonas Project
4 // Originally part of QCad Community Edition by Andrew Mustun
5 // Extensively rewritten and refactored by James L. Hammons
6 // (C) 2010 Underground Software
7 //
8 // JLH = James L. Hammons <jlhamm@acm.org>
9 //
10 // Who  When        What
11 // ---  ----------  -----------------------------------------------------------
12 // JLH  06/02/2010  Added this text. :-)
13 //
14
15 #include "rs_undo.h"
16
17 #include "rs_debug.h"
18 #include "rs_undoable.h"
19
20 /**
21  * Default constructor.
22  */
23 RS_Undo::RS_Undo()
24 {
25 #warning "!!! Need to deal with setAutoDelete() Qt3->Qt4 !!!"
26 //      undoList.setAutoDelete(true);
27         undoPointer = -1;
28         currentCycle = NULL;
29 }
30
31 /*virtual*/ RS_Undo::~RS_Undo()
32 {
33         while (!undoList.isEmpty())
34                 delete undoList.takeFirst();
35 }
36
37 /**
38  * @return Number of Cycles that can be undone.
39  */
40 int RS_Undo::countUndoCycles()
41 {
42         RS_DEBUG->print("RS_Undo::countUndoCycles");
43
44         return undoPointer + 1;
45 }
46
47 /**
48  * @return Number of Cycles that can be redone.
49  */
50 int RS_Undo::countRedoCycles()
51 {
52         RS_DEBUG->print("RS_Undo::countRedoCycles");
53
54         return (int)undoList.count() - 1 - undoPointer;
55 }
56
57 /**
58  * Adds an Undo Cycle at the current position in the list.
59  * All Cycles after the new one are removed and the Undoabels
60  * on them deleted.
61  */
62 void RS_Undo::addUndoCycle(RS_UndoCycle * i)
63 {
64         RS_DEBUG->print("RS_Undo::addUndoCycle");
65
66         undoList.insert(++undoPointer, i);
67
68         RS_DEBUG->print("RS_Undo::addUndoCycle: ok");
69 }
70
71 /**
72  * Starts a new cycle for one undo step. Every undoable that is
73  * added after calling this method goes into this cycle.
74  */
75 void RS_Undo::startUndoCycle()
76 {
77         RS_DEBUG->print("RS_Undo::startUndoCycle");
78
79         // definitely delete Undo Cycles and all Undoables in them
80         //   that cannot be redone now:
81         while ((int)undoList.count() > undoPointer + 1 && (int)undoList.count() > 0)
82         {
83                 RS_UndoCycle * l = undoList.last();
84
85                 if (l != NULL)
86                 {
87                         RS_Undoable * u = NULL;
88                         bool done = false;
89
90                         do
91                         {
92                                 u = l->getFirstUndoable();
93
94                                 if (u != NULL)
95                                 {
96                                         // Remove the pointer from _all_ cycles:
97 //                                      for(RS_UndoCycle * l2=undoList.first(); l2!=NULL; l2=undoList.next())
98 //                                              l2->removeUndoable(u);
99                                         for(int i=0; i<undoList.size(); i++)
100                                                 undoList[i]->removeUndoable(u);
101
102                                         // Delete the Undoable for good:
103                                         if (u->isUndone())
104                                         {
105                                                 removeUndoable(u);
106                                         }
107                                 }
108                                 else
109                                 {
110                                         done = true;
111                                 }
112                         }
113                         while(!done);
114                 }
115
116                 // Remove obsolete undo cycles:
117                 undoList.removeLast();
118         }
119
120         currentCycle = new RS_UndoCycle();
121 }
122
123 /**
124  * Adds an undoable to the current undo cycle.
125  */
126 void RS_Undo::addUndoable(RS_Undoable * u)
127 {
128         RS_DEBUG->print("RS_Undo::addUndoable");
129
130         if (currentCycle != NULL)
131         {
132                 currentCycle->addUndoable(u);
133         }
134         else
135         {
136                 RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Undo::addUndoable(): No undo cycle active.");
137         }
138 }
139
140 /**
141  * Ends the current undo cycle.
142  */
143 void RS_Undo::endUndoCycle()
144 {
145         addUndoCycle(currentCycle);
146         currentCycle = NULL;
147 }
148
149 /**
150  * Undoes the last undo cycle.
151  */
152 void RS_Undo::undo()
153 {
154         RS_DEBUG->print("RS_Undo::undo");
155
156         if (undoPointer >= 0)
157         {
158                 RS_UndoCycle * i = undoList.at(undoPointer);
159
160                 if (i != NULL)
161                 {
162 //                      for(RS_Undoable * u=i->undoables.first(); u!=NULL; u=i->undoables.next())
163 //                              u->changeUndoState();
164                         for(int j=0; j<i->undoables.size(); j++)
165                                 i->undoables[j]->changeUndoState();
166
167                         undoPointer--;
168                 }
169         }
170 }
171
172 /**
173  * Redoes the undo cycle which was at last undone.
174  */
175 void RS_Undo::redo()
176 {
177         RS_DEBUG->print("RS_Undo::redo");
178
179         if (undoPointer + 1 < (int)undoList.count())
180         {
181                 undoPointer++;
182                 RS_UndoCycle * i = undoList.at(undoPointer);
183
184                 if (i != NULL)
185                 {
186 //            for(RS_Undoable * u=i->undoables.first(); u!=NULL; u=i->undoables.next())
187 //                u->changeUndoState();
188                         for(int j=0; j<i->undoables.size(); j++)
189                                 i->undoables[j]->changeUndoState();
190                 }
191         }
192 }
193
194 /**
195  * @return The undo item that is next if we're about to undo
196  * or NULL.
197  */
198 RS_UndoCycle * RS_Undo::getUndoCycle()
199 {
200         RS_UndoCycle * ret = NULL;
201
202         RS_DEBUG->print("RS_Undo::getUndoCycle");
203
204         if (undoPointer >= 0 && undoPointer < (int)undoList.count())
205                 ret = undoList.at(undoPointer);
206
207         RS_DEBUG->print("RS_Undo::getUndoCycle: OK");
208
209         return ret;
210 }
211
212 /**
213  * @return The redo item that is next if we're about to redo
214  * or NULL.
215  */
216 RS_UndoCycle * RS_Undo::getRedoCycle()
217 {
218         RS_DEBUG->print("RS_Undo::getRedoCycle");
219
220         if (undoPointer + 1 >= 0 && undoPointer + 1 < (int)undoList.count())
221                 return undoList.at(undoPointer + 1);
222
223         return NULL;
224 }
225
226 /**
227  * Dumps the undo list to stdout.
228  */
229 std::ostream & operator<<(std::ostream & os, RS_Undo & l)
230 {
231         os << "Undo List: " <<  "\n";
232         os << " Pointer is at: " << l.undoPointer << "\n";
233
234 //      for(RS_UndoCycle * i=l.undoList.first(); i!=NULL; i=l.undoList.next())
235         for(int j=0; j<l.undoList.size(); j++)
236         {
237                 RS_UndoCycle * i = l.undoList[j];
238
239 //              if (l.undoList.at() == l.undoPointer)
240                 if (j == l.undoPointer)
241                         os << " -->";
242                 else
243                         os << "    ";
244
245                 os << *i << "\n";
246         }
247
248         return os;
249 }
250
251 //huh? how is this getting defined???
252 #undef RS_TEST
253 #ifdef RS_TEST
254 /**
255  * Testing Undoables, Undo Cycles and the Undo container.
256  */
257 /*static*/ bool RS_Undo::test()
258 {
259         int i, k;
260         RS_UndoStub undo;
261         //RS_UndoCycle * c1;
262         RS_Undoable * u1;
263
264         std::cout << "Testing RS_Undo\n";
265         std::cout << "  Adding 500 cycles..";
266
267         // Add 500 Undo Cycles with i Undoables in every Cycle
268         for(i=1; i<=500; ++i)
269         {
270                 //c1 = new RS_UndoCycle();
271                 undo.startUndoCycle();
272
273                 for(k=1; k<=i; ++k)
274                 {
275                         u1 = new RS_Undoable();
276                         //c1->
277                         undo.addUndoable(u1);
278                 }
279
280                 //undo.addUndoCycle(c1);
281                 undo.endUndoCycle();
282         }
283
284         std::cout << "OK\n";
285
286         assert(undo.countUndoCycles() == 500);
287         assert(undo.countRedoCycles() == 0);
288
289         std::cout << "  Undo 500 cycles..";
290         // Undo all 500 cycles
291
292         for(i=1; i<=500; ++i)
293                 undo.undo();
294
295         std::cout << "OK\n";
296
297         assert(undo.countUndoCycles() == 0);
298         assert(undo.countRedoCycles() == 500);
299
300         std::cout << "  Redo 500 cycles..";
301         // Redo all 500 cycles
302
303         for(i=1; i<=500; ++i)
304                 undo.redo();
305
306         std::cout << "OK\n";
307
308         assert(undo.countUndoCycles() == 500);
309         assert(undo.countRedoCycles() == 0);
310
311         std::cout << "  Undo 250 cycles..";
312         // Undo all 500 cycles
313
314         for(i=1; i<=250; ++i)
315                 undo.undo();
316
317         std::cout << "OK\n";
318
319         assert(undo.countUndoCycles() == 250);
320         assert(undo.countRedoCycles() == 250);
321
322         std::cout << "  Adding 10 cycles..";
323
324         for(i=1; i<=10; ++i)
325         {
326                 //c1 = new RS_UndoCycle();
327                 undo.startUndoCycle();
328
329                 for(k=1; k<=10; ++k)
330                 {
331                         u1 = new RS_Undoable();
332                         //c1->addUndoable(u1);
333                         undo.addUndoable(u1);
334                 }
335
336                 //undo.addUndoCycle(c1);
337                 undo.endUndoCycle();
338         }
339
340         std::cout << "OK\n";
341
342         assert(undo.countUndoCycles() == 260);
343         assert(undo.countRedoCycles() == 0);
344
345         std::cout << "  Undo 5 cycles..";
346
347         for(i=1; i<=5; ++i)
348                 undo.undo();
349
350         std::cout << "OK\n";
351
352         assert(undo.countUndoCycles() == 255);
353         assert(undo.countRedoCycles() == 5);
354
355         std::cout << "  Redo 5 cycles..";
356
357         for(i=1; i<=5; ++i)
358                 undo.redo();
359
360         std::cout << "OK\n";
361
362         assert(undo.countUndoCycles() == 260);
363         assert(undo.countRedoCycles() == 0);
364
365         std::cout << "  Undo 15 cycles..";
366
367         for(i=1; i<=15; ++i)
368                 undo.undo();
369
370         std::cout << "OK\n";
371
372         assert(undo.countUndoCycles() == 245);
373         assert(undo.countRedoCycles() == 15);
374
375         std::cout << "  Adding 1 cycle..";
376
377         for(i=1; i<=1; ++i)
378         {
379                 //c1 = new RS_UndoCycle();
380                 undo.startUndoCycle();
381
382                 for(k=1; k<=10; ++k)
383                 {
384                         u1 = new RS_Undoable();
385                         //c1->addUndoable(u1);
386                         undo.addUndoable(u1);
387                 }
388
389                 //undo.addUndoCycle(c1);
390                 undo.endUndoCycle();
391         }
392
393         std::cout << "OK\n";
394
395         assert(undo.countUndoCycles() == 246);
396         assert(undo.countRedoCycles() == 0);
397
398         return true;
399 }
400 #endif