Version: 8.3.0
SchemaComposedNodeItem.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 
22 #include "Resource.hxx"
23 #include "SchemaComposedNodeItem.hxx"
24 #include "SchemaNodeItem.hxx"
25 #include "SchemaInPortItem.hxx"
26 #include "SchemaOutPortItem.hxx"
27 #include "SchemaComponentItem.hxx"
28 #include "SchemaContainerItem.hxx"
29 #include "SchemaDataTypeItem.hxx"
30 #include "SchemaLinkItem.hxx"
31 #include "SchemaDirTypesItem.hxx"
32 #include "SchemaDirContainersItem.hxx"
33 #include "SchemaDirLinksItem.hxx"
34 #include "Menus.hxx"
35 #include "Message.hxx"
36 #include "QtGuiContext.hxx"
37 #include "ItemMimeData.hxx"
38 #include "GuiEditor.hxx"
39 #include "RuntimeSALOME.hxx"
40 #include "Catalog.hxx"
41 
42 #include "commandsProc.hxx"
43 #include "ComposedNode.hxx"
44 #include "guiObservers.hxx"
45 #include "Node.hxx"
46 #include "Switch.hxx"
47 
48 #include <QIcon>
49 #include <QMimeData>
50 
51 #include <cassert>
52 
53 //#define _DEVDEBUG_
54 #include "YacsTrace.hxx"
55 
56 using namespace std;
57 using namespace YACS::ENGINE;
58 using namespace YACS::HMI;
59 
60 SchemaComposedNodeItem::SchemaComposedNodeItem(SchemaItem *parent, QString label, Subject* subject)
61  : SchemaItem(parent, label, subject)
62 {
63  DEBTRACE("SchemaComposedNodeItem::SchemaComposedNodeItem");
64  switch (subject->getType())
65  {
66  case YACS::HMI::BLOC:
67  _itemDeco.replace(YLabel, QIcon("icons:block_node.png"));
68  break;
69  case YACS::HMI::FORLOOP:
70  case YACS::HMI::FOREACHLOOP:
71  case YACS::HMI::WHILELOOP:
72  case YACS::HMI::OPTIMIZERLOOP:
73  _itemDeco.replace(YLabel, QIcon("icons:loop_node.png"));
74  break;
75  case YACS::HMI::SWITCH:
76  _itemDeco.replace(YLabel, QIcon("icons:switch_node.png"));
77  break;
78  default:
79  _itemDeco.replace(YLabel, QIcon("icons:block_node.png"));
80  }
81  _dirTypesItem = 0;
82  _dirContainersItem = 0;
83  _dirLinksItem = 0;
84  Subject *son = 0;
85  int nbsons = childCount();
86  SchemaModel *model = QtGuiContext::getQtCurrent()->getSchemaModel();
87 
88  model->beginInsertRows(modelIndex(), nbsons, nbsons);
89  if (SubjectProc* sProc = dynamic_cast<SubjectProc*>(subject))
90  {
91  son = new Subject(getSubject());
92  _dirTypesItem = new SchemaDirTypesItem(this, "Types", son);
93  son = new Subject(getSubject());
94  _dirContainersItem = new SchemaDirContainersItem(this, "Containers", son);
95  }
96  son = new Subject(getSubject());
97  _dirLinksItem = new SchemaDirLinksItem(this, "Links", son);
98  model->endInsertRows();
99 
100  if (!model->isEdition())
101  {
102  setExecState(YACS::UNDEFINED);
103  }
104 
105  SubjectComposedNode *scn = dynamic_cast<SubjectComposedNode*>(subject);
106  YASSERT(scn);
107  if (scn->hasValue())
108  {
109  _itemData.replace(YType, scn->getValue().c_str());
110  model->setData(modelIndex(YType), 0);
111  }
112 
113  setCaseValue();
114 }
115 
116 SchemaComposedNodeItem::~SchemaComposedNodeItem()
117 {
118  DEBTRACE("SchemaComposedNodeItem::~SchemaComposedNodeItem");
119 }
120 
121 void SchemaComposedNodeItem::update(GuiEvent event, int type, Subject* son)
122 {
123  DEBTRACE("SchemaComposedNodeItem::update "<<eventName(event)<<" "<<type<<" "<<son);
124  SchemaModel *model = QtGuiContext::getQtCurrent()->getSchemaModel();
125  SchemaItem *item = 0;
126  SubjectNode *snode = 0;
127  SubjectComposedNode *scnode = 0;
128  Node* node = 0;
129  switch (event)
130  {
131  case YACS::HMI::ADD:
132  switch (type)
133  {
134  case YACS::HMI::BLOC:
135  case YACS::HMI::FORLOOP:
136  case YACS::HMI::WHILELOOP:
137  case YACS::HMI::SWITCH:
138  case YACS::HMI::FOREACHLOOP:
139  case YACS::HMI::OPTIMIZERLOOP:
140  {
141  int nbsons = childCount();
142  model->beginInsertRows(modelIndex(), nbsons, nbsons);
143  item = new SchemaComposedNodeItem(this,
144  son->getName().c_str(),
145  son);
146  model->endInsertRows();
147  }
148  break;
149  case YACS::HMI::PYTHONNODE:
150  case YACS::HMI::PYFUNCNODE:
151  case YACS::HMI::CORBANODE:
152  case YACS::HMI::CPPNODE:
153  case YACS::HMI::SALOMENODE:
154  case YACS::HMI::SALOMEPYTHONNODE:
155  case YACS::HMI::XMLNODE:
156  case YACS::HMI::PRESETNODE:
157  case YACS::HMI::OUTNODE:
158  case YACS::HMI::STUDYINNODE:
159  case YACS::HMI::STUDYOUTNODE:
160  {
161  int nbsons = childCount();
162  model->beginInsertRows(modelIndex(), nbsons, nbsons);
163  item = new SchemaNodeItem(this,
164  son->getName().c_str(),
165  son);
166  model->endInsertRows();
167  }
168  break;
169  case YACS::HMI::INPUTPORT:
170  case YACS::HMI::INPUTDATASTREAMPORT:
171  {
172  int nbsons = childCount();
173  model->beginInsertRows(modelIndex(), nbsons, nbsons);
174  item = new SchemaInPortItem(this,
175  son->getName().c_str(),
176  son);
177  model->endInsertRows();
178  }
179  break;
180  case YACS::HMI::OUTPUTPORT:
181  case YACS::HMI::OUTPUTDATASTREAMPORT:
182  {
183  int nbsons = childCount();
184  model->beginInsertRows(modelIndex(), nbsons, nbsons);
185  item = new SchemaOutPortItem(this,
186  son->getName().c_str(),
187  son);
188  model->endInsertRows();
189  }
190  break;
191  case YACS::HMI::COMPONENT:
192  {
193  YASSERT(_dirContainersItem);
194  _dirContainersItem->addComponentItem(son);
195  }
196  break;
197  case YACS::HMI::CONTAINER:
198  {
199  YASSERT(_dirContainersItem);
200  _dirContainersItem->addContainerItem(son);
201  }
202  break;
203  case YACS::HMI::DATATYPE:
204  {
205  YASSERT(_dirTypesItem);
206  _dirTypesItem->addTypeItem(son);
207  }
208  break;
209  }
210  break;
211 
212  case YACS::HMI::REMOVE:
213  switch (type)
214  {
215  case YACS::HMI::DATATYPE:
216  {
217  YASSERT(_dirTypesItem);
218  _dirTypesItem->removeTypeItem(son);
219  }
220  break;
221  }
222  break;
223 
224  case YACS::HMI::UPDATE:
225  snode = dynamic_cast<SubjectNode*>(_subject);
226  YASSERT(snode);
227  node = snode->getNode();
228  YASSERT(node);
229  switch (node->getState())
230  {
231  case YACS::INVALID:
232  _itemForeground.replace(YLabel, QColor("red"));
233  model->setData(modelIndex(YLabel), 0);
234  break;
235  case YACS::READY:
236  _itemForeground.replace(YLabel, QColor("blue"));
237  model->setData(modelIndex(YLabel), 0);
238  break;
239  default:
240  break;
241  }
242  break;
243  case YACS::HMI::ADDLINK:
244  case YACS::HMI::ADDCONTROLLINK:
245  {
246  YASSERT(_dirLinksItem);
247  _dirLinksItem->addLinkItem(son);
248  }
249  break;
250  case YACS::HMI::UPDATEPROGRESS:
251  setExecState(type);
252  model->setData(modelIndex(YState), 0);
253  break;
254  case YACS::HMI::SETVALUE:
255  scnode = dynamic_cast<SubjectComposedNode*>(_subject);
256  if (scnode->hasValue())
257  {
258  _itemData.replace(YType, scnode->getValue().c_str());
259  model->setData(modelIndex(YType), 0);
260  }
261  case YACS::HMI::SETCASE:
262  {
263  SubjectSwitch *sSwitch = dynamic_cast<SubjectSwitch*>(_subject);
264  if (sSwitch)
265  {
266  Switch *aSwitch = dynamic_cast<Switch*>(sSwitch->getNode());
267  Node *node = aSwitch->edGetNode(type);
268  if (node)
269  {
270  if (GuiContext::getCurrent()->_mapOfSubjectNode.count(node))
271  {
272  Subject* sub = GuiContext::getCurrent()->_mapOfSubjectNode[node];
273  if (QtGuiContext::getQtCurrent()->_mapOfSchemaItem.count(sub))
274  {
275  SchemaItem* item = QtGuiContext::getQtCurrent()->_mapOfSchemaItem[sub];
276  item->setCaseValue();
277  }
278  }
279  }
280  }
281  }
282  break;
283  case YACS::HMI::SETSELECT:
284  {
285  SubjectSwitch *sSwitch = dynamic_cast<SubjectSwitch*>(_subject);
286  if (sSwitch && sSwitch->hasValue())
287  {
288  _itemData.replace(YType, sSwitch->getValue().c_str());
289  model->setData(modelIndex(YType), 0);
290  }
291  }
292  break;
293  case YACS::HMI::CUT:
294  {
295  SchemaItem *toMove = QtGuiContext::getQtCurrent()->_mapOfSchemaItem[son];
296  int position = toMove->row();
297  model->beginRemoveRows(modelIndex(), position, position);
298  removeChild(toMove);
299  model->endRemoveRows();
300  }
301  break;
302  case YACS::HMI::PASTE:
303  {
304  SchemaItem *toPaste = QtGuiContext::getQtCurrent()->_mapOfSchemaItem[son];
305  int nbsons = childCount();
306  model->beginInsertRows(modelIndex(), nbsons, nbsons);
307  toPaste->reparent(this);
308  model->endInsertRows();
309  }
310  break;
311  default:
312  //DEBTRACE("SchemaComposedNodeItem::update(), event not handled: "<< eventName(event));
313  SchemaItem::update(event, type, son);
314  }
315 }
316 
317 std::list<YACS::ENGINE::Node*> SchemaComposedNodeItem::getDirectDescendants() const
318 {
319  SubjectNode* SNode = dynamic_cast<SubjectNode*>(_subject);
320  YASSERT(SNode);
321  ComposedNode* CNode = dynamic_cast<ComposedNode*>(SNode->getNode());
322  YASSERT(CNode);
323  return CNode->edGetDirectDescendants();
324 }
325 
326 void SchemaComposedNodeItem::popupMenu(QWidget *caller, const QPoint &globalPos)
327 {
328  ComposedNodeMenu m;
329  m.popupMenu(caller, globalPos);
330 }
331 
332 Qt::ItemFlags SchemaComposedNodeItem::flags(const QModelIndex &index)
333 {
334  //DEBTRACE("SchemaComposedNodeItem::flags");
335  Qt::ItemFlags pflag = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
336  if (!QtGuiContext::getQtCurrent() || !QtGuiContext::getQtCurrent()->isEdition())
337  return pflag;
338 
339  Qt::ItemFlags flagEdit = 0;
340  int column = index.column();
341  switch (column)
342  {
343  case YValue:
344  flagEdit = Qt::ItemIsEditable; // --- item value editable in model view (for node case in switch)
345  break;
346  }
347 
348  return pflag | flagEdit;
349 
350 }
351 
356 bool SchemaComposedNodeItem::dropMimeData(const QMimeData* data, Qt::DropAction action)
357 {
358  DEBTRACE("SchemaComposedNodeItem::dropMimeData");
359  if (!data) return false;
360  const ItemMimeData* myData = dynamic_cast<const ItemMimeData*>(data);
361  if (!myData) return false;
362  bool ret =false;
363  if (myData->hasFormat("yacs/cataService") || myData->hasFormat("yacs/cataNode"))
364  {
365  ret =true;
366  SubjectComposedNode *cnode = dynamic_cast<SubjectComposedNode*>(getSubject());
367  bool createNewComponentInstance=Resource::COMPONENT_INSTANCE_NEW;
368  // by default getControl gives false. In this case we use the user preference COMPONENT_INSTANCE_NEW
369  // to create the node. If getControl gives true we invert the user preference
370  if(myData->getControl())
371  createNewComponentInstance=!Resource::COMPONENT_INSTANCE_NEW;
372  QtGuiContext::getQtCurrent()->getGMain()->_guiEditor->CreateNodeFromCatalog(myData, cnode,createNewComponentInstance);
373  }
374  else if(myData->hasFormat("yacs/subjectNode"))
375  {
376  ret = true;
377  Subject *sub = myData->getSubject();
378  if (!sub) return false;
379  SubjectNode *node = dynamic_cast<SubjectNode*>(sub);
380  if (!node) return false;
381  SubjectComposedNode *cnode = dynamic_cast<SubjectComposedNode*>(getSubject());
382  if (cnode)
383  if (! node->reparent(cnode))
384  Message mess;
385  }
386  else if(myData->hasFormat("yacs/subjectOutGate"))
387  {
388  Subject *subFrom = myData->getSubject();
389  if (!subFrom) return false;
390  SubjectNode* from = dynamic_cast<SubjectNode*>(subFrom);
391 
392  SubjectNode *to = dynamic_cast<SubjectNode*>(getSubject());
393  if (!to) return false;
394 
395  bool ret =false;
396  if (from && to)
397  {
398  ret =true;
399  if (!SubjectNode::tryCreateLink(from, to))
400  Message mess;
401  }
402  }
403  return ret;
404 }
405 
410 QString SchemaComposedNodeItem::getMimeFormat()
411 {
412  if (QApplication::mouseButtons() == Qt::MidButton)
413  return "yacs/subjectNode";
414  else
415  return "yacs/subjectOutGate";
416 }
417 
418 void SchemaComposedNodeItem::setCaseValue()
419 {
420  DEBTRACE("SchemaComposedNodeItem::setCaseValue");
421  Subject *sub = _parentItem->getSubject();
422  SubjectSwitch *sSwitch = dynamic_cast<SubjectSwitch*>(sub);
423  if (!sSwitch) return;
424 
425  SchemaModel *model = QtGuiContext::getQtCurrent()->getSchemaModel();
426  Switch *aSwitch = dynamic_cast<Switch*>(sSwitch->getNode());
427  YASSERT(aSwitch);
428  SubjectNode *sNode = dynamic_cast<SubjectNode*>(_subject);
429  YASSERT(sNode);
430  int rank = aSwitch->getRankOfNode(sNode->getNode());
431  if (rank == Switch::ID_FOR_DEFAULT_NODE)
432  _itemData.replace(YValue, "default");
433  else
434  _itemData.replace(YValue, rank);
435  model->setData(modelIndex(YValue), 0);
436 }
437 
438 QVariant SchemaComposedNodeItem::editionWhatsThis(int column) const
439 {
440  return "<p>To edit the node properties, select the node and use the input panel. <a href=\"modification.html#property-page-for-block-node\">More...</a></p>";
441 }