creaContours_lib
CommandsHandler.cxx
Go to the documentation of this file.
1 /*# ---------------------------------------------------------------------
2 #
3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
4 # pour la Sant�)
5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
8 #
9 # This software is governed by the CeCILL-B license under French law and
10 # abiding by the rules of distribution of free software. You can use,
11 # modify and/ or redistribute the software under the terms of the CeCILL-B
12 # license as circulated by CEA, CNRS and INRIA at the following URL
13 # http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
14 # or in the file LICENSE.txt.
15 #
16 # As a counterpart to the access to the source code and rights to copy,
17 # modify and redistribute granted by the license, users are provided only
18 # with a limited warranty and the software's author, the holder of the
19 # economic rights, and the successive licensors have only limited
20 # liability.
21 #
22 # The fact that you are presently reading this means that you have had
23 # knowledge of the CeCILL-B license and that you accept its terms.
24 # ------------------------------------------------------------------------ */
25 
26 
27 //----------------------------------------------------------------------------------------------------------------
28 // Class definition include
29 //----------------------------------------------------------------------------------------------------------------
30 #include "CommandsHandler.h"
31 
32 //----------------------------------------------------------------------------------------------------------------
33 // Class implementation
34 //----------------------------------------------------------------------------------------------------------------
37 //------------------------------------------------------------------------------------------------------------
38 // Constructors & Destructors
39 //------------------------------------------------------------------------------------------------------------
40 
41  /*
42  * Constructs the CommandsHandler
43  */
44  CommandsHandler :: CommandsHandler()
45  {
46  redo_actions = new CommandsRegisterStructure();
47  unDo_actions = new CommandsRegisterStructure();
48 
49  posibleREDO = false;
50  posibleUNDO = false;
51 
52  isLastREDO_executed = true;
53  isLastUNDO_executed = false;
54  }
55 
56  /*
57  * Destructs the CommandsHandler
58  */
59  CommandsHandler :: ~CommandsHandler()
60  {
61  clearActions();
62  delete redo_actions;
63  delete unDo_actions;
64  }
65 
66 //------------------------------------------------------------------------------------------------------------
67 // Methods
68 //------------------------------------------------------------------------------------------------------------
69 
70  /*
71  * Registers in the vectors of doneActions and unDoActions the given commands that all ready corresponds each other to the inverse of the otherone.
72  * If is the first registered action notifies the posibleUNDO avaliability.
73  * @param doneAction Is the action to register in the redo_actions vector.
74  * @param unDoAction Is the action to register in the unDo_actions vector.
75  */
76  void CommandsHandler :: registerCommand(CommandObject* doneAction, CommandObject* unDoAction)
77  {
78  int actToUNDO = unDo_actions->getActualIndex();
79  redo_actions->setActualIndex( actToUNDO );
80 
81  redo_actions->registerCommand(doneAction);
82  unDo_actions->registerCommand(unDoAction);
83 
84  posibleREDO = false;
85  posibleUNDO = true;
86 
87  isLastREDO_executed = true;
88  isLastUNDO_executed = false;
89 
90  }
91 
92  /*
93  * Undo a command. Managing the correspondig vectors and the execution of the inverse action to the - ACTUAL DONE- action
94  * @return Returns true if the inverse command ( the actual to execute in UNDO actions) is executed. If it is false the state of the vector must not change.
95  */
96  bool CommandsHandler :: undo()
97  {
98  bool executed = posibleUNDO;
99  if( posibleUNDO )
100  {
101  validateOperationsAvaliability();//para borrar!!!!!!!!-----------------------------*********************---------------------
102  executed = theWorksSpaceBoss->executeCommand(getActual_UNDO(), true);
103  isLastUNDO_executed = true;
104  if (!unDo_actions->hasActualNext() && !redo_actions->hasActualNext())
105  {
106  if(unDo_actions->hasActualPrevious())
107  executed = unDo_actions->moveBack_Actual() ;
108  else
109  executed = true;
110  if( unDo_actions->hasLastNext() )
111  executed = executed && unDo_actions->moveBack_Last();
112  isLastREDO_executed = false;
113  }
114  else if (!unDo_actions->hasActualPrevious() && redo_actions->hasActualPrevious())
115  {
116  executed = redo_actions->moveBack_Actual();
117  executed = executed && redo_actions->moveBack_Last();
118  executed = executed && unDo_actions->moveBack_Last();
119  }
120  else
121  {
122  executed = unDo_actions->moveBack_Last();
123  executed = executed && unDo_actions->moveBack_Actual();
124  executed = executed && redo_actions->moveBack_Actual();
125  if( redo_actions->hasLastNext() )
126  executed = executed && redo_actions->moveBack_Last();
127  }
128  validateOperationsAvaliability();
129  }
130  return executed;
131  }
132 
133  /*
134  * Redo a command. Managing the correspondig vectors and the execution of the inverse action to the - ACTUAL DONE- action
135  * @return Returns true if the actual command to execute ( the actual to execute in REDO actions )has been executed. If it is false the state of the vector must not change.
136  */
137  bool CommandsHandler :: redo()
138  {
139  bool executed = posibleREDO;
140  if( posibleREDO )
141  {
142  validateOperationsAvaliability();//para borrar!!!!!!!!-----------------------------*********************---------------------
143  isLastREDO_executed = true;
144  //isLastUNDO_executed = false; // Posible needed
145  executed = theWorksSpaceBoss->executeCommand(getActual_REDO(), true);
146  if (!unDo_actions->hasActualPrevious() && !redo_actions->hasActualPrevious())
147  {
148  executed = redo_actions->moveForward_Actual();
149  executed = executed && redo_actions->moveBack_Last();
150  isLastUNDO_executed = false;
151  }
152  else if (!unDo_actions->hasActualPrevious() && redo_actions->hasActualPrevious())
153  {
154  executed = redo_actions->moveForward_Actual();
155  if(unDo_actions->hasLastNext())
156  executed = executed && unDo_actions->moveForward_Last();
157  executed = executed && unDo_actions->moveForward_Actual();
158  if(redo_actions->hasLastNext())
159  executed = executed && redo_actions->moveForward_Last();
160  }
161  else
162  {
163  executed = unDo_actions->moveForward_Actual();
164  executed = executed && unDo_actions->moveForward_Last();
165  executed = executed && redo_actions->moveForward_Actual();
166  if( redo_actions->hasLastNext() )
167  executed = executed && redo_actions->moveForward_Last();
168  else
169  executed = executed && redo_actions->moveBack_Last();
170  }
171  if (!unDo_actions->hasActualPrevious() && redo_actions->hasActualPrevious())
172  {
173  isLastUNDO_executed = false;
174  }
175  if (!unDo_actions->hasActualNext() && !redo_actions->hasActualNext())
176  {
177  isLastUNDO_executed = false;
178  }
179  validateOperationsAvaliability();
180  }
181  return executed;
182  }
183 
184  /*
185  * Notitify if posibleREDO is posible or not.
186  * @return Returns the state of posibleUNDO
187  */
188  bool CommandsHandler :: isPosibleUNDO()
189  {
190  return posibleUNDO;
191  }
192 
193  /*
194  * Indicates if posibleUNDO is posible or not.
195  * @return Returns the state of posibleREDO
196  */
197  bool CommandsHandler :: isPosibleREDO()
198  {
199  return posibleREDO;
200  }
201 
202  /*
203  * Sets posibleREDO state.
204  * @param UNDOstate The state of posibleUNDO to set
205  */
206  void CommandsHandler :: setPosibleUNDO( bool UNDOstate )
207  {
208  posibleUNDO = UNDOstate;
209  }
210 
211  /*
212  * Sets posibleUNDO state.
213  * @param REDOstate The state of posibleREDO to set
214  */
215  void CommandsHandler :: setPosibleREDO( bool REDOstate )
216  {
217  posibleREDO = REDOstate;
218  }
219 
220  /*
221  * Clear the registered actions in the DO and UNDO vectors.
222  */
223  void CommandsHandler :: clearActions()
224  {
225  redo_actions->clearActions();
226  unDo_actions->clearActions();
227  }
228 
229  /*
230  * Returns hoy mane paired commands had been registered, if the done and unDo vectors dont match returns -1 as error code.
231  * @return Returns how many paired-commands had been registered
232  */
233  int CommandsHandler :: getTotalCommands()
234  {
235  int value = redo_actions->getTotalCommandsCount();
236  return value == (unDo_actions->getTotalCommandsCount()) ? value : -1;
237  }
238 
239 
240  /*
241  * Gets the actual command in the UNDO-list
242  * @return Returns a pointer to the actual undo action
243  */
244  CommandObject * CommandsHandler :: getActual_UNDO()
245  {
246  return unDo_actions->getActual_Pointer();
247  }
248 
249  /*
250  * Gets the actual command in the REDO-list
251  * @return Returns a pointer to the actual do action
252  */
253  CommandObject * CommandsHandler :: getActual_REDO()
254  {
255  return redo_actions->getActual_Pointer();
256  }
257 
258  /*
259  * Gets the command at the given position in the DO (REDO) vector
260  * @return The pointer to the referenced object by the position
261  */
262  CommandObject * CommandsHandler :: get_DO_CommandAt(int position)
263  {
264  return redo_actions->getCommandAt(position);
265  }
266 
267  /*
268  * Gets the command at the given position in the UNDO vector
269  * @return The pointer to the referenced object by the position
270  */
271  CommandObject * CommandsHandler :: get_UNDO_CommandAt(int position)
272  {
273  return unDo_actions->getCommandAt(position);
274  }
275 
276  /*
277  * Sets the model parent of the action handler
278  * @param theModelParent The boss reference
279  */
280  void CommandsHandler :: setModelBoss(ICommandsUser * theModelParent)
281  {
282  theWorksSpaceBoss = theModelParent;
283  }
284 
285  /*
286  * Validates if it is posible of not to do UNDO and/or REDO and sets the corresponding values
287  */
288  void CommandsHandler :: validateOperationsAvaliability()
289  {
290  posibleREDO = (redo_actions->hasActualNext() && unDo_actions->hasActualNext() )? true :
291  ( (!redo_actions->hasActualNext()&& unDo_actions->hasActualNext() ) ? true :
292  ( !unDo_actions->hasActualNext() && !redo_actions->hasActualNext() )? false : true && !isLastREDO_executed );
293 
294  posibleUNDO = (redo_actions->hasActualPrevious() && unDo_actions->hasActualPrevious() )? true :
295  ( (!unDo_actions->hasActualPrevious()&& redo_actions->hasActualPrevious() ) ? true :
296  ( !unDo_actions->hasActualPrevious() && !redo_actions->hasActualPrevious() )? false : true && !isLastUNDO_executed );
297 
298  }