Yes I did it again ;)
[blender-staging.git] / intern / action / intern / ACT_ActionStack.cpp
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * @author      Maarten Gribnau
37  * @date        March 31, 2001
38  */
39
40 #ifdef HAVE_CONFIG_H
41 #include <config.h>
42 #endif
43
44 #include "ACT_ActionStack.h"
45
46
47 ACT_ActionStack::ACT_ActionStack(unsigned int maxStackDepth)
48         : m_maxStackDepth(maxStackDepth),
49           m_undoIndex(0), m_undoIndexValid(false),
50           m_redoIndex(0), m_redoIndexValid(false)
51 {
52 }
53
54
55 ACT_ActionStack::~ACT_ActionStack()
56 {
57         flush();
58 }
59
60
61 unsigned int ACT_ActionStack::getStackDepth() const
62 {
63         return m_stack.size();
64 }
65
66
67 unsigned int ACT_ActionStack::getMaxStackDepth() const
68 {
69         return m_maxStackDepth;
70 }
71
72
73 void ACT_ActionStack::setMaxStackDepth(unsigned int maxStackDepth)
74 {
75         if (maxStackDepth != m_maxStackDepth) {
76                 if (maxStackDepth) {
77                         unsigned int size = m_stack.size();
78                         if (maxStackDepth < size) {
79                                 // New max stack size is smaller than current stack size, need to shrink stack
80                                 unsigned int numRemove = size - maxStackDepth;
81                                 if (m_undoIndex >= maxStackDepth) {
82                                         // Pop items from the front (throw away undo steps)
83                                         popFront(numRemove);
84                                         m_undoIndex -= numRemove;
85                                         m_redoIndex = m_undoIndex + 1;
86                                         m_redoIndexValid = m_redoIndexValid && (maxStackDepth > 1);
87                                 }
88                                 else {
89                                         // Pop items from the back (throw away redo steps)
90                                         popBack(numRemove);
91                                         m_redoIndexValid = m_redoIndexValid && (m_redoIndex < maxStackDepth);
92                                 }
93                         }
94                 }
95                 else {
96                         // New stack size is zero
97                         flush();
98                 }
99                 m_maxStackDepth = maxStackDepth;
100         }
101 }
102
103
104 void ACT_ActionStack::push(ACT_Action& action)
105 {
106         if (m_maxStackDepth) {
107                 unsigned int size = m_stack.size();
108                 if (m_redoIndexValid) {
109                         // Remove items after the current action (throw away redo steps)
110                         popBack(size - m_redoIndex);
111                 }
112                 else if (size >= m_maxStackDepth) {
113                         // Remove items from the front (throw away undo steps)
114                         popFront(m_maxStackDepth - size + 1);
115                 }
116
117                 // Store the action
118                 if (!action.getIsApplied()) {
119                         action.apply();
120                 }
121                 action.incRef();
122                 m_stack.push_back(&action);
123
124                 // Update action indices
125                 m_redoIndex = m_stack.size();
126                 m_redoIndexValid = false;
127                 m_undoIndex = m_redoIndex - 1;
128                 m_undoIndexValid = true;
129         }
130 }
131
132
133 ACT_Action* ACT_ActionStack::peekUndo()
134 {
135         unsigned int i;
136         return getUndoIndex(i) ? m_stack[i] : 0;
137 }
138
139
140 ACT_Action* ACT_ActionStack::peekRedo()
141 {
142         unsigned int i;
143         return getRedoIndex(i) ? m_stack[i] : 0;
144 }
145
146
147 void ACT_ActionStack::flush()
148 {
149         popBack(m_stack.size());
150         m_undoIndex = 0;
151         m_undoIndexValid = false;
152         m_redoIndex = 0;
153         m_redoIndexValid = false;
154 }
155
156
157 bool ACT_ActionStack::canUndo() const
158 {
159         unsigned int i;
160         return getUndoIndex(i);
161 }
162
163
164 void ACT_ActionStack::undo()
165 {
166         ACT_Action* action = peekUndo();
167         if (action) {
168                 action->undo();
169
170                 // Update action indices
171                 m_redoIndex = m_undoIndex;
172                 m_redoIndexValid = true;
173                 if (m_undoIndex) {
174                         m_undoIndex--;
175                 }
176                 else {
177                         m_undoIndexValid = false;
178                 }
179         }
180 }
181
182
183 bool ACT_ActionStack::canRedo() const
184 {
185         unsigned int i;
186         return getRedoIndex(i);
187 }
188
189
190 void ACT_ActionStack::redo()
191 {
192         ACT_Action* action = peekRedo();
193         if (action) {
194                 action->apply();
195
196                 // Update action indices
197                 m_undoIndex = m_redoIndex;
198                 m_undoIndexValid = true;
199                 m_redoIndex++;
200                 m_redoIndexValid = m_redoIndex < m_stack.size();
201         }
202 }
203
204
205 unsigned int ACT_ActionStack::popFront(unsigned int numActions)
206 {
207         unsigned int numRemoved = 0;
208
209         while (numActions-- && m_stack.size()) {
210                 ACT_Action* action = m_stack[0];
211                 action->decRef();
212                 m_stack.pop_front();
213                 numRemoved++;
214         }
215         return numRemoved;      
216 }
217
218
219 unsigned int ACT_ActionStack::popBack(unsigned int numActions)
220 {
221         unsigned int numRemoved = 0;
222         unsigned int size;
223
224         while (numActions-- && (size = m_stack.size())) {
225                 ACT_Action* action = m_stack[size-1];
226                 action->decRef();
227                 m_stack.pop_back();
228                 numRemoved++;
229         }
230         return numRemoved;      
231 }
232
233
234 bool ACT_ActionStack::getUndoIndex(unsigned int& i) const
235 {
236         i = m_undoIndex;
237         return m_undoIndexValid;
238 }
239
240
241 bool ACT_ActionStack::getRedoIndex(unsigned int& i) const
242 {
243         i = m_redoIndex;
244         return m_redoIndexValid;
245 }