Version: 8.3.0
SchemaInPortItem.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 "SchemaInPortItem.hxx"
21 #include "ItemMimeData.hxx"
22 #include "QtGuiContext.hxx"
23 #include "Menus.hxx"
24 #include "Message.hxx"
25 
26 #include "commandsProc.hxx"
27 #include "DataPort.hxx"
28 #include "TypeCode.hxx"
29 #include "InputPort.hxx"
30 #include "OutputPort.hxx"
31 #include "DataNode.hxx"
32 #include "InlineNode.hxx"
33 
34 #include <QIcon>
35 
36 //#define _DEVDEBUG_
37 #include "YacsTrace.hxx"
38 
39 using namespace std;
40 using namespace YACS::ENGINE;
41 using namespace YACS::HMI;
42 
47 SchemaInPortItem::SchemaInPortItem(SchemaItem *parent, QString label, Subject* subject)
48  : SchemaItem(parent, label, subject)
49 {
50  SubjectDataPort *subPort = dynamic_cast<SubjectDataPort*>(subject);
51  _isDataStream = false;
52  if (subPort)
53  {
54  DataPort *dport = subPort->getPort();
55  TypeOfElem typort = ProcInvoc::getTypeOfPort(dport);
56  TypeOfElem typnode = ProcInvoc::getTypeOfNode(dport->getNode());
57 // _itemData.replace(YType, dport->edGetType()->getKindRepr());
58  _itemData.replace(YType, dport->edGetType()->name());
59  _itemForeground.replace(YType, QColor("black"));
60  InputPort *inport = 0;
61 
62  if(typnode==YACS::HMI::STUDYOUTNODE)
63  {
64  //It's a study out node
65  if(typort==YACS::HMI::INPUTPORT)
66  {
67  _itemDeco.replace(YLabel, QIcon("icons:in_port.png"));
68  inport = dynamic_cast<InputPort*>(dport);
69  std::string val=inport->getAsString();
70  if(val != "")
71  {
72  _itemData.replace(YValue, val.c_str());
73  if (inport->edGetNumberOfLinks())
74  _itemForeground.replace(YValue, QColor("green"));
75  else
76  _itemForeground.replace(YValue, QColor("red"));
77  }
78  else
79  {
80  _itemData.replace(YValue, "not initialized");
81  _itemForeground.replace(YValue, QColor("red"));
82  }
83  }
84  return;
85  }
86 
87  switch (typort)
88  {
89  case YACS::HMI::INPUTPORT:
90  _isDataStream = false;
91  _itemDeco.replace(YLabel, QIcon("icons:in_port.png"));
92  inport = dynamic_cast<InputPort*>(dport);
93  if (inport->edIsManuallyInitialized())
94  {
95  _itemData.replace(YValue, inport->getAsString().c_str());
96  _itemForeground.replace(YValue, QColor("green"));
97  }
98  else if (inport->edGetNumberOfLinks())
99  {
100  _itemData.replace(YValue, "linked");
101  _itemForeground.replace(YValue, QColor("blue"));
102  }
103  else
104  {
105  _itemData.replace(YValue, "not initialized");
106  _itemForeground.replace(YValue, QColor("red"));
107  }
108  break;
109  case YACS::HMI::INPUTDATASTREAMPORT:
110  _isDataStream = true;
111  _itemDeco.replace(YLabel, QIcon("icons:in_port.png"));
112  _itemData.replace(YValue, "stream");
113  _itemForeground.replace(YValue, QColor("grey"));
114  break;
115  }
116  }
117 }
118 
119 void SchemaInPortItem::update(GuiEvent event, int type, Subject* son)
120 {
121  DEBTRACE("SchemaInPortItem::update");
122  SchemaItem::update(event, type, son);
123  QModelIndex index = QModelIndex();
124  SchemaModel *model = QtGuiContext::getQtCurrent()->getSchemaModel();
125  switch (event)
126  {
127  case SETVALUE:
128  {
129  SubjectInputPort *sip = dynamic_cast<SubjectInputPort*>(son);
130  if (sip)
131  {
132  InputPort* port = dynamic_cast<InputPort*>(sip->getPort());
133  TypeOfElem typnode = ProcInvoc::getTypeOfNode(port->getNode());
134  DEBTRACE(port->getAsString());
135  if(typnode==YACS::HMI::STUDYOUTNODE)
136  {
137  if(port->getAsString().empty())
138  {
139  _itemData.replace(YValue, "not initialized");
140  if (port->edGetNumberOfLinks())
141  _itemForeground.replace(YValue, QColor("blue"));
142  else
143  _itemForeground.replace(YValue, QColor("red"));
144  }
145  else
146  {
147  _itemData.replace(YValue, port->getAsString().c_str());
148  if (port->edGetNumberOfLinks())
149  _itemForeground.replace(YValue, QColor("green"));
150  else
151  _itemForeground.replace(YValue, QColor("red"));
152  }
153  }
154  else
155  {
156  _itemData.replace(YValue, port->getAsString().c_str());
157  _itemForeground.replace(YValue, QColor("green"));
158  }
159  model->setData(modelIndex(YValue), 0); // --- to emit dataChanged signal
160  }
161  }
162  break;
163  case UPDATE:
164  {
165  SubjectInputPort *sip = dynamic_cast<SubjectInputPort*>(_subject);
166  if (sip)
167  {
168  InputPort* port = dynamic_cast<InputPort*>(sip->getPort());
169  TypeOfElem typnode = ProcInvoc::getTypeOfNode(port->getNode());
170  TypeOfElem typort = ProcInvoc::getTypeOfPort(port);
171  _itemData.replace(YType, port->edGetType()->name());
172  _itemForeground.replace(YType, QColor("black"));
173  if(typnode==YACS::HMI::STUDYOUTNODE)
174  {
175  if(port->getAsString().empty())
176  {
177  _itemData.replace(YValue, "not initialized");
178  if (port->edGetNumberOfLinks())
179  _itemForeground.replace(YValue, QColor("blue"));
180  else
181  _itemForeground.replace(YValue, QColor("red"));
182  }
183  else
184  {
185  _itemData.replace(YValue, port->getAsString().c_str());
186  if (port->edGetNumberOfLinks())
187  _itemForeground.replace(YValue, QColor("green"));
188  else
189  _itemForeground.replace(YValue, QColor("red"));
190  }
191  }
192  else
193  {
194  if (port->edGetNumberOfLinks())
195  {
196  _itemData.replace(YValue, "linked");
197  _itemForeground.replace(YValue, QColor("blue"));
198  }
199  else if (port->edIsManuallyInitialized())
200  {
201  _itemData.replace(YValue, port->getAsString().c_str());
202  _itemForeground.replace(YValue, QColor("green"));
203  }
204  else
205  {
206  _itemData.replace(YValue, "not initialized");
207  _itemForeground.replace(YValue, QColor("red"));
208  }
209  }
210  model->setData(modelIndex(YValue), 0); // --- to emit dataChanged signal
211  }
212  }
213  break;
214  case UPDATEPROGRESS:
215  {
216  SubjectInputPort *sip = dynamic_cast<SubjectInputPort*>(son);
217  if (sip)
218  {
219  _itemData.replace(YValue, sip->getExecValue().c_str());
220  _itemForeground.replace(YValue, QColor("darkCyan"));
221  model->setData(modelIndex(YValue), 0); // --- to emit dataChanged signal
222  }
223  }
224  break;
225  }
226 }
227 
228 Qt::ItemFlags SchemaInPortItem::flags(const QModelIndex &index)
229 {
230  //DEBTRACE("SchemaInPortItem::flags");
231  Qt::ItemFlags pflag = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled;
232 
233  Qt::ItemFlags flagEdit = 0;
234  int column = index.column();
235  switch (column)
236  {
237  case 0:
238  {
239  SubjectDataPort *sdp = dynamic_cast<SubjectDataPort*>(_subject);
240  Node *parent = sdp->getPort()->getNode();
241  if (parent)
242  if ( (dynamic_cast<DataNode*>(parent) || dynamic_cast<InlineNode*>(parent)) &&
243  QtGuiContext::getQtCurrent()->isEdition() )
244  flagEdit = Qt::ItemIsEditable; // --- port name editable
245  }
246  break;
247  case 2:
248  if (!_isDataStream)
249  flagEdit = Qt::ItemIsEditable; // --- port value editable
250  }
251  return pflag | flagEdit;
252 }
253 
254 bool SchemaInPortItem::dropMimeData(const QMimeData* data, Qt::DropAction action)
255 {
256  DEBTRACE("SchemaInPortItem::dropMimeData");
257  if (!data) return false;
258  const ItemMimeData* myData = dynamic_cast<const ItemMimeData*>(data);
259  if (!myData) return false;
260  if(!myData->hasFormat("yacs/subjectOutPort")) return false;
261  SubjectDataPort *to = dynamic_cast<SubjectDataPort*>(getSubject());
262  if (!to) return false;
263  InPort *toport = dynamic_cast<InPort*>(to->getPort());
264  if (!toport) return false;
265 
266  bool ret =false;
267  TypeOfElem typort = ProcInvoc::getTypeOfPort(toport);
268  switch (typort)
269  {
270  case YACS::HMI::INPUTPORT:
271  case YACS::HMI::INPUTDATASTREAMPORT:
272  {
273  ret =true;
274  Subject *sub = myData->getSubject();
275  if (!sub) break;
276  SubjectDataPort* from = dynamic_cast<SubjectDataPort*>(sub);
277  if (from && to)
278  if (!SubjectDataPort::tryCreateLink(from, to,myData->getControl()))
279  Message mess;
280  break;
281  }
282  default:
283  break;
284  }
285  return ret;
286 }
287 
288 void SchemaInPortItem::popupMenu(QWidget *caller, const QPoint &globalPos)
289 {
290  InPortMenu m;
291  m.popupMenu(caller, globalPos);
292 }
293 
294 QVariant SchemaInPortItem::editionWhatsThis(int column) const
295 {
296  QString answer;
297  if (_isDataStream)
298  answer = "Edition, DataStream input port ";
299  else
300  answer = "Edition, DataFlow input port ";
301  switch (column)
302  {
303  case YLabel:
304  answer += "name=";
305  answer += _itemData.value(column).toString();
306  answer += "\nInput port is edited in the input panel of the node.\n" \
307  "Select the node to get access to it's input panel.";
308  break;
309  case YType:
310  answer += "type=";
311  answer += _itemData.value(column).toString();
312  answer += "\nInput port is edited in the input panel of the node.\n" \
313  "Select the node to get access to it's input panel.\n" \
314  "Type is not modifiable, you must delete and recreate the port. Existing links will be lost.";
315  break;
316  case YValue:
317  answer += "value=";
318  answer += _itemData.value(column).toString();
319  answer += "\nInput port is edited in the input panel of the node.\n" \
320  "Select the node to get access to it's input panel.\n";
321  if (_isDataStream)
322  answer += "DataStream ports have no editable value, they must be linked to an output DataStream port.";
323  else
324  {
325  answer += "DataFlow ports must be either manually initialized or linked to an output DataFlow port. ";
326  answer += "If the port is manually initialized and linked, the value from the link will prevail ";
327  answer += "if it is available when the node is executed.";
328  }
329  break;
330  }
331  return answer;
332 }
333 
334