Version: 8.3.0
commandsProc.cxx
Go to the documentation of this file.
1 // Copyright (C) 2006-2016 CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 
20 #include <Python.h>
21 #include "commandsProc.hxx"
22 
23 #include "Node.hxx"
24 #include "ComposedNode.hxx"
25 #include "Bloc.hxx"
26 #include "Proc.hxx"
27 #include "ElementaryNode.hxx"
28 #include "InlineNode.hxx"
29 #include "ServiceNode.hxx"
30 #include "PythonNode.hxx"
31 #include "CORBANode.hxx"
32 #include "CppNode.hxx"
33 #include "XMLNode.hxx"
34 #include "SalomePythonNode.hxx"
35 #include "XMLNode.hxx"
36 #include "ForLoop.hxx"
37 #include "ForEachLoop.hxx"
38 #include "WhileLoop.hxx"
39 #include "Switch.hxx"
40 #include "OptimizerLoop.hxx"
41 #include "PresetNode.hxx"
42 #include "OutNode.hxx"
43 #include "StudyNodes.hxx"
44 #include "Exception.hxx"
45 #include "DataPort.hxx"
46 #include "InputDataStreamPort.hxx"
47 #include "OutputDataStreamPort.hxx"
48 #include "StudyPorts.hxx"
49 #include "PresetPorts.hxx"
50 #include "ComponentDefinition.hxx"
51 #include "SalomeContainer.hxx"
52 #include "SalomeHPContainer.hxx"
53 #include "SalomeComponent.hxx"
54 #include "TypeCode.hxx"
55 #include "RuntimeSALOME.hxx"
56 #include "TypeConversions.hxx"
57 
58 #include "guiContext.hxx"
59 
60 #include <iostream>
61 #include <sstream>
62 #include <string>
63 
64 //#define _DEVDEBUG_
65 #include "YacsTrace.hxx"
66 
67 using namespace std;
68 
69 using namespace YACS;
70 using namespace YACS::ENGINE;
71 using namespace YACS::HMI;
72 
73 
74 static std::map<int, std::string> createErrorMsgMap()
75 {
76  std::map<int, std::string> m;
77  m[1] = "\nUse the [Ctrl] Drag_N_Drop method if you want to create a input/output link without the associated control link";
78  return m;
79 }
80 
81 std::map<int, std::string> ErrorMsg = createErrorMsgMap();
82 
83 void setErrorMsg(YACS::Exception& ex)
84 {
85  DEBTRACE("errorNumber= "<<ex.errNumber);
86  if(ex.errNumber > 0 && ErrorMsg.count(ex.errNumber) != 0)
87  {
88  DEBTRACE(ErrorMsg[ex.errNumber]);
89  GuiContext::getCurrent()->_lastErrorMessage = ex.what() + ErrorMsg[ex.errNumber];
90  }
91  else
92  GuiContext::getCurrent()->_lastErrorMessage = ex.what();
93 }
94 
95 std::map<int, std::string> ProcInvoc::_typeNameMap;
96 
97 // ----------------------------------------------------------------------------
98 
99 ProcInvoc::ProcInvoc()
100  : Invocator()
101 {
102  _typeNameMap.clear();
103  _typeNameMap[SALOMEPROC] = "SALOMEPROC";
104  _typeNameMap[BLOC] = "BLOC";
105  _typeNameMap[FOREACHLOOP] = "FOREACHLOOP";
106  _typeNameMap[OPTIMIZERLOOP] = "OPTIMIZERLOOP";
107  _typeNameMap[FORLOOP] = "FORLOOP";
108  _typeNameMap[WHILELOOP] = "WHILELOOP";
109  _typeNameMap[SWITCH] = "SWITCH";
110  _typeNameMap[PYTHONNODE] = "PYTHONNODE";
111  _typeNameMap[PYFUNCNODE] = "PYFUNCNODE";
112  _typeNameMap[CORBANODE] = "CORBANODE";
113  _typeNameMap[SALOMENODE] = "SALOMENODE";
114  _typeNameMap[CPPNODE] = "CPPNODE";
115  _typeNameMap[SALOMEPYTHONNODE] = "SALOMEPYTHONNODE";
116  _typeNameMap[XMLNODE] = "XMLNODE";
117  _typeNameMap[SPLITTERNODE] = "SPLITTERNODE";
118  _typeNameMap[DFTODSFORLOOPNODE] = "DFTODSFORLOOPNODE";
119  _typeNameMap[DSTODFFORLOOPNODE] = "DSTODFFORLOOPNODE";
120  _typeNameMap[PRESETNODE] = "PRESETNODE";
121  _typeNameMap[OUTNODE] = "OUTNODE";
122  _typeNameMap[STUDYINNODE] = "STUDYINNODE";
123  _typeNameMap[STUDYOUTNODE] = "STUDYOUTNODE";
124  _typeNameMap[INPUTPORT] = "INPUTPORT";
125  _typeNameMap[OUTPUTPORT] = "OUTPUTPORT";
126  _typeNameMap[INPUTDATASTREAMPORT] = "INPUTDATASTREAMPORT";
127  _typeNameMap[OUTPUTDATASTREAMPORT] = "OUTPUTDATASTREAMPORT";
128  _typeNameMap[DATALINK] = "DATALINK";
129  _typeNameMap[CONTROLLINK] = "CONTROLLINK";
130  _typeNameMap[CONTAINER] = "CONTAINER";
131  _typeNameMap[COMPONENT] = "COMPONENT";
132  _typeNameMap[REFERENCE] = "REFERENCE";
133  _typeNameMap[DATATYPE] = "DATATYPE";
134 }
135 
136 TypeOfElem ProcInvoc::getTypeOfNode(YACS::ENGINE::Node* node)
137 {
138  TypeOfElem nodeType = UNKNOWN;
139  if (dynamic_cast<YACS::ENGINE::Bloc*>(node)) nodeType = BLOC;
140  else if (dynamic_cast<YACS::ENGINE::PythonNode*>(node)) nodeType = PYTHONNODE;
141  else if (dynamic_cast<YACS::ENGINE::PyFuncNode*>(node)) nodeType = PYFUNCNODE;
142  else if (dynamic_cast<YACS::ENGINE::CORBANode*>(node)) nodeType = CORBANODE;
143  else if (dynamic_cast<YACS::ENGINE::CppNode*>(node)) nodeType = CPPNODE;
144  else if (dynamic_cast<YACS::ENGINE::SalomeNode*>(node)) nodeType = SALOMENODE;
145  else if (dynamic_cast<YACS::ENGINE::SalomePythonNode*>(node)) nodeType = SALOMEPYTHONNODE;
146  else if (dynamic_cast<YACS::ENGINE::XmlNode*>(node)) nodeType = XMLNODE;
147  else if (dynamic_cast<YACS::ENGINE::SplitterNode*>(node)) nodeType = SPLITTERNODE;
148  else if (dynamic_cast<YACS::ENGINE::ForLoop*>(node)) nodeType = FORLOOP;
149  else if (dynamic_cast<YACS::ENGINE::WhileLoop*>(node)) nodeType = WHILELOOP;
150  else if (dynamic_cast<YACS::ENGINE::Switch*>(node)) nodeType = SWITCH;
151  else if (dynamic_cast<YACS::ENGINE::ForEachLoop*>(node)) nodeType = FOREACHLOOP;
152  else if (dynamic_cast<YACS::ENGINE::OptimizerLoop*>(node)) nodeType = OPTIMIZERLOOP;
153  else if (dynamic_cast<YACS::ENGINE::PresetNode*>(node)) nodeType = PRESETNODE;
154  else if (dynamic_cast<YACS::ENGINE::OutNode*>(node)) nodeType = OUTNODE;
155  else if (dynamic_cast<YACS::ENGINE::StudyInNode*>(node)) nodeType = STUDYINNODE;
156  else if (dynamic_cast<YACS::ENGINE::StudyOutNode*>(node)) nodeType = STUDYOUTNODE;
157  return nodeType;
158 }
159 
160 TypeOfElem ProcInvoc::getTypeOfPort(YACS::ENGINE::DataPort* port)
161 {
162  TypeOfElem portType = UNKNOWN;
163  if (dynamic_cast<YACS::ENGINE::InputPort*>(port)) portType = INPUTPORT;
164  else if (dynamic_cast<YACS::ENGINE::OutputPort*>(port)) portType = OUTPUTPORT;
165  else if (dynamic_cast<YACS::ENGINE::InputDataStreamPort*>(port)) portType = INPUTDATASTREAMPORT;
166  else if (dynamic_cast<YACS::ENGINE::OutputDataStreamPort*>(port)) portType = OUTPUTDATASTREAMPORT;
167  return portType;
168 }
169 
170 std::string ProcInvoc::getTypeName(TypeOfElem type)
171 {
172  if (_typeNameMap.count(type))
173  return _typeNameMap[type];
174  else
175  return "UNKNOWN";
176 }
177 
178 // ----------------------------------------------------------------------------
179 
180 CommandAddNodeFromCatalog::CommandAddNodeFromCatalog(YACS::ENGINE::Catalog *catalog,
181  std::string compo,
182  std::string type,
183  std::string position,
184  std::string name,
185  bool newCompoInst,
186  int swCase)
187  : Command(), _catalog(catalog), _compoName(compo), _typeName(type),
188  _position(position), _name(name), _newCompoInst(newCompoInst), _swCase(swCase)
189 {
190  DEBTRACE("CommandAddNodeFromCatalog " << compo << " " << type << " " << position << " " << name);
191  _node=0;
192  _snode=0;
193 }
194 
195 std::string CommandAddNodeFromCatalog::dump()
196 {
197  string ret ="CommandAddNodeFromCatalog " + _compoName + " " + _typeName + " " + _position + " " + _name;
198  return ret;
199 }
200 
201 YACS::ENGINE::Node *CommandAddNodeFromCatalog::getNode()
202 {
203  return _node;
204 }
205 
206 YACS::HMI::SubjectNode *CommandAddNodeFromCatalog::getSubjectNode()
207 {
208  return _snode;
209 }
210 
211 bool CommandAddNodeFromCatalog::localExecute()
212 {
213  DEBTRACE("CommandAddNodeFromCatalog::localExecute");
214 
215  Node *son = 0;
216  Node *nodeToClone = 0;
217  try
218  {
219  if (_compoName.empty())
220  {
221  if (_catalog->_nodeMap.count(_typeName))
222  nodeToClone = _catalog->_nodeMap[_typeName];
223  else if (_catalog->_composednodeMap.count(_typeName))
224  nodeToClone = _catalog->_composednodeMap[_typeName];
225  }
226  else
227  if (_catalog->_componentMap.count(_compoName))
228  {
229  YACS::ENGINE::ComponentDefinition* compodef = _catalog->_componentMap[_compoName];
230  if (compodef->_serviceMap.count(_typeName))
231  nodeToClone = compodef->_serviceMap[_typeName];
232  }
233  if (nodeToClone)
234  _typeNode = ProcInvoc::getTypeOfNode(nodeToClone);
235 
236  GuiContext::getCurrent()->setCurrentCatalog(_catalog);
237  Proc* proc = GuiContext::getCurrent()->getProc();
238  Node* node = proc;
239  ServiceNode *service = 0;
240 
241  if (!_position.empty()) node = proc->getChildByName(_position);
242  ComposedNode* father =dynamic_cast<ComposedNode*> (node);
243  if (father && nodeToClone)
244  {
245  son = nodeToClone->clone(0);
246  son->setName(_name);
247  service = dynamic_cast<ServiceNode*>(son);
248  }
249 
250  // Node creation eventually reusing old component instance
251  ComponentInstance *compo = 0;
252  if (service)
253  compo = service->getComponent();
254 
255  if(compo)
256  {
257  std::string compoName=compo->getCompoName();
258  DEBTRACE(compoName);
259  std::string compoInstName=compo->getInstanceName();
260  DEBTRACE(compoInstName);
261  if(!_newCompoInst)
262  {
263  ComponentInstance *lastcompo = GuiContext::getCurrent()->_mapOfLastComponentInstance[compoName];
264  DEBTRACE(lastcompo);
265  if(lastcompo)
266  {
267  DEBTRACE(lastcompo->getInstanceName());
268  service->setComponent(lastcompo); // use the last component instance of the same type and not a new instance
269  }
270  else
271  GuiContext::getCurrent()->_mapOfLastComponentInstance[compoName]=compo;
272  }
273  else
274  GuiContext::getCurrent()->_mapOfLastComponentInstance[compoName]=compo;
275  }
276 
277  if (son)
278  {
279  TypeOfElem fatherType = ProcInvoc::getTypeOfNode(father);
280  switch (fatherType)
281  {
282  case BLOC:
283  (dynamic_cast<YACS::ENGINE::Bloc*>(father))->edAddChild(son);
284  break;
285  case FORLOOP:
286  (dynamic_cast<YACS::ENGINE::ForLoop*>(father))->edSetNode(son);
287  break;
288  case WHILELOOP:
289  (dynamic_cast<YACS::ENGINE::WhileLoop*>(father))->edSetNode(son);
290  break;
291  case SWITCH:
292  (dynamic_cast<YACS::ENGINE::Switch*>(father))->edSetNode(_swCase,son);
293  break;
294  case FOREACHLOOP:
295  (dynamic_cast<YACS::ENGINE::ForEachLoop*>(father))->edSetNode(son);
296  break;
297  case OPTIMIZERLOOP:
298  (dynamic_cast<YACS::ENGINE::OptimizerLoop*>(father))->edSetNode(son);
299  break;
300  default:
301  YASSERT(0);
302  }
303  }
304  _node = son;
305  if (!_node)
306  throw YACS::Exception("node from catalog is not correct: check if catalog is up to date!");
307 
308  SubjectComposedNode *sfather = dynamic_cast<SubjectComposedNode*>(GuiContext::getCurrent()->_mapOfSubjectNode[father]);
309  _snode= sfather->addSubjectNode(_node, "", _catalog, _compoName, _typeName);
310  _snode->loadChildren();
311  _snode->loadLinks();
312  }
313  catch (Exception& ex)
314  {
315  DEBTRACE("CommandAddNode::localExecute() : " << ex.what());
316  setErrorMsg(ex);
317  if (son) delete son;
318  _node = 0;
319  }
320  return (_node != 0);
321 }
322 
323 bool CommandAddNodeFromCatalog::localReverse()
324 {
325  DEBTRACE("CommandAddNodeFromCatalog::localReverse");
326  try
327  {
328  Proc* proc = GuiContext::getCurrent()->getProc();
329  string nodeName;
330  if (_position.empty())
331  nodeName= _name;
332  else
333  nodeName = _position + "." + _name;
334  DEBTRACE(nodeName);
335  _node = proc->getChildByName(nodeName);
336  YASSERT(_node);
337  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(_node));
338  _snode = GuiContext::getCurrent()->_mapOfSubjectNode[_node];
339 
340  Subject *father=_snode->getParent();
341  DEBTRACE(father);
342  DEBTRACE(father->getName());
343  Subject::erase(_snode);
344  _snode= 0;
345  _node = 0;
346  if (father)
347  {
348  DEBTRACE("REMOVE");
349  father->select(true);
350  father->update(REMOVE,0,0);
351  }
352  return true;
353  }
354  catch (Exception& ex)
355  {
356  DEBTRACE("CommandAddNodeFromCatalog::localReverse(): " << ex.what());
357  setErrorMsg(ex);
358  return false;
359  }
360 }
361 
362 // ----------------------------------------------------------------------------
363 
364 CommandReparentNode::CommandReparentNode(std::string position,
365  std::string newParent)
366  : Command(), _position(position), _newParent(newParent)
367 {
368  DEBTRACE("CommandReparentNode::CommandReparentNode " << _position << " " << _newParent);
369  _oldParent = "";
370 }
371 
372 std::string CommandReparentNode::dump()
373 {
374  string ret ="CommandReparentNode " + _position + " " + _newParent;
375  return ret;
376 }
377 
378 bool CommandReparentNode::localExecute()
379 {
380  DEBTRACE("CommandReparentNode::localExecute");
381  Proc* proc = GuiContext::getCurrent()->getProc();
382  Node* node = 0;
383  try
384  {
385  if (_position == proc->getName())
386  throw YACS::Exception("Reparent the proc (main bloc) is impossible");
387  node = proc->getChildByName(_position);
388  ComposedNode *oldFather = node->getFather();
389  ComposedNode *newFather = proc;
390  Node *newF = 0;
391  if (_newParent != proc->getName())
392  {
393  newF = proc->getChildByName(_newParent);
394  newFather = dynamic_cast<ComposedNode*>(newF);
395  }
396  if (!newFather)
397  throw YACS::Exception("new parent must be a composed node");
398  if (oldFather == newFather)
399  throw YACS::Exception("no need to reparent to the same parent");
400  if (ComposedNode *cnode = dynamic_cast<ComposedNode*>(node))
401  if (cnode->isInMyDescendance(newFather))
402  throw YACS::Exception("reparent a node to one of it's children is impossible");
403  if (Loop *loop = dynamic_cast<Loop*>(newFather))
404  if (!loop->edGetDirectDescendants().empty())
405  throw YACS::Exception("Already a node in a new parent of Loop type");
406  if (DynParaLoop * dpl = dynamic_cast<DynParaLoop*>(newFather))
407  if (dpl->getExecNode() != NULL)
408  throw YACS::Exception("Already an execution node in the new parent of type dynamic loop");
409  Node *nodeSameName = 0;
410  try
411  {
412  nodeSameName = newFather->getChildByName(node->getName());
413  }
414  catch (Exception& e)
415  {
416  }
417  if (nodeSameName)
418  throw YACS::Exception("there is already a child of same name in the new parent");
419  SubjectNode * snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
420  Subject *subo = GuiContext::getCurrent()->_mapOfSubjectNode[oldFather];
421  Subject *subn = GuiContext::getCurrent()->_mapOfSubjectNode[newFather];
422  SubjectComposedNode* sop = dynamic_cast<SubjectComposedNode*>(subo);
423  SubjectComposedNode* snp = dynamic_cast<SubjectComposedNode*>(subn);
424  //save existing links
425  snode->saveLinks();
426  snode->removeExternalLinks();
427  snode->removeExternalControlLinks();
428  sop->houseKeepingAfterCutPaste(true, snode);
429  oldFather->edRemoveChild(node);
430  newFather->edAddChild(node);
431  snp->houseKeepingAfterCutPaste(false, snode);
432  //restore links
433  snode->restoreLinks();
434  if (oldFather == proc) _oldParent = proc->getName();
435  else _oldParent = proc->getChildName(oldFather);
436  _newpos = proc->getChildName(node);
437  sop->update(CUT, ProcInvoc::getTypeOfNode(node), snode);
438  snp->update(PASTE, ProcInvoc::getTypeOfNode(node), snode);
439  snode->recursiveUpdate(RENAME, 0, snode);
440  snode->_parent = snp;
441  }
442  catch (Exception& ex)
443  {
444  DEBTRACE("CommandReparentNode::localExecute() : " << ex.what());
445  setErrorMsg(ex);
446  node = 0;
447  }
448  catch (...)
449  {
450  GuiContext::getCurrent()->_lastErrorMessage = "Unknown exception";
451  node = 0;
452  }
453  return (node != 0);
454 }
455 
456 bool CommandReparentNode::localReverse()
457 {
458  DEBTRACE("CommandReparentNode::localReverse " << _newpos << " " << _oldParent);
459  Proc* proc = GuiContext::getCurrent()->getProc();
460  Node* node = 0;
461  try
462  {
463  node = proc->getChildByName(_newpos);
464  ComposedNode *father = node->getFather();
465  ComposedNode *oldFather = proc;
466  Node *oldF = 0;
467  if (_oldParent != proc->getName())
468  {
469  oldF = proc->getChildByName(_oldParent);
470  oldFather = dynamic_cast<ComposedNode*>(oldF);
471  }
472  SubjectNode * snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
473  Subject *subn = GuiContext::getCurrent()->_mapOfSubjectNode[father];
474  Subject *subo = GuiContext::getCurrent()->_mapOfSubjectNode[oldFather];
475  SubjectComposedNode* snp = dynamic_cast<SubjectComposedNode*>(subn);
476  SubjectComposedNode* sop = dynamic_cast<SubjectComposedNode*>(subo);
477  //save existing links
478  snode->saveLinks();
479  snode->removeExternalLinks();
480  snode->removeExternalControlLinks();
481  snp->houseKeepingAfterCutPaste(true, snode);
482  father->edRemoveChild(node);
483  oldFather->edAddChild(node);
484  sop->houseKeepingAfterCutPaste(false, snode);
485  //restore links
486  snode->restoreLinks();
487  snp->update(CUT, ProcInvoc::getTypeOfNode(node), snode);
488  sop->update(PASTE, ProcInvoc::getTypeOfNode(node), snode);
489  snode->recursiveUpdate(RENAME, 0, snode);
490  snode->_parent = sop;
491  }
492  catch (Exception& ex)
493  {
494  DEBTRACE("CommandReparentNode::localReverse() : " << ex.what());
495  setErrorMsg(ex);
496  node = 0;
497  }
498  catch (...)
499  {
500  GuiContext::getCurrent()->_lastErrorMessage = "Unknown exception";
501  node = 0;
502  }
503  return (node != 0);
504 }
505 
506 // ----------------------------------------------------------------------------
507 CommandPutInComposedNode::CommandPutInComposedNode(std::string position,
508  std::string newParent,
509  std::string type,
510  bool toSaveRestoreLinks)
511  : Command(), _position(position), _newParent(newParent), _type(type), _toSaveRestoreLinks(toSaveRestoreLinks)
512 {
513  DEBTRACE("CommandPutInComposedNode::CommandPutInComposedNode " << _position << " " << _newParent);
514  _newpos ="";
515 }
516 
517 std::string CommandPutInComposedNode::dump()
518 {
519  string save = _toSaveRestoreLinks ? "true" : "false";
520  string ret ="CommandPutInComposedNode " + _position + " " + _newParent + " " + _type + " " + save;
521  return ret;
522 }
523 
524 
525 bool CommandPutInComposedNode::localExecute()
526 {
527  DEBTRACE("CommandPutInComposedNode::localExecute");
528  Proc* proc = GuiContext::getCurrent()->getProc();
529  Node* node = 0;
530  try
531  {
532  if (_position == proc->getName())
533  throw YACS::Exception("You cannot put the proc (main bloc) in a " + _type);
534  node = proc->getChildByName(_position);
535  ComposedNode *oldFather = node->getFather();
536  SubjectNode * snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
537  Subject *subo = GuiContext::getCurrent()->_mapOfSubjectNode[oldFather];
538  SubjectComposedNode* sop = dynamic_cast<SubjectComposedNode*>(subo);
539  if (_toSaveRestoreLinks)
540  snode->saveLinks(); //save existing links
541  //remove external links
542  snode->removeExternalLinks();
543  snode->removeExternalControlLinks();
544  //remove subject node from subject old father
545  sop->houseKeepingAfterCutPaste(true, snode);
546  //remove node from old father
547  oldFather->edRemoveChild(node);
548  //refresh node views
549  sop->update(CUT, ProcInvoc::getTypeOfNode(node), snode);
550 
551  // try to find a node with the given name:
552  // success: use it as target composed node
553  // fail: create such a node and use it
554  std::list<Node*> children = proc->getChildren();
555  Node* composednode = 0;
556  SubjectNode *scomposednode = 0;
557  for (list<Node*>::iterator it = children.begin(); it != children.end(); ++it)
558  {
559  if ( _newParent == (*it)->getName() )
560  {
561  //get an existing ComposedNode with name _newParent
562  composednode = (*it);
563  break;
564  }
565  }
566  // target node was found
567  if ( composednode )
568  {
569  scomposednode = GuiContext::getCurrent()->_mapOfSubjectNode[composednode];
570  }
571  // creation of target node
572  else
573  {
574  //create a ComposedNode (type _type) with name _newParent
575  YACS::ENGINE::Catalog *catalog = YACS::ENGINE::getSALOMERuntime()->getBuiltinCatalog();
576  Node* nodeToClone = catalog->_composednodeMap[_type];
577  composednode = nodeToClone->cloneWithoutCompAndContDeepCpy(0);
578  composednode->setName(_newParent);
579  //add the new composednode as child of oldfather
580  oldFather->edAddChild(composednode);
581  //create the subject composednode
582  scomposednode = sop->addSubjectNode(composednode,"",catalog,"",_type);
583  }
584 
585  //add the old node as child of new composednode
586  (dynamic_cast<YACS::ENGINE::ComposedNode*>(composednode))->edAddChild(node);
587  _newpos = proc->getChildName(node);
588  //add the subject node to subject composednode
589  (dynamic_cast<SubjectComposedNode*>(scomposednode))->houseKeepingAfterCutPaste(false, snode);
590  snode->setParent(scomposednode);
591  if (_toSaveRestoreLinks)
592  snode->restoreLinks(); //restore links
593  //refresh all views
594  scomposednode->update(PASTE, ProcInvoc::getTypeOfNode(node), snode);
595  snode->recursiveUpdate(RENAME, 0, snode);
596  snode->select(true);
597  }
598  catch (Exception& ex)
599  {
600  DEBTRACE("CommandPutInComposedNode::localExecute() : " << ex.what());
601  setErrorMsg(ex);
602  node = 0;
603  }
604  catch (...)
605  {
606  GuiContext::getCurrent()->_lastErrorMessage = "Unknown exception";
607  node = 0;
608  }
609  return (node != 0);
610 }
611 
612 bool CommandPutInComposedNode::localReverse()
613 {
614  DEBTRACE("CommandPutInComposedNode::localReverse");
615  Proc* proc = GuiContext::getCurrent()->getProc();
616  Node* node = 0;
617  try
618  {
619  YASSERT(_newpos != proc->getName())
620  node = proc->getChildByName(_newpos);
621  ComposedNode *oldFather = node->getFather();
622  SubjectNode * snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
623  Subject *subo = GuiContext::getCurrent()->_mapOfSubjectNode[oldFather];
624  SubjectComposedNode* sop = dynamic_cast<SubjectComposedNode*>(subo);
625  //save existing links
626  snode->saveLinks();
627  //remove external links
628  snode->removeExternalLinks();
629  snode->removeExternalControlLinks();
630  //remove subject node from subject old father
631  sop->houseKeepingAfterCutPaste(true, snode);
632  //remove node from old father
633  oldFather->edRemoveChild(node);
634  //refresh node views, temporary paste in proc to keep widgets associated to node
635  sop->update(CUT, ProcInvoc::getTypeOfNode(node), snode);
636  GuiContext::getCurrent()->getSubjectProc()->update(PASTE, ProcInvoc::getTypeOfNode(node), snode);
637 
638  //remove composed node oldFather
639  ComposedNode *oldGrandFather = oldFather->getFather();
640  Subject *subog = GuiContext::getCurrent()->_mapOfSubjectNode[oldGrandFather];
641  SubjectComposedNode* sogp = dynamic_cast<SubjectComposedNode*>(subog);
642  Subject::erase(sop);
643 
644  //add the old node as child of new composednode
645  oldGrandFather->edAddChild(node);
646  _newpos = proc->getChildName(node);
647  //add the subject node to subject composednode
648  sogp->houseKeepingAfterCutPaste(false, snode);
649  snode->setParent(sogp);
650  //restore links
651  snode->restoreLinks();
652  //refresh all views
653  GuiContext::getCurrent()->getSubjectProc()->update(CUT, ProcInvoc::getTypeOfNode(node), snode);
654  sogp->update(PASTE, ProcInvoc::getTypeOfNode(node), snode);
655  snode->recursiveUpdate(RENAME, 0, snode);
656  snode->select(true);
657  }
658  catch (Exception& ex)
659  {
660  DEBTRACE("CommandPutInComposedNode::localReverse() : " << ex.what());
661  setErrorMsg(ex);
662  node = 0;
663  }
664  return (node != 0);
665 }
666 // ----------------------------------------------------------------------------
667 
668 CommandCopyNode::CommandCopyNode(YACS::ENGINE::Proc *fromproc,
669  std::string position,
670  std::string newParent,
671  int swCase)
672  : Command(), _fromproc(fromproc), _position(position), _newParent(newParent), _newName(""), _clone(0), _case(swCase)
673 {
674  DEBTRACE("CommandCopyNode::CommandCopyNode " << _position << " " << _newParent);
675 }
676 
677 std::string CommandCopyNode::dump()
678 {
679  string ret ="CommandCopyNode " + _position + " " + _newParent;
680  return ret;
681 }
682 
683 YACS::ENGINE::Node *CommandCopyNode::getNode()
684 {
685  return _clone;
686 }
687 
688 bool CommandCopyNode::localExecute()
689 {
690  DEBTRACE("CommandCopyNode::localExecute");
691  Proc* proc = GuiContext::getCurrent()->getProc();
692  Node* node = 0;
693  try
694  {
695  if (_position == _fromproc->getName())
696  throw YACS::Exception("Copy the proc (main bloc) is impossible");
697  node = _fromproc->getChildByName(_position);
698  ComposedNode *oldFather = node->getFather();
699  ComposedNode *newFather = proc;
700  Node *newF = 0;
701  if (_newParent != proc->getName())
702  {
703  newF = proc->getChildByName(_newParent);
704  newFather = dynamic_cast<ComposedNode*>(newF);
705  }
706  if (!newFather)
707  throw YACS::Exception("new parent must be a composed node");
708  if (Loop *loop = dynamic_cast<Loop*>(newFather))
709  if (!loop->edGetDirectDescendants().empty())
710  throw YACS::Exception("Already a node in a new parent of Loop type");
711  //_clone = node->cloneWithoutCompAndContDeepCpy(newFather);
712  _clone = node->cloneWithoutCompAndContDeepCpy(0);
713  if (!_clone)
714  throw YACS::Exception("Node cannot be cloned");
715  int nodeSuffix = -1;
716  bool sameName = true;
717  stringstream s;
718  do
719  {
720  s.str("");
721  s << node->getName();
722  if (nodeSuffix >= 0) // --- first try <0 means without suffix
723  s << nodeSuffix;
724  DEBTRACE(s.str());
725  try
726  {
727  Node *nodeSameName = newFather->getChildByName(s.str());
728  }
729  catch (Exception& e)
730  {
731  sameName = false;
732  }
733  nodeSuffix++;
734  }
735  while(sameName);
736  _clone->setName(s.str());
737  _newName = _clone->getName();
738 
739  if (YACS::ENGINE::Switch* theswitch = dynamic_cast<YACS::ENGINE::Switch*>(newFather))
740  {
741  DEBTRACE("father is a switch " << newFather->getName());
742  int theCase=_case;
743  if(theswitch->edGetNode(_case))
744  {
745  //the case is already used. Try another one
746  theCase=theswitch->getMaxCase()+1;
747  }
748  theswitch->edSetNode(theCase,_clone);
749  }
750  else
751  newFather->edAddChild(_clone);
752 
753  _newName = _clone->getQualifiedName();
754  DEBTRACE(_newName);
755 
756  SubjectNode *sub = GuiContext::getCurrent()->_mapOfSubjectNode[newFather];
757  SubjectComposedNode *snp = dynamic_cast<SubjectComposedNode*>(sub);
758  SubjectNode *son = snp->addSubjectNode(_clone);
759  son->loadChildren();
760  son->loadLinks();
761  }
762  catch (Exception& ex)
763  {
764  DEBTRACE("CommandCopyNode::localExecute() : " << ex.what());
765  setErrorMsg(ex);
766  _clone = 0;
767  }
768  return (_clone != 0);
769 }
770 
771 bool CommandCopyNode::localReverse()
772 {
773  DEBTRACE("CommandCopyNode::localReverse " << _position << " " << _newParent);
774  try
775  {
776  Proc* proc = GuiContext::getCurrent()->getProc();
777  string nodeName = _newParent + "." + _newName;
778  if (_newParent == proc->getName())
779  nodeName = _newName;
780  DEBTRACE(nodeName);
781  _clone = proc->getChildByName(nodeName);
782 
783  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(_clone));
784  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[_clone];
785  Subject *father = snode->getParent();
786  Subject::erase(snode);
787  _clone = 0;
788  if (father)
789  {
790  DEBTRACE("REMOVE");
791  father->select(true);
792  father->update(REMOVE,0,0);
793  }
794  return true;
795  }
796  catch (Exception& ex)
797  {
798  DEBTRACE("CommandCopyNode::localReverse(): " << ex.what());
799  setErrorMsg(ex);
800  return false;
801  }
802  return true;
803 }
804 
805 // ----------------------------------------------------------------------------
806 
807 CommandRenameNode::CommandRenameNode(std::string position, std::string name)
808  : Command(), _position(position), _name(name)
809 {
810  DEBTRACE("CommandRenameNode::CommandRenameNode " << _position << " " << _name);
811  _oldName ="";
812  _newpos="";
813 }
814 
815 std::string CommandRenameNode::dump()
816 {
817  string ret ="CommandRenameNode " + _position + " " + _name;
818  return ret;
819 }
820 
821 bool CommandRenameNode::localExecute()
822 {
823  DEBTRACE("CommandRenameNode::localExecute");
824  Proc* proc = GuiContext::getCurrent()->getProc();
825  Node* node = proc;
826  try
827  {
828  if (_position != proc->getName()) node = proc->getChildByName(_position);
829  _oldName = node->getName();
830  node->setName(_name);
831  if (node == proc)
832  _newpos = _name;
833  else
834  _newpos = proc->getChildName(node);
835  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
836  if (snode)
837  snode->recursiveUpdate(RENAME, 0, snode);
838  }
839  catch (Exception& ex)
840  {
841  DEBTRACE("CommandRenameNode::localExecute() : " << ex.what());
842  setErrorMsg(ex);
843  node = 0;
844  }
845  return (node != 0);
846 }
847 
848 bool CommandRenameNode::localReverse()
849 {
850  DEBTRACE("CommandRenameNode::localReverse");
851  Proc* proc = GuiContext::getCurrent()->getProc();
852  Node* node = proc;
853  try
854  {
855  if (_newpos != proc->getName()) node = proc->getChildByName(_newpos);
856  YASSERT(node->getName() == _name);
857  node->setName(_oldName);
858  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
859  if (snode)
860  snode->recursiveUpdate(RENAME, 0, snode);
861  }
862  catch (Exception& ex)
863  {
864  DEBTRACE("CommandRenameNode::localReverse() : " << ex.what());
865  setErrorMsg(ex);
866  node = 0;
867  }
868  return (node != 0);
869 }
870 
871 // ----------------------------------------------------------------------------
872 
873 CommandRenameContainer::CommandRenameContainer(std::string oldName, std::string newName)
874  : Command(), _oldName(oldName), _newName(newName)
875 {
876  DEBTRACE("CommandRenameContainer::CommandRenameContainer " << _oldName << " " << _newName);
877 }
878 
879 std::string CommandRenameContainer::dump()
880 {
881  string ret ="CommandRenameContainer " +_oldName + " " + _newName;
882  return ret;
883 }
884 
885 bool CommandRenameContainer::localExecute()
886 {
887  DEBTRACE("CommandRenameContainer::localExecute");
888  Proc* proc = GuiContext::getCurrent()->getProc();
889  Container *container = 0;
890  try
891  {
892  YASSERT(proc->containerMap.count(_oldName));
893  container = proc->containerMap[_oldName];
894  if (proc->containerMap.count(_newName))
895  {
896  GuiContext::getCurrent()->_lastErrorMessage = "Container name already existing";
897  return 0;
898  }
899  proc->containerMap.erase(_oldName);
900  container->setName(_newName);
901  proc->containerMap[_newName] = container;
902  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(container));
903  SubjectContainerBase *scont(GuiContext::getCurrent()->_mapOfSubjectContainer[container]);
904  scont-> update(RENAME, 0, scont);
905  scont->notifyComponentsChange(ASSOCIATE, CONTAINER, scont);
906  }
907  catch (Exception& ex)
908  {
909  DEBTRACE("CommandRenameContainer::localExecute() : " << ex.what());
910  setErrorMsg(ex);
911  container = 0;
912  }
913  return (container != 0);
914 }
915 
916 bool CommandRenameContainer::localReverse()
917 {
918  DEBTRACE("CommandRenameContainer::localReverse");
919  Proc* proc = GuiContext::getCurrent()->getProc();
920  Container *container = 0;
921  try
922  {
923  YASSERT(proc->containerMap.count(_newName));
924  container = proc->containerMap[_newName];
925  proc->containerMap.erase(_newName);
926  container->setName(_oldName);
927  proc->containerMap[_oldName] = container;
928  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(container));
929  SubjectContainerBase *scont(GuiContext::getCurrent()->_mapOfSubjectContainer[container]);
930  scont-> update(RENAME, 0, scont);
931  scont->notifyComponentsChange(ASSOCIATE, CONTAINER, scont);
932  }
933  catch (Exception& ex)
934  {
935  DEBTRACE("CommandRenameContainer::localReverse() : " << ex.what());
936  setErrorMsg(ex);
937  container = 0;
938  }
939  return (container != 0);
940 }
941 
942 // ----------------------------------------------------------------------------
943 
944 CommandRenameInDataPort::CommandRenameInDataPort(std::string position,
945  std::string oldName,
946  std::string newName, TypeOfElem portType)
947  : Command(), _position(position), _oldName(oldName), _newName(newName), _portType(portType)
948 {
949  DEBTRACE("CommandRenameInDataPort::CommandRenameInDataPort "
950  << _position << " " << _oldName<< " " << _newName);
951 }
952 
953 std::string CommandRenameInDataPort::dump()
954 {
955  string ret ="CommandRenameInDataPort " + _position + " " + _oldName + " " + _newName;
956  return ret;
957 }
958 
959 bool CommandRenameInDataPort::localExecute()
960 {
961  DEBTRACE("CommandRenameInDataPort::localExecute");
962  Proc* proc = GuiContext::getCurrent()->getProc();
963  Node* node = proc;
964  try
965  {
966  if (_position != proc->getName()) node = proc->getChildByName(_position);
967  InPort * port = 0;
968 
969  try
970  {
971  if(_portType==INPUTPORT)
972  port = node->getInputPort(_newName);
973  else
974  port = node->getInputDataStreamPort(_newName);
975  }
976  catch (Exception& e) {} // --- raised when no existing port with _newName
977  if (port)
978  throw Exception("there is already a port with the new name");
979 
980  if(_portType==INPUTPORT)
981  port = node->getInputPort(_oldName);
982  else
983  port = node->getInputDataStreamPort(_oldName);
984  port->setName(_newName);
985  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(port));
986  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[port];
987  sport->update(RENAME, 0, sport);
988  }
989  catch (Exception& ex)
990  {
991  DEBTRACE("CommandRenameInDataPort::localExecute() : " << ex.what());
992  setErrorMsg(ex);
993  node = 0;
994  }
995  return (node != 0);
996 }
997 
998 bool CommandRenameInDataPort::localReverse()
999 {
1000  DEBTRACE("CommandRenameInDataPort::localReverse");
1001  Proc* proc = GuiContext::getCurrent()->getProc();
1002  Node* node = proc;
1003  try
1004  {
1005  if (_position != proc->getName()) node = proc->getChildByName(_position);
1006  InPort * port = 0;
1007 
1008  try
1009  {
1010  if(_portType==INPUTPORT)
1011  port = node->getInputPort(_oldName);
1012  else
1013  port = node->getInputDataStreamPort(_oldName);
1014  }
1015  catch (Exception& e) {} // --- raised when no existing port with _newName
1016  if (port)
1017  throw Exception("there is already a port with the old name");
1018 
1019  if(_portType==INPUTPORT)
1020  port = node->getInputPort(_newName);
1021  else
1022  port = node->getInputDataStreamPort(_newName);
1023  port->setName(_oldName);
1024  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(port));
1025  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[port];
1026  sport->update(RENAME, 0, sport);
1027  }
1028  catch (Exception& ex)
1029  {
1030  DEBTRACE("CommandRenameInDataPort::localReverse() : " << ex.what());
1031  setErrorMsg(ex);
1032  node = 0;
1033  }
1034  return (node != 0);
1035 }
1036 
1037 // ----------------------------------------------------------------------------
1038 
1039 CommandRenameOutDataPort::CommandRenameOutDataPort(std::string position,
1040  std::string oldName,
1041  std::string newName, TypeOfElem portType)
1042  : Command(), _position(position), _oldName(oldName), _newName(newName), _portType(portType)
1043 {
1044  DEBTRACE("CommandRenameOutDataPort::CommandRenameOutDataPort "
1045  << _position << " " << _oldName<< " " << _newName);
1046 }
1047 
1048 std::string CommandRenameOutDataPort::dump()
1049 {
1050  string ret ="CommandRenameOutDataPort " + _position + " " + _oldName + " " + _newName;
1051  return ret;
1052 }
1053 
1054 bool CommandRenameOutDataPort::localExecute()
1055 {
1056  DEBTRACE("CommandRenameOutDataPort::localExecute");
1057  Proc* proc = GuiContext::getCurrent()->getProc();
1058  Node* node = proc;
1059  try
1060  {
1061  if (_position != proc->getName()) node = proc->getChildByName(_position);
1062  OutPort * port = 0;
1063  try
1064  {
1065  if(_portType==OUTPUTPORT)
1066  port = node->getOutputPort(_newName);
1067  else
1068  port = node->getOutputDataStreamPort(_newName);
1069  }
1070  catch (Exception& e) {} // --- raised when no existing port with _newName
1071  if (port)
1072  throw Exception("there is already a port with the new name");
1073 
1074  if(_portType==OUTPUTPORT)
1075  port = node->getOutputPort(_oldName);
1076  else
1077  port = node->getOutputDataStreamPort(_oldName);
1078  port->setName(_newName);
1079  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(port));
1080  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[port];
1081  sport->update(RENAME, 0, sport);
1082  }
1083  catch (Exception& ex)
1084  {
1085  DEBTRACE("CommandRenameOutDataPort::localExecute() : " << ex.what());
1086  setErrorMsg(ex);
1087  node = 0;
1088  }
1089  return (node != 0);
1090 }
1091 
1092 bool CommandRenameOutDataPort::localReverse()
1093 {
1094  DEBTRACE("CommandRenameOutDataPort::localReverse");
1095  Proc* proc = GuiContext::getCurrent()->getProc();
1096  Node* node = proc;
1097  try
1098  {
1099  if (_position != proc->getName()) node = proc->getChildByName(_position);
1100  OutPort * port = 0;
1101  try
1102  {
1103  if(_portType==OUTPUTPORT)
1104  port = node->getOutputPort(_oldName);
1105  else
1106  port = node->getOutputDataStreamPort(_oldName);
1107  }
1108  catch (Exception& e) {} // --- raised when no existing port with _newName
1109  if (port)
1110  throw Exception("there is already a port with the old name");
1111 
1112  if(_portType==OUTPUTPORT)
1113  port = node->getOutputPort(_newName);
1114  else
1115  port = node->getOutputDataStreamPort(_newName);
1116  port->setName(_oldName);
1117  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(port));
1118  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[port];
1119  sport->update(RENAME, 0, sport);
1120  }
1121  catch (Exception& ex)
1122  {
1123  DEBTRACE("CommandRenameOutDataPort::localReverse() : " << ex.what());
1124  setErrorMsg(ex);
1125  node = 0;
1126  }
1127  return (node != 0);
1128 }
1129 
1130 // ----------------------------------------------------------------------------
1131 
1132 CommandAddDataTypeFromCatalog::CommandAddDataTypeFromCatalog(YACS::ENGINE::Catalog* catalog,
1133  std::string typeName)
1134  : Command(), _catalog(catalog), _typeName(typeName)
1135 {
1136  DEBTRACE("CommandAddDataTypeFromCatalog::CommandAddDataTypeFromCatalog: " << typeName);
1137 }
1138 
1139 std::string CommandAddDataTypeFromCatalog::dump()
1140 {
1141  string ret ="CommandAddDataTypeFromCatalog " + _typeName;
1142  return ret;
1143 }
1144 
1145 YACS::ENGINE::TypeCode *CommandAddDataTypeFromCatalog::getTypeCode()
1146 {
1147 
1148  if (GuiContext::getCurrent()->getProc()->typeMap.count(_typeName))
1149  return GuiContext::getCurrent()->getProc()->typeMap[_typeName];
1150  else return 0;
1151 }
1152 
1153 bool CommandAddDataTypeFromCatalog::localExecute()
1154 {
1155  DEBTRACE("CommandAddDataTypeFromCatalog::localExecute");
1156  Proc* proc = GuiContext::getCurrent()->getProc();
1157  if (proc->typeMap.count(_typeName))
1158  {
1159  DEBTRACE("typecode already existing in proc: " << _typeName);
1160  GuiContext::getCurrent()->_lastErrorMessage = "typeCode already existing in proc: " + _typeName;
1161  return false;
1162  }
1163  else
1164  if (_catalog->_typeMap.count(_typeName))
1165  {
1166  DEBTRACE("typecode found in catalog, cloned: " << _typeName);
1167  proc->typeMap[_typeName] = _catalog->_typeMap[_typeName]->clone();
1168  proc->typeMap[_typeName]->incrRef();
1169  SubjectProc *sproc = GuiContext::getCurrent()->getSubjectProc();
1170  SubjectDataType *son = sproc->addSubjectDataType(getTypeCode(), _typeName);
1171  return (son!=0);
1172  }
1173  GuiContext::getCurrent()->_lastErrorMessage = "typecode not found in catalog: " + _typeName;
1174  return false;
1175 }
1176 
1177 bool CommandAddDataTypeFromCatalog::localReverse()
1178 {
1179  DEBTRACE("CommandAddDataTypeFromCatalog::localReverse");
1180  try
1181  {
1182  SubjectProc *sproc = GuiContext::getCurrent()->getSubjectProc();
1183  sproc->removeSubjectDataType(_typeName);
1184  return true;
1185  }
1186  catch (Exception& ex)
1187  {
1188  DEBTRACE("CommandAddDataTypeFromCatalog::localReverse(): " << ex.what());
1189  setErrorMsg(ex);
1190  return 0;
1191  }
1192 }
1193 
1194 
1195 // ----------------------------------------------------------------------------
1196 
1197 CommandAddInputPortFromCatalog::CommandAddInputPortFromCatalog(YACS::ENGINE::Catalog *catalog,
1198  std::string type,
1199  std::string node,
1200  std::string name)
1201  : Command(), _catalog(catalog), _typePort(type), _node(node), _name(name)
1202 {
1203  _inputPort = 0;
1204  _sip = 0;
1205 }
1206 
1207 std::string CommandAddInputPortFromCatalog::dump()
1208 {
1209  string ret ="CommandAddInputPortFromCatalog " + _typePort + " " + _node + " " + _name;
1210  return ret;
1211 }
1212 
1213 YACS::ENGINE::InputPort *CommandAddInputPortFromCatalog::getInputPort()
1214 {
1215  return _inputPort;
1216 }
1217 
1218 SubjectInputPort* CommandAddInputPortFromCatalog::getSubjectInputPort()
1219 {
1220  return _sip;
1221 }
1222 
1223 bool CommandAddInputPortFromCatalog::localExecute()
1224 {
1225  DEBTRACE("CommandAddInputPortFromCatalog::localExecute");
1226  InputPort *son = 0;
1227  try
1228  {
1229  Proc* proc = GuiContext::getCurrent()->getProc();
1230  Node* node = proc->getChildByName(_node);
1231  ElementaryNode* father = dynamic_cast<ElementaryNode*>(node);
1232  if (father)
1233  {
1234  //try proc types and then catalog if not in proc
1235  if(proc->typeMap.count(_typePort))
1236  son = father->edAddInputPort(_name, proc->typeMap[_typePort]);
1237  else if (_catalog->_typeMap.count(_typePort))
1238  son = father->edAddInputPort(_name, _catalog->_typeMap[_typePort]);
1239  else
1240  {
1241  DEBTRACE(_typePort << " not found in catalog " << _catalog);
1242  GuiContext::getCurrent()->_lastErrorMessage = _typePort + " not found in catalog";
1243  }
1244  }
1245  _inputPort = son;
1246  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1247  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1248  _sip = snode->addSubjectInputPort(son, _name);
1249  snode->update(SYNCHRO,0,0); // when output port tab in node edition is visible
1250  }
1251  catch (Exception& ex)
1252  {
1253  DEBTRACE("CommandAddInputPortFromCatalog::localExecute() : " << ex.what());
1254  setErrorMsg(ex);
1255  if (son) delete son;
1256  _inputPort = 0;
1257  }
1258  return (_inputPort != 0);
1259 }
1260 
1261 bool CommandAddInputPortFromCatalog::localReverse()
1262 {
1263  DEBTRACE("CommandAddInputPortFromCatalog::localReverse");
1264  try
1265  {
1266  Proc* proc = GuiContext::getCurrent()->getProc();
1267  Node *node = proc->getChildByName(_node);
1268  ElementaryNode* enode = dynamic_cast<ElementaryNode*>(node);
1269  YASSERT(enode);
1270  _inputPort = enode->getInputPort(_name);
1271  YASSERT(_inputPort);
1272  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(_inputPort));
1273  _sip = dynamic_cast<SubjectInputPort*>(GuiContext::getCurrent()->_mapOfSubjectDataPort[_inputPort]);
1274  YASSERT(_sip);
1275 
1276  Subject *father=_sip->getParent();
1277  Subject::erase(_sip);
1278  _sip = 0;
1279  _inputPort = 0;
1280  if (father)
1281  {
1282  DEBTRACE("REMOVE");
1283  father->select(true);
1284  father->update(REMOVE,0,0);
1285  }
1286  return true;
1287  }
1288  catch (Exception& ex)
1289  {
1290  DEBTRACE("CommandAddInputPortFromCatalog::localReverse(): " << ex.what());
1291  setErrorMsg(ex);
1292  return false;
1293  }
1294 }
1295 
1296 // ----------------------------------------------------------------------------
1297 
1298 CommandAddOutputPortFromCatalog::CommandAddOutputPortFromCatalog(YACS::ENGINE::Catalog *catalog,
1299  std::string type,
1300  std::string node,
1301  std::string name)
1302  : Command(), _catalog(catalog), _typePort(type), _node(node), _name(name)
1303 {
1304  _outputPort = 0;
1305  _sop = 0;
1306 }
1307 
1308 std::string CommandAddOutputPortFromCatalog::dump()
1309 {
1310  string ret ="CommandAddOutputPortFromCatalog " + _typePort + " " + _node + " " + _name;
1311  return ret;
1312 }
1313 
1314 YACS::ENGINE::OutputPort *CommandAddOutputPortFromCatalog::getOutputPort()
1315 {
1316  return _outputPort;
1317 }
1318 
1319 SubjectOutputPort* CommandAddOutputPortFromCatalog::getSubjectOutputPort()
1320 {
1321  return _sop;
1322 }
1323 
1324 bool CommandAddOutputPortFromCatalog::localExecute()
1325 {
1326  DEBTRACE("CommandAddOutputPortFromCatalog::localExecute");
1327  OutputPort *son = 0;
1328  try
1329  {
1330  Proc* proc = GuiContext::getCurrent()->getProc();
1331  Node* node = proc->getChildByName(_node);
1332  ElementaryNode* father =dynamic_cast<ElementaryNode*> (node);
1333  if (father)
1334  {
1335  //try proc types and then catalog if not in proc
1336  if(proc->typeMap.count(_typePort))
1337  son = father->edAddOutputPort(_name, proc->typeMap[_typePort]);
1338  else if (_catalog->_typeMap.count(_typePort))
1339  son = father->edAddOutputPort(_name, _catalog->_typeMap[_typePort]);
1340  else
1341  {
1342  DEBTRACE(_typePort << " not found in catalog");
1343  GuiContext::getCurrent()->_lastErrorMessage = _typePort + " not found in catalog";
1344  }
1345  }
1346  _outputPort = son;
1347  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1348  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1349  _sop = snode->addSubjectOutputPort(son, _name);
1350  snode->update(SYNCHRO,0,0); // when input port tab in node edition is visible
1351  }
1352  catch (Exception& ex)
1353  {
1354  DEBTRACE("CommandAddOutputPortFromCatalog::localExecute() : " << ex.what());
1355  setErrorMsg(ex);
1356  if (son) delete son;
1357  _outputPort = 0;
1358  }
1359  return (_outputPort != 0);
1360 }
1361 
1362 bool CommandAddOutputPortFromCatalog::localReverse()
1363 {
1364  DEBTRACE("CommandAddOutputPortFromCatalog::localReverse");
1365  try
1366  {
1367  Proc* proc = GuiContext::getCurrent()->getProc();
1368  Node *node = proc->getChildByName(_node);
1369  ElementaryNode* enode = dynamic_cast<ElementaryNode*>(node);
1370  YASSERT(enode);
1371  _outputPort = enode->getOutputPort(_name);
1372  YASSERT(_outputPort);
1373  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(_outputPort));
1374  _sop = dynamic_cast<SubjectOutputPort*>(GuiContext::getCurrent()->_mapOfSubjectDataPort[_outputPort]);
1375  YASSERT(_sop);
1376 
1377  Subject *father=_sop->getParent();
1378  Subject::erase(_sop);
1379  _sop = 0;
1380  _outputPort = 0;
1381  if (father)
1382  {
1383  DEBTRACE("REMOVE");
1384  father->select(true);
1385  father->update(REMOVE,0,0);
1386  }
1387  return true;
1388  }
1389  catch (Exception& ex)
1390  {
1391  DEBTRACE("CommandAddOutputPortFromCatalog::localReverse(): " << ex.what());
1392  setErrorMsg(ex);
1393  return false;
1394  }
1395 }
1396 
1397 // ----------------------------------------------------------------------------
1398 
1399 CommandAddIDSPortFromCatalog::CommandAddIDSPortFromCatalog(YACS::ENGINE::Catalog *catalog,
1400  std::string type,
1401  std::string node,
1402  std::string name)
1403  : Command(), _catalog(catalog), _typePort(type), _node(node), _name(name)
1404 {
1405  _IDSPort = 0;
1406  _sip = 0;
1407 }
1408 
1409 std::string CommandAddIDSPortFromCatalog::dump()
1410 {
1411  string ret ="CommandAddIDSPortFromCatalog " + _typePort + " " + _node + " " + _name;
1412  return ret;
1413 }
1414 
1415 YACS::ENGINE::InputDataStreamPort *CommandAddIDSPortFromCatalog::getIDSPort()
1416 {
1417  DEBTRACE("CommandAddIDSPortFromCatalog");
1418  return _IDSPort;
1419 }
1420 
1421 SubjectInputDataStreamPort* CommandAddIDSPortFromCatalog::getSubjectIDSPort()
1422 {
1423  return _sip;
1424 }
1425 
1426 bool CommandAddIDSPortFromCatalog::localExecute()
1427 {
1428  DEBTRACE("CommandAddIDSPortFromCatalog::localExecute");
1429  InputDataStreamPort *son = 0;
1430  try
1431  {
1432  Proc* proc = GuiContext::getCurrent()->getProc();
1433  Node* node = proc->getChildByName(_node);
1434  ElementaryNode* father =dynamic_cast<ElementaryNode*> (node);
1435  if (father)
1436  {
1437  if (_catalog->_typeMap.count(_typePort))
1438  son = father->edAddInputDataStreamPort(_name, _catalog->_typeMap[_typePort]);
1439  else
1440  {
1441  DEBTRACE(_typePort << " not found in catalog");
1442  GuiContext::getCurrent()->_lastErrorMessage = _typePort + " not found in catalog";
1443  }
1444  }
1445  _IDSPort = son;
1446  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1447  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1448  _sip = snode->addSubjectIDSPort(son, _name);
1449  }
1450  catch (Exception& ex)
1451  {
1452  DEBTRACE("CommandAddIDSPortFromCatalog::localExecute() : " << ex.what());
1453  setErrorMsg(ex);
1454  if (son) delete son;
1455  _IDSPort = 0;
1456  }
1457  return (_IDSPort != 0);
1458 }
1459 
1460 bool CommandAddIDSPortFromCatalog::localReverse()
1461 {
1462  DEBTRACE("CommandAddIDSPortFromCatalog::localReverse");
1463  try
1464  {
1465  Proc* proc = GuiContext::getCurrent()->getProc();
1466  Node *node = proc->getChildByName(_node);
1467  ElementaryNode* enode = dynamic_cast<ElementaryNode*>(node);
1468  YASSERT(enode);
1469  _IDSPort = enode->getInputDataStreamPort(_name);
1470  YASSERT(_IDSPort);
1471  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(_IDSPort));
1472  _sip = dynamic_cast<SubjectInputDataStreamPort*>(GuiContext::getCurrent()->_mapOfSubjectDataPort[_IDSPort]);
1473  YASSERT(_sip);
1474 
1475  Subject *father=_sip->getParent();
1476  Subject::erase(_sip);
1477  _IDSPort =0;
1478  _sip = 0;
1479  if (father)
1480  {
1481  DEBTRACE("REMOVE");
1482  father->select(true);
1483  father->update(REMOVE,0,0);
1484  }
1485  return true;
1486  }
1487  catch (Exception& ex)
1488  {
1489  DEBTRACE("CommandAddIDSPortFromCatalog::localReverse(): " << ex.what());
1490  setErrorMsg(ex);
1491  return false;
1492  }
1493 }
1494 
1495 // ----------------------------------------------------------------------------
1496 
1497 CommandAddODSPortFromCatalog::CommandAddODSPortFromCatalog(YACS::ENGINE::Catalog *catalog,
1498  std::string type,
1499  std::string node,
1500  std::string name)
1501  : Command(), _catalog(catalog), _typePort(type), _node(node), _name(name)
1502 {
1503  DEBTRACE("CommandAddODSPortFromCatalog");
1504  _ODSPort = 0;
1505  _sop = 0;
1506 }
1507 
1508 std::string CommandAddODSPortFromCatalog::dump()
1509 {
1510  string ret ="CommandAddODSPortFromCatalog " + _typePort + " " + _node + " " + _name;
1511  return ret;
1512 }
1513 
1514 YACS::ENGINE::OutputDataStreamPort *CommandAddODSPortFromCatalog::getODSPort()
1515 {
1516  return _ODSPort;
1517 }
1518 
1519 SubjectOutputDataStreamPort* CommandAddODSPortFromCatalog::getSubjectODSPort()
1520 {
1521  return _sop;
1522 }
1523 
1524 bool CommandAddODSPortFromCatalog::localExecute()
1525 {
1526  DEBTRACE("CommandAddODSPortFromCatalog::localExecute");
1527  OutputDataStreamPort *son = 0;
1528  try
1529  {
1530  Proc* proc = GuiContext::getCurrent()->getProc();
1531  Node* node = proc->getChildByName(_node);
1532  ElementaryNode* father =dynamic_cast<ElementaryNode*> (node);
1533  if (father)
1534  {
1535  if (_catalog->_typeMap.count(_typePort))
1536  son = father->edAddOutputDataStreamPort(_name, _catalog->_typeMap[_typePort]);
1537  else
1538  {
1539  DEBTRACE(_typePort << " not found in catalog");
1540  GuiContext::getCurrent()->_lastErrorMessage = _typePort + " not found in catalog";
1541  }
1542  }
1543  _ODSPort = son;
1544  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1545  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1546  _sop = snode->addSubjectODSPort(son, _name);
1547  }
1548  catch (Exception& ex)
1549  {
1550  DEBTRACE("CommandAddODSPortFromCatalog::localExecute() : " << ex.what());
1551  setErrorMsg(ex);
1552  if (son) delete son;
1553  _ODSPort = 0;
1554  }
1555  return (_ODSPort != 0);
1556 }
1557 
1558 bool CommandAddODSPortFromCatalog::localReverse()
1559 {
1560  DEBTRACE("CommandAddODSPortFromCatalog::localReverse");
1561  try
1562  {
1563  Proc* proc = GuiContext::getCurrent()->getProc();
1564  Node *node = proc->getChildByName(_node);
1565  ElementaryNode* enode = dynamic_cast<ElementaryNode*>(node);
1566  YASSERT(enode);
1567  _ODSPort = enode->getOutputDataStreamPort(_name);
1568  YASSERT(_ODSPort);
1569  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(_ODSPort));
1570  _sop = dynamic_cast<SubjectOutputDataStreamPort*>(GuiContext::getCurrent()->_mapOfSubjectDataPort[_ODSPort]);
1571  YASSERT(_sop);
1572 
1573  Subject *father=_sop->getParent();
1574  Subject::erase(_sop);
1575  _sop = 0;
1576  _ODSPort = 0;
1577  if (father)
1578  {
1579  DEBTRACE("REMOVE");
1580  father->select(true);
1581  father->update(REMOVE,0,0);
1582  }
1583  return true;
1584  }
1585  catch (Exception& ex)
1586  {
1587  DEBTRACE("CommandAddODSPortFromCatalog::localReverse(): " << ex.what());
1588  setErrorMsg(ex);
1589  return false;
1590  }
1591 }
1592 
1593 // ----------------------------------------------------------------------------
1594 
1598 CommandOrderInputPorts::CommandOrderInputPorts(std::string node,
1599  std::string port,
1600  int isUp)
1601  : Command(), _node(node), _port(port), _isUp(isUp), _rank(-1)
1602 {
1603  DEBTRACE("CommandOrderInputPorts");
1604 }
1605 
1606 std::string CommandOrderInputPorts::dump()
1607 {
1608  ostringstream s;
1609  s << _isUp;
1610  string ret ="CommandOrderInputPorts " + _node + " " + _port + " " + s.str();
1611  return ret;
1612 }
1613 
1614 bool CommandOrderInputPorts::localExecute()
1615 {
1616  DEBTRACE("CommandOrderInputPorts::localExecute " << _node << " " << _port << " " << _isUp);
1617  ElementaryNode* father = 0;
1618  try
1619  {
1620  Proc* proc = GuiContext::getCurrent()->getProc();
1621  Node* node = proc->getChildByName(_node);
1622  father = dynamic_cast<ElementaryNode*> (node);
1623  if (!father) return false;
1624  InputPort *portToMove = father->getInputPort(_port);
1625  DEBTRACE(portToMove->getName());
1626 
1627  list<InputPort*> plist = father->getSetOfInputPort();
1628  list<InputPort*>::iterator pos = find(plist.begin(), plist.end(), portToMove);
1629 
1630  int isUp = _isUp;
1631  if (isUp)
1632  {
1633  if(pos == plist.begin())
1634  pos=plist.end(); // --- cycle
1635  else
1636  do { pos--; isUp--; } while (isUp);
1637  }
1638  else
1639  {
1640  pos++;
1641  if (pos == plist.end())
1642  pos = plist.begin(); // --- cycle
1643  else
1644  pos++; // --- insert before the 2nd next port
1645  }
1646 
1647  InputPort *portBefore = 0;
1648  if (pos != plist.end())
1649  portBefore = (*pos);
1650 
1651  plist.remove(portToMove);
1652  if (portBefore)
1653  {
1654  DEBTRACE(portBefore->getName());
1655  pos = find(plist.begin(), plist.end(), portBefore);
1656  _rank = 0;
1657  for (list<InputPort*>::iterator it = plist.begin(); it != pos; ++it)
1658  _rank++;
1659  plist.insert(pos, portToMove);
1660  }
1661  else
1662  {
1663  _rank = plist.size();
1664  plist.push_back(portToMove);
1665  }
1666  father->edOrderInputPorts(plist);
1667  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1668  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1669  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[portToMove];
1670  snode->update(ORDER, true, sport);
1671  snode->update(SYNCHRO, true, sport); // --- synchronise edition and scene
1672  }
1673  catch (Exception& ex)
1674  {
1675  DEBTRACE("CommandOrderInputPorts::localExecute() : " << ex.what());
1676  setErrorMsg(ex);
1677  father = 0;
1678  }
1679  return (father != 0);
1680 }
1681 
1682 bool CommandOrderInputPorts::localReverse()
1683 {
1684  DEBTRACE("CommandOrderInputPorts::localReverse " << _node << " " << _port << " " << _isUp);
1685  ElementaryNode* father = 0;
1686  try
1687  {
1688  int isUpRev = -_isUp;
1689  if (isUpRev == 0) isUpRev =1;
1690  Proc* proc = GuiContext::getCurrent()->getProc();
1691  Node* node = proc->getChildByName(_node);
1692  father = dynamic_cast<ElementaryNode*> (node);
1693  if (!father) return false;
1694  InputPort *portToMove = father->getInputPort(_port);
1695  DEBTRACE(portToMove->getName());
1696 
1697  list<InputPort*> plist = father->getSetOfInputPort();
1698  list<InputPort*>::iterator pos = find(plist.begin(), plist.end(), portToMove);
1699 
1700  if (isUpRev>0)
1701  {
1702  if(pos == plist.begin())
1703  pos=plist.end(); // --- cycle
1704  else
1705  do { pos--; isUpRev--; } while (isUpRev);
1706  }
1707  else
1708  {
1709  pos++;
1710  if (pos == plist.end())
1711  pos = plist.begin(); // --- cycle
1712  else
1713  do { pos++; isUpRev++; } while (isUpRev<0);// --- insert before the 2nd next port
1714  }
1715 
1716  InputPort *portBefore = 0;
1717  if (pos != plist.end())
1718  portBefore = (*pos);
1719 
1720  plist.remove(portToMove);
1721  if (portBefore)
1722  {
1723  DEBTRACE(portBefore->getName());
1724  pos = find(plist.begin(), plist.end(), portBefore);
1725  _rank = 0;
1726  for (list<InputPort*>::iterator it = plist.begin(); it != pos; ++it)
1727  _rank++;
1728  plist.insert(pos, portToMove);
1729  }
1730  else
1731  {
1732  _rank = plist.size();
1733  plist.push_back(portToMove);
1734  }
1735  father->edOrderInputPorts(plist);
1736  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1737  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1738  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[portToMove];
1739  snode->update(ORDER, true, sport);
1740  snode->update(SYNCHRO, true, sport); // --- synchronise edition and scene
1741  }
1742  catch (Exception& ex)
1743  {
1744  DEBTRACE("CommandOrderInputPorts::localExecute() : " << ex.what());
1745  setErrorMsg(ex);
1746  father = 0;
1747  }
1748  return (father != 0);
1749 }
1750 
1751 // ----------------------------------------------------------------------------
1752 
1756 CommandOrderOutputPorts::CommandOrderOutputPorts(std::string node,
1757  std::string port,
1758  int isUp)
1759  : Command(), _node(node), _port(port), _isUp(isUp), _rank(-1)
1760 {
1761  DEBTRACE("CommandOrderOutputPorts");
1762 }
1763 
1764 std::string CommandOrderOutputPorts::dump()
1765 {
1766  ostringstream s;
1767  s << _isUp;
1768  string ret ="CommandOrderOutputPorts " + _node + " " + _port + " " + s.str();
1769  return ret;
1770 }
1771 
1772 bool CommandOrderOutputPorts::localExecute()
1773 {
1774  DEBTRACE("CommandOrderOutputPorts::localExecute " << _node << " " << _port << " " << _isUp);
1775  ElementaryNode* father = 0;
1776  try
1777  {
1778  Proc* proc = GuiContext::getCurrent()->getProc();
1779  Node* node = proc->getChildByName(_node);
1780  father = dynamic_cast<ElementaryNode*> (node);
1781  if (!father) return false;
1782  OutputPort *portToMove = father->getOutputPort(_port);
1783  DEBTRACE(portToMove->getName());
1784 
1785  list<OutputPort*> plist = father->getSetOfOutputPort();
1786  list<OutputPort*>::iterator pos = find(plist.begin(), plist.end(), portToMove);
1787 
1788  int isUp = _isUp;
1789  if (isUp)
1790  {
1791  if(pos == plist.begin())
1792  pos=plist.end(); // --- cycle
1793  else
1794  do { pos--; isUp--; } while (isUp);
1795  }
1796  else
1797  {
1798  pos++;
1799  if (pos == plist.end())
1800  pos = plist.begin(); // --- cycle
1801  else
1802  pos++; // --- insert before the 2nd next port
1803  }
1804 
1805  OutputPort *portBefore = 0;
1806  if (pos != plist.end())
1807  portBefore = (*pos);
1808 
1809  plist.remove(portToMove);
1810  if (portBefore)
1811  {
1812  DEBTRACE(portBefore->getName());
1813  pos = find(plist.begin(), plist.end(), portBefore);
1814  _rank = 0;
1815  for (list<OutputPort*>::iterator it = plist.begin(); it != pos; ++it)
1816  _rank++;
1817  plist.insert(pos, portToMove);
1818  }
1819  else
1820  {
1821  _rank = plist.size();
1822  plist.push_back(portToMove);
1823  }
1824  father->edOrderOutputPorts(plist);
1825  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1826  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1827  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[portToMove];
1828  snode->update(ORDER, false, sport);
1829  snode->update(SYNCHRO, false, sport); // --- synchronise edition and scene
1830  }
1831  catch (Exception& ex)
1832  {
1833  DEBTRACE("CommandOrderOutputPorts::localExecute() : " << ex.what());
1834  setErrorMsg(ex);
1835  father = 0;
1836  }
1837  return (father != 0);
1838 }
1839 
1840 bool CommandOrderOutputPorts::localReverse()
1841 {
1842  DEBTRACE("CommandOrderOutputPorts::localReverse " << _node << " " << _port << " " << _isUp);
1843  ElementaryNode* father = 0;
1844  try
1845  {
1846  int isUpRev = -_isUp;
1847  if (isUpRev == 0) isUpRev =1;
1848  Proc* proc = GuiContext::getCurrent()->getProc();
1849  Node* node = proc->getChildByName(_node);
1850  father = dynamic_cast<ElementaryNode*> (node);
1851  if (!father) return false;
1852  OutputPort *portToMove = father->getOutputPort(_port);
1853  DEBTRACE(portToMove->getName());
1854 
1855  list<OutputPort*> plist = father->getSetOfOutputPort();
1856  list<OutputPort*>::iterator pos = find(plist.begin(), plist.end(), portToMove);
1857 
1858  if (isUpRev>0)
1859  {
1860  if(pos == plist.begin())
1861  pos=plist.end(); // --- cycle
1862  else
1863  do { pos--; isUpRev--; } while (isUpRev);
1864  }
1865  else
1866  {
1867  pos++;
1868  if (pos == plist.end())
1869  pos = plist.begin(); // --- cycle
1870  else
1871  do { pos++; isUpRev++; } while (isUpRev<0);// --- insert before the 2nd next port
1872  }
1873 
1874  OutputPort *portBefore = 0;
1875  if (pos != plist.end())
1876  portBefore = (*pos);
1877 
1878  plist.remove(portToMove);
1879  if (portBefore)
1880  {
1881  DEBTRACE(portBefore->getName());
1882  pos = find(plist.begin(), plist.end(), portBefore);
1883  _rank = 0;
1884  for (list<OutputPort*>::iterator it = plist.begin(); it != pos; ++it)
1885  _rank++;
1886  plist.insert(pos, portToMove);
1887  }
1888  else
1889  {
1890  _rank = plist.size();
1891  plist.push_back(portToMove);
1892  }
1893  father->edOrderOutputPorts(plist);
1894  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1895  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1896  SubjectDataPort *sport = GuiContext::getCurrent()->_mapOfSubjectDataPort[portToMove];
1897  snode->update(ORDER, false, sport);
1898  snode->update(SYNCHRO, false, sport); // --- synchronise edition and scene
1899  }
1900  catch (Exception& ex)
1901  {
1902  DEBTRACE("CommandOrderOutputPorts::localExecute() : " << ex.what());
1903  setErrorMsg(ex);
1904  father = 0;
1905  }
1906  return (father != 0);
1907 }
1908 
1909 // ----------------------------------------------------------------------------
1910 
1911 CommandDestroy::CommandDestroy(TypeOfElem elemType,
1912  std::string startnode, std::string startport, TypeOfElem startportType,
1913  std::string endnode, std::string endport, TypeOfElem endportType)
1914  : Command(), _elemType(elemType), _startnode(startnode), _startport(startport),
1915  _endnode(endnode), _endport(endport), _startportType(startportType), _endportType(endportType)
1916 {
1917  DEBTRACE("CommandDestroy::CommandDestroy");
1918  _normalReverse = false;
1919 }
1920 
1921 std::string CommandDestroy::dump()
1922 {
1923  string ret ="CommandDestroy " + ProcInvoc::getTypeName(_elemType);
1924  ret += " " + _startnode + " " + _startport;
1925  ret += " " + _endnode + " " + _endport;
1926  return ret;
1927 }
1928 
1929 bool CommandDestroy::localExecute()
1930 {
1931  DEBTRACE("CommandDestroy::localExecute");
1932  try
1933  {
1934  Proc* proc = GuiContext::getCurrent()->getProc();
1935  Subject *subject = 0;
1936  Subject *father = 0;
1937  switch (_elemType)
1938  {
1939  case SALOMEPROC:
1940  case BLOC:
1941  case FOREACHLOOP:
1942  case OPTIMIZERLOOP:
1943  case FORLOOP:
1944  case WHILELOOP:
1945  case SWITCH:
1946  case PYTHONNODE:
1947  case PYFUNCNODE:
1948  case CORBANODE:
1949  case SALOMENODE:
1950  case CPPNODE:
1951  case SALOMEPYTHONNODE:
1952  case XMLNODE:
1953  case SPLITTERNODE:
1954  case DFTODSFORLOOPNODE:
1955  case DSTODFFORLOOPNODE:
1956  case PRESETNODE:
1957  case OUTNODE:
1958  case STUDYINNODE:
1959  case STUDYOUTNODE:
1960  {
1961  Node* node = proc;
1962  if (!_startnode.empty()) node = proc->getChildByName(_startnode);
1963  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
1964  subject = GuiContext::getCurrent()->_mapOfSubjectNode[node];
1965  father = subject->getParent();
1966  }
1967  break;
1968  case INPUTPORT:
1969  {
1970  Node* node = proc->getChildByName(_startnode);
1971  InPort* inp = node->getInputPort(_startport);
1972  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(inp));
1973  subject = GuiContext::getCurrent()->_mapOfSubjectDataPort[inp];
1974  father = subject->getParent();
1975  }
1976  break;
1977  case INPUTDATASTREAMPORT:
1978  {
1979  Node* node = proc->getChildByName(_startnode);
1980  InPort* inp = node->getInputDataStreamPort(_startport);
1981  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(inp));
1982  subject = GuiContext::getCurrent()->_mapOfSubjectDataPort[inp];
1983  father = subject->getParent();
1984  }
1985  break;
1986  case OUTPUTPORT:
1987  {
1988  Node* node = proc->getChildByName(_startnode);
1989  OutPort* outp = node->getOutputPort(_startport);
1990  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(outp));
1991  subject = GuiContext::getCurrent()->_mapOfSubjectDataPort[outp];
1992  father = subject->getParent();
1993  }
1994  break;
1995  case OUTPUTDATASTREAMPORT:
1996  {
1997  Node* node = proc->getChildByName(_startnode);
1998  OutPort* outp = node->getOutputDataStreamPort(_startport);
1999  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(outp));
2000  subject = GuiContext::getCurrent()->_mapOfSubjectDataPort[outp];
2001  father = subject->getParent();
2002  }
2003  break;
2004  case DATALINK:
2005  {
2006  Node* outn = proc->getChildByName(_startnode);
2007  Node* inn = proc->getChildByName(_endnode);
2008 
2009  OutPort* outp;
2010  InPort* inp;
2011 
2012  if(_startportType == OUTPUTPORT)
2013  outp = outn->getOutputPort(_startport);
2014  else
2015  outp = outn->getOutputDataStreamPort(_startport);
2016 
2017  if(_endportType == INPUTPORT)
2018  inp = inn->getInputPort(_endport);
2019  else
2020  inp = inn->getInputDataStreamPort(_endport);
2021 
2022  pair<OutPort*,InPort*> keymap = pair<OutPort*,InPort*>(outp,inp);
2023  YASSERT(GuiContext::getCurrent()->_mapOfSubjectLink.count(keymap));
2024  subject = GuiContext::getCurrent()->_mapOfSubjectLink[keymap];
2025  father = subject->getParent();
2026  }
2027  break;
2028  case CONTROLLINK:
2029  {
2030  Node* outn = proc->getChildByName(_startnode);
2031  Node* inn = proc->getChildByName(_endnode);
2032  pair<Node*,Node*> keymap = pair<Node*,Node*>(outn,inn);
2033  YASSERT(GuiContext::getCurrent()->_mapOfSubjectControlLink.count(keymap));
2034  subject = GuiContext::getCurrent()->_mapOfSubjectControlLink[keymap];
2035  father = subject->getParent();
2036  }
2037  break;
2038  case CONTAINER:
2039  {
2040  Container *container = proc->containerMap[_startnode];
2041  subject = GuiContext::getCurrent()->_mapOfSubjectContainer[container];
2042  break;
2043  }
2044  case COMPONENT:
2045  case REFERENCE:
2046  case DATATYPE:
2047  case UNKNOWN:
2048  throw Exception("Command Destroy not implemented for that type");
2049  break;
2050  }
2051  YASSERT(subject);
2052  Subject::erase(subject);
2053  if (father)
2054  {
2055  father->select(true);
2056  father->update(REMOVE, 0, 0);
2057  }
2058  subject = 0;
2059  return true;
2060  }
2061  catch (Exception& ex)
2062  {
2063  DEBTRACE("CommandDestroy::localExecute() : " << ex.what());
2064  setErrorMsg(ex);
2065  return false;
2066  }
2067 }
2068 
2069 bool CommandDestroy::localReverse()
2070 {
2071  DEBTRACE("CommandDestroy::localReverse");
2073  return true;
2074 }
2075 
2076 // ----------------------------------------------------------------------------
2077 
2078 CommandSetInPortValue::CommandSetInPortValue(std::string node,
2079  std::string port,
2080  std::string value)
2081  : Command(), _node(node), _port(port), _value(value)
2082 {
2083  DEBTRACE("CommandSetInPortValue::CommandSetInPortValue " << node << " " << port << " " << value);
2084  _oldValue = "";
2085 }
2086 
2087 std::string CommandSetInPortValue::dump()
2088 {
2089  string ret ="CommandSetInPortValue " + _node + " " + _port + " " + _value;
2090  return ret;
2091 }
2092 
2093 bool CommandSetInPortValue::localExecute()
2094 {
2095  DEBTRACE("CommandSetInPortValue::localExecute");
2096  InputPort* inp ;
2097  InputPresetPort *inpp = 0;
2098  InputStudyPort *insp = 0;
2099  DataNode *dnode = 0;
2100  SubjectDataPort *sinp = 0;
2101  try
2102  {
2103  Proc* proc = GuiContext::getCurrent()->getProc();
2104  Node* node = proc->getChildByName(_node);
2105  inp = node->getInputPort(_port);
2106  inpp = dynamic_cast<InputPresetPort*>(inp);
2107  insp = dynamic_cast<InputStudyPort*>(inp);
2108  dnode = dynamic_cast<DataNode*>(node);
2109  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(inp));
2110  sinp = GuiContext::getCurrent()->_mapOfSubjectDataPort[inp];
2111  }
2112  catch (Exception& ex)
2113  {
2114  DEBTRACE("CommandSetInPortValue::localExecute() : " << ex.what());
2115  setErrorMsg(ex);
2116  return false;
2117  }
2118 
2119  if(insp && dnode)
2120  {
2121  //It's a study port
2122  _oldValue = insp->getAsString();
2123  DEBTRACE("old value="<< _oldValue);
2124  dnode->setData(insp, _value );
2125  sinp->update(SETVALUE, 0, sinp);
2126  return true;
2127  }
2128 
2129  PyObject *result;
2130  PyGILState_STATE gstate = PyGILState_Ensure();
2131  try
2132  {
2133  _oldValue = inp->getAsString();
2134  if (_oldValue == "None") _oldValue = "";
2135  DEBTRACE("old value="<< _oldValue);
2136  std::string strval;
2137  if (inp->edGetType()->kind() == YACS::ENGINE::String || inp->edGetType()->isA(Runtime::_tc_file))
2138  strval = "\"" + _value + "\"";
2139  else
2140  strval = _value;
2141  result = YACS::ENGINE::getSALOMERuntime()->convertStringToPyObject(strval.c_str());
2142  inp->edInit("Python", result);
2143  Py_DECREF(result);
2144 
2145  PyGILState_Release(gstate);
2146  sinp->update(SETVALUE, 0, sinp);
2147  return true;
2148  }
2149  catch (Exception& ex)
2150  {
2151  DEBTRACE("CommandSetInPortValue::localExecute() : " << ex.what());
2152  //Py_DECREF(result);
2153  PyGILState_Release(gstate);
2154  setErrorMsg(ex);
2155  return false;
2156  }
2157 }
2158 
2159 bool CommandSetInPortValue::localReverse()
2160 {
2161  DEBTRACE("CommandSetInPortValue::localReverse");
2162  InputPort* inp ;
2163  InputPresetPort *inpp = 0;
2164  InputStudyPort *insp = 0;
2165  DataNode *dnode = 0;
2166  SubjectDataPort *sinp = 0;
2167  try
2168  {
2169  Proc* proc = GuiContext::getCurrent()->getProc();
2170  Node* node = proc->getChildByName(_node);
2171  inp = node->getInputPort(_port);
2172  inpp = dynamic_cast<InputPresetPort*>(inp);
2173  insp = dynamic_cast<InputStudyPort*>(inp);
2174  dnode = dynamic_cast<DataNode*>(node);
2175  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(inp));
2176  sinp = GuiContext::getCurrent()->_mapOfSubjectDataPort[inp];
2177  }
2178  catch (Exception& ex)
2179  {
2180  DEBTRACE("CommandSetInPortValue::localExecute() : " << ex.what());
2181  setErrorMsg(ex);
2182  return false;
2183  }
2184 
2185  if(insp && dnode)
2186  {
2187  //It's a study port
2188  _value = insp->getAsString();
2189  DEBTRACE("value="<< _value);
2190  DEBTRACE("old value="<< _oldValue);
2191  dnode->setData(insp, _oldValue );
2192  sinp->update(SETVALUE, 0, sinp);
2193  return true;
2194  }
2195 
2196  PyObject *result = Py_None;
2197  PyGILState_STATE gstate = PyGILState_Ensure();
2198  try
2199  {
2200  _value = inp->getAsString();
2201  DEBTRACE("value="<< _value);
2202  DEBTRACE("old value="<< _oldValue);
2203  if (!_oldValue.empty())
2204  {
2205  std::string strval;
2206  if (inp->edGetType()->kind() == YACS::ENGINE::String || inp->edGetType()->isA(Runtime::_tc_file))
2207  strval = "\"" + _oldValue + "\"";
2208  else
2209  strval = _oldValue;
2210  result = YACS::ENGINE::getSALOMERuntime()->convertStringToPyObject(strval.c_str());
2211  }
2212  inp->edInit("Python", result);
2213  Py_DECREF(result);
2214  PyGILState_Release(gstate);
2215  sinp->update(SETVALUE, 0, sinp);
2216  return true;
2217  }
2218  catch (Exception& ex)
2219  {
2220  DEBTRACE("CommandSetInPortValue::localExecute() : " << ex.what());
2221  //Py_DECREF(result);
2222  PyGILState_Release(gstate);
2223  setErrorMsg(ex);
2224  return false;
2225  }
2226 }
2227 
2228 // ----------------------------------------------------------------------------
2229 
2230 CommandSetOutPortValue::CommandSetOutPortValue(std::string node,
2231  std::string port,
2232  std::string value)
2233  : Command(), _node(node), _port(port), _value(value)
2234 {
2235  DEBTRACE("CommandSetOutPortValue::CommandSetOutPortValue " << node << " " << port << " " << value);
2236  _oldValue = "";
2237 }
2238 
2239 std::string CommandSetOutPortValue::dump()
2240 {
2241  string ret ="CommandSetOutPortValue " + _node + " " + _port + " " + _value;
2242  return ret;
2243 }
2244 
2245 bool CommandSetOutPortValue::localExecute()
2246 {
2247  DEBTRACE("CommandSetOutPortValue::localExecute");
2248  OutputPresetPort *outpp = 0;
2249  OutputStudyPort *outsp = 0;
2250  DataNode *dnode = 0;
2251  SubjectDataPort *soutp = 0;
2252  try
2253  {
2254  Proc* proc = GuiContext::getCurrent()->getProc();
2255  Node* node = proc->getChildByName(_node);
2256  OutputPort* outp = node->getOutputPort(_port);
2257  outpp = dynamic_cast<OutputPresetPort*>(outp);
2258  outsp = dynamic_cast<OutputStudyPort*>(outp);
2259  dnode = dynamic_cast<DataNode*>(node);
2260  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(outp));
2261  soutp = GuiContext::getCurrent()->_mapOfSubjectDataPort[outp];
2262  }
2263  catch (Exception& ex)
2264  {
2265  DEBTRACE("CommandSetOutPortValue::localExecute() : " << ex.what());
2266  setErrorMsg(ex);
2267  return false;
2268  }
2269 
2270  if (!outpp && !outsp)
2271  {
2272  DEBTRACE("Set value on output port only possible on a presetPort or a studyPort");
2273  GuiContext::getCurrent()->_lastErrorMessage = "Set value on output port only possible on a presetPort or a studyPort";
2274  return false;
2275  }
2276 
2277  if (!dnode)
2278  {
2279  DEBTRACE("Set value on output port only possible on a dataNode");
2280  GuiContext::getCurrent()->_lastErrorMessage = "Set value on output port only possible on a dataNode";
2281  return false;
2282  }
2283 
2284  if(outsp)
2285  {
2286  //It's a study port
2287  _oldValue = outsp->getAsString();
2288  DEBTRACE("old value="<< _oldValue);
2289  dnode->setData(outsp, _value );
2290  soutp->update(SETVALUE, 0, soutp);
2291  return true;
2292  }
2293 
2294  PyObject *result;
2295  try
2296  {
2297  _oldValue = outpp->getAsString();
2298  if (_oldValue == "None") _oldValue = "";
2299  DEBTRACE("old value="<< _oldValue);
2300  std::string strval;
2301  if (outpp->edGetType()->kind() == YACS::ENGINE::String || outpp->edGetType()->isA(Runtime::_tc_file))
2302  strval = "\"" + _value + "\"";
2303  else
2304  strval = _value;
2305  result = YACS::ENGINE::getSALOMERuntime()->convertStringToPyObject(strval.c_str());
2306  }
2307  catch (Exception& ex)
2308  {
2309  DEBTRACE("CommandSetOutPortValue::localExecute() : " << ex.what());
2310  setErrorMsg(ex);
2311  return false;
2312  }
2313 
2314  string val;
2315  PyGILState_STATE gstate = PyGILState_Ensure();
2316  try
2317  {
2318  DEBTRACE(PyObject_Str(result));
2319  val = convertPyObjectXml(outpp->edGetType(), result);
2320  DEBTRACE(val);
2321  dnode->setData(outpp, val );
2322  soutp->update(SETVALUE, 0, soutp);
2323  }
2324  catch (Exception& ex)
2325  {
2326  DEBTRACE("CommandSetOutPortValue::localExecute() : " << ex.what());
2327  setErrorMsg(ex);
2328  Py_DECREF(result);
2329  PyGILState_Release(gstate);
2330  return false;
2331  }
2332 
2333  Py_DECREF(result);
2334  PyGILState_Release(gstate);
2335  return true;
2336 }
2337 
2338 bool CommandSetOutPortValue::localReverse()
2339 {
2340  DEBTRACE("CommandSetOutPortValue::localReverse");
2341  OutputPresetPort *outpp = 0;
2342  OutputStudyPort *outsp = 0;
2343  DataNode *dnode = 0;
2344  SubjectDataPort *soutp = 0;
2345  try
2346  {
2347  Proc* proc = GuiContext::getCurrent()->getProc();
2348  Node* node = proc->getChildByName(_node);
2349  OutputPort* outp = node->getOutputPort(_port);
2350  outpp = dynamic_cast<OutputPresetPort*>(outp);
2351  outsp = dynamic_cast<OutputStudyPort*>(outp);
2352  dnode = dynamic_cast<DataNode*>(node);
2353  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(outp));
2354  soutp = GuiContext::getCurrent()->_mapOfSubjectDataPort[outp];
2355  }
2356  catch (Exception& ex)
2357  {
2358  DEBTRACE("CommandSetOutPortValue::localExecute() : " << ex.what());
2359  setErrorMsg(ex);
2360  return false;
2361  }
2362 
2363  if (!outpp && !outsp)
2364  {
2365  DEBTRACE("Set value on output port only possible on a presetPort or a studyPort");
2366  GuiContext::getCurrent()->_lastErrorMessage = "Set value on output port only possible on a presetPort or a studyPort";
2367  return false;
2368  }
2369 
2370  if (!dnode)
2371  {
2372  DEBTRACE("Set value on output port only possible on a dataNode");
2373  GuiContext::getCurrent()->_lastErrorMessage = "Set value on output port only possible on a dataNode";
2374  return false;
2375  }
2376 
2377  if(outsp)
2378  {
2379  //It's a study port
2380  _value = outsp->getAsString();
2381  DEBTRACE("value="<< _value);
2382  DEBTRACE("old value="<< _oldValue);
2383  dnode->setData(outsp, _oldValue );
2384  soutp->update(SETVALUE, 0, soutp);
2385  return true;
2386  }
2387 
2388  PyObject *result = Py_None;
2389  try
2390  {
2391  _value = outpp->getAsString();
2392  DEBTRACE("value="<< _value);
2393  DEBTRACE("old value="<< _oldValue);
2394  if (!_oldValue.empty())
2395  {
2396  std::string strval;
2397  if (outpp->edGetType()->kind() == YACS::ENGINE::String || outpp->edGetType()->isA(Runtime::_tc_file))
2398  strval = "\"" + _value + "\"";
2399  else
2400  strval = _value;
2401  result = YACS::ENGINE::getSALOMERuntime()->convertStringToPyObject(strval.c_str());
2402  }
2403  }
2404  catch (Exception& ex)
2405  {
2406  DEBTRACE("CommandSetOutPortValue::localExecute() : " << ex.what());
2407  setErrorMsg(ex);
2408  return false;
2409  }
2410 
2411  string val;
2412  PyGILState_STATE gstate = PyGILState_Ensure();
2413  try
2414  {
2415  DEBTRACE(PyObject_Str(result));
2416  val = convertPyObjectXml(outpp->edGetType(), result);
2417  DEBTRACE(val);
2418  dnode->setData(outpp, val );
2419  soutp->update(SETVALUE, 0, soutp);
2420  }
2421  catch (Exception& ex)
2422  {
2423  DEBTRACE("CommandSetOutPortValue::localExecute() : " << ex.what());
2424  setErrorMsg(ex);
2425  Py_DECREF(result);
2426  PyGILState_Release(gstate);
2427  return false;
2428  }
2429 
2430  Py_DECREF(result);
2431  PyGILState_Release(gstate);
2432  return true;
2433 }
2434 
2435 // ----------------------------------------------------------------------------
2436 
2437 CommandSetSwitchSelect::CommandSetSwitchSelect(std::string aSwitch,
2438  std::string value)
2439  : Command(), _switch(aSwitch), _value(value)
2440 {
2441  DEBTRACE("CommandSetSwitchSelect::CommandSetSwitchSelect");
2442  _oldValue = "0";
2443 }
2444 
2445 std::string CommandSetSwitchSelect::dump()
2446 {
2447  string ret ="CommandSetSwitchSelect " + _switch + " " + _value;
2448  return ret;
2449 }
2450 
2451 bool CommandSetSwitchSelect::localExecute()
2452 {
2453  DEBTRACE("CommandSetSwitchSelect::localExecute");
2454  try
2455  {
2456  Proc* proc = GuiContext::getCurrent()->getProc();
2457  Switch* aSwitch = dynamic_cast<Switch*>(proc->getChildByName(_switch));
2458  InputPort *condPort = aSwitch->edGetConditionPort();
2459  _oldValue = condPort->getAsString();
2460  if (_oldValue == "None") _oldValue = "0";
2461  int val = atoi(_value.c_str());
2462  condPort->edInit(val);
2463  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(aSwitch));
2464  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[aSwitch];
2465  snode->update(SETSELECT, 0, snode);
2466  }
2467  catch (Exception& ex)
2468  {
2469  DEBTRACE("CommandSetSwitchSelect::localExecute() : " << ex.what());
2470  setErrorMsg(ex);
2471  return false;
2472  }
2473 }
2474 
2475 bool CommandSetSwitchSelect::localReverse()
2476 {
2477  DEBTRACE("CommandSetSwitchSelect::localReverse");
2478  try
2479  {
2480  Proc* proc = GuiContext::getCurrent()->getProc();
2481  Switch* aSwitch = dynamic_cast<Switch*>(proc->getChildByName(_switch));
2482  InputPort *condPort = aSwitch->edGetConditionPort();
2483  int val = atoi(_oldValue.c_str());
2484  condPort->edInit(val);
2485  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(aSwitch));
2486  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[aSwitch];
2487  snode->update(SETSELECT, 0, snode);
2488  }
2489  catch (Exception& ex)
2490  {
2491  DEBTRACE("CommandSetSwitchSelect::localReverse() : " << ex.what());
2492  setErrorMsg(ex);
2493  return false;
2494  }
2495 }
2496 
2497 // ----------------------------------------------------------------------------
2498 
2499 CommandSetSwitchCase::CommandSetSwitchCase(std::string aSwitch,
2500  std::string node,
2501  std::string value)
2502  : Command(), _switch(aSwitch), _node(node), _value(value)
2503 {
2504  DEBTRACE("CommandSetSwitchCase::CommandSetSwitchCase");
2505  _oldValue = 0;
2506  _oldNode = "";
2507 }
2508 
2509 std::string CommandSetSwitchCase::dump()
2510 {
2511  string ret ="CommandSetSwitchCase " + _switch + " " + _node + " " + _value;
2512  return ret;
2513 }
2514 
2515 bool CommandSetSwitchCase::localExecute()
2516 {
2517  DEBTRACE("CommandSetSwitchCase::localExecute");
2518  try
2519  {
2520  DEBTRACE("CommandSetSwitchCase::localExecute");
2521  Proc* proc = GuiContext::getCurrent()->getProc();
2522  Switch* aSwitch = dynamic_cast<Switch*>(proc->getChildByName(_switch));
2523  Node* node = proc->getChildByName(_node);
2524  int val = atoi(_value.c_str());
2525  if (aSwitch->edGetNode(val))
2526  {
2527  throw YACS::Exception("Set Switch Case impossible: value already used");
2528  }
2529  int oldVal = aSwitch->getRankOfNode(node);
2530  aSwitch->edChangeCase(oldVal,val);
2531  _oldValue = oldVal;
2532  _oldNode = proc->getChildName(node);
2533  DEBTRACE("CommandSetSwitchCase::localExecute OK " << val);
2534  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(aSwitch));
2535  SubjectNode *ssw = GuiContext::getCurrent()->_mapOfSubjectNode[aSwitch];
2536  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
2537  ssw->update(SETCASE, val, snode);
2538  snode->recursiveUpdate(RENAME, 0, snode);
2539  return true;
2540  }
2541  catch (Exception& ex)
2542  {
2543  DEBTRACE("CommandSetSwitchCase::localExecute() : " << ex.what());
2544  setErrorMsg(ex);
2545  return false;
2546  }
2547 }
2548 
2549 bool CommandSetSwitchCase::localReverse()
2550 {
2551  DEBTRACE("CommandSetSwitchCase::localReverse");
2552  try
2553  {
2554  DEBTRACE("CommandSetSwitchCase::localReverse");
2555  Proc* proc = GuiContext::getCurrent()->getProc();
2556  Switch* aSwitch = dynamic_cast<Switch*>(proc->getChildByName(_switch));
2557  Node* node = proc->getChildByName(_oldNode);
2558  int val = _oldValue;
2559  if (aSwitch->edGetNode(val))
2560  {
2561  throw YACS::Exception("Set Switch Case impossible: value already used");
2562  }
2563  int oldVal = aSwitch->getRankOfNode(node);
2564  aSwitch->edChangeCase(oldVal,val);
2565  DEBTRACE("CommandSetSwitchCase::localReverse OK " << val);
2566  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(aSwitch));
2567  SubjectNode *ssw = GuiContext::getCurrent()->_mapOfSubjectNode[aSwitch];
2568  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
2569  ssw->update(SETCASE, val, snode);
2570  snode->recursiveUpdate(RENAME, 0, snode);
2571  return true;
2572  }
2573  catch (Exception& ex)
2574  {
2575  DEBTRACE("CommandSetSwitchCase::localReverse() : " << ex.what());
2576  setErrorMsg(ex);
2577  return false;
2578  }
2579 }
2580 
2581 // ----------------------------------------------------------------------------
2582 
2583 CommandSetForLoopSteps::CommandSetForLoopSteps(std::string forLoop,
2584  std::string value)
2585  : Command(), _forLoop(forLoop), _value(value)
2586 {
2587  DEBTRACE("CommandSetForLoopSteps::CommandSetForLoopSteps");
2588  _oldValue = 0;
2589 }
2590 
2591 
2592 std::string CommandSetForLoopSteps::dump()
2593 {
2594  string ret ="CommandSetForLoopSteps " + _forLoop + " " + _value;
2595  return ret;
2596 }
2597 
2598 bool CommandSetForLoopSteps::localExecute()
2599 {
2600  DEBTRACE("CommandSetForLoopSteps::localExecute");
2601  try
2602  {
2603  DEBTRACE("CommandSetForLoopSteps::localExecute");
2604  Proc* proc = GuiContext::getCurrent()->getProc();
2605  ForLoop* forLoop = dynamic_cast<ForLoop*>(proc->getChildByName(_forLoop));
2606  InputPort *nbSteps = forLoop->edGetNbOfTimesInputPort();
2607  _oldValue = atoi(forLoop->edGetNbOfTimesInputPort()->getAsString().c_str());
2608  int val = atoi(_value.c_str());
2609  nbSteps->edInit(val);
2610  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(forLoop));
2611  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[forLoop];
2612  snode->update(SETVALUE, 0, snode);
2613  return true;
2614  }
2615  catch (Exception& ex)
2616  {
2617  DEBTRACE("CommandSetForLoopSteps::localExecute() : " << ex.what());
2618  setErrorMsg(ex);
2619  return false;
2620  }
2621 }
2622 
2623 bool CommandSetForLoopSteps::localReverse()
2624 {
2625  DEBTRACE("CommandSetForLoopSteps::localReverse");
2626  try
2627  {
2628  DEBTRACE("CommandSetForLoopSteps::localReverse");
2629  Proc* proc = GuiContext::getCurrent()->getProc();
2630  ForLoop* forLoop = dynamic_cast<ForLoop*>(proc->getChildByName(_forLoop));
2631  InputPort *nbSteps = forLoop->edGetNbOfTimesInputPort();
2632  nbSteps->edInit(_oldValue);
2633  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(forLoop));
2634  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[forLoop];
2635  snode->update(SETVALUE, 0, snode);
2636  return true;
2637  }
2638  catch (Exception& ex)
2639  {
2640  DEBTRACE("CommandSetForLoopSteps::localReverse() : " << ex.what());
2641  setErrorMsg(ex);
2642  return false;
2643  }
2644 }
2645 
2646 // ----------------------------------------------------------------------------
2647 
2648 CommandSetWhileCondition::CommandSetWhileCondition(std::string whileLoop,
2649  std::string value)
2650  : Command(), _whileLoop(whileLoop), _value(value)
2651 {
2652  DEBTRACE("CommandSetWhileCondition::CommandSetWhileCondition");
2653  _oldValue = 0;
2654 }
2655 
2656 std::string CommandSetWhileCondition::dump()
2657 {
2658  string ret ="CommandSetWhileCondition " + _whileLoop + " " + _value;
2659  return ret;
2660 }
2661 
2662 bool CommandSetWhileCondition::localExecute()
2663 {
2664  DEBTRACE("CommandSetWhileCondition::localExecute");
2665  try
2666  {
2667  Proc* proc = GuiContext::getCurrent()->getProc();
2668  WhileLoop* whileLoop = dynamic_cast<WhileLoop*>(proc->getChildByName(_whileLoop));
2669  InputPort *cond = whileLoop->edGetConditionPort();
2670  _oldValue = atoi(whileLoop->edGetConditionPort()->getAsString().c_str());
2671  bool val = atoi(_value.c_str());
2672  cond->edInit(val);
2673  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(whileLoop));
2674  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[whileLoop];
2675  snode->update(SETVALUE, 0, snode);
2676  return true;
2677  }
2678  catch (Exception& ex)
2679  {
2680  DEBTRACE("CommandSetWhileCondition::localExecute() : " << ex.what());
2681  setErrorMsg(ex);
2682  return false;
2683  }
2684 }
2685 
2686 bool CommandSetWhileCondition::localReverse()
2687 {
2688  DEBTRACE("CommandSetWhileCondition::localReverse");
2689  try
2690  {
2691  Proc* proc = GuiContext::getCurrent()->getProc();
2692  WhileLoop* whileLoop = dynamic_cast<WhileLoop*>(proc->getChildByName(_whileLoop));
2693  InputPort *cond = whileLoop->edGetConditionPort();
2694  cond->edInit(_oldValue);
2695  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(whileLoop));
2696  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[whileLoop];
2697  snode->update(SETVALUE, 0, snode);
2698  return true;
2699  }
2700  catch (Exception& ex)
2701  {
2702  DEBTRACE("CommandSetWhileCondition::localReverse() : " << ex.what());
2703  setErrorMsg(ex);
2704  return false;
2705  }
2706 }
2707 
2708 // ----------------------------------------------------------------------------
2709 
2710 CommandSetForEachBranch::CommandSetForEachBranch(std::string forEach,
2711  std::string value)
2712  : Command(), _forEach(forEach), _value(value)
2713 {
2714  DEBTRACE("CommandSetForEachBranch::CommandSetForEachBranch");
2715  _oldValue = 0;
2716 }
2717 
2718 std::string CommandSetForEachBranch::dump()
2719 {
2720  string ret ="CommandSetForEachBranch " + _forEach + " " + _value;
2721  return ret;
2722 }
2723 
2724 bool CommandSetForEachBranch::localExecute()
2725 {
2726  DEBTRACE("CommandSetForEachBranch::localExecute");
2727  try
2728  {
2729  Proc* proc = GuiContext::getCurrent()->getProc();
2730  Node* node=proc->getChildByName(_forEach);
2731  InputPort *nbBranches = node->getInputPort("nbBranches");
2732  _oldValue = atoi(nbBranches->getAsString().c_str());
2733  int val = atoi(_value.c_str());
2734  nbBranches->edInit(val);
2735  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(nbBranches));
2736  SubjectDataPort *spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(nbBranches)];
2737  spo->update(SETVALUE, 0, spo);
2738  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
2739  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
2740  snode->update(SETVALUE, 0, snode);
2741  return true;
2742  }
2743  catch (Exception& ex)
2744  {
2745  DEBTRACE("CommandSetForEachBranch::localExecute() : " << ex.what());
2746  setErrorMsg(ex);
2747  return false;
2748  }
2749 }
2750 
2751 bool CommandSetForEachBranch::localReverse()
2752 {
2753  DEBTRACE("CommandSetForEachBranch::localReverse");
2754  try
2755  {
2756  Proc* proc = GuiContext::getCurrent()->getProc();
2757  Node* node=proc->getChildByName(_forEach);
2758  InputPort *nbBranches = node->getInputPort("nbBranches");
2759  nbBranches->edInit(_oldValue);
2760  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(nbBranches));
2761  SubjectDataPort *spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(nbBranches)];
2762  spo->update(SETVALUE, 0, spo);
2763  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
2764  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
2765  snode->update(SETVALUE, 0, snode);
2766  return true;
2767  }
2768  catch (Exception& ex)
2769  {
2770  DEBTRACE("CommandSetForEachBranch::localReverse() : " << ex.what());
2771  setErrorMsg(ex);
2772  return false;
2773  }
2774 }
2775 
2776 // ----------------------------------------------------------------------------
2777 
2778 CommandSetAlgo::CommandSetAlgo(std::string optimizer, std::string alglib, std::string symbol)
2779  : Command(), _optimizer(optimizer), _alglib(alglib), _symbol(symbol)
2780 {
2781  DEBTRACE("CommandSetAlgo::CommandSetAlgo" << _optimizer << " " << _alglib << " " << _symbol);
2782  _oldAlglib = "";
2783  _oldSymbol = "";
2784 }
2785 
2786 std::string CommandSetAlgo::dump()
2787 {
2788  string ret ="CommandSetAlgo " + _optimizer + " " + _alglib + " " + _symbol;
2789  return ret;
2790 }
2791 
2792 bool CommandSetAlgo::localExecute()
2793 {
2794  DEBTRACE("CommandSetAlgo::localExecute");
2795  try
2796  {
2797  Proc* proc = GuiContext::getCurrent()->getProc();
2798  OptimizerLoop* loop = dynamic_cast<OptimizerLoop*>(proc->getChildByName(_optimizer));
2799  loop->setAlgorithm(_alglib,_symbol);
2800  _oldAlglib = _alglib;
2801  _oldSymbol = _symbol;
2802  InputPort *port = loop->edGetPortForOutPool();
2803  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(static_cast<DataPort*>(port)));
2804  SubjectDataPort *spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(port)];
2805  spo->update(UPDATE, 0, spo);
2806  OutputPort *oport = loop->edGetSamplePort();
2807  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(static_cast<DataPort*>(oport)));
2808  spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(oport)];
2809  spo->update(UPDATE, 0, spo);
2810  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(loop));
2811  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[loop];
2812  snode->update(SETVALUE, 0, snode);
2813  return true;
2814  }
2815  catch (Exception& ex)
2816  {
2817  DEBTRACE("CommandSetAlgo::localExecute() : " << ex.what());
2818  setErrorMsg(ex);
2819  return false;
2820  }
2821 }
2822 
2823 bool CommandSetAlgo::localReverse()
2824 {
2825  DEBTRACE("CommandSetAlgo::localReverse");
2826  try
2827  {
2828  Proc* proc = GuiContext::getCurrent()->getProc();
2829  OptimizerLoop* loop = dynamic_cast<OptimizerLoop*>(proc->getChildByName(_optimizer));
2830  loop->setAlgorithm(_oldAlglib,_oldSymbol);
2831  InputPort *port = loop->edGetPortForOutPool();
2832  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(static_cast<DataPort*>(port)));
2833  SubjectDataPort *spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(port)];
2834  spo->update(UPDATE, 0, spo);
2835  OutputPort *oport = loop->edGetSamplePort();
2836  YASSERT(GuiContext::getCurrent()->_mapOfSubjectDataPort.count(static_cast<DataPort*>(oport)));
2837  spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(oport)];
2838  spo->update(UPDATE, 0, spo);
2839  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(loop));
2840  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[loop];
2841  snode->update(SETVALUE, 0, snode);
2842  return true;
2843  }
2844  catch (Exception& ex)
2845  {
2846  DEBTRACE("CommandSetAlgo::localReverse() : " << ex.what());
2847  setErrorMsg(ex);
2848  return false;
2849  }
2850  return true;
2851 }
2852 
2853 // ----------------------------------------------------------------------------
2854 
2855 CommandAddLink::CommandAddLink(std::string outNode, std::string outPort, TypeOfElem outPortType,
2856  std::string inNode, std::string inPort, TypeOfElem inPortType, bool control)
2857  : Command(), _outNode(outNode), _outPort(outPort), _outPortType(outPortType),
2858  _inNode(inNode), _inPort(inPort), _inPortType(inPortType), _control(control)
2859 {
2860  DEBTRACE("CommandAddLink::CommandAddLink "<<outNode<<"."<<outPort<<"->"<<inNode<<"."<<inPort<<" "<<control);
2861  _controlCreatedWithDF = false;
2862 }
2863 
2864 std::string CommandAddLink::dump()
2865 {
2866  string s = "false";
2867  if (_control) s = "true";
2868  string ret ="CommandAddLink " + _outNode + " " + _outPort + " " + _inNode + " " + _inPort + " " + s;
2869  return ret;
2870 }
2871 
2872 bool CommandAddLink::localExecute()
2873 {
2874  DEBTRACE("CommandAddLink::localExecute");
2875  DEBTRACE(_outNode<<"."<<_outPort<<"->"<<_inNode<<"."<<_inPort<<" "<<_control);
2876  try
2877  {
2878  Proc* proc = GuiContext::getCurrent()->getProc();
2879  Node* outn = proc->getChildByName(_outNode);
2880  Node* inn = proc->getChildByName(_inNode);
2881  OutPort* outp;
2882  InPort* inp;
2883 
2884  // --- is a control link already existing ?
2885  bool preexistingControl = false;
2886  {
2887  Node* outn2=outn;
2888  Node* inn2=inn;
2889  ComposedNode* father = ComposedNode::getLowestCommonAncestor(outn2,inn2);
2890  if(outn2==father || inn2==father)
2891  preexistingControl = true;
2892  else
2893  {
2894  while(outn2->getFather() != father)
2895  outn2 = outn2->getFather();
2896  while(inn2->getFather() != father)
2897  inn2 = inn2->getFather();
2898  OutGate *ogate = outn2->getOutGate();
2899  InGate *igate = inn2->getInGate();
2900  if (ogate->isAlreadyInSet(igate))
2901  preexistingControl = true;
2902  }
2903  }
2904 
2905  if(_outPortType == OUTPUTPORT)
2906  outp = outn->getOutputPort(_outPort);
2907  else
2908  outp = outn->getOutputDataStreamPort(_outPort);
2909 
2910  if(_inPortType == INPUTPORT)
2911  inp = inn->getInputPort(_inPort);
2912  else
2913  inp = inn->getInputDataStreamPort(_inPort);
2914 
2915  ComposedNode *cla = ComposedNode::getLowestCommonAncestor(outn->getFather(),inn->getFather());
2916  DEBTRACE(cla->getName());
2917  if (dynamic_cast<OutputDataStreamPort*>(outp))
2918  cla->edAddLink(outp,inp);
2919  else if(_control)
2920  cla->edAddDFLink(outp,inp);
2921  else
2922  cla->edAddLink(outp,inp);
2923 
2924  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(cla));
2925  SubjectNode *sub = GuiContext::getCurrent()->_mapOfSubjectNode[cla];
2926  SubjectComposedNode *scla = dynamic_cast<SubjectComposedNode*>(sub);
2927  DEBTRACE(scla->getName());
2928  SubjectNode *sno = GuiContext::getCurrent()->_mapOfSubjectNode[outn];
2929  SubjectNode *sni = GuiContext::getCurrent()->_mapOfSubjectNode[inn];
2930  SubjectDataPort *subOutport = GuiContext::getCurrent()->_mapOfSubjectDataPort[outp];
2931  SubjectDataPort *subInport = GuiContext::getCurrent()->_mapOfSubjectDataPort[inp];
2932  SubjectLink *slink = scla->addSubjectLink(sno, subOutport, sni, subInport);
2933 
2934  // --- if control link, identify the nodes linked and draw the control link if not already existing
2935 
2936  if (_control)
2937  {
2938  ComposedNode* father = ComposedNode::getLowestCommonAncestor(outn,inn);
2939  if(outn==father || inn==father) return true;
2940  while(outn->getFather() != father)
2941  outn = outn->getFather();
2942  while(inn->getFather() != father)
2943  inn = inn->getFather();
2944  OutGate *ogate = outn->getOutGate();
2945  InGate *igate = inn->getInGate();
2946  if (ogate->isAlreadyInSet(igate))
2947  {
2948  if (!preexistingControl)
2949  _controlCreatedWithDF = true;
2950  pair<Node*,Node*> keyLink(outn,inn);
2951  if (!GuiContext::getCurrent()->_mapOfSubjectControlLink.count(keyLink))
2952  {
2953  SubjectNode *sfno = GuiContext::getCurrent()->_mapOfSubjectNode[outn];
2954  SubjectNode *sfni = GuiContext::getCurrent()->_mapOfSubjectNode[inn];
2955  if (!sfno || !sfni) return true;
2956  SubjectControlLink *sclink = scla->addSubjectControlLink(sfno, sfni);
2957  }
2958  }
2959  }
2960  return true;
2961  }
2962  catch (Exception& ex)
2963  {
2964  DEBTRACE("CommandAddLink::localExecute() : " << ex.what());
2965  setErrorMsg(ex);
2966  return false;
2967  }
2968 }
2969 
2970 bool CommandAddLink::localReverse()
2971 {
2972  DEBTRACE("CommandAddLink::localReverse");
2973  try
2974  {
2975  SubjectLink *slink =0;
2976  SubjectControlLink *sclink = 0;
2977  Proc* proc = GuiContext::getCurrent()->getProc();
2978  Node* outn = proc->getChildByName(_outNode);
2979  Node* inn = proc->getChildByName(_inNode);
2980  OutPort* outp;
2981  InPort* inp;
2982  if(_outPortType == OUTPUTPORT)
2983  outp = outn->getOutputPort(_outPort);
2984  else
2985  outp = outn->getOutputDataStreamPort(_outPort);
2986  if(_inPortType == INPUTPORT)
2987  inp = inn->getInputPort(_inPort);
2988  else
2989  inp = inn->getInputDataStreamPort(_inPort);
2990  YASSERT(GuiContext::getCurrent()->_mapOfSubjectLink.count(pair<OutPort*,InPort*>(outp,inp)));
2991  slink = GuiContext::getCurrent()->_mapOfSubjectLink[pair<OutPort*,InPort*>(outp,inp)];
2992  if (_controlCreatedWithDF)
2993  {
2994  YASSERT(GuiContext::getCurrent()->_mapOfSubjectControlLink.count(pair<Node*,Node*>(outn,inn)));
2995  sclink = GuiContext::getCurrent()->_mapOfSubjectControlLink[pair<Node*,Node*>(outn,inn)];
2996  }
2997 
2998  Subject *father = slink->getParent();
2999  Subject::erase(slink);
3000  slink = 0;
3001  if (father)
3002  {
3003  DEBTRACE("REMOVE");
3004  father->select(true);
3005  father->update(REMOVE,0,0);
3006  }
3007  if (!sclink)
3008  return true;
3009  father=sclink->getParent();
3010  Subject::erase(sclink);
3011  sclink = 0;
3012  if (father)
3013  {
3014  DEBTRACE("REMOVE");
3015  father->select(true);
3016  father->update(REMOVE,0,0);
3017  }
3018  return true;
3019  }
3020  catch (Exception& ex)
3021  {
3022  DEBTRACE("CommandAddLink::localReverse(): " << ex.what());
3023  setErrorMsg(ex);
3024  return false;
3025  }
3026 }
3027 
3028 // ----------------------------------------------------------------------------
3029 
3030 CommandAddControlLink::CommandAddControlLink(std::string outNode, std::string inNode)
3031  : Command(), _outNode(outNode), _inNode(inNode)
3032 {
3033  DEBTRACE("CommandAddControlLink::CommandAddControlLink "<<outNode<<"-->>"<<inNode);
3034 }
3035 
3036 std::string CommandAddControlLink::dump()
3037 {
3038  string ret ="CommandAddControlLink " + _outNode + " " + _inNode;
3039  return ret;
3040 }
3041 
3042 bool CommandAddControlLink::localExecute()
3043 {
3044  DEBTRACE("CommandAddControlLink::localExecute");
3045  try
3046  {
3047  Proc* proc = GuiContext::getCurrent()->getProc();
3048  Node* outn = proc;
3049  if (! _outNode.empty())
3050  outn = proc->getChildByName(_outNode);
3051  Node* inn = proc;
3052  if (! _inNode.empty())
3053  inn = proc->getChildByName(_inNode);
3054  ComposedNode *cla = ComposedNode::getLowestCommonAncestor(outn,inn);
3055  DEBTRACE(cla->getName());
3056  bool ret= cla->edAddCFLink(outn,inn);
3057  if(ret==false)
3058  GuiContext::getCurrent()->_lastErrorMessage = "Link already exists";
3059 
3060  cla = ComposedNode::getLowestCommonAncestor(outn->getFather(),
3061  inn->getFather());
3062  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(cla));
3063  SubjectNode *sub = GuiContext::getCurrent()->_mapOfSubjectNode[cla];
3064  SubjectComposedNode *scla = dynamic_cast<SubjectComposedNode*>(sub);
3065  DEBTRACE(scla->getName());
3066  SubjectNode *sno = GuiContext::getCurrent()->_mapOfSubjectNode[outn];
3067  SubjectNode *sni = GuiContext::getCurrent()->_mapOfSubjectNode[inn];
3068  SubjectControlLink *sclink = scla->addSubjectControlLink(sno,sni);
3069  return ret;
3070  }
3071  catch (Exception& ex)
3072  {
3073  DEBTRACE("CommandAddControlLink::localExecute() : " << ex.what());
3074  setErrorMsg(ex);
3075  return false;
3076  }
3077 }
3078 
3079 bool CommandAddControlLink::localReverse()
3080 {
3081  DEBTRACE("CommandAddControlLink::localReverse");
3082  try
3083  {
3084  SubjectControlLink *sclink = 0;
3085  Proc* proc = GuiContext::getCurrent()->getProc();
3086  Node* outn = proc->getChildByName(_outNode);
3087  Node* inn = proc->getChildByName(_inNode);
3088  YASSERT(GuiContext::getCurrent()->_mapOfSubjectControlLink.count(pair<Node*,Node*>(outn,inn)));
3089  sclink = GuiContext::getCurrent()->_mapOfSubjectControlLink[pair<Node*,Node*>(outn,inn)];
3090 
3091  Subject *father=sclink->getParent();
3092  Subject::erase(sclink);
3093  sclink = 0;
3094  if (father)
3095  {
3096  DEBTRACE("REMOVE");
3097  father->select(true);
3098  father->update(REMOVE,0,0);
3099  }
3100  return true;
3101  }
3102  catch (Exception& ex)
3103  {
3104  DEBTRACE("CommandAddControlLink::localReverse(): " << ex.what());
3105  setErrorMsg(ex);
3106  return false;
3107  }
3108 }
3109 
3110 // ----------------------------------------------------------------------------
3111 
3112 CommandAddContainerBase::CommandAddContainerBase(std::string name, std::string refContainer)
3113  : Command(), _name(name), _containerToClone(refContainer), _subcont(0)
3114 {
3115  DEBTRACE("CommandAddContainerBase::CommandAddContainerBase " << name << " " << refContainer);
3116 }
3117 
3118 CommandAddContainerBase::~CommandAddContainerBase()
3119 {
3120 }
3121 
3122 bool CommandAddContainerBase::localExecute()
3123 {
3124  DEBTRACE("CommandAddContainerBase::localExecute");
3125  try
3126  {
3127  Proc* proc = GuiContext::getCurrent()->getProc();
3128  if (proc->containerMap.count(_name))
3129  {
3130  GuiContext::getCurrent()->_lastErrorMessage = "There is already a container with that name";
3131  return false;
3132  }
3133  Container *container(createNewInstance());
3134  if (! _containerToClone.empty())
3135  {
3136  if (proc->containerMap.count(_containerToClone))
3137  {
3138  Container *ref = proc->containerMap[_containerToClone];
3139  YASSERT(ref);
3140  container->setProperties(ref->getProperties());
3141  }
3142  else
3143  {
3144  GuiContext::getCurrent()->_lastErrorMessage = "There is no reference container to clone properties";
3145  return false;
3146  }
3147  }
3148  container->setName(_name);
3149  container->setProc(proc);
3150  proc->containerMap[_name] = container;
3151 
3152  SubjectProc* sproc = GuiContext::getCurrent()->getSubjectProc();
3153  _subcont = sproc->addSubjectContainer(container, _name);
3154  return true;
3155  }
3156  catch (Exception& ex)
3157  {
3158  DEBTRACE("CommandAddContainerBase::localExecute() : " << ex.what());
3159  setErrorMsg(ex);
3160  return false;
3161  }
3162 }
3163 
3164 bool CommandAddContainerBase::localReverse()
3165 {
3166  DEBTRACE("CommandAddContainerBase::localReverse");
3167  try
3168  {
3169  Proc* proc = GuiContext::getCurrent()->getProc();
3170  YASSERT(proc->containerMap.count(_name));
3171  Container *container = proc->containerMap[_name];
3172  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(container));
3173  _subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[container];
3174  YASSERT(!_subcont->isUsed());
3175  SubjectProc* sproc = GuiContext::getCurrent()->getSubjectProc();
3176  sproc->removeSubjectContainer(_subcont);
3177  return true;
3178  }
3179  catch (Exception& ex)
3180  {
3181  DEBTRACE("CommandAddContainer::localExecute() : " << ex.what());
3182  setErrorMsg(ex);
3183  return false;
3184  }
3185 }
3186 
3187 // ----------------------------------------------------------------------------
3188 
3189 CommandAddContainer::CommandAddContainer(std::string name, std::string refContainer):CommandAddContainerBase(name,refContainer)
3190 {
3191 }
3192 
3193 std::string CommandAddContainer::dump()
3194 {
3195  string ret ="CommandAddContainer " + _name + " " + _containerToClone;
3196  return ret;
3197 }
3198 
3199 Container *CommandAddContainer::createNewInstance() const
3200 {
3201  return new SalomeContainer;
3202 }
3203 
3204 // ----------------------------------------------------------------------------
3205 
3206 CommandAddHPContainer::CommandAddHPContainer(std::string name, std::string refContainer):CommandAddContainerBase(name,refContainer)
3207 {
3208 }
3209 
3210 std::string CommandAddHPContainer::dump()
3211 {
3212  string ret ="CommandAddHPContainer " + _name + " " + _containerToClone;
3213  return ret;
3214 }
3215 
3216 Container *CommandAddHPContainer::createNewInstance() const
3217 {
3218  return new SalomeHPContainer;
3219 }
3220 
3221 // ----------------------------------------------------------------------------
3222 
3223 CommandSetNodeProperties::CommandSetNodeProperties(std::string position, std::map<std::string,std::string> properties)
3224  : Command(), _position(position), _properties(properties)
3225 {
3226  DEBTRACE("CommandSetNodeProperties::CommandSetNodeProperties " << position);
3227  _oldProp.clear();
3228 }
3229 
3230 std::string CommandSetNodeProperties::dump()
3231 {
3232  string ret ="CommandSetNodeProperties " + _position;
3233  return ret;
3234 }
3235 
3236 bool CommandSetNodeProperties::localExecute()
3237 {
3238  DEBTRACE("CommandSetNodeProperties::localExecute");
3239  try
3240  {
3241  Proc* proc = GuiContext::getCurrent()->getProc();
3242  Node* node = proc;
3243 
3244  if (!_position.empty()) node = proc->getChildByName(_position);
3245 
3246  if (node)
3247  {
3248  _oldProp = node->getPropertyMap();
3249  node->setProperties(_properties);
3250  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
3251  snode->update(SETVALUE, 0, snode);
3252  return true;
3253  }
3254  GuiContext::getCurrent()->_lastErrorMessage = "node not found: " + _position;
3255  return false;
3256  }
3257  catch (Exception& ex)
3258  {
3259  DEBTRACE("CommandSetNodeProperties::localExecute() : " << ex.what());
3260  setErrorMsg(ex);
3261  return false;
3262  }
3263 }
3264 
3265 bool CommandSetNodeProperties::localReverse()
3266 {
3267  DEBTRACE("CommandSetNodeProperties::localReverse");
3268  try
3269  {
3270  Proc* proc = GuiContext::getCurrent()->getProc();
3271  Node* node = proc;
3272 
3273  if (!_position.empty()) node = proc->getChildByName(_position);
3274 
3275  if (node)
3276  {
3277  node->setProperties(_oldProp);
3278  SubjectNode *snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
3279  snode->update(SETVALUE, 0, snode);
3280  return true;
3281  }
3282  GuiContext::getCurrent()->_lastErrorMessage = "node not found: " + _position;
3283  return false;
3284  }
3285  catch (Exception& ex)
3286  {
3287  DEBTRACE("CommandSetNodeProperties::localReverse() : " << ex.what());
3288  setErrorMsg(ex);
3289  return false;
3290  }
3291 }
3292 
3293 // ----------------------------------------------------------------------------
3294 
3295 CommandSetComponentInstanceProperties::CommandSetComponentInstanceProperties(std::string compoinstance,
3296  std::map<std::string,std::string> properties)
3297  : Command(), _compoinstance(compoinstance), _properties(properties)
3298 {
3299  DEBTRACE("CommandSetComponentInstanceProperties::CommandSetComponentInstanceProperties " << compoinstance);
3300  _oldProp.clear();
3301 }
3302 
3303 std::string CommandSetComponentInstanceProperties::dump()
3304 {
3305  string ret ="CommandSetComponentInstanceProperties " + _compoinstance;
3306  return ret;
3307 }
3308 
3309 bool CommandSetComponentInstanceProperties::localExecute()
3310 {
3311  DEBTRACE("CommandSetComponentInstanceProperties::localExecute");
3312  try
3313  {
3314  Proc* proc = GuiContext::getCurrent()->getProc();
3315  if (proc->componentInstanceMap.count(_compoinstance))
3316  {
3317  ComponentInstance *ref = proc->componentInstanceMap[_compoinstance];
3318  YASSERT(ref);
3319  _oldProp = ref->getProperties();
3320  _oldAnon = ref->isAnonymous();
3321  ref->setProperties(_properties);
3322  ref->setAnonymous(false);
3323  SubjectComponent* subcompo = GuiContext::getCurrent()->_mapOfSubjectComponent[ref];
3324  subcompo->update(SETVALUE, 0, subcompo);
3325  return true;
3326  }
3327  GuiContext::getCurrent()->_lastErrorMessage = "compoinstance not found: " + _compoinstance;
3328  return false;
3329  }
3330  catch (Exception& ex)
3331  {
3332  DEBTRACE("CommandSetComponentInstanceProperties::localExecute() : " << ex.what());
3333  setErrorMsg(ex);
3334  return false;
3335  }
3336 }
3337 
3338 bool CommandSetComponentInstanceProperties::localReverse()
3339 {
3340  DEBTRACE("CommandSetComponentInstanceProperties::localReverse");
3341  try
3342  {
3343  Proc* proc = GuiContext::getCurrent()->getProc();
3344  if (proc->componentInstanceMap.count(_compoinstance))
3345  {
3346  ComponentInstance *ref = proc->componentInstanceMap[_compoinstance];
3347  YASSERT(ref);
3348  ref->setProperties(_oldProp);
3349  ref->setAnonymous(_oldAnon);
3350  SubjectComponent* subcompo = GuiContext::getCurrent()->_mapOfSubjectComponent[ref];
3351  subcompo->update(SETVALUE, 0, subcompo);
3352  return true;
3353  }
3354  GuiContext::getCurrent()->_lastErrorMessage = "compoinstance not found: " + _compoinstance;
3355  return false;
3356  }
3357  catch (Exception& ex)
3358  {
3359  DEBTRACE("CommandSetComponentInstanceProperties::localReverse() : " << ex.what());
3360  setErrorMsg(ex);
3361  return false;
3362  }
3363 }
3364 
3365 // ----------------------------------------------------------------------------
3366 
3367 CommandSetContainerProperties::CommandSetContainerProperties(std::string container,
3368  std::map<std::string,std::string> properties)
3369  : Command(), _container(container), _properties(properties)
3370 {
3371  DEBTRACE("CommandSetContainerProperties::CommandSetContainerProperties " << container);
3372  _oldProp.clear();
3373 }
3374 
3375 std::string CommandSetContainerProperties::dump()
3376 {
3377  string ret ="CommandSetContainerProperties " + _container;
3378  return ret;
3379 }
3380 
3381 bool CommandSetContainerProperties::localExecute()
3382 {
3383  DEBTRACE("CommandSetContainerProperties::localExecute");
3384  try
3385  {
3386  Proc* proc = GuiContext::getCurrent()->getProc();
3387  if (proc->containerMap.count(_container))
3388  {
3389  Container *ref(proc->containerMap[_container]);
3390  YASSERT(ref);
3391  _oldProp = ref->getProperties();
3392  ref->setProperties(_properties);
3393  SubjectContainerBase *scont(GuiContext::getCurrent()->_mapOfSubjectContainer[ref]);
3394  scont->update(UPDATE, 0, scont);
3395  scont->notifyComponentsChange(ASSOCIATE, CONTAINER, scont);
3396  return true;
3397  }
3398  GuiContext::getCurrent()->_lastErrorMessage = "container not found: " + _container;
3399  return false;
3400  }
3401  catch (Exception& ex)
3402  {
3403  DEBTRACE("CommandSetContainerProperties::localExecute() : " << ex.what());
3404  setErrorMsg(ex);
3405  return false;
3406  }
3407 }
3408 
3409 bool CommandSetContainerProperties::localReverse()
3410 {
3411  DEBTRACE("CommandSetContainerProperties::localReverse");
3412  try
3413  {
3414  Proc* proc = GuiContext::getCurrent()->getProc();
3415  if (proc->containerMap.count(_container))
3416  {
3417  Container *ref = proc->containerMap[_container];
3418  YASSERT(ref);
3419  ref->setProperties(_oldProp);
3420  return true;
3421  }
3422  GuiContext::getCurrent()->_lastErrorMessage = "container not found: " + _container;
3423  return false;
3424  }
3425  catch (Exception& ex)
3426  {
3427  DEBTRACE("CommandSetContainerProperties::localReverse() : " << ex.what());
3428  setErrorMsg(ex);
3429  return false;
3430  }
3431 }
3432 
3433 // ----------------------------------------------------------------------------
3434 
3435 CommandSetDSPortProperties::CommandSetDSPortProperties(std::string node, std::string port, bool isInport,
3436  std::map<std::string,std::string> properties)
3437  : Command(), _nodeName(node), _portName(port), _isInport(isInport), _properties(properties)
3438 {
3439  DEBTRACE("CommandSetDSPortProperties::CommandSetDSPortProperties " << node << "." << port << " " << isInport);
3440  _oldProp.clear();
3441 }
3442 
3443 std::string CommandSetDSPortProperties::dump()
3444 {
3445  string s = "false";
3446  if (_isInport) s = "true";
3447  string ret ="CommandSetDSPortProperties " + _nodeName + " " + _portName + " " + s;
3448  return ret;
3449 }
3450 
3451 bool CommandSetDSPortProperties::localExecute()
3452 {
3453  DEBTRACE("CommandSetDSPortProperties::localExecute");
3454  try
3455  {
3456  Proc* proc = GuiContext::getCurrent()->getProc();
3457  Node* node = proc->getChildByName(_nodeName);
3458  DataStreamPort* DSPort = 0;
3459  if (_isInport)
3460  DSPort = node->getInputDataStreamPort(_portName);
3461  else
3462  DSPort = node->getOutputDataStreamPort(_portName);
3463  _oldProp = DSPort->getProperties();
3464  DSPort->setProperties(_properties);
3465  return true;
3466  }
3467  catch (Exception& ex)
3468  {
3469  DEBTRACE("CommandSetDSPortProperties::localExecute() : " << ex.what());
3470  setErrorMsg(ex);
3471  return false;
3472  }
3473 }
3474 
3475 bool CommandSetDSPortProperties::localReverse()
3476 {
3477  DEBTRACE("CommandSetDSPortProperties::localReverse");
3478  try
3479  {
3480  Proc* proc = GuiContext::getCurrent()->getProc();
3481  Node* node = proc->getChildByName(_nodeName);
3482  DataStreamPort* DSPort = 0;
3483  if (_isInport)
3484  DSPort = node->getInputDataStreamPort(_portName);
3485  else
3486  DSPort = node->getOutputDataStreamPort(_portName);
3487  DSPort->setProperties(_oldProp);
3488  return true;
3489  }
3490  catch (Exception& ex)
3491  {
3492  DEBTRACE("CommandSetDSPortProperties::localReverse() : " << ex.what());
3493  setErrorMsg(ex);
3494  return false;
3495  }
3496 }
3497 
3498 // ----------------------------------------------------------------------------
3499 
3500 CommandSetLinkProperties::CommandSetLinkProperties(std::string startnode, std::string startport,
3501  std::string endnode, std::string endport,
3502  std::map<std::string,std::string> properties)
3503  : Command(), _startNodeName(startnode), _startPortName(startport),
3504  _endNodeName(endnode), _endPortName(endport),
3505  _properties(properties)
3506 {
3507  DEBTRACE("CommandSetLinkProperties::CommandSetLinkProperties " );
3508  _oldProp.clear();
3509 }
3510 
3511 std::string CommandSetLinkProperties::dump()
3512 {
3513  string ret ="CommandSetLinkProperties " + _startNodeName + " " + _startPortName + " " + _endNodeName + " " + _endPortName;
3514  return ret;
3515 }
3516 
3517 bool CommandSetLinkProperties::localExecute()
3518 {
3519  DEBTRACE("CommandSetLinkProperties::localExecute");
3520  try
3521  {
3522  Proc* proc = GuiContext::getCurrent()->getProc();
3523  Node* node;
3524  InputDataStreamPort* inDSPort = 0;
3525  OutputDataStreamPort* outDSPort = 0;
3526 
3527  node = proc->getChildByName(_startNodeName);
3528  outDSPort = node->getOutputDataStreamPort(_startPortName);
3529  outDSPort->setProperties(_properties);
3530 
3531  node = proc->getChildByName(_endNodeName);
3532  inDSPort = node->getInputDataStreamPort(_endPortName);
3533  _oldProp = inDSPort->getProperties();
3534  inDSPort->setProperties(_properties);
3535 
3536  std::pair<OutPort*,InPort*> keymap = std::pair<OutPort*,InPort*>(outDSPort,inDSPort);
3537  SubjectLink* subject = GuiContext::getCurrent()->_mapOfSubjectLink[keymap];
3538  subject->update(SETVALUE, 0, subject);
3539  return true;
3540  }
3541  catch (Exception& ex)
3542  {
3543  DEBTRACE("CommandSetDSPortProperties::localExecute() : " << ex.what());
3544  setErrorMsg(ex);
3545  return false;
3546  }
3547 }
3548 
3549 bool CommandSetLinkProperties::localReverse()
3550 {
3551  DEBTRACE("CommandSetLinkProperties::localReverse");
3552  try
3553  {
3554  Proc* proc = GuiContext::getCurrent()->getProc();
3555  Node* node;
3556  InputDataStreamPort* inDSPort = 0;
3557  OutputDataStreamPort* outDSPort = 0;
3558 
3559  node = proc->getChildByName(_startNodeName);
3560  outDSPort = node->getOutputDataStreamPort(_startPortName);
3561  outDSPort->setProperties(_properties);
3562 
3563  node = proc->getChildByName(_endNodeName);
3564  inDSPort = node->getInputDataStreamPort(_endPortName);
3565  inDSPort->setProperties(_oldProp);
3566 
3567  std::pair<OutPort*,InPort*> keymap = std::pair<OutPort*,InPort*>(outDSPort,inDSPort);
3568  SubjectLink* subject = GuiContext::getCurrent()->_mapOfSubjectLink[keymap];
3569  subject->update(SETVALUE, 0, subject);
3570  return true;
3571  }
3572  catch (Exception& ex)
3573  {
3574  DEBTRACE("CommandSetDSPortProperties::localReverse() : " << ex.what());
3575  setErrorMsg(ex);
3576  return false;
3577  }
3578 }
3579 
3580 // ----------------------------------------------------------------------------
3581 
3582 CommandSetFuncNodeFunctionName::CommandSetFuncNodeFunctionName(std::string node, std::string funcName)
3583  : Command(), _nodeName(node), _funcName(funcName)
3584 {
3585  DEBTRACE("CommandSetFuncNodeFunctionName::CommandSetFuncNodeFunctionName " << node << " " <<funcName);
3586  _oldName.clear();
3587 }
3588 
3589 std::string CommandSetFuncNodeFunctionName::dump()
3590 {
3591  string ret ="CommandSetFuncNodeFunctionName " + _nodeName + " " + _funcName;
3592  return ret;
3593 }
3594 
3595 bool CommandSetFuncNodeFunctionName::localExecute()
3596 {
3597  DEBTRACE("CommandSetFuncNodeFunctionName::localExecute");
3598  try
3599  {
3600  Proc* proc = GuiContext::getCurrent()->getProc();
3601  Node* node = proc->getChildByName(_nodeName);
3602  if (_funcName.empty())
3603  {
3604  GuiContext::getCurrent()->_lastErrorMessage = "InlineFuncNode function name empty: " + _nodeName;
3605  return false;
3606  }
3607  if (YACS::ENGINE::InlineFuncNode* funcNode = dynamic_cast<YACS::ENGINE::InlineFuncNode*>(node))
3608  {
3609  _oldName = funcNode->getFname();
3610  funcNode->setFname(_funcName);
3611  return true;
3612  }
3613  else
3614  {
3615  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineFuncNode: " + _nodeName;
3616  return false;
3617  }
3618  }
3619  catch (Exception& ex)
3620  {
3621  DEBTRACE("CommandSetFuncNodeFunctionName::localExecute() : " << ex.what());
3622  setErrorMsg(ex);
3623  return false;
3624  }
3625 }
3626 
3627 bool CommandSetFuncNodeFunctionName::localReverse()
3628 {
3629  DEBTRACE("CommandSetFuncNodeFunctionName::localReverse");
3630  try
3631  {
3632  Proc* proc = GuiContext::getCurrent()->getProc();
3633  Node* node = proc->getChildByName(_nodeName);
3634  if (YACS::ENGINE::InlineFuncNode* funcNode = dynamic_cast<YACS::ENGINE::InlineFuncNode*>(node))
3635  {
3636  funcNode->setFname(_oldName);
3637  return true;
3638  }
3639  else
3640  {
3641  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineFuncNode: " + _nodeName;
3642  return false;
3643  }
3644  }
3645  catch (Exception& ex)
3646  {
3647  DEBTRACE("CommandSetFuncNodeFunctionName::localReverse() : " << ex.what());
3648  setErrorMsg(ex);
3649  return false;
3650  }
3651 }
3652 
3653 // ----------------------------------------------------------------------------
3654 
3655 CommandSetInlineNodeScript::CommandSetInlineNodeScript(std::string node, std::string script)
3656  : Command(), _nodeName(node), _script(script)
3657 {
3658  DEBTRACE("CommandSetInlineNodeScript::CommandSetInlineNodeScript " << node << " " <<script);
3659  _oldScript.clear();
3660 }
3661 
3662 std::string CommandSetInlineNodeScript::dump()
3663 {
3664  string ret ="CommandSetInlineNodeScript " + _nodeName;
3665  return ret;
3666 }
3667 
3668 bool CommandSetInlineNodeScript::localExecute()
3669 {
3670  DEBTRACE("CommandSetInlineNodeScript::localExecute");
3671  try
3672  {
3673  Proc* proc = GuiContext::getCurrent()->getProc();
3674  Node* node = proc->getChildByName(_nodeName);
3675  if (_script.empty())
3676  {
3677  GuiContext::getCurrent()->_lastErrorMessage = "InlineNode script empty: " + _nodeName;
3678  return false;
3679  }
3680  if (YACS::ENGINE::InlineNode* inlineNode = dynamic_cast<YACS::ENGINE::InlineNode*>(node))
3681  {
3682  _oldScript = inlineNode->getScript();
3683  inlineNode->setScript(_script);
3684  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
3685  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
3686  snode->update(SYNCHRO,0,snode);
3687  return true;
3688  }
3689  else
3690  {
3691  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineNode: " + _nodeName;
3692  return false;
3693  }
3694  }
3695  catch (Exception& ex)
3696  {
3697  DEBTRACE("CommandSetInlineNodeScript::localExecute() : " << ex.what());
3698  setErrorMsg(ex);
3699  return false;
3700  }
3701 }
3702 
3703 bool CommandSetInlineNodeScript::localReverse()
3704 {
3705  DEBTRACE("CommandSetInlineNodeScript::localReverse");
3706  try
3707  {
3708  Proc* proc = GuiContext::getCurrent()->getProc();
3709  Node* node = proc->getChildByName(_nodeName);
3710  if (YACS::ENGINE::InlineNode* inlineNode = dynamic_cast<YACS::ENGINE::InlineNode*>(node))
3711  {
3712  inlineNode->setScript(_oldScript);
3713  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
3714  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
3715  snode->update(SYNCHRO,0,snode);
3716  return true;
3717  }
3718  else
3719  {
3720  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineNode: " + _nodeName;
3721  return false;
3722  }
3723  }
3724  catch (Exception& ex)
3725  {
3726  DEBTRACE("CommandSetInlineNodeScript::localExecute() : " << ex.what());
3727  setErrorMsg(ex);
3728  return false;
3729  }
3730 }
3731 
3732 // ----------------------------------------------------------------------------
3733 
3734 CommandAddComponentInstance::CommandAddComponentInstance(std::string compoName,
3735  std::string container,
3736  std::string name)
3737  : Command(), _compoName(compoName), _container(container), _name(name), _subcompo(0)
3738 {
3739  DEBTRACE("CommandAddComponentInstance::CommandAddComponentInstance " <<_compoName);
3740 }
3741 
3742 std::string CommandAddComponentInstance::dump()
3743 {
3744  string ret ="CommandAddComponentInstance " + _compoName + " " + _container + " " + _name;
3745  return ret;
3746 }
3747 
3748 bool CommandAddComponentInstance::localExecute()
3749 {
3750  DEBTRACE("CommandAddComponentInstance::localExecute "<< _compoName << " " << _container << " " << _name);
3751  try
3752  {
3753  Proc* proc = GuiContext::getCurrent()->getProc();
3754  YASSERT(proc->containerMap.count(_container));
3755  Container *cont = proc->containerMap[_container];
3756  ComponentInstance* compoInst = new SalomeComponent(_compoName);
3757  compoInst->setContainer(cont);
3758  proc->addComponentInstance(compoInst, _name);
3759 
3760  SubjectProc *sproc = GuiContext::getCurrent()->getSubjectProc();
3761  _subcompo = sproc->addSubjectComponent(compoInst);
3762  _name = compoInst->getInstanceName();
3763  DEBTRACE(_name);
3764  return true;
3765  }
3766  catch (Exception& ex)
3767  {
3768  DEBTRACE("CommandAddComponentInstance::localExecute() : " << ex.what());
3769  setErrorMsg(ex);
3770  return false;
3771  }
3772 }
3773 
3774 bool CommandAddComponentInstance::localReverse()
3775 {
3776  DEBTRACE("CommandAddComponentInstance::localReverse");
3777  try
3778  {
3779  Proc* proc = GuiContext::getCurrent()->getProc();
3780  YASSERT(proc->componentInstanceMap.count(_name));
3781  ComponentInstance *compo = proc->componentInstanceMap[_name];
3782  YASSERT(GuiContext::getCurrent()->_mapOfSubjectComponent.count(compo));
3783  _subcompo = GuiContext::getCurrent()->_mapOfSubjectComponent[compo];
3784  YASSERT(!_subcompo->hasServices());
3785  Container *cont = compo->getContainer();
3786  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(cont));
3787  SubjectContainerBase *subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[cont];
3788  subcont->detachComponent(_subcompo);
3789  GuiContext::getCurrent()->_mapOfSubjectComponent.erase(compo);
3790  proc->removeComponentInstance(compo);
3791  return true;
3792  }
3793  catch (Exception& ex)
3794  {
3795  DEBTRACE("CommandAddComponentInstance::localReverse() : " << ex.what());
3796  setErrorMsg(ex);
3797  return false;
3798  }
3799 }
3800 
3801 // ----------------------------------------------------------------------------
3802 CommandSetExecutionMode::CommandSetExecutionMode(std::string nodeName, std::string mode)
3803  : Command(), _mode(mode),_nodeName(nodeName)
3804 {
3805  DEBTRACE("CommandSetExecutionMode::CommandSetExecutionMode " << nodeName << " " << mode);
3806  _oldmode = "local";
3807 }
3808 
3809 std::string CommandSetExecutionMode::dump()
3810 {
3811  string ret ="CommandSetExecutionMode " + _mode + " " + _nodeName;
3812  return ret;
3813 }
3814 
3815 bool CommandSetExecutionMode::localExecute()
3816 {
3817  DEBTRACE("CommandSetExecutionMode::localExecute");
3818  try
3819  {
3820  Proc* proc = GuiContext::getCurrent()->getProc();
3821  Node* node = proc->getChildByName(_nodeName);
3822  if (YACS::ENGINE::InlineNode* pyNode = dynamic_cast<YACS::ENGINE::InlineNode*>(node))
3823  {
3824  _oldmode = pyNode->getExecutionMode();
3825  pyNode->setExecutionMode(_mode);
3826  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[pyNode];
3827  snode->update(UPDATE, 0, 0);
3828  return true;
3829  }
3830  else
3831  {
3832  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineNode: " + _nodeName;
3833  return false;
3834  }
3835  }
3836  catch (Exception& ex)
3837  {
3838  DEBTRACE("CommandSetExecutionMode::localExecute() : " << ex.what());
3839  setErrorMsg(ex);
3840  return false;
3841  }
3842 }
3843 
3844 bool CommandSetExecutionMode::localReverse()
3845 {
3846  DEBTRACE("CommandSetExecutionMode::localReverse");
3847  try
3848  {
3849  if (_oldmode == _mode) return true;
3850  Proc* proc = GuiContext::getCurrent()->getProc();
3851  Node* node = proc->getChildByName(_nodeName);
3852  if (YACS::ENGINE::InlineNode* pyNode = dynamic_cast<YACS::ENGINE::InlineNode*>(node))
3853  {
3854  pyNode->setExecutionMode(_oldmode);
3855  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[pyNode];
3856  snode->update(UPDATE, 0, 0);
3857  return true;
3858  }
3859  else
3860  {
3861  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineNode: " + _nodeName;
3862  return false;
3863  }
3864  }
3865  catch (Exception& ex)
3866  {
3867  DEBTRACE("CommandSetExecutionMode::localReverse() : " << ex.what());
3868  setErrorMsg(ex);
3869  return false;
3870  }
3871  return true;
3872 }
3873 
3874 
3875 // ----------------------------------------------------------------------------
3876 
3877 CommandSetContainer::CommandSetContainer(std::string nodeName, std::string container)
3878  : Command(), _container(container),_nodeName(nodeName)
3879 {
3880  DEBTRACE("CommandSetContainer::CommandSetContainer " << nodeName << " " << container);
3881  _oldcont = "DefaultContainer";
3882 }
3883 
3884 std::string CommandSetContainer::dump()
3885 {
3886  string ret ="CommandSetContainer " + _container + " " + _nodeName;
3887  return ret;
3888 }
3889 
3890 bool CommandSetContainer::localExecute()
3891 {
3892  DEBTRACE("CommandSetContainer::localExecute");
3893  try
3894  {
3895  Proc* proc = GuiContext::getCurrent()->getProc();
3896  if (proc->containerMap.count(_container))
3897  {
3898  Container *cont = proc->containerMap[_container];
3899  Node* node = proc->getChildByName(_nodeName);
3900  if (YACS::ENGINE::InlineNode* pyNode = dynamic_cast<YACS::ENGINE::InlineNode*>(node))
3901  {
3902  Container* oldcont = pyNode->getContainer();
3903  if(oldcont)
3904  _oldcont = pyNode->getContainer()->getName();
3905  pyNode->setContainer(cont);
3906  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[pyNode];
3907  SubjectContainerBase *subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[cont];
3908  snode->update(ASSOCIATE, 0, subcont);
3909  return true;
3910  }
3911  else
3912  {
3913  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineNode: " + _nodeName;
3914  return false;
3915  }
3916  }
3917  else
3918  GuiContext::getCurrent()->_lastErrorMessage = "Container not found: " + _container;
3919  return false;
3920  }
3921  catch (Exception& ex)
3922  {
3923  DEBTRACE("CommandSetContainer::localExecute() : " << ex.what());
3924  setErrorMsg(ex);
3925  return false;
3926  }
3927 }
3928 
3929 bool CommandSetContainer::localReverse()
3930 {
3931  DEBTRACE("CommandSetContainer::localReverse");
3932  try
3933  {
3934  if (_oldcont == _container) return true;
3935  Proc* proc = GuiContext::getCurrent()->getProc();
3936  if (proc->containerMap.count(_oldcont))
3937  {
3938  Container *cont = proc->containerMap[_oldcont];
3939  Node* node = proc->getChildByName(_nodeName);
3940  if (YACS::ENGINE::InlineNode* pyNode = dynamic_cast<YACS::ENGINE::InlineNode*>(node))
3941  {
3942  pyNode->setContainer(cont);
3943  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[pyNode];
3944  SubjectContainerBase *subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[cont];
3945  snode->update(ASSOCIATE, 0, subcont);
3946  return true;
3947  }
3948  else
3949  {
3950  GuiContext::getCurrent()->_lastErrorMessage = "node is not an InlineNode: " + _nodeName;
3951  return false;
3952  }
3953  }
3954  else
3955  GuiContext::getCurrent()->_lastErrorMessage = "Container not found: " + _oldcont;
3956  return false;
3957  }
3958  catch (Exception& ex)
3959  {
3960  DEBTRACE("CommandSetContainer::localReverse() : " << ex.what());
3961  setErrorMsg(ex);
3962  return false;
3963  }
3964  return true;
3965 }
3966 
3967 
3968 
3969 // ----------------------------------------------------------------------------
3970 
3971 CommandAssociateComponentToContainer::CommandAssociateComponentToContainer(std::string instanceName,
3972  std::string container)
3973  : Command(), _container(container),_instanceName(instanceName)
3974 {
3975  DEBTRACE("CommandAssociateComponentToContainer::CommandAssociateComponentToContainer " << instanceName << " " << container);
3976  _oldcont = "DefaultContainer";
3977 }
3978 
3979 std::string CommandAssociateComponentToContainer::dump()
3980 {
3981  string ret ="CommandAssociateComponentToContainer " + _container + " " + _instanceName;
3982  return ret;
3983 }
3984 
3985 bool CommandAssociateComponentToContainer::localExecute()
3986 {
3987  DEBTRACE("CommandAssociateComponentToContainer::localExecute");
3988  try
3989  {
3990  Proc* proc = GuiContext::getCurrent()->getProc();
3991  if (proc->containerMap.count(_container))
3992  {
3993  Container *cont = proc->containerMap[_container];
3994  if (proc->componentInstanceMap.count(_instanceName))
3995  {
3996  DEBTRACE(_instanceName);
3997  ComponentInstance *compo = proc->componentInstanceMap[_instanceName];
3998  if (compo->getContainer())
3999  _oldcont = compo->getContainer()->getName();
4000  compo->setContainer(cont);
4001 
4002  YASSERT(GuiContext::getCurrent()->_mapOfSubjectComponent.count(compo));
4003  SubjectComponent *scomp = GuiContext::getCurrent()->_mapOfSubjectComponent[compo];
4004  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(cont));
4005  SubjectContainerBase *subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[cont];
4006  scomp->addSubjectReference(subcont);
4007  if (scomp->_subRefContainer)
4008  subcont->moveComponent(scomp->_subRefContainer);
4009  else
4010  scomp->_subRefContainer = subcont->attachComponent(scomp);
4011  scomp->notifyServicesChange(ASSOCIATE, CONTAINER, subcont);
4012  return true;
4013  }
4014  else
4015  GuiContext::getCurrent()->_lastErrorMessage = "Component instance not found: " + _instanceName;
4016  }
4017  else
4018  GuiContext::getCurrent()->_lastErrorMessage = "Container not found: " + _container;
4019  return false;
4020  }
4021  catch (Exception& ex)
4022  {
4023  DEBTRACE("CommandAssociateComponentToContainer::localExecute() : " << ex.what());
4024  setErrorMsg(ex);
4025  return false;
4026  }
4027 }
4028 
4029 bool CommandAssociateComponentToContainer::localReverse()
4030 {
4031  DEBTRACE("CommandAssociateComponentToContainer::localReverse");
4032  try
4033  {
4034  if (_oldcont == _container) return true;
4035  Proc* proc = GuiContext::getCurrent()->getProc();
4036  if (proc->containerMap.count(_oldcont))
4037  {
4038  Container *cont = proc->containerMap[_oldcont];
4039  if (proc->componentInstanceMap.count(_instanceName))
4040  {
4041  DEBTRACE(_instanceName);
4042  ComponentInstance *compo = proc->componentInstanceMap[_instanceName];
4043  compo->setContainer(cont);
4044 
4045  YASSERT(GuiContext::getCurrent()->_mapOfSubjectComponent.count(compo));
4046  SubjectComponent *scomp = GuiContext::getCurrent()->_mapOfSubjectComponent[compo];
4047  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(cont));
4048  SubjectContainerBase *subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[cont];
4049  scomp->addSubjectReference(subcont);
4050  if (scomp->_subRefContainer)
4051  subcont->moveComponent(scomp->_subRefContainer);
4052  else
4053  scomp->_subRefContainer = subcont->attachComponent(scomp);
4054  scomp->notifyServicesChange(ASSOCIATE, CONTAINER, subcont);
4055  return true;
4056  }
4057  else
4058  GuiContext::getCurrent()->_lastErrorMessage = "Component instance not found: " + _instanceName;
4059  }
4060  else
4061  GuiContext::getCurrent()->_lastErrorMessage = "Container not found: " + _oldcont;
4062  return false;
4063  }
4064  catch (Exception& ex)
4065  {
4066  DEBTRACE("CommandAssociateComponentToContainer::localReverse() : " << ex.what());
4067  setErrorMsg(ex);
4068  return false;
4069  }
4070  return true;
4071 }
4072 
4073 // ----------------------------------------------------------------------------
4074 
4075 CommandAssociateServiceToComponent::CommandAssociateServiceToComponent(std::string service,
4076  std::string instanceName)
4077  : Command(), _service(service), _instanceName(instanceName)
4078 {
4079  DEBTRACE("CommandAssociateServiceToComponent::CommandAssociateServiceToComponent "<< service << " " <<instanceName);
4080  _oldInstance="";
4081 }
4082 
4083 std::string CommandAssociateServiceToComponent::dump()
4084 {
4085  string ret ="CommandAssociateServiceToComponent " + _service + " " + _instanceName;
4086  return ret;
4087 }
4088 
4089 bool CommandAssociateServiceToComponent::localExecute()
4090 {
4091  DEBTRACE("CommandAssociateServiceToComponent::localExecute");
4092  try
4093  {
4094  Proc* proc = GuiContext::getCurrent()->getProc();
4095  if (_service == proc->getName()) return false; // proc is not an elementary node
4096  Node* node = proc->getChildByName(_service);
4097  if (ServiceNode *service = dynamic_cast<ServiceNode*>(node))
4098  {
4099  if (proc->componentInstanceMap.count(_instanceName))
4100  {
4101  DEBTRACE(_instanceName);
4102  ComponentInstance *compo = proc->componentInstanceMap[_instanceName];
4103  service->setComponent(compo);
4104 
4105  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(service));
4106  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[service];
4107  SubjectServiceNode *ssnode = dynamic_cast<SubjectServiceNode*>(snode);
4108  YASSERT(ssnode);
4109  YASSERT(GuiContext::getCurrent()->_mapOfSubjectComponent.count(compo));
4110  SubjectComponent *subCompo = GuiContext::getCurrent()->_mapOfSubjectComponent[compo];
4111  snode->addSubjectReference(subCompo);
4112  if (ssnode->_subRefComponent)
4113  {
4114  SubjectComponent* oldcomp = dynamic_cast<SubjectComponent*>(ssnode->_subRefComponent->getParent());
4115  YASSERT(oldcomp);
4116  _oldInstance = oldcomp->getName();
4117  _oldcont = oldcomp->getComponent()->getContainer()->getName();
4118  subCompo->moveService(ssnode->_subRefComponent);
4119  }
4120  else
4121  ssnode->_subRefComponent = subCompo->attachService(ssnode);
4122 
4123  return true;
4124  }
4125  else
4126  GuiContext::getCurrent()->_lastErrorMessage = "Component instance not found: " + _instanceName;
4127  }
4128  else
4129  GuiContext::getCurrent()->_lastErrorMessage = "Node is not a service node: " + _service;
4130  return false;
4131  }
4132  catch (Exception& ex)
4133  {
4134  DEBTRACE("CommandAssociateServiceToComponent::localExecute() : " << ex.what());
4135  setErrorMsg(ex);
4136  return false;
4137  }
4138 }
4139 
4140 bool CommandAssociateServiceToComponent::localReverse()
4141 {
4142  DEBTRACE("CommandAssociateServiceToComponent::localReverse");
4143  try
4144  {
4145  Proc* proc = GuiContext::getCurrent()->getProc();
4146  if (_service == proc->getName()) return false; // proc is not an elementary node
4147  Node* node = proc->getChildByName(_service);
4148  if (ServiceNode *service = dynamic_cast<ServiceNode*>(node))
4149  {
4150  ComponentInstance *compo;
4151  if (!proc->componentInstanceMap.count(_oldInstance))
4152  {
4153  //component instance does not exist anymore recreate it
4154  ComponentInstance *oldcompo = service->getComponent();
4155  compo = oldcompo->cloneAlways();
4156  compo->setName(_oldInstance);
4157  proc->addComponentInstance(compo, _oldInstance);
4158  Container *cont = proc->containerMap[_oldcont];
4159  compo->setContainer(cont);
4160  SubjectProc *sproc = GuiContext::getCurrent()->getSubjectProc();
4161  sproc->addSubjectComponent(compo);
4162  }
4163  else
4164  {
4165  compo = proc->componentInstanceMap[_oldInstance];
4166  }
4167 
4168  DEBTRACE(_oldInstance);
4169  service->setComponent(compo);
4170 
4171  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(service));
4172  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[service];
4173  SubjectServiceNode *ssnode = dynamic_cast<SubjectServiceNode*>(snode);
4174  YASSERT(ssnode);
4175  YASSERT(GuiContext::getCurrent()->_mapOfSubjectComponent.count(compo));
4176  SubjectComponent *subCompo = GuiContext::getCurrent()->_mapOfSubjectComponent[compo];
4177  snode->addSubjectReference(subCompo);
4178  if (ssnode->_subRefComponent)
4179  subCompo->moveService(ssnode->_subRefComponent);
4180  else
4181  ssnode->_subRefComponent = subCompo->attachService(ssnode);
4182 
4183  return true;
4184  }
4185  else
4186  GuiContext::getCurrent()->_lastErrorMessage = "Node is not a service node: " + _service;
4187  return false;
4188  }
4189  catch (Exception& ex)
4190  {
4191  DEBTRACE("CommandAssociateServiceToComponent::localReverse() : " << ex.what());
4192  setErrorMsg(ex);
4193  return false;
4194  }
4195 }
4196 
4197 // ----------------------------------------------------------------------------
4198 
4199 CommandAddComponentFromCatalog::CommandAddComponentFromCatalog(YACS::ENGINE::Catalog* catalog,
4200  std::string position,
4201  std::string compo,
4202  std::string service)
4203  : Command(), _catalog(catalog), _position(position), _compo(compo), _service(service)
4204 {
4205  DEBTRACE("CommandAddComponentFromCatalog::CommandAddComponentFromCatalog " << position << " " << compo << " " << service);
4206  _nameInProc="";
4207  _createdInstance = false;
4208 }
4209 
4210 std::string CommandAddComponentFromCatalog::dump()
4211 {
4212  string ret = "CommandAddComponentFromCatalog " + _position + " " + _compo + " " + _service;
4213  return ret;
4214 }
4215 
4216 bool CommandAddComponentFromCatalog::localExecute()
4217 {
4218  DEBTRACE("CommandAddComponentFromCatalog::localExecute");
4219  try
4220  {
4221  DEBTRACE("_nameInProc: " << _nameInProc);
4222  Proc* proc = GuiContext::getCurrent()->getProc();
4223  Node* node = proc;
4224  if (!_position.empty()) node = proc->getChildByName(_position);
4225  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
4226  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
4227  SubjectServiceNode *ssnode = dynamic_cast<SubjectServiceNode*>(snode);
4228  YASSERT(ssnode);
4229  if (_catalog->_componentMap.count(_compo))
4230  {
4231  YACS::ENGINE::ComponentDefinition* compodef = _catalog->_componentMap[_compo];
4232  if (compodef->_serviceMap.count(_service))
4233  {
4234  Proc* proc = GuiContext::getCurrent()->getProc();
4235  ComponentInstance *instance =ssnode->_serviceNode->getComponent();
4236  YASSERT(instance);
4237  SubjectComponent* subCompo = 0;
4238  _createdInstance = false;
4239  if(!GuiContext::getCurrent()->_mapOfSubjectComponent.count(instance))
4240  {
4241  _createdInstance = true;
4242  //automatic rename of the component instance by the proc on first execute
4243  DEBTRACE("name given to proc:" << _nameInProc);
4244  proc->addComponentInstance(instance,_nameInProc, true);
4245  _nameInProc= instance->getInstanceName();
4246  DEBTRACE("name given by proc:" << _nameInProc);
4247  subCompo = GuiContext::getCurrent()->getSubjectProc()->addSubjectComponent(instance);
4248  }
4249  else
4250  subCompo = GuiContext::getCurrent()->_mapOfSubjectComponent[instance];
4251  YASSERT(subCompo);
4252  ssnode->addSubjectReference(subCompo);
4253  YASSERT(! ssnode->_subRefComponent);
4254  ssnode->_subRefComponent = subCompo->attachService(ssnode);
4255  }
4256  }
4257  return true;
4258  }
4259  catch (Exception& ex)
4260  {
4261  DEBTRACE("CommandAddComponentFromCatalog::localExecute() : " << ex.what());
4262  setErrorMsg(ex);
4263  return false;
4264  }
4265 }
4266 
4267 bool CommandAddComponentFromCatalog::localReverse()
4268 {
4269  DEBTRACE("CommandAddComponentFromCatalog::localReverse");
4270  try
4271  {
4272  Proc* proc = GuiContext::getCurrent()->getProc();
4273  Node* node = proc;
4274  if (!_position.empty()) node = proc->getChildByName(_position);
4275  YASSERT(GuiContext::getCurrent()->_mapOfSubjectNode.count(node));
4276  SubjectNode* snode = GuiContext::getCurrent()->_mapOfSubjectNode[node];
4277  SubjectServiceNode *ssnode = dynamic_cast<SubjectServiceNode*>(snode);
4278  YASSERT(ssnode);
4279 
4280  DEBTRACE("_nameInProc: " << _nameInProc);
4281  YASSERT(proc->componentInstanceMap.count(_nameInProc));
4282  ComponentInstance *compo = proc->componentInstanceMap[_nameInProc];
4283  YASSERT(GuiContext::getCurrent()->_mapOfSubjectComponent.count(compo));
4284  SubjectComponent *subCompo = GuiContext::getCurrent()->_mapOfSubjectComponent[compo];
4285 
4286  subCompo->detachService(ssnode);
4287  if (subCompo->hasServices())
4288  throw YACS::Exception("Component instance with services attached, not removed");
4289  Container *cont = compo->getContainer();
4290  YASSERT(GuiContext::getCurrent()->_mapOfSubjectContainer.count(cont));
4291  SubjectContainerBase *subcont = GuiContext::getCurrent()->_mapOfSubjectContainer[cont];
4292  subcont->detachComponent(subCompo);
4293  //remove componentInstance from proc, from context
4294  if (_createdInstance)
4295  {
4296  GuiContext::getCurrent()->_mapOfSubjectComponent.erase(compo);
4297  proc->removeComponentInstance(compo);
4298  }
4299  DEBTRACE("_nameInProc: " << _nameInProc);
4300  return true;
4301  }
4302  catch (Exception& ex)
4303  {
4304  DEBTRACE("CommandAddComponentFromCatalog::localReverse() : " << ex.what());
4305  setErrorMsg(ex);
4306  return false;
4307  }
4308 }
4309