Version: 9.15.0
GenericGui.cxx
Go to the documentation of this file.
1 // Copyright (C) 2006-2025 CEA, EDF
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 "SALOME_ResourcesManager.hxx"
22 #include "SALOME_LifeCycleCORBA.hxx"
23 
24 #include "RuntimeSALOME.hxx"
25 #include "Proc.hxx"
26 #include "InputPort.hxx"
27 #include "ServiceNode.hxx"
28 #include "parsers.hxx"
29 #include "Logger.hxx"
30 #include "YACSGuiLoader.hxx"
31 #include "ComponentInstance.hxx"
32 
33 #include "ServiceUnreachable.hxx"
34 #include "SALOME_NamingService_Wrapper.hxx"
35 #include "SALOME_ModuleCatalog.hxx"
36 #include "SALOME_ModuleCatalog.hh"
37 #include "SALOMEDS_Tool.hxx"
38 
39 #include "QtGuiContext.hxx"
40 
41 #include "GuiEditor.hxx"
42 #include "GraphicsView.hxx"
43 #include "Scene.hxx"
44 #include "GenericGui.hxx"
45 #include "SceneItem.hxx"
46 #include "SceneNodeItem.hxx"
47 #include "SceneComposedNodeItem.hxx"
48 #include "ItemEdition.hxx"
49 #include "CatalogWidget.hxx"
50 #include "TreeView.hxx"
51 #include "VisitorSaveGuiSchema.hxx"
52 #include "TypeCode.hxx"
53 #include "LinkInfo.hxx"
54 #include "LogViewer.hxx"
55 #include "chrono.hxx"
56 #include "Resource.hxx"
57 #include "Message.hxx"
58 #include "ListJobs_GUI.hxx"
59 
60 #include <QFileDialog>
61 #include <sstream>
62 #include <QDir>
63 #include <QDateTime>
64 #include <QMessageBox>
65 #include <QWhatsThis>
66 
67 #include <cstdlib>
68 
69 #include <ctime>
70 
71 #ifdef WIN32
72 #define WEXITSTATUS(w) ((int) ((w) & 0x40000000))
73 #endif
74 
75 //#define _DEVDEBUG_
76 #include "YacsTrace.hxx"
77 
78 using namespace std;
79 using namespace YACS::HMI;
80 
81 GenericGui::GenericGui(YACS::HMI::SuitWrapper* wrapper, QMainWindow *parent)
82 {
83  _wrapper = wrapper;
84  _parent = parent;
85  _dwTree = 0;
86  _dwStacked = 0;
87  _dwCatalogs = 0;
88  _catalogsWidget = 0;
89  _sessionCatalog = 0;
90  _schemaCnt = 0;
91  _isSaved = false;
92  _mapViewContext.clear();
93  _machineList.clear();
94  _menuId = 190;
95  _BJLdialog = NULL;
96  QtGuiContext::_counters = new counters(100);
97  srand((unsigned)time(0));
98 
99  GuiObserver::setEventMap();
100 
101  string iconPath = getenv("YACS_ROOT_DIR");
102  iconPath += "/share/salome/resources/yacs";
103  DEBTRACE(iconPath);
104  QDir::addSearchPath("icons", iconPath.c_str());
105 
106  _guiEditor = new GuiEditor();
107 
108  YACS::ENGINE::RuntimeSALOME::setRuntime();
109  _loader = new YACSGuiLoader();
110  _loader->registerProcCataLoader();
111  _builtinCatalog = YACS::ENGINE::getSALOMERuntime()->getBuiltinCatalog();
112 
113  try
114  {
115  YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime();
116  CORBA::ORB_ptr orb = runTime->getOrb();
117  if (orb)
118  {
119  SALOME_NamingService_Wrapper namingService(orb);
120  CORBA::Object_ptr obj = namingService.Resolve("/Kernel/ModulCatalog");
121  SALOME_ModuleCatalog::ModuleCatalog_var aModuleCatalog =
122  SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj);
123  if (! CORBA::is_nil(aModuleCatalog))
124  {
125  DEBTRACE("SALOME_ModuleCatalog::ModuleCatalog found");
126  std::string anIOR = orb->object_to_string( aModuleCatalog );
127  _sessionCatalog = runTime->loadCatalog( "session", anIOR );
128  runTime->addCatalog(_sessionCatalog);
129  {
130  std::map< std::string, YACS::ENGINE::ComponentDefinition * >::iterator it;
131  for (it = _sessionCatalog->_componentMap.begin();
132  it != _sessionCatalog->_componentMap.end(); ++it)
133  DEBTRACE("Component: " <<(*it).first);
134  }
135  {
136  std::map< std::string, YACS::ENGINE::TypeCode*>::iterator it;
137  for (it = _sessionCatalog->_typeMap.begin();
138  it != _sessionCatalog->_typeMap.end(); ++it)
139  DEBTRACE("Type : " <<(*it).first
140  << " " << (*it).second->getKindRepr()
141  << " " << (*it).second->name()
142  << " " << (*it).second->shortName()
143  << " " << (*it).second->id() );
144  }
145  DEBTRACE("_sessionCatalog " << _sessionCatalog);
146  }
147  }
148  }
149  catch(ServiceUnreachable& e)
150  {
151  DEBTRACE("Caught Exception. "<<e);
152  }
153 
154  _dwTree = new QDockWidget(_parent);
155  _dwTree->setVisible(false);
156  _dwTree->setWindowTitle("Tree View: edition mode");
157  _dwTree->setObjectName("yacsTreeViewDock");
158  _parent->addDockWidget(Qt::LeftDockWidgetArea, _dwTree);
159  _dwStacked = new QDockWidget(_parent);
160  _dwStacked->setVisible(false);
161  _dwStacked->setWindowTitle("Input Panel");
162  _dwStacked->setObjectName("yacsInputPanelDock");
163  _dwStacked->setMinimumWidth(270); // --- force a minimum until display
164  _parent->addDockWidget(Qt::RightDockWidgetArea, _dwStacked);
165  _dwCatalogs = new QDockWidget(_parent);
166  _dwCatalogs->setVisible(false);
167  _dwCatalogs->setWindowTitle("Catalogs");
168  _dwCatalogs->setObjectName("yacsCatalogsDock");
169  _parent->addDockWidget(Qt::RightDockWidgetArea, _dwCatalogs);
170  _catalogsWidget = new CatalogWidget(_dwCatalogs,
171  _builtinCatalog,
172  _sessionCatalog);
173  _dwCatalogs->setWidget(_catalogsWidget);
174 
175  _parent->tabifyDockWidget(_dwStacked, _dwCatalogs);
176  if (_wrapper->objectBrowser())
177  _parent->tabifyDockWidget(_dwTree, _wrapper->objectBrowser());
178  _parent->setTabPosition(Qt::AllDockWidgetAreas, Resource::tabPanelsUp? QTabWidget::North: QTabWidget::South);
179  //Import user catalog
180  std::string usercata=Resource::userCatalog.toStdString();
181  _catalogsWidget->addCatalogFromFile(usercata);
182 }
183 
184 GenericGui::~GenericGui()
185 {
186  if(_BJLdialog) delete _BJLdialog;
187 }
188 
189 void GenericGui::createActions()
190 {
191  // QAction* createAction(const int id,
192  // const QString& toolTip,
193  // const QIcon& icon,
194  // const QString& menu,
195  // const QString& status,
196  // const int shortCut,
197  // QObject* parent =0,
198  // bool checkable = false,
199  // QObject* receiver =0,
200  // const char* member =0);
201 
202  _newSchemaAct = _wrapper->createAction(getMenuId(), tr("Create a new YACS Schema"), QIcon("icons:schema.png"),
203  tr("New Schema"), tr("Create a new YACS Schema"),
204  0, _parent, false, this, SLOT(onNewSchema()));
205  _newSchemaAct->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_N); // --- QKeySequence::New ambiguous in SALOME
206 
207  _importSchemaAct = _wrapper->createAction(getMenuId(), tr("Import a YACS Schema for edition"), QIcon("icons:import_dataflow.png"),
208  tr("Import Schema"), tr("Import a YACS Schema for edition"),
209  0, _parent, false, this, SLOT(onImportSchema()));
210  _importSchemaAct->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_O); // --- QKeySequence::Open ambiguous in SALOME
211 
212  _importSupervSchemaAct = _wrapper->createAction(getMenuId(), tr("Import a SUPERV Schema for edition"), QIcon("icons:import_superv_dataflow.png"),
213  tr("Import SUPERV Schema"), tr("Import a SUPERV Schema for edition"),
214  0, _parent, false, this, SLOT(onImportSupervSchema()));
215 
216  _exportSchemaAct = _wrapper->createAction(getMenuId(), tr("Save the current YACS Schema"), QIcon("icons:save_dataflow.png"),
217  tr("Save Schema"), tr("Save the current YACS Schema"),
218  0, _parent, false, this, SLOT(onExportSchema()));
219  _exportSchemaAct->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_S); // --- QKeySequence::Save ambiguous in SALOME
220 
221  _exportSchemaAsAct = _wrapper->createAction(getMenuId(), tr("Save the current YACS Schema As..."), QIcon("icons:export_dataflow.png"),
222  tr("Save Schema As"), tr("Save the current YACS Schema As..."),
223  0, _parent, false, this, SLOT(onExportSchemaAs()));
224  //_exportSchemaAsAct->setShortcut(QKeySequence::SaveAs); // --- ambiguous in SALOME
225 
226  _importCatalogAct = _wrapper->createAction(getMenuId(), tr("Import a Schema as a Catalog"), QIcon("icons:insert_file.png"),
227  tr("Import Catalog"), tr("Import a Schema as a Catalog"),
228  0, _parent, false, this, SLOT(onImportCatalog()));
229 
230 
231  _runLoadedSchemaAct = _wrapper->createAction(getMenuId(), tr("Prepare the current edited schema for run"), QIcon("icons:run_active.png"),
232  tr("Run Current Schema"), tr("Prepare the current edited schema for run"),
233  0, _parent, false, this, SLOT(onRunLoadedSchema()));
234 
235  _loadRunStateSchemaAct = _wrapper->createAction(getMenuId(), tr("Load a previous run state for this schema, prepare to run"), QIcon("icons:load_execution_state.png"),
236  tr("Load Run State"), tr("Load a previous run state for this schema, prepare to run"),
237  0, _parent, false, this, SLOT(onLoadRunStateSchema()));
238 
239  _loadAndRunSchemaAct = _wrapper->createAction(getMenuId(), tr("Load a schema for run"), QIcon("icons:run.png"),
240  tr("Load Schema to run"), tr("Load a schema for run"),
241  0, _parent, false, this, SLOT(onLoadAndRunSchema()));
242 
243  _chooseBatchJobAct = _wrapper->createAction(getMenuId(), tr("Choose Batch Job to watch"), QIcon("icons:batch.png"),
244  tr("Choose Batch Job to watch"), tr("Choose Batch Job to watch"),
245  0, _parent, false, this, SLOT(onChooseBatchJob()));
246 
247  _startResumeAct = _wrapper->createAction(getMenuId(), tr("Start or Resume Schema execution"), QIcon("icons:suspend_resume.png"),
248  tr("Start/Resume execution"), tr("Start or Resume Schema execution"),
249  0, _parent, false, this, SLOT(onStartResume()));
250 
251  _abortAct = _wrapper->createAction(getMenuId(), tr("Abort the current execution"), QIcon("icons:kill.png"),
252  tr("Abort execution"), tr("Abort the current execution"),
253  0, _parent, false, this, SLOT(onAbort()));
254 
255  _pauseAct = _wrapper->createAction(getMenuId(), tr("Suspend the current execution"), QIcon("icons:pause.png"),
256  tr("Suspend execution"), tr("Suspend the current execution"),
257  0, _parent, false, this, SLOT(onPause()));
258 
259  _resetAct = _wrapper->createAction(getMenuId(), tr("Reset error nodes and restart the current execution"), QIcon("icons:reset.png"),
260  tr("Restart execution"), tr("Restart the current execution with reset of error nodes"),
261  0, _parent, false, this, SLOT(onReset()));
262 
263 
264  _saveRunStateAct = _wrapper->createAction(getMenuId(), tr("Save the current run state"), QIcon("icons:save_dataflow_state.png"),
265  tr("Save State"), tr("Save the current run state"),
266  0, _parent, false, this, SLOT(onSaveRunState()));
267 
268  _newEditionAct = _wrapper->createAction(getMenuId(), tr("Edit again the current schema in a new context"), QIcon("icons:new_edition.png"),
269  tr("Edit Again"), tr("Edit again the current schema in a new context"),
270  0, _parent, false, this, SLOT(onNewEdition()));
271 
272 
273  _getYacsContainerLogAct = _wrapper->createAction(getMenuId(), tr("get YACS container log"), QIcon("icons:change_informations.png"),
274  tr("YACS Container Log"), tr("get YACS container log"),
275  0, _parent, false, this, SLOT(onGetYacsContainerLog()));
276 
277  _getErrorReportAct = _wrapper->createAction(getMenuId(), tr("get Node Error Report"), QIcon("icons:filter_notification.png"),
278  tr("Node Error Report"), tr("get Node Error Report"),
279  0, _parent, false, this, SLOT(onGetErrorReport()));
280 
281  _getErrorDetailsAct = _wrapper->createAction(getMenuId(), tr("get Node Error Details"), QIcon("icons:icon_text.png"),
282  tr("Node Error Details"), tr("get Node Error Details"),
283  0, _parent, false, this, SLOT(onGetErrorDetails()));
284 
285  _getContainerLogAct = _wrapper->createAction(getMenuId(), tr("get Node Container Log"), QIcon("icons:change_informations.png"),
286  tr("Node Container Log"), tr("get Node Container Log"),
287  0, _parent, false, this, SLOT(onGetContainerLog()));
288 
289  _shutdownProcAct = _wrapper->createAction(getMenuId(), tr("Shutdown Proc"), QIcon("icons:kill.png"),
290  tr("Shutdown Proc"), tr("Shutdown Proc"),
291  0, _parent, false, this, SLOT(onShutdownProc()));
292 
293 
294  _editDataTypesAct = _wrapper->createAction(getMenuId(), tr("Edit Data Types"), QIcon("icons:kill.png"),
295  tr("Edit Data Types"), tr("Edit Data Types"),
296  0, _parent, false, this, SLOT(onEditDataTypes()));
297 
298  _createDataTypeAct = _wrapper->createAction(getMenuId(), tr("Create Data Types"), QIcon("icons:kill.png"),
299  tr("Create Data Types"), tr("Create Data Types"),
300  0, _parent, false, this, SLOT(onCreateDataType()));
301 
302  _importDataTypeAct = _wrapper->createAction(getMenuId(), tr("Import Data Types, use drag and drop from catalog"), QIcon("icons:folder_cyan.png"),
303  tr("Import Data Types"), tr("Import Data Types, use drag and drop from catalog"),
304  0, _parent, false, this, SLOT(onImportDataType()));
305 
306  _newContainerAct = _wrapper->createAction(getMenuId(), tr("Create a New Container"), QIcon("icons:container.png"),
307  tr("Create Container"), tr("Create a New Container"),
308  0, _parent, false, this, SLOT(onNewContainer()));
309 
310  _newHPContainerAct = _wrapper->createAction(getMenuId(), tr("Create a New HP Container"), QIcon("icons:container.png"),
311  tr("Create HP Container"), tr("Create a New Homogeneous Pool Container."),
312  0, _parent, false, this, SLOT(onNewHPContainer()));
313 
314  _selectComponentInstanceAct = _wrapper->createAction(getMenuId(), tr("Select a Component Instance"), QIcon("icons:icon_select.png"),
315  tr("Select a Component Instance"), tr("Select a Component Instance"),
316  0, _parent, false, this, SLOT(onSelectComponentInstance()));
317 
318  _newSalomeComponentAct = _wrapper->createAction(getMenuId(), tr("Create a New SALOME Component Instance"), QIcon("icons:new_salome_component.png"),
319  tr("Create Component Instance"), tr("Create a New SALOME Component Instance"),
320  0, _parent, false, this, SLOT(onNewSalomeComponent()));
321 
322  _newSalomePythonComponentAct = _wrapper->createAction(getMenuId(), tr("Create a New SALOME Python Component"), QIcon("icons:new_salomepy_component.png"),
323  tr("SALOME Python Component"), tr("Create a New SALOME Python Component"),
324  0, _parent, false, this, SLOT(onNewSalomePythonComponent()));
325 
326  _newCorbaComponentAct = _wrapper->createAction(getMenuId(), tr("Create a New CORBA Component"), QIcon("icons:new_corba_component.png"),
327  tr("CORBA Component"), tr("Create a New CORBA Component"),
328  0, _parent, false, this, SLOT(onNewCorbaComponent()));
329 
330  _salomeServiceNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New SALOME Service Node"), QIcon("icons:new_salome_service_node.png"),
331  tr("SALOME Service Node"), tr("Create a New SALOME Service Node"),
332  0, _parent, false, this, SLOT(onSalomeServiceNode()));
333 
334  _serviceInlineNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Inline Service Node"), QIcon("icons:new_service_inline_node.png"),
335  tr("Inline Service Node"), tr("Create a New Inline Service Node"),
336  0, _parent, false, this, SLOT(onServiceInlineNode()));
337 
338  _CORBAServiceNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New CORBA Service Node"), QIcon("icons:new_corba_service_node.png"),
339  tr("CORBA Node"), tr("Create a New CORBA Service Node"),
340  0, _parent, false, this, SLOT(onCORBAServiceNode()));
341 
342  _nodeNodeServiceNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Node referencing a Node"), QIcon("icons:new_nodenode_service_node.png"),
343  tr("Ref on Node"), tr("Create a New Node referencing a Node"),
344  0, _parent, false, this, SLOT(onNodeNodeServiceNode()));
345 
346  _cppNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New C++ Node"), QIcon("icons:new_cpp_node.png"),
347  tr("Cpp Node"), tr("Create a New C++ Node"),
348  0, _parent, false, this, SLOT(onCppNode()));
349 
350  _inDataNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Input data Node"), QIcon("icons:node.png"),
351  tr("Input Data Node"), tr("Create a New Input data Node"),
352  0, _parent, false, this, SLOT(onInDataNode()));
353 
354  _outDataNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Output data Node"), QIcon("icons:node.png"),
355  tr("Output Data Node"), tr("Create a New Output data Node"),
356  0, _parent, false, this, SLOT(onOutDataNode()));
357 
358  _inStudyNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Input Study Node"), QIcon("icons:node.png"),
359  tr("Input Study Node"), tr("Create a New Input Study Node"),
360  0, _parent, false, this, SLOT(onInStudyNode()));
361 
362  _outStudyNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Output Study Node"), QIcon("icons:node.png"),
363  tr("Output Study Node"), tr("Create a New Output Study Node"),
364  0, _parent, false, this, SLOT(onOutStudyNode()));
365 
366  _inlineScriptNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Inline Python Script Node"), QIcon("icons:new_inline_script_node.png"),
367  tr("Inline Script Node"), tr("Create a New Inline Python Script Node"),
368  0, _parent, false, this, SLOT(onInlineScriptNode()));
369 
370  _inlineFunctionNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Inline Python Function Node"), QIcon("icons:new_inline_function_node.png"),
371  tr("Inline Function Node"), tr("Create a New Inline Python Function Node"),
372  0, _parent, false, this, SLOT(onInlineFunctionNode()));
373 
374  _blockNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Bloc Node"), QIcon("icons:new_block_node.png"),
375  tr("bloc Node"), tr("Create a New Bloc Node"),
376  0, _parent, false, this, SLOT(onBlockNode()));
377 
378  _FORNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New For Loop Node"), QIcon("icons:new_for_loop_node.png"),
379  tr("For Loop Node"), tr("Create a New For Loop Node"),
380  0, _parent, false, this, SLOT(onFORNode()));
381 
382  _FOREACHNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New For Each Loop Node"), QIcon("icons:new_foreach_loop_node.png"),
383  tr("For Each Loop Node"), tr("Create a New For Each Loop Node"),
384  0, _parent, false, this, SLOT(onFOREACHNode()));
385 
386  _WHILENodeAct = _wrapper->createAction(getMenuId(), tr("Create a New While Loop Node"), QIcon("icons:new_while_loop_node.png"),
387  tr("While Loop Node"), tr("Create a New While Loop Node"),
388  0, _parent, false, this, SLOT(onWHILENode()));
389 
390  _SWITCHNodeAct = _wrapper->createAction(getMenuId(), tr("Create a New Switch Node"), QIcon("icons:new_switch_loop_node.png"),
391  tr("Switch Node"), tr("Create a New Switch Node"),
392  0, _parent, false, this, SLOT(onSWITCHNode()));
393 
394  _OptimizerLoopAct = _wrapper->createAction(getMenuId(), tr("Create a New Optimizer Loop Node"), QIcon("icons:new_for_loop_node.png"),
395  tr("Optimizer Loop"), tr("Create a New Optimizer Loop"),
396  0, _parent, false, this, SLOT(onOptimizerLoop()));
397 
398  _nodeFromCatalogAct = _wrapper->createAction(getMenuId(), tr("Create a New Node from Catalog, use drag and drop from catalog"), QIcon("icons:new_from_library_node.png"),
399  tr("Node from Catalog"), tr("Create a New Node from Catalog, use drag and drop from catalog"),
400  0, _parent, false, this, SLOT(onNodeFromCatalog()));
401 
402  _deleteItemAct = _wrapper->createAction(getMenuId(), tr("Delete a Schema Item"), QIcon("icons:delete.png"),
403  tr("Delete Item"), tr("Delete a Schema Item"),
404  0, _parent, false, this, SLOT(onDeleteItem()));
405  _deleteItemAct->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_D); // --- QKeySequence::Delete dangerous...
406 
407  _cutItemAct = _wrapper->createAction(getMenuId(), tr("Cut a Schema Item"), QIcon("icons:cut.png"),
408  tr("Cut Item"), tr("Cut a Schema Item"),
409  0, _parent, false, this, SLOT(onCutItem()));
410  _cutItemAct->setShortcut(QKeySequence::Cut);
411 
412  _copyItemAct = _wrapper->createAction(getMenuId(), tr("Copy a Schema Item"), QIcon("icons:copy.png"),
413  tr("Copy Item"), tr("Copy a Schema Item"),
414  0, _parent, false, this, SLOT(onCopyItem()));
415  _copyItemAct->setShortcut(QKeySequence::Copy);
416 
417  _pasteItemAct = _wrapper->createAction(getMenuId(), tr("Paste a Schema Item"), QIcon("icons:paste.png"),
418  tr("Paste Item"), tr("Paste a Schema Item"),
419  0, _parent, false, this, SLOT(onPasteItem()));
420  _pasteItemAct->setShortcut(QKeySequence::Paste);
421 
422  _putInBlocAct = _wrapper->createAction(getMenuId(), tr("Put node in block"), QIcon("icons:paste.png"),
423  tr("Put node in block"), tr("Put node in block"),
424  0, _parent, false, this, SLOT(onPutInBloc()));
425 
426  _putGraphInBlocAct = _wrapper->createAction(getMenuId(), tr("Bloc"), QIcon("icons:new_block_node.png"),
427  tr("Bloc"), tr("Bloc"),
428  0, _parent, false, this, SLOT(onPutGraphInBloc()));
429 
430  _putGraphInForLoopAct = _wrapper->createAction(getMenuId(), tr("For Loop"), QIcon("icons:new_for_loop_node.png"),
431  tr("For Loop"), tr("For Loop"),
432  0, _parent, false, this, SLOT(onPutGraphInForLoop()));
433 
434  _putGraphInWhileLoopAct = _wrapper->createAction(getMenuId(), tr("While Loop"), QIcon("icons:new_while_loop_node.png"),
435  tr("While Loop"), tr("While Loop"),
436  0, _parent, false, this, SLOT(onPutGraphInWhileLoop()));
437 
438  _putGraphInOptimizerLoopAct = _wrapper->createAction(getMenuId(), tr("Optimizer Loop"), QIcon("icons:new_for_loop_node.png"),
439  tr("Optimizer Loop"), tr("Optimizer Loop"),
440  0, _parent, false, this, SLOT(onPutGraphInOptimizerLoop()));
441 
442  _arrangeLocalNodesAct = _wrapper->createAction(getMenuId(), tr("arrange nodes on that bloc level, without recursion"), QIcon("icons:arrange_nodes.png"),
443  tr("arrange local nodes"), tr("arrange nodes on that bloc level, without recursion"),
444  0, _parent, false, this, SLOT(onArrangeLocalNodes()));
445 
446  _arrangeRecurseNodesAct = _wrapper->createAction(getMenuId(), tr("arrange nodes on that bloc level, with recursion"), QIcon("icons:sample.png"),
447  tr("arrange nodes recursion"), tr("arrange nodes on that bloc level, with recursion"),
448  0, _parent, false, this, SLOT(onArrangeRecurseNodes()));
449 
450  _computeLinkAct = _wrapper->createAction(getMenuId(), tr("compute orthogonal links"), QIcon("icons:rebuild_links.png"),
451  tr("compute links"), tr("compute orthogonal links"),
452  0, _parent, false, this, SLOT(onRebuildLinks()));
453 
454  _zoomToBlocAct = _wrapper->createAction(getMenuId(), tr("zoom 2D view to selected bloc"), QIcon("icons:zoomToBloc.png"),
455  tr("zoom to bloc"), tr("zoom 2D view to the selected composed node"),
456  0, _parent, false, this, SLOT(onZoomToBloc()));
457 
458  _centerOnNodeAct = _wrapper->createAction(getMenuId(), tr("center 2D view on selected node"), QIcon("icons:centerOnNode.png"),
459  tr("center on node"), tr("center 2D view on selected node"),
460  0, _parent, false, this, SLOT(onCenterOnNode()));
461  _centerOnNodeAct->setShortcut(QKeySequence::Find);
462 
463  _shrinkExpand = _wrapper->createAction(getMenuId(), tr("shrink or expand the selected node"), QIcon("icons:shrinkExpand.png"),
464  tr("shrink/expand"), tr("shrink or expand the selected node"),
465  0, _parent, false, this, SLOT(onShrinkExpand()));
466 
467  _shrinkExpandChildren = _wrapper->createAction(getMenuId(), tr("shrink or expand direct children of the selected node"), QIcon("icons:shrinkExpand.png"),
468  tr("shrink/expand children"), tr("shrink or expand direct children of the selected node"),
469  0, _parent, false, this, SLOT(onShrinkExpandChildren()));
470 
471  _shrinkExpandElementaryRecursively = _wrapper->createAction(getMenuId(), tr("shrink or expand elementary nodes of the selected node recursively"), QIcon("icons:shrinkExpand.png"),
472  tr("shrink/expand elementary"), tr("shrink or expand elementary nodes of the selected node recursively"),
473  0, _parent, false, this, SLOT(onShrinkExpandElementaryRecursively()));
474 
475  _toggleStraightLinksAct = _wrapper->createAction(getMenuId(), tr("draw straight or orthogonal links"), QIcon("icons:straightLink.png"),
476  tr("straight/orthogonal"), tr("draw straight or orthogonal links"),
477  0, _parent, true, this, SLOT(onToggleStraightLinks(bool)));
478 
479  _toggleStraightLinksAct->setChecked(Resource::straightLinks);
480  onToggleStraightLinks(Resource::straightLinks);
481 
482  _toggleAutomaticComputeLinkAct = _wrapper->createAction(getMenuId(), tr("compute othogonal links automatically when nodes move"), QIcon("icons:autoComputeLink.png"),
483  tr("automatic link"), tr("compute othogonal links automatically when nodes move"),
484  0, _parent, true, this, SLOT(onToggleAutomaticComputeLinks(bool)));
485 
486  _toggleAutomaticComputeLinkAct->setChecked(Resource::autoComputeLinks);
487  onToggleAutomaticComputeLinks(Resource::autoComputeLinks); // Why is this needed ?
488 
489  _toggleSimplifyLinkAct = _wrapper->createAction(getMenuId(), tr("simplify links by removing unnecessary direction changes"), QIcon("icons:simplifyLink.png"),
490  tr("simplify links"), tr("simplify links by removing unnecessary direction changes"),
491  0, _parent, true, this, SLOT(onToggleSimplifyLinks(bool)));
492  _toggleSimplifyLinkAct->setChecked(Resource::simplifyLink);
493  onToggleSimplifyLinks(Resource::simplifyLink);
494 
495  _toggleForce2NodesLinkAct = _wrapper->createAction(getMenuId(), tr("force orthogonal links by adding an edge on simples links"), QIcon("icons:force2nodeLink.png"),
496  tr("force ortho links"), tr("force orthogonal links by adding an edge on simples links"),
497  0, _parent, true, this, SLOT(onToggleForce2NodesLinks(bool)));
498  _toggleForce2NodesLinkAct->setChecked(true);
499 
500  _toggleAddRowColsAct = _wrapper->createAction(getMenuId(), tr("allow more path for the links, for a better separation"), QIcon("icons:addRowCols.png"),
501  tr("separate links"), tr("allow more path for the links, for a better separation"),
502  0, _parent, true, this, SLOT(onToggleAddRowCols(bool)));
503  _toggleAddRowColsAct->setChecked(Resource::addRowCols);
504  onToggleAddRowCols(Resource::addRowCols);
505 
506  _selectReferenceAct = _wrapper->createAction(getMenuId(), tr("select reference"), QIcon("icons:ob_service_node.png"),
507  tr("select reference"), tr("select reference"),
508  0, _parent, false, this, SLOT(onSelectReference()));
509 
510  _whatsThisAct = _wrapper->createAction(getMenuId(), tr("active whatsThis Mode to get help on widgets"), QIcon("icons:whatsThis.png"),
511  tr("whatsThis Mode"), tr("active whatsThis Mode to get help on widgets"),
512  0, _parent, false, this, SLOT(onWhatsThis()));
513  _whatsThisAct->setShortcut(QKeySequence::WhatsThis);
514 
515  _withoutStopModeAct = _wrapper->createAction(getMenuId(), tr("set execution mode without stop"), QIcon("icons:run_active.png"),
516  tr("mode without stop"), tr("set execution mode without stop"),
517  0, _parent, true, this, SLOT(onWithoutStopMode(bool)));
518 
519  _breakpointsModeAct = _wrapper->createAction(getMenuId(), tr("set execution mode with stop on breakpoints"), QIcon("icons:breakpoints_active.png"),
520  tr("mode breakpoints"), tr("set execution mode with stop on breakpoints"),
521  0, _parent, true, this, SLOT(onBreakpointsMode(bool)));
522 
523  _stepByStepModeAct = _wrapper->createAction(getMenuId(), tr("set execution mode step by step"), QIcon("icons:step_by_step_active.png"),
524  tr("mode step by step"), tr("set execution mode step by step"),
525  0, _parent, true, this, SLOT(onStepByStepMode(bool)));
526 
527  _toggleStopOnErrorAct = _wrapper->createAction(getMenuId(), tr("Force stop on first error during execution"), QIcon("icons:toggle_stop_on_error.png"),
528  tr("stop on error"), tr("Force stop on first error during execution"),
529  0, _parent, true, this, SLOT(onToggleStopOnError(bool)));
530 
531  _toggleSceneItemVisibleAct = _wrapper->createAction(getMenuId(), tr("toggle 2D scene item visibility"), QIcon("icons:toggleVisibility.png"),
532  tr("visible/hidden"), tr("toggle 2D scene item visibility"),
533  0, _parent, true, this, SLOT(onToggleSceneItemVisible(bool)));
534 
535 
536 
537  _showAllLinksAct = _wrapper->createAction(getMenuId(), tr("Show all the links"), QIcon("icons:showLink.png"),
538  tr("show all links"), tr("Show all the links"),
539  0, _parent, false, this, SLOT(onShowAllLinks()));
540 
541  _hideAllLinksAct = _wrapper->createAction(getMenuId(), tr("Hide all the links"), QIcon("icons:hideLink.png"),
542  tr("hide all links"), tr("Hide all the links"),
543  0, _parent, false, this, SLOT(onHideAllLinks()));
544 
545 
546  _showOnlyPortLinksAct = _wrapper->createAction(getMenuId(), tr("Show only links from/to this port"), QIcon("icons:showLink.png"),
547  tr("show only links"), tr("Show only links from/to this port"),
548  0, _parent, false, this, SLOT(onShowOnlyPortLinks()));
549 
550  _showPortLinksAct = _wrapper->createAction(getMenuId(), tr("Show links from/to this port"), QIcon("icons:showLink.png"),
551  tr("show links"), tr("Show links from/to this port"),
552  0, _parent, false, this, SLOT(onShowPortLinks()));
553 
554  _hidePortLinksAct = _wrapper->createAction(getMenuId(), tr("Hide links from/to this port"), QIcon("icons:hideLink.png"),
555  tr("hide links"), tr("Hide links from/to this port"),
556  0, _parent, false, this, SLOT(onHidePortLinks()));
557 
558 
559  _showOnlyCtrlLinksAct = _wrapper->createAction(getMenuId(), tr("Show only control links from/to this node"), QIcon("icons:showLink.png"),
560  tr("show only Control links"), tr("Show only control links from/to this node"),
561  0, _parent, false, this, SLOT(onShowOnlyCtrlLinks()));
562 
563  _showCtrlLinksAct = _wrapper->createAction(getMenuId(), tr("Show control links from/to this node"), QIcon("icons:showLink.png"),
564  tr("show control links"), tr("Show control links from/to this node"),
565  0, _parent, false, this, SLOT(onShowCtrlLinks()));
566 
567  _hideCtrlLinksAct = _wrapper->createAction(getMenuId(), tr("Hide control links from/to this node"), QIcon("icons:hideLink.png"),
568  tr("hide control links"), tr("Hide control links from/to this node"),
569  0, _parent, false, this, SLOT(onHideCtrlLinks()));
570 
571 
572  _showOnlyLinkAct = _wrapper->createAction(getMenuId(), tr("Show only this link"), QIcon("icons:showLink.png"),
573  tr("show only"), tr("Show only this link"),
574  0, _parent, false, this, SLOT(onShowOnlyLink()));
575 
576  _showLinkAct = _wrapper->createAction(getMenuId(), tr("Show this link"), QIcon("icons:showLink.png"),
577  tr("show"), tr("Show this link"),
578  0, _parent, false, this, SLOT(onShowLink()));
579 
580  _hideLinkAct = _wrapper->createAction(getMenuId(), tr("Hide this link"), QIcon("icons:hideLink.png"),
581  tr("hide"), tr("Hide this link"),
582  0, _parent, false, this, SLOT(onHideLink()));
583 
584 
585  _emphasisPortLinksAct = _wrapper->createAction(getMenuId(), tr("emphasis on links from/to this port"), QIcon("icons:emphasisLink.png"),
586  tr("emphasize links"), tr("emphasis on links from/to this port"),
587  0, _parent, false, this, SLOT(onEmphasisPortLinks()));
588 
589  _emphasisCtrlLinksAct = _wrapper->createAction(getMenuId(), tr("emphasis on control links from/to this node"), QIcon("icons:emphasisLink.png"),
590  tr("emphasize control links"), tr("emphasis on control links from/to this node"),
591  0, _parent, false, this, SLOT(onEmphasisCtrlLinks()));
592 
593  _emphasisLinkAct = _wrapper->createAction(getMenuId(), tr("emphasis on this link"), QIcon("icons:emphasisLink.png"),
594  tr("emphasize"), tr("emphasis on this link"),
595  0, _parent, false, this, SLOT(onEmphasisLink()));
596 
597  _deEmphasizeAllAct = _wrapper->createAction(getMenuId(), tr("remove all emphasis"), QIcon("icons:deEmphasisLink.png"),
598  tr("remove all emphasis"), tr("remove all emphasis"),
599  0, _parent, false, this, SLOT(onDeEmphasizeAll()));
600 
601 
602  _undoAct = _wrapper->createAction(getMenuId(), tr("undo last action"), QIcon("icons:undo.png"),
603  tr("undo"), tr("undo last action"),
604  0, _parent, false, this, SLOT(onUndo()));
605  _undoAct->setShortcut(QKeySequence::Undo);
606 
607  _redoAct = _wrapper->createAction(getMenuId(), tr("redo last action"), QIcon("icons:redo.png"),
608  tr("redo"), tr("redo last action"),
609  0, _parent, false, this, SLOT(onRedo()));
610  _redoAct->setShortcut(QKeySequence::Redo);
611 
612  _showUndoAct = _wrapper->createAction(getMenuId(), tr("show undo commands"), QIcon("icons:undo.png"),
613  tr("show undo"), tr("show undo commands"),
614  0, _parent, false, this, SLOT(onShowUndo()));
615 
616  _showRedoAct = _wrapper->createAction(getMenuId(), tr("show redo commands"), QIcon("icons:redo.png"),
617  tr("show redo"), tr("show redo commands"),
618  0, _parent, false, this, SLOT(onShowRedo()));
619 
620 
621  _execModeGroup = new QActionGroup(this);
622  _execModeGroup->addAction(_withoutStopModeAct);
623  _execModeGroup->addAction(_breakpointsModeAct);
624  _execModeGroup->addAction(_stepByStepModeAct);
625  _withoutStopModeAct->setChecked(true);
626 }
627 
628 void GenericGui::createMenus()
629 {
630  int aMenuId;
631  aMenuId = _wrapper->createMenu( tr( "File" ), -1, -1 );
632  _wrapper->createMenu( _wrapper->separator(), aMenuId, -1, 10 );
633  aMenuId = _wrapper->createMenu( "YACS", aMenuId, -1, 10 );
634  _wrapper->createMenu( _newSchemaAct, aMenuId );
635  _wrapper->createMenu( _importSchemaAct, aMenuId );
636 
637  aMenuId = _wrapper->createMenu( "YACS", -1, -1, 30 );
638  _wrapper->createMenu( _newSchemaAct, aMenuId );//, 10
639  _wrapper->createMenu( _importSchemaAct, aMenuId );
640  _wrapper->createMenu( _importSupervSchemaAct, aMenuId );
641  _wrapper->createMenu( _wrapper->separator(), aMenuId);
642  _wrapper->createMenu( _exportSchemaAct, aMenuId );
643  _wrapper->createMenu( _exportSchemaAsAct, aMenuId );
644  _wrapper->createMenu( _wrapper->separator(), aMenuId);
645  _wrapper->createMenu( _runLoadedSchemaAct, aMenuId );
646  _wrapper->createMenu( _loadRunStateSchemaAct, aMenuId );
647  _wrapper->createMenu( _loadAndRunSchemaAct, aMenuId );
648  _wrapper->createMenu( _chooseBatchJobAct, aMenuId );
649  _wrapper->createMenu( _wrapper->separator(), aMenuId);
650  _wrapper->createMenu( _undoAct, aMenuId );
651  _wrapper->createMenu( _redoAct, aMenuId );
652  _wrapper->createMenu( _showUndoAct, aMenuId );
653  _wrapper->createMenu( _showRedoAct, aMenuId );
654  _wrapper->createMenu( _wrapper->separator(), aMenuId);
655  _wrapper->createMenu( _startResumeAct, aMenuId );
656  _wrapper->createMenu( _abortAct, aMenuId );
657  _wrapper->createMenu( _pauseAct, aMenuId );
658  _wrapper->createMenu( _resetAct, aMenuId );
659  _wrapper->createMenu( _wrapper->separator(), aMenuId);
660  _wrapper->createMenu( _saveRunStateAct, aMenuId );
661  //_wrapper->createMenu( _newEditionAct, aMenuId );
662  _wrapper->createMenu( _wrapper->separator(), aMenuId);
663  _wrapper->createMenu( _withoutStopModeAct, aMenuId );
664  _wrapper->createMenu( _breakpointsModeAct, aMenuId );
665  _wrapper->createMenu( _stepByStepModeAct, aMenuId );
666  _wrapper->createMenu( _wrapper->separator(), aMenuId);
667  _wrapper->createMenu( _toggleStopOnErrorAct, aMenuId );
668  _wrapper->createMenu( _wrapper->separator(), aMenuId);
669  _wrapper->createMenu( _importCatalogAct, aMenuId );
670  _wrapper->createMenu( _wrapper->separator(), aMenuId);
671  _wrapper->createMenu( _toggleStraightLinksAct, aMenuId );
672  _wrapper->createMenu( _toggleAutomaticComputeLinkAct, aMenuId );
673  _wrapper->createMenu( _toggleSimplifyLinkAct, aMenuId );
674  _wrapper->createMenu( _toggleForce2NodesLinkAct, aMenuId );
675  _wrapper->createMenu( _toggleAddRowColsAct, aMenuId );
676  _wrapper->createMenu( _wrapper->separator(), aMenuId);
677  _wrapper->createMenu( _showAllLinksAct, aMenuId );
678  _wrapper->createMenu( _hideAllLinksAct, aMenuId );
679  _wrapper->createMenu( _wrapper->separator(), aMenuId);
680  _wrapper->createMenu( _whatsThisAct, aMenuId );
681 }
682 
683 void GenericGui::createTools()
684 {
685  int aToolId = _wrapper->createTool ( tr( "YACS Toolbar" ), QString( "YACSToolbar" ) );
686  _wrapper->createTool( _newSchemaAct, aToolId );
687  _wrapper->createTool( _importSchemaAct, aToolId );
688  _wrapper->createTool( _wrapper->separator(), aToolId );
689  _wrapper->createTool( _exportSchemaAct, aToolId );
690  _wrapper->createTool( _exportSchemaAsAct, aToolId );
691  _wrapper->createTool( _wrapper->separator(), aToolId);
692  _wrapper->createTool( _runLoadedSchemaAct, aToolId );
693  _wrapper->createTool( _loadRunStateSchemaAct, aToolId );
694  _wrapper->createTool( _loadAndRunSchemaAct, aToolId );
695  _wrapper->createTool( _chooseBatchJobAct, aToolId );
696  _wrapper->createTool( _wrapper->separator(), aToolId );
697  _wrapper->createTool( _undoAct, aToolId );
698  _wrapper->createTool( _redoAct, aToolId );
699  _wrapper->createTool( _wrapper->separator(), aToolId );
700  _wrapper->createTool( _startResumeAct, aToolId );
701  _wrapper->createTool( _abortAct, aToolId );
702  _wrapper->createTool( _pauseAct, aToolId );
703  _wrapper->createTool( _resetAct, aToolId );
704  _wrapper->createTool( _wrapper->separator(), aToolId );
705  _wrapper->createTool( _saveRunStateAct, aToolId );
706  //_wrapper->createTool( _newEditionAct, aToolId );
707  _wrapper->createTool( _withoutStopModeAct, aToolId );
708  _wrapper->createTool( _breakpointsModeAct, aToolId );
709  _wrapper->createTool( _stepByStepModeAct, aToolId );
710  _wrapper->createTool( _wrapper->separator(), aToolId );
711  _wrapper->createTool( _toggleStopOnErrorAct, aToolId );
712  _wrapper->createTool( _wrapper->separator(), aToolId );
713  _wrapper->createTool( _importCatalogAct, aToolId );
714  _wrapper->createTool( _wrapper->separator(), aToolId );
715  _wrapper->createTool( _toggleStraightLinksAct, aToolId );
716  _wrapper->createTool( _toggleAutomaticComputeLinkAct, aToolId );
717  _wrapper->createTool( _toggleSimplifyLinkAct, aToolId );
718  //_wrapper->createTool( _toggleForce2NodesLinkAct, aToolId );
719  _wrapper->createTool( _toggleAddRowColsAct, aToolId );
720  _wrapper->createTool( _wrapper->separator(), aToolId );
721  _wrapper->createTool( _showAllLinksAct, aToolId );
722  _wrapper->createTool( _hideAllLinksAct, aToolId );
723  _wrapper->createTool( _wrapper->separator(), aToolId );
724  _wrapper->createTool( _whatsThisAct, aToolId );
725 }
726 
727 void GenericGui::initialMenus()
728 {
729  showEditionMenus(false);
730  showExecMenus(false);
731  showCommonMenus(false);
732  showBaseMenus(true);
733 }
734 
735 void GenericGui::hideAllMenus()
736 {
737  showBaseMenus (false);
738  showCommonMenus (false);
739  showEditionMenus(false);
740  showExecMenus (false);
741 }
742 
743 void GenericGui::showBaseMenus(bool show)
744 {
745  DEBTRACE("GenericGui::showBaseMenus " << show);
746  _wrapper->setMenuShown(_newSchemaAct, show);
747  _wrapper->setToolShown(_newSchemaAct, show);
748  _wrapper->setMenuShown(_importSchemaAct, show);
749  _wrapper->setToolShown(_importSchemaAct, show);
750  _wrapper->setMenuShown(_importSupervSchemaAct, show);
751  _wrapper->setMenuShown(_loadAndRunSchemaAct, show);
752  _wrapper->setToolShown(_loadAndRunSchemaAct, show);
753  _wrapper->setMenuShown(_chooseBatchJobAct, show);
754  _wrapper->setToolShown(_chooseBatchJobAct, show);
755  _wrapper->setMenuShown(_whatsThisAct, show);
756  _wrapper->setToolShown(_whatsThisAct, show);
757 }
758 
759 void GenericGui::showEditionMenus(bool show)
760 {
761  DEBTRACE("GenericGui::showEditionMenus " << show);
762  _wrapper->setMenuShown(_exportSchemaAct, show);
763  _wrapper->setToolShown(_exportSchemaAct, show);
764  _wrapper->setMenuShown(_exportSchemaAsAct, show);
765  _wrapper->setToolShown(_exportSchemaAsAct, show);
766  _wrapper->setMenuShown(_runLoadedSchemaAct, show);
767  _wrapper->setToolShown(_loadRunStateSchemaAct, show);
768  _wrapper->setMenuShown(_loadRunStateSchemaAct, show);
769  _wrapper->setToolShown(_runLoadedSchemaAct, show);
770  _wrapper->setMenuShown(_undoAct, show);
771  _wrapper->setToolShown(_undoAct, show);
772  _wrapper->setMenuShown(_redoAct, show);
773  _wrapper->setToolShown(_redoAct, show);
774  _wrapper->setMenuShown(_showUndoAct, show);
775  _wrapper->setMenuShown(_showRedoAct, show);
776  _wrapper->setMenuShown(_importCatalogAct, show);
777  _wrapper->setToolShown(_importCatalogAct, show);
778 }
779 
780 void GenericGui::showExecMenus(bool show)
781 {
782  DEBTRACE("GenericGui::showExecMenus " << show);
783  _wrapper->setMenuShown(_startResumeAct, show);
784  _wrapper->setToolShown(_startResumeAct, show);
785  _wrapper->setMenuShown(_abortAct, show);
786  _wrapper->setToolShown(_abortAct, show);
787  _wrapper->setMenuShown(_pauseAct, show);
788  _wrapper->setToolShown(_pauseAct, show);
789  _wrapper->setMenuShown(_resetAct, show);
790  _wrapper->setToolShown(_resetAct, show);
791  _wrapper->setMenuShown(_saveRunStateAct, show);
792  _wrapper->setToolShown(_saveRunStateAct, show);
793  //_wrapper->setMenuShown(_newEditionAct, show);
794  //_wrapper->setToolShown(_newEditionAct, show);
795  _wrapper->setMenuShown(_withoutStopModeAct, show);
796  _wrapper->setToolShown(_withoutStopModeAct, show);
797  _wrapper->setMenuShown(_breakpointsModeAct, show);
798  _wrapper->setToolShown(_breakpointsModeAct, show);
799  _wrapper->setMenuShown(_stepByStepModeAct, show);
800  _wrapper->setToolShown(_stepByStepModeAct, show);
801  _wrapper->setMenuShown(_toggleStopOnErrorAct, show);
802  _wrapper->setToolShown(_toggleStopOnErrorAct, show);
803 }
804 
805 void GenericGui::showCommonMenus(bool show)
806 {
807  DEBTRACE("GenericGui::showCommonMenus " << show);
808  _wrapper->setMenuShown(_toggleStraightLinksAct, show);
809  _wrapper->setToolShown(_toggleStraightLinksAct, show);
810  _wrapper->setMenuShown(_toggleAutomaticComputeLinkAct, show);
811  _wrapper->setToolShown(_toggleAutomaticComputeLinkAct, show);
812  _wrapper->setMenuShown(_toggleSimplifyLinkAct, show);
813  _wrapper->setToolShown(_toggleSimplifyLinkAct, show);
814  _wrapper->setMenuShown(_toggleForce2NodesLinkAct, show);
815  //_wrapper->setToolShown(_toggleForce2NodesLinkAct, show);
816  _wrapper->setMenuShown(_toggleAddRowColsAct, show);
817  _wrapper->setToolShown(_toggleAddRowColsAct, show);
818  _wrapper->setMenuShown(_showAllLinksAct, show);
819  _wrapper->setToolShown(_showAllLinksAct, show);
820  _wrapper->setMenuShown(_hideAllLinksAct, show);
821  _wrapper->setToolShown(_hideAllLinksAct, show);
822 }
823 
824 void GenericGui::switchContext(QWidget *view, bool onExit)
825 {
826  DEBTRACE("GenericGui::switchContext " << view);
827  if (! _mapViewContext.count(view))
828  {
829  onExit ? hideAllMenus() : initialMenus();
830  _dwTree->setWidget(0);
831  _dwStacked->setWidget(0);
832  return;
833  }
834  QtGuiContext* newContext = _mapViewContext[view];
835 
836  _dwTree->setWidget(newContext->getEditTree());
837  _dwTree->widget()->show();
838  _dwTree->raise();
839  _dwStacked->setWidget(newContext->getStackedWidget());
840 
841  QtGuiContext::setQtCurrent(newContext);
842 
843  if (newContext->isEdition())
844  {
845  showExecMenus(false);
846  showBaseMenus(true);
847  showEditionMenus(true);
848  showCommonMenus(true);
849  if (_dwTree) _dwTree->setWindowTitle("Tree View: edition mode");
850  }
851  else
852  {
853  showEditionMenus(false);
854  showBaseMenus(true);
855  showExecMenus(true);
856  showCommonMenus(true);
857  _withoutStopModeAct->setChecked(true);
858  if (_dwTree) _dwTree->setWindowTitle("Tree View: execution mode");
859  }
860  _dwStacked->setMinimumWidth(10);
861 }
862 
863 bool GenericGui::closeContext(QWidget *view, bool onExit)
864 {
865  DEBTRACE("GenericGui::closeContext " << onExit);
866  if (! _mapViewContext.count(view))
867  return true;
868  QtGuiContext* context = _mapViewContext[view];
869  switchContext(view);
870 
871  bool tryToSave = false;
872 
873  if (QtGuiContext::getQtCurrent()->isEdition())
874  {
875  if (!QtGuiContext::getQtCurrent()->_setOfModifiedSubjects.empty())
876  {
877  QMessageBox msgBox;
878  msgBox.setText("Some elements are modified and not taken into account.");
879  string info = "do you want to apply your changes ?\n";
880  info += " - Save : do not take into account edition in progress,\n";
881  info += " but if there are other modifications, select a file name for save\n";
882  info += " - Discard : discard all modifications and close the schema";
883  if (!onExit)
884  info += "\n - Cancel : do not close the schema, return to edition";
885  msgBox.setInformativeText(info.c_str());
886  if (!onExit)
887  {
888  msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
889  msgBox.setDefaultButton(QMessageBox::Cancel);
890  }
891  else
892  {
893  msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard);
894  msgBox.setDefaultButton(QMessageBox::Save);
895  }
896  int ret = msgBox.exec();
897  switch (ret)
898  {
899  case QMessageBox::Save:
900  tryToSave = true;
901  break;
902  case QMessageBox::Discard:
903  tryToSave = false;
904  break;
905  case QMessageBox::Cancel:
906  default:
907  DEBTRACE("Cancel or default");
908  return false;
909  break;
910  }
911  }
912  else
913  if (QtGuiContext::getQtCurrent()->isNotSaved())
914  {
915  QMessageBox msgBox;
916  msgBox.setWindowTitle("Close the active schema");
917  msgBox.setText("The schema has been modified");
918  string info = "do you want to save the schema ?\n";
919  info += " - Save : select a file name for save\n";
920  info += " - Discard : discard all modifications and close the schema";
921  if (!onExit)
922  info += "\n - Cancel : do not close the schema, return to edition";
923  msgBox.setInformativeText(info.c_str());
924  if (!onExit)
925  {
926  msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
927  msgBox.setDefaultButton(QMessageBox::Cancel);
928  }
929  else
930  {
931  msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard);
932  msgBox.setDefaultButton(QMessageBox::Save);
933  }
934  int ret = msgBox.exec();
935  switch (ret)
936  {
937  case QMessageBox::Save:
938  tryToSave = true;
939  break;
940  case QMessageBox::Discard:
941  tryToSave = false;
942  break;
943  case QMessageBox::Cancel:
944  DEBTRACE("Cancel or default");
945  default:
946  return false;
947  break;
948  }
949  }
950 
951  if (tryToSave)
952  {
953  onExportSchemaAs();
954  if ((!onExit) && (!_isSaved)) // --- probably, user has cancelled the save dialog. Do not close
955  return false;
956  }
957  }
958 
959  map<QWidget*, YACS::HMI::QtGuiContext*>::iterator it = _mapViewContext.begin();
960  QtGuiContext* newContext = 0;
961  QWidget* newView = 0;
962  for (; it != _mapViewContext.end(); ++it)
963  {
964  if ((*it).second != context)
965  {
966  newView = (*it).first;
967  newContext = (*it).second;
968  break;
969  }
970  }
971  _wrapper->deleteSchema(view);
972  DEBTRACE("delete context");
973  if (GuiExecutor* exec = context->getGuiExecutor())
974  {
975  exec->closeContext();
976  }
977  delete context;
978  _mapViewContext.erase(view);
979  switchContext(newView, onExit);
980  return true;
981 }
982 
983 void GenericGui::showDockWidgets(bool isVisible)
984 {
985  DEBTRACE("GenericGui::showDockWidgets " << isVisible);
986  if (_dwTree) _dwTree->setVisible(isVisible);
987  if (_dwTree) _dwTree->toggleViewAction()->setVisible(isVisible);
988  if (_dwStacked) _dwStacked->setVisible(isVisible);
989  if (_dwStacked) _dwStacked->toggleViewAction()->setVisible(isVisible);
990  if (_dwCatalogs) _dwCatalogs->setVisible(isVisible);
991  if (_dwCatalogs) _dwCatalogs->toggleViewAction()->setVisible(isVisible);
992 }
993 
994 void GenericGui::raiseStacked()
995 {
996  if (_dwStacked) _dwStacked->raise();
997 }
998 
999 std::list<std::string> GenericGui::getMachineList()
1000 {
1001  if (!_machineList.empty()) return _machineList;
1002 
1003  YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime();
1004  CORBA::ORB_ptr orb = runTime->getOrb();
1005  if (!orb) return _machineList;
1006 
1007  SALOME_NamingService_Wrapper namingService(orb);
1008  SALOME_LifeCycleCORBA lcc(&namingService);
1009 
1010  CORBA::Object_var obj =
1011  namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS);
1012  if (CORBA::is_nil(obj)) return _machineList;
1013 
1014  Engines::ResourcesManager_var resManager = Engines::ResourcesManager::_narrow(obj);
1015  if(!resManager) return _machineList;
1016 
1017  Engines::ResourceParameters params;
1018  lcc.preSet(params);
1019 
1020  Engines::ResourceList* resourceList =
1021  resManager->GetFittingResources(params);
1022 
1023  for (int i = 0; i < resourceList->length(); i++)
1024  {
1025  const char* aResource = (*resourceList)[i];
1026  _machineList.push_back(aResource);
1027  }
1028 
1029  return _machineList;
1030 }
1031 
1032 // -----------------------------------------------------------------------------
1033 
1043 void GenericGui::createContext(YACS::ENGINE::Proc* proc,
1044  const QString& schemaName,
1045  const QString& runName,
1046  bool forEdition)
1047 {
1048  DEBTRACE("GenericGui::createContext");
1049  clock_t start_t;
1050  clock_t end_t;
1051  start_t = clock();
1052 
1053 
1054  QWidget* central = _parent->centralWidget();
1055  if (central)
1056  central->setFocus();
1057  else
1058  DEBTRACE("No Central Widget");
1059 
1060  QString fileName;
1061  QWidget* refWindow = 0; // --- used only on run to refer to the schema in edition
1062  if (forEdition)
1063  {
1064  fileName = schemaName;
1065  }
1066  else
1067  {
1068  fileName = runName;
1069  if (QtGuiContext::getQtCurrent())
1070  refWindow = QtGuiContext::getQtCurrent()->getWindow();
1071  }
1072 
1073  QtGuiContext* context = new QtGuiContext(this);
1074  QtGuiContext::setQtCurrent(context);
1075 
1076  // --- catalogs
1077 
1078  context->setEdition(forEdition);
1079  context->setSessionCatalog(_sessionCatalog);
1080  context->setFileName(fileName);
1081  context->setCurrentCatalog(_builtinCatalog);
1082 
1083  // --- scene, viewWindow & GraphicsView
1084 
1085  Scene *scene = new Scene();
1086  QWidget *viewWindow = _wrapper->getNewWindow(scene);
1087  _mapViewContext[viewWindow] = context;
1088  GraphicsView* gView = new GraphicsView(viewWindow);
1089  gView->setScene(scene);
1090  gView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
1091  _wrapper->AssociateViewToWindow(gView, viewWindow);
1092  context->setScene(scene);
1093  context->setView(gView);
1094  context->setWindow(viewWindow);
1095  gView->show();
1096 
1097  // --- Schema Model
1098 
1099  SchemaModel *schemaModel = new SchemaModel(context, viewWindow);
1100  schemaModel->setEdition(forEdition);
1101  context->setSchemaModel(schemaModel);
1102  RootSceneItem *rootSceneItem = new RootSceneItem(context);
1103 
1104  // --- tree associated to model
1105 
1106  FormEditTree *editTree = new FormEditTree(_dwTree);
1107  editTree->setMinimumHeight(400);
1108  _dwTree->setWidget(editTree);
1109  editTree->show();
1110  context->setEditTree(editTree);
1111  editTree->tv_schema->setModel(schemaModel);
1112  context->setSelectionModel(editTree->tv_schema->selectionModel());
1113  _dwTree->raise();
1114 
1115  QObject::connect(editTree->tv_schema->selectionModel(),
1116  SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
1117  schemaModel,
1118  SLOT(updateSelection(const QItemSelection &, const QItemSelection &)));
1119 
1120  // --- stacked widget
1121 
1122  QStackedWidget *stacked = new QStackedWidget(_dwStacked);
1123  _dwStacked->setWidget(stacked);
1124  context->setStackedWidget(stacked);
1125  YACS::HMI::ItemEditionRoot* rootEdit = new YACS::HMI::ItemEditionRoot(context,
1126  0,
1127  context->getName().c_str());
1128  context->setEditionRoot(rootEdit);
1129 
1130  QObject::connect(schemaModel,
1131  SIGNAL(signalSelection(const QModelIndex &)),
1132  editTree->tv_schema,
1133  SLOT(viewSelection(const QModelIndex &)));
1134 
1135  // --- load schema
1136 
1137  proc->setEdition(forEdition);
1138 
1139  {
1140  end_t = clock();
1141  double passe = (end_t -start_t);
1142  passe = passe/CLOCKS_PER_SEC;
1143  DEBTRACE("create context -1- : " << passe);
1144  start_t = end_t;
1145  }
1146 
1147  context->setLoading(true);
1148 
1149  context->setProc(proc);
1150  setLoadedPresentation(proc);
1151 
1152  {
1153  end_t = clock();
1154  double passe = (end_t -start_t);
1155  passe = passe/CLOCKS_PER_SEC;
1156  DEBTRACE("create context - load proc- : " << passe);
1157  start_t = end_t;
1158  }
1159 
1160  context->setLoading(false);
1161 
1162  if (forEdition && _wrapper) // --- Edition mode
1163  {
1164  _wrapper->createNewSchema(fileName, viewWindow);
1165  }
1166  else if (_wrapper) // --- Execution Mode
1167  {
1168  GuiExecutor *guiExec = new GuiExecutor(proc);
1169  context->setGuiExecutor(guiExec);
1170  _wrapper->createNewRun(schemaName, fileName, refWindow, viewWindow);
1171  }
1172 
1173 
1174  QtGuiContext::getQtCurrent()->getSubjectProc()->update(UPDATE,
1175  ProcInvoc::getTypeOfNode(proc),
1176  0); // --- force validity check
1177 
1178  // --- adjust widgets
1179 
1180  TreeView *vtree = dynamic_cast<TreeView*>(editTree->tv_schema);
1181  YASSERT(vtree);
1182  vtree->resizeColumns();
1183  _catalogsWidget->setMinimumWidth(10); // --- reset the constraint on width
1184  editTree->setMinimumHeight(40);
1185  _dwStacked->setMinimumWidth(10);
1186  // --- show menus
1187 
1188  if (forEdition)
1189  {
1190  showExecMenus(false);
1191  showEditionMenus(true);
1192  showCommonMenus(true);
1193  if (_dwTree) _dwTree->setWindowTitle("Tree View: edition mode");
1194  }
1195  else
1196  {
1197  showEditionMenus(false);
1198  showExecMenus(true);
1199  showCommonMenus(true);
1200  _withoutStopModeAct->setChecked(true);
1201  if (_dwTree) _dwTree->setWindowTitle("Tree View: execution mode");
1202  }
1203 
1204  QtGuiContext::getQtCurrent()->setNotSaved(false);
1205  {
1206  end_t = clock();
1207  double passe = (end_t -start_t);
1208  passe = passe/CLOCKS_PER_SEC;
1209  DEBTRACE("create context - end - : " << passe);
1210  start_t = end_t;
1211  }
1212 }
1213 
1214 // -----------------------------------------------------------------------------
1215 
1216 void GenericGui::setLoadedPresentation(YACS::ENGINE::Proc* proc)
1217 {
1218  DEBTRACE("GenericGui::setLoadedPresentation");
1219  QtGuiContext::getQtCurrent()->setLoadingPresentation(true);
1220  map<SceneNodeItem*, QPointF> nodesToMove;
1221  map<YACS::ENGINE::Node*, PrsData> presNodes = _loader->getPrsData(proc);
1222  if (!presNodes.empty())
1223  {
1224  map<YACS::ENGINE::Node*, PrsData>::iterator it = presNodes.begin();
1225  for (; it!= presNodes.end(); ++it)
1226  {
1227  YACS::ENGINE::Node* node = (*it).first;
1228  PrsData pres = (*it).second;
1229  SubjectNode *snode = QtGuiContext::getQtCurrent()->_mapOfSubjectNode[node];
1230  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[snode];
1231  YASSERT(item);
1232  SceneNodeItem *inode = dynamic_cast<SceneNodeItem*>(item);
1233  YASSERT(inode);
1234  inode->setPos(QPointF(pres._x, pres._y));
1235  inode->setWidth(pres._width);
1236  inode->setHeight(pres._height);
1237  inode->setExpanded(pres._expanded);
1238  QPointF anExpandedPos = QPointF(pres._expx, pres._expy);
1239  if (anExpandedPos.isNull())
1240  anExpandedPos = inode->pos();
1241  inode->setExpandedPos(anExpandedPos);
1242  inode->setExpandedWH(pres._expWidth, pres._expHeight);
1243  inode->setShownState(shownState(pres._shownState));
1244 
1245  // collect nodes to correct it's Y-position if this collides with parent's header
1246  if (inode->getParent() ) {
1247  qreal anX = inode->x();
1248  qreal anY = inode->y();
1249  if (inode->getShownState() == shrinkHidden) {
1250  anX = inode->getExpandedX();
1251  anY = inode->getExpandedY();
1252  }
1253  if (anY < inode->getParent()->getHeaderBottom())
1254  nodesToMove[inode] = QPointF(anX, inode->getParent()->getHeaderBottom()+1);
1255  }
1256  }
1257  }
1258  QtGuiContext::getQtCurrent()->setLoadingPresentation(false);
1259 
1260  //after loading of presentation:
1261 
1262  //move nodes because of progress bar, if any was added
1263  map<SceneNodeItem*, QPointF>::iterator it = nodesToMove.begin();
1264  for (; it!= nodesToMove.end(); ++it)
1265  {
1266  (*it).first->setTopLeft((*it).second);
1267  }
1268 
1269  //update links
1270  if (Scene::_autoComputeLinks)
1271  _guiEditor->rebuildLinks();
1272  else
1273  {
1274  YACS::HMI::SubjectProc* subproc = QtGuiContext::getQtCurrent()->getSubjectProc();
1275  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[subproc];
1276  SceneComposedNodeItem *proc = dynamic_cast<SceneComposedNodeItem*>(item);
1277  proc->updateLinks();
1278  }
1279 }
1280 
1281 // -----------------------------------------------------------------------------
1282 
1283 void GenericGui::onNewSchema()
1284 {
1285  DEBTRACE("GenericGui::onNewSchema");
1286 
1287  std::stringstream name;
1288  name << "newSchema_" << ++_schemaCnt;
1289 
1290  YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime();
1291  YACS::ENGINE::Proc *proc = runTime->createProc(name.str());
1292 
1293  _loader->reset();
1294 
1295  QString fileName = name.str().c_str();
1296  createContext(proc, fileName, "", true);
1297 }
1298 
1299 void GenericGui::loadSchema(const std::string& filename,bool edit, bool arrangeLocalNodes)
1300 {
1301  YACS::ENGINE::Proc *proc = _loader->load(filename.c_str());
1302  if (!proc)
1303  return;
1304  YACS::ENGINE::Logger* logger= proc->getLogger("parser");
1305  if(!logger->isEmpty())
1306  {
1307  DEBTRACE(logger->getStr());
1308  }
1309  QString fn=QString::fromUtf8(filename.c_str());
1310  if(edit)
1311  createContext(proc, fn, "", true);
1312  else
1313  createContext(proc, fn, fn, false);
1314  if (arrangeLocalNodes)
1315  {
1316  _guiEditor->arrangeProc();
1317  }
1318 }
1319 
1320 void GenericGui::onImportSchema()
1321 {
1322  clock_t start_t;
1323  clock_t end_t;
1324  start_t = clock();
1325  DEBTRACE("GenericGui::onImportSchema");
1326  QFileDialog dialog(_parent,
1327  "Choose a filename to load" ,
1328  QString::null,
1329  tr( "XML-Files (*.xml);;All Files (*)" ));
1330 
1331  dialog.setHistory(_wrapper->getQuickDirList());
1332 
1333  QString fn;
1334  QStringList fileNames;
1335  if (dialog.exec())
1336  {
1337  fileNames = dialog.selectedFiles();
1338  if (!fileNames.isEmpty())
1339  fn = fileNames.first();
1340  }
1341 
1342  if ( !fn.isEmpty() )
1343  {
1344  // add ".xml" suffix
1345  QFileInfo fi(fn);
1346  if (!fi.exists() && fi.suffix() != "xml")
1347  fn += ".xml";
1348 
1349  DEBTRACE("file loaded : " <<fn.toUtf8().constData());
1350  YACS::ENGINE::Proc *proc = 0;
1351 
1352  try {
1353  proc = _loader->load(fn.toUtf8().constData());
1354  }
1355  catch (...) {
1356  }
1357 
1358  {
1359  end_t = clock();
1360  double passe = (end_t -start_t);
1361  passe = passe/CLOCKS_PER_SEC;
1362  DEBTRACE("load xml file : " << passe);
1363  start_t = end_t;
1364  }
1365 
1366  if (!proc)
1367  {
1368  QMessageBox msgBox(QMessageBox::Critical,
1369  "Import YACS Schema, native YACS XML format",
1370  "The file has not the native YACS XML format or is not readable.");
1371  msgBox.exec();
1372  return;
1373  }
1374  YACS::ENGINE::Logger* logger= proc->getLogger("parser");
1375  if(!logger->isEmpty())
1376  {
1377  DEBTRACE(logger->getStr());
1378  }
1379  createContext(proc, fn, "", true);
1380  }
1381 }
1382 
1383 void GenericGui::onImportSupervSchema()
1384 {
1385  DEBTRACE("GenericGui::onImportSupervSchema");
1386  QFileDialog dialog(_parent,
1387  "Choose a SUPERV filename to load" ,
1388  QString::null,
1389  tr( "XML-Files (*.xml);;All Files (*)" ));
1390 
1391  dialog.setHistory(_wrapper->getQuickDirList());
1392 
1393  QString fn;
1394  QStringList fileNames;
1395  if (dialog.exec())
1396  {
1397  fileNames = dialog.selectedFiles();
1398  if (!fileNames.isEmpty())
1399  fn = fileNames.first();
1400  }
1401 
1402  if (fn.isEmpty()) return;
1403 
1404  // add ".xml" suffix
1405  QFileInfo fi(fn);
1406  if (!fi.exists() && fi.suffix() != "xml")
1407  fn += ".xml";
1408 
1409  DEBTRACE("file loaded : " <<fn.toStdString());
1410  QString tmpFileName;
1411  try
1412  {
1413 #ifdef WIN32
1414  QString tmpDir = getenv("TEMP");
1415  QString fileExt = "bat";
1416 #else
1417  QString tmpDir = "/tmp";
1418  QString fileExt = "sh";
1419 #endif
1420  QDir aTmpDir(tmpDir);
1421  aTmpDir.mkdir(QString("YACS_") + getenv("USER"));
1422  YASSERT(aTmpDir.cd(QString("YACS_") + getenv("USER")));
1423  QDateTime curTime = QDateTime::currentDateTime();
1424  tmpFileName = "SUPERV_import_" + curTime.toString("yyyyMMdd_hhmmss") + ".xml";
1425  QString tmpOutput = "salomeloader_output";
1426  tmpFileName = aTmpDir.absoluteFilePath(tmpFileName);
1427  DEBTRACE(tmpFileName.toStdString());
1428 
1429  QString aCall = "salomeloader."+ fileExt+ " "+ fn + " " + tmpFileName + " > " + tmpOutput;
1430  DEBTRACE(aCall.toStdString());
1431 
1432  int ret = system(aCall.toLatin1());
1433  if(ret != 0)
1434  {
1435  // --- read file with logs
1436  fstream f(tmpOutput.toLatin1());
1437  stringstream hfile;
1438  hfile << f.rdbuf();
1439  f.close();
1440 
1441  // --- Problem in execution
1442  int status=WEXITSTATUS(ret);
1443  if(status == 1)
1444  {
1445  QString mes = "Problems in conversion: some errors but an incomplete proc has nevertheless been created.\n\n";
1446  mes += QString(hfile.str().c_str());
1447  QMessageBox msgBox(QMessageBox::Warning,
1448  "Import YACS Schema, SUPERV XML format",
1449  mes);
1450  msgBox.exec();
1451  }
1452  else if(status == 2)
1453  {
1454  QString mes = "Problems in conversion: a fatal error has been encountered. The proc can't be created.\n\n";
1455  mes += QString(hfile.str().c_str());
1456  QMessageBox msgBox(QMessageBox::Critical,
1457  "Import YACS Schema, SUPERV XML format",
1458  mes);
1459  msgBox.exec();
1460  return;
1461  }
1462  else
1463  {
1464  DEBTRACE("Unknown problem: " << ret );
1465  QMessageBox msgBox(QMessageBox::Critical,
1466  "Import YACS Schema, SUPERV XML format",
1467  "Unexpected exception in salomeloader.");
1468  msgBox.exec();
1469  return;
1470  }
1471  }
1472  }
1473  catch(...)
1474  {
1475  QMessageBox msgBox(QMessageBox::Critical,
1476  "Import YACS Schema, SUPERV XML format",
1477  "Unexpected exception in convertSupervFile");
1478  msgBox.exec();
1479  return;
1480  }
1481 
1482  fn = tmpFileName;
1483  if (fn.isEmpty()) return; // must not happen
1484 
1485  DEBTRACE("file loaded : " <<fn.toStdString());
1486  YACS::ENGINE::Proc *proc = _loader->load(fn.toLatin1());
1487  if (!proc)
1488  {
1489  QMessageBox msgBox(QMessageBox::Critical,
1490  "Import YACS Schema, SUPERV file converted in native YACS XML format",
1491  "The file has not the native YACS XML format or is not readable.");
1492  msgBox.exec();
1493  return;
1494  }
1495  YACS::ENGINE::Logger* logger= proc->getLogger("parser");
1496  if(!logger->isEmpty())
1497  {
1498  DEBTRACE(logger->getStr());
1499  }
1500  createContext(proc, fn, "", true);
1501 }
1502 
1504 QString GenericGui::getSaveFileName(const QString& fileName)
1505 {
1506  QFileDialog dialog(_parent, "Save schema", fileName);
1507  QStringList filters;
1508  filters << "XML files (*.xml)"
1509  << "Any files (*)";
1510  dialog.setFileMode(QFileDialog::AnyFile);
1511  dialog.setNameFilters(filters);
1512  dialog.selectNameFilter("(*.xml)");
1513  dialog.setDefaultSuffix("xml");
1514  dialog.setConfirmOverwrite(true);
1515  //dialog.setConfirmOverwrite(false); // bug Qt4.3.3
1516  dialog.setAcceptMode(QFileDialog::AcceptSave);
1517  QString selectedFile;
1518  QStringList fileNames;
1519  fileNames.clear();
1520  if (bool ret = dialog.exec())
1521  {
1522  DEBTRACE(ret << " " << dialog.confirmOverwrite());
1523  fileNames = dialog.selectedFiles();
1524  if (!fileNames.isEmpty())
1525  selectedFile = fileNames.first();
1526  }
1527  QString filteredName = _guiEditor->asciiFilter(selectedFile);
1528  DEBTRACE(filteredName.toStdString());
1529  return filteredName;
1530 }
1531 
1532 void GenericGui::onExportSchema()
1533 {
1534  DEBTRACE("GenericGui::onExportSchema");
1535  if (!QtGuiContext::getQtCurrent()) return;
1536  YACS::ENGINE::Proc* proc = QtGuiContext::getQtCurrent()->getProc();
1537  QString fo = QtGuiContext::getQtCurrent()->getFileName();
1538  QString foo = fo;
1539  QString fn = fo;
1540  if (fo.startsWith("newSchema_"))
1541  {
1542  fo.clear();
1543  fn = getSaveFileName(fo);
1544  }
1545  if (fn.isEmpty()) return;
1546 
1547  DEBTRACE("GenericGui::onExportSchema: " << fn.toUtf8().constData());
1548  //to be sure that all pending changes are effective
1549  _parent->setFocus();
1550  QtGuiContext::getQtCurrent()->setFileName(fn);
1551  VisitorSaveGuiSchema aWriter(proc);
1552  aWriter.openFileSchema( fn.toUtf8().constData() );
1553  aWriter.visitProc();
1554  aWriter.closeFileSchema();
1555  QtGuiContext::getQtCurrent()->setNotSaved(false);
1556 
1557  if (fn.compare(foo) && _wrapper)
1558  _wrapper->renameSchema(foo, fn, QtGuiContext::getQtCurrent()->getWindow());
1559 }
1560 
1561 void GenericGui::onExportSchemaAs()
1562 {
1563  DEBTRACE("GenericGui::onExportSchemaAs");
1564  _isSaved = false;
1565  if (!QtGuiContext::getQtCurrent()) return;
1566  YACS::ENGINE::Proc* proc = QtGuiContext::getQtCurrent()->getProc();
1567  QString fo = QtGuiContext::getQtCurrent()->getFileName();
1568  QString foo = fo;
1569  if (fo.startsWith("newSchema_")) fo.clear();
1570  QString fn = getSaveFileName(fo);
1571  if (fn.isEmpty()) return;
1572 
1573  DEBTRACE("GenericGui::onExportSchemaAs: " << fn.toUtf8().constData());
1574  QtGuiContext::getQtCurrent()->setFileName(fn);
1575  VisitorSaveGuiSchema aWriter(proc);
1576  aWriter.openFileSchema(fn.toUtf8().constData());
1577  aWriter.visitProc();
1578  aWriter.closeFileSchema();
1579  _isSaved = true;
1580  QtGuiContext::getQtCurrent()->setNotSaved(false);
1581 
1582  if (fn.compare(foo) && _wrapper)
1583  _wrapper->renameSchema(foo, fn, QtGuiContext::getQtCurrent()->getWindow());
1584 }
1585 
1586 void GenericGui::onImportCatalog()
1587 {
1588  DEBTRACE("GenericGui::onImportCatalog");
1589  QFileDialog dialog(_parent,
1590  "Choose a YACS Schema to load as a Catalog" ,
1591  QString::null,
1592  tr( "XML-Files (*.xml);;All Files (*)" ));
1593 
1594  dialog.setHistory(_wrapper->getQuickDirList());
1595 
1596  QString fn;
1597  QStringList fileNames;
1598  if (dialog.exec())
1599  {
1600  fileNames = dialog.selectedFiles();
1601  if (!fileNames.isEmpty())
1602  fn = fileNames.first();
1603  }
1604 
1605  if ( !fn.isEmpty() )
1606  _catalogsWidget->addCatalogFromFile(fn.toStdString());
1607 }
1608 
1609 void GenericGui::onRunLoadedSchema(bool withState)
1610 {
1611  DEBTRACE("GenericGui::onRunLoadedSchema");
1612  if (!QtGuiContext::getQtCurrent()) return;
1613 
1614  clock_t start_t;
1615  clock_t end_t;
1616  start_t = clock();
1617 
1618  // --- check proc state (cf. editionProc)
1619 
1620  if (!QtGuiContext::getQtCurrent()->_setOfModifiedSubjects.empty())
1621  {
1622  set<Subject*>::iterator it = QtGuiContext::getQtCurrent()->_setOfModifiedSubjects.begin();
1623  (*it)->select(true);
1624  return;
1625  }
1626 
1627  YACS::ENGINE::Proc* proc = QtGuiContext::getQtCurrent()->getProc();
1628  if (!proc->isValid())
1629  {
1630  QtGuiContext::getQtCurrent()->getSubjectProc()->select(true);
1631  return;
1632  }
1633 
1634  YACS::ENGINE::LinkInfo info(YACS::ENGINE::LinkInfo::ALL_STOP_ASAP);
1635  try
1636  {
1637  proc->checkConsistency(info);
1638  }
1639  catch (Exception &ex)
1640  {
1641  DEBTRACE(ex.what());
1642  QtGuiContext::getQtCurrent()->getSubjectProc()->select(true);
1643  return;
1644  }
1645  if (info.areWarningsOrErrors()) return;
1646 
1647  {
1648  end_t = clock();
1649  double passe = (end_t -start_t);
1650  passe = passe/CLOCKS_PER_SEC;
1651  cerr <<"run schema -1- : " << passe << endl;
1652  start_t = end_t;
1653  }
1654  // --- save proc under a run name
1655 
1656  QFileInfo fo = QtGuiContext::getQtCurrent()->getFileName();
1657  QString procName = fo.baseName();
1658  //QString tmpDir = SALOMEDS_Tool::GetTmpDir().c_str();
1659 #ifdef WIN32
1660  QString tmpDir = getenv("TEMP");
1661 #else
1662  QString tmpDir = "/tmp";
1663 #endif
1664  QDir aTmpDir(tmpDir);
1665  aTmpDir.mkdir(QString("YACS_") + getenv("USER"));
1666  YASSERT(aTmpDir.cd(QString("YACS_") + getenv("USER")));
1667  QDateTime curTime = QDateTime::currentDateTime();
1668  QString aRunName = procName + "_" + curTime.toString("yyyyMMdd_hhmmss") + ".xml";
1669  aRunName = aTmpDir.absoluteFilePath(aRunName);
1670  DEBTRACE(aRunName.toStdString());
1671 
1672  VisitorSaveGuiSchema aWriter(proc);
1673  aWriter.openFileSchema(aRunName.toStdString());
1674  aWriter.visitProc();
1675  aWriter.closeFileSchema();
1676 
1677  // --- create a run context
1678 
1679  YACS::ENGINE::Proc *procrun = _loader->load(aRunName.toLatin1());
1680  {
1681  end_t = clock();
1682  double passe = (end_t -start_t);
1683  passe = passe/CLOCKS_PER_SEC;
1684  cerr <<"run schema -2- : " << passe << endl;
1685  start_t = end_t;
1686  }
1687  createContext(procrun, QtGuiContext::getQtCurrent()->getFileName(), aRunName, false);
1688 
1689  // load state if required
1690 
1691  GuiExecutor *executor = QtGuiContext::getQtCurrent()->getGuiExecutor();
1692  if (!executor) return;
1693  if (withState)
1694  {
1695  QString fn = QFileDialog::getOpenFileName( _parent,
1696  "Choose a previous run state to load" ,
1697  QString::null,
1698  tr( "XML-Files (*.xml);;All Files (*)" ));
1699  if (!fn.isEmpty())
1700  {
1701  DEBTRACE("run state to load: " <<fn.toStdString());
1702  executor->setLoadStateFile(fn.toStdString());
1703  }
1704  }
1705  executor->startResumeDataflow(true); // --- initialise gui state
1706  if(_toggleStopOnErrorAct->isChecked())
1707  executor->setStopOnError(false);
1708 }
1709 
1710 void GenericGui::onLoadRunStateSchema()
1711 {
1712  DEBTRACE("GenericGui::onLoadRunStateSchema");
1713  onRunLoadedSchema(true);
1714 }
1715 
1716 void GenericGui::onLoadAndRunSchema()
1717 {
1718  DEBTRACE("GenericGui::onLoadAndRunSchema");
1719  QString fn = QFileDialog::getOpenFileName( _parent,
1720  "Choose a filename to load" ,
1721  QString::null,
1722  tr( "XML-Files (*.xml);;All Files (*)" ));
1723  if ( !fn.isEmpty() )
1724  {
1725  // add ".xml" suffix
1726  QFileInfo fi(fn);
1727  if (!fi.exists() && fi.suffix() != "xml")
1728  fn += ".xml";
1729 
1730  DEBTRACE("file loaded : " <<fn.toStdString());
1731  YACS::ENGINE::Proc *proc =0;
1732 
1733  try {
1734  proc = _loader->load(fn.toLatin1());
1735  }
1736  catch (...) {
1737  }
1738 
1739  if (!proc)
1740  {
1741  QMessageBox msgBox(QMessageBox::Critical,
1742  "Import YACS Schema, native YACS XML format",
1743  "The file has not the native YACS XML format or is not readable.");
1744  msgBox.exec();
1745  return;
1746  }
1747  YACS::ENGINE::Logger* logger= proc->getLogger("parser");
1748  if(!logger->isEmpty())
1749  {
1750  DEBTRACE(logger->getStr());
1751  }
1752  createContext(proc, fn, "", true);
1753  onRunLoadedSchema();
1754  }
1755 }
1756 
1757 void GenericGui::onChooseBatchJob() {
1758  DEBTRACE("GenericGui::onChooseBatchJob");
1759 
1760  // Show the Batch Jobs list
1761  if(_BJLdialog) delete _BJLdialog;
1762  _BJLdialog = new BatchJobsListDialog(tr("Select one Batch Job to watch"),this);
1763  _BJLdialog->show();
1764  _BJLdialog->move(300,200);
1765  _BJLdialog->resize(450,200);
1766 
1767 }
1768 
1769 void GenericGui::onStartResume()
1770 {
1771  DEBTRACE("GenericGui::onStartResume");
1772  if (!QtGuiContext::getQtCurrent()) return;
1773  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1774  QtGuiContext::getQtCurrent()->getGuiExecutor()->startResumeDataflow();
1775 }
1776 
1777 void GenericGui::onAbort()
1778 {
1779  DEBTRACE("GenericGui::onAbort");
1780  if (!QtGuiContext::getQtCurrent()) return;
1781  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1782  QtGuiContext::getQtCurrent()->getGuiExecutor()->killDataflow();
1783 }
1784 
1785 void GenericGui::onPause()
1786 {
1787  DEBTRACE("GenericGui::onPause");
1788  if (!QtGuiContext::getQtCurrent()) return;
1789  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1790  QtGuiContext::getQtCurrent()->getGuiExecutor()->suspendDataflow();
1791 }
1792 
1793 void GenericGui::onReset()
1794 {
1795  DEBTRACE("GenericGui::onReset");
1796  if (!QtGuiContext::getQtCurrent()) return;
1797  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1798  QtGuiContext::getQtCurrent()->getGuiExecutor()->resetDataflow();
1799 }
1800 
1801 void GenericGui::onSaveRunState()
1802 {
1803  DEBTRACE("GenericGui::onSaveRunState");
1804  if (!QtGuiContext::getQtCurrent()) return;
1805  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1806  QDateTime curTime = QDateTime::currentDateTime();
1807  QFileInfo procName = QtGuiContext::getQtCurrent()->getFileName();
1808  QString stateName = procName.baseName();
1809  DEBTRACE(stateName.toStdString());
1810  stateName += "_state_" + curTime.toString("yyyyMMdd_hhmmss") + ".xml";
1811  DEBTRACE(stateName.toStdString());
1812  stateName = getSaveFileName(stateName);
1813  DEBTRACE(stateName.toStdString());
1814  if (!stateName.isEmpty())
1815  QtGuiContext::getQtCurrent()->getGuiExecutor()->saveState(stateName.toStdString());
1816 }
1817 
1818 void GenericGui::onNewEdition()
1819 {
1820  DEBTRACE("GenericGui::onNewEdition");
1821  // if (!QtGuiContext::getQtCurrent()) return;
1822  // if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1823  // QtGuiContext::getQtCurrent()->getGuiExecutor()->resetDataflow();
1824 }
1825 
1826 void GenericGui::onGetYacsContainerLog()
1827 {
1828  DEBTRACE("GenericGui::onGetYacsContainerLog");
1829  if (!QtGuiContext::getQtCurrent()) return;
1830  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1831  string log = QtGuiContext::getQtCurrent()->getGuiExecutor()->getContainerLog();
1832  ContainerLogViewer *lv = new ContainerLogViewer("YACS Container Log", _parent);
1833  lv->readFile(log);
1834  lv->show();
1835 }
1836 
1837 void GenericGui::onGetErrorReport()
1838 {
1839  DEBTRACE("GenericGui::onGetErrorReport");
1840  if (!QtGuiContext::getQtCurrent()) return;
1841  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
1842  SubjectNode *snode = dynamic_cast<SubjectNode*>(sub);
1843  if (!snode) return;
1844  string log;
1845  if (QtGuiContext::getQtCurrent()->getGuiExecutor())
1846  {
1847  log = QtGuiContext::getQtCurrent()->getGuiExecutor()->getErrorReport(snode->getNode());
1848  }
1849  else
1850  {
1851  log = snode->getNode()->getErrorReport();
1852  }
1853 
1854  LogViewer *lv = new LogViewer("Node error report", _parent);
1855  lv->setText(log);
1856  lv->show();
1857 }
1858 
1859 void GenericGui::onGetErrorDetails()
1860 {
1861  DEBTRACE("GenericGui::onGetErrorDetails");
1862  if (!QtGuiContext::getQtCurrent()) return;
1863  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
1864  SubjectNode *snode = dynamic_cast<SubjectNode*>(sub);
1865  if (!snode) return;
1866  string log;
1867  if (QtGuiContext::getQtCurrent()->getGuiExecutor())
1868  {
1869  log = QtGuiContext::getQtCurrent()->getGuiExecutor()->getErrorDetails(snode->getNode());
1870  }
1871  else
1872  {
1873  log = snode->getNode()->getErrorDetails();
1874  }
1875 
1876  LogViewer *lv = new LogViewer("Node Error Details", _parent);
1877  lv->setText(log);
1878  lv->show();
1879 }
1880 
1881 void GenericGui::onGetContainerLog()
1882 {
1883  DEBTRACE("GenericGui::onGetContainerLog");
1884  if (!QtGuiContext::getQtCurrent()) return;
1885  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1886  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
1887  SubjectElementaryNode *snode = dynamic_cast<SubjectElementaryNode*>(sub);
1888  if (!snode) return;
1889  string log = QtGuiContext::getQtCurrent()->getGuiExecutor()->getContainerLog(snode->getNode());
1890 
1891  LogViewer *lv = new LogViewer("Node Container Log", _parent);
1892  if (log.empty())
1893  {
1894  string info = "\n";
1895  if (dynamic_cast<YACS::ENGINE::ServiceNode*>(snode->getNode()))
1896  {
1897  info +="The container log of this node\n";
1898  info += "is not stored in a file and \n";
1899  info += "can't be displayed here, \n";
1900  info += "but you can have a look at \n";
1901  info += "the SALOME standard output,\n";
1902  info += "on your terminal...";
1903  }
1904  else
1905  {
1906  info += "See YACS Container log \n";
1907  info += "(on main proc menu) \n";
1908  info += "for all inline nodes";
1909  }
1910  lv->setText(info);
1911  }
1912  else
1913  lv->readFile(log);
1914  lv->show();
1915 }
1916 
1917 void GenericGui::onShutdownProc()
1918 {
1919  DEBTRACE("GenericGui::onShutdownProc");
1920  if (!QtGuiContext::getQtCurrent()) return;
1921  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
1922  QtGuiContext::getQtCurrent()->getGuiExecutor()->shutdownProc();
1923 }
1924 
1925 void GenericGui::onEditDataTypes()
1926 {
1927  DEBTRACE("GenericGui::onEditDataTypes");
1928 }
1929 
1930 void GenericGui::onCreateDataType()
1931 {
1932  DEBTRACE("GenericGui::onCreateDataType");
1933 }
1934 
1935 void GenericGui::onImportDataType()
1936 {
1937  DEBTRACE("GenericGui::onImportDataType");
1938  if (_dwCatalogs) _dwCatalogs->raise();
1939 }
1940 
1941 void GenericGui::onSelectComponentInstance()
1942 {
1943  DEBTRACE("GenericGui::onSelectComponentInstance");
1944  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
1945  if (!sub) return;
1946  SubjectComponent *ref = dynamic_cast<SubjectComponent*>(sub);
1947  YASSERT(ref);
1948  YACS::ENGINE::ComponentInstance* compo=ref->getComponent();
1949  QtGuiContext::getQtCurrent()->_mapOfLastComponentInstance[compo->getCompoName()]=compo;
1950 }
1951 
1952 void GenericGui::onNewContainer()
1953 {
1954  DEBTRACE("GenericGui::onNewContainer");
1955  _guiEditor->CreateContainer();
1956 }
1957 
1958 void GenericGui::onNewHPContainer()
1959 {
1960  DEBTRACE("GenericGui::onNewHPContainer");
1961  _guiEditor->CreateHPContainer();
1962 }
1963 
1964 void GenericGui::onNewSalomeComponent()
1965 {
1966  DEBTRACE("GenericGui::onNewSalomeComponent");
1967  _guiEditor->CreateComponentInstance();
1968 }
1969 
1970 void GenericGui::onNewSalomePythonComponent()
1971 {
1972  DEBTRACE("GenericGui::onNewSalomePythonComponent");
1973 }
1974 
1975 void GenericGui::onNewCorbaComponent()
1976 {
1977  DEBTRACE("GenericGui::onNewCorbaComponent");
1978 }
1979 
1980 
1981 void GenericGui::onSalomeServiceNode()
1982 {
1983  DEBTRACE("GenericGui::onSalomeServiceNode");
1984  _guiEditor->CreateNode("SalomeNode");
1985 }
1986 
1987 void GenericGui::onServiceInlineNode()
1988 {
1989  DEBTRACE("GenericGui::onServiceInlineNode");
1990  _guiEditor->CreateNode("SalomePythonNode");
1991 }
1992 
1993 void GenericGui::onCORBAServiceNode()
1994 {
1995  DEBTRACE("GenericGui::onCORBAServiceNode");
1996  _guiEditor->CreateNode("CORBANode");
1997 }
1998 
1999 void GenericGui::onNodeNodeServiceNode()
2000 {
2001  DEBTRACE("GenericGui::onNodeNodeServiceNode");
2002 }
2003 
2004 void GenericGui::onCppNode()
2005 {
2006  DEBTRACE("GenericGui::onCppNode");
2007  _guiEditor->CreateNode("CppNode");
2008 }
2009 
2010 void GenericGui::onXMLNode()
2011 {
2012  DEBTRACE("GenericGui::onXMLNode");
2013  _guiEditor->CreateNode("XmlNode");
2014 }
2015 
2016 void GenericGui::onInDataNode()
2017 {
2018  DEBTRACE("GenericGui::onInDataNode");
2019  _guiEditor->CreateNode("PresetNode");
2020 }
2021 
2022 void GenericGui::onOutDataNode()
2023 {
2024  DEBTRACE("GenericGui::onOutDataNode");
2025  _guiEditor->CreateNode("OutNode");
2026 }
2027 
2028 void GenericGui::onInStudyNode()
2029 {
2030  DEBTRACE("GenericGui::onInStudyNode");
2031  _guiEditor->CreateNode("StudyInNode");
2032 }
2033 
2034 void GenericGui::onOutStudyNode()
2035 {
2036  DEBTRACE("GenericGui::onOutStudyNode");
2037  _guiEditor->CreateNode("StudyOutNode");
2038 }
2039 
2040 void GenericGui::onInlineScriptNode()
2041 {
2042  DEBTRACE("GenericGui::onInlineScriptNode");
2043  _guiEditor->CreateNode("PyScript");
2044 }
2045 
2046 void GenericGui::onInlineFunctionNode()
2047 {
2048  DEBTRACE("GenericGui::onInlineFunctionNode");
2049  _guiEditor->CreateNode("PyFunction");
2050 }
2051 
2052 void GenericGui::onBlockNode()
2053 {
2054  DEBTRACE("GenericGui::onBlockNode");
2055  _guiEditor->CreateBloc();
2056 }
2057 
2058 void GenericGui::onFORNode()
2059 {
2060  DEBTRACE("GenericGui::onFORNode");
2061  _guiEditor->CreateForLoop();
2062 }
2063 
2064 void GenericGui::onFOREACHNode()
2065 {
2066  DEBTRACE("GenericGui::onFOREACHNode");
2067  createForEachLoop("double");
2068 }
2069 
2070 void GenericGui::createForEachLoop(std::string type)
2071 {
2072  DEBTRACE("GenericGui::createForEachLoop");
2073  _guiEditor->CreateForEachLoop(type);
2074 }
2075 
2076 void GenericGui::onWHILENode()
2077 {
2078  DEBTRACE("GenericGui::onWHILENode");
2079  _guiEditor->CreateWhileLoop();
2080 }
2081 
2082 void GenericGui::onSWITCHNode()
2083 {
2084  DEBTRACE("GenericGui::onSWITCHNode");
2085  _guiEditor->CreateSwitch();
2086 }
2087 
2088 void GenericGui::onOptimizerLoop()
2089 {
2090  DEBTRACE("GenericGui::onOptimizerLoop");
2091  _guiEditor->CreateOptimizerLoop();
2092 }
2093 
2094 void GenericGui::onNodeFromCatalog()
2095 {
2096  DEBTRACE("GenericGui::onNodeFromCatalog");
2097  if (_dwCatalogs) _dwCatalogs->raise();
2098 }
2099 
2100 void GenericGui::onDeleteItem()
2101 {
2102  DEBTRACE("GenericGui::onDeleteItem");
2103  _guiEditor->DeleteSubject();
2104 }
2105 
2106 void GenericGui::onCutItem()
2107 {
2108  DEBTRACE("GenericGui::onCutItem");
2109  _guiEditor->CutSubject();
2110 }
2111 
2112 void GenericGui::onCopyItem()
2113 {
2114  DEBTRACE("GenericGui::onCopyItem");
2115  _guiEditor->CopySubject();
2116 }
2117 
2118 void GenericGui::onPasteItem()
2119 {
2120  DEBTRACE("GenericGui::onPasteItem");
2121  _guiEditor->PasteSubject();
2122 }
2123 
2124 void GenericGui::onPutInBloc()
2125 {
2126  _guiEditor->PutSubjectInBloc();
2127 }
2128 
2129 void GenericGui::onPutGraphInBloc()
2130 {
2131  DEBTRACE("GenericGui::onPutGraphInBloc");
2132  _guiEditor->PutGraphInBloc();
2133  _guiEditor->arrangeNodes(false);
2134 }
2135 
2136 void GenericGui::onPutGraphInForLoop()
2137 {
2138  DEBTRACE("GenericGui::onPutGraphInForLoop");
2139  _guiEditor->PutGraphInNode("ForLoop");
2140 }
2141 
2142 void GenericGui::putGraphInForeachLoop(std::string type)
2143 {
2144  DEBTRACE("GenericGui::PutGraphInForeachLoop");
2145  _guiEditor->PutGraphInNode("ForEachLoop_"+type);
2146 }
2147 
2148 void GenericGui::onPutGraphInWhileLoop()
2149 {
2150  DEBTRACE("GenericGui::onPutGraphInWhileLoop");
2151  _guiEditor->PutGraphInNode("WhileLoop");
2152 }
2153 
2154 void GenericGui::onPutGraphInOptimizerLoop()
2155 {
2156  DEBTRACE("GenericGui::onPutGraphInOptimizerLoop");
2157  _guiEditor->PutGraphInNode("OptimizerLoop");
2158 }
2159 
2160 void GenericGui::onArrangeLocalNodes()
2161 {
2162  DEBTRACE("GenericGui::onArrangeLocalNodes");
2163  _guiEditor->arrangeNodes(false);
2164 }
2165 
2166 void GenericGui::onArrangeRecurseNodes()
2167 {
2168  DEBTRACE("GenericGui::onArrangeRecurseNodes");
2169  _guiEditor->arrangeNodes(true);
2170 }
2171 
2172 void GenericGui::onRebuildLinks()
2173 {
2174  DEBTRACE("GenericGui::onRebuildLinks");
2175  _guiEditor->rebuildLinks();
2176 }
2177 
2178 void GenericGui::onZoomToBloc()
2179 {
2180  DEBTRACE("GenericGui::onZoomToBloc");
2181  QtGuiContext::getQtCurrent()->getView()->onZoomToBloc();
2182 }
2183 
2184 void GenericGui::onCenterOnNode()
2185 {
2186  DEBTRACE("GenericGui::onCenterOnNode");
2187  QtGuiContext::getQtCurrent()->getView()->onCenterOnNode();
2188 }
2189 
2190 void GenericGui::onShrinkExpand() {
2191  DEBTRACE("GenericGui::onShrinkExpand");
2192  _guiEditor->shrinkExpand();
2193 }
2194 
2195 void GenericGui::onShrinkExpandChildren() {
2196  DEBTRACE("GenericGui::onShrinkExpandChildren");
2197  _guiEditor->shrinkExpand(Qt::ControlModifier|Qt::ShiftModifier);
2198 }
2199 
2200 void GenericGui::onShrinkExpandElementaryRecursively() {
2201  DEBTRACE("GenericGui::onShrinkExpandElementaryRecursively");
2202  _guiEditor->shrinkExpand(Qt::ControlModifier);
2203 }
2204 
2205 void GenericGui::onToggleStraightLinks(bool checked)
2206 {
2207  Scene::_straightLinks = checked;
2208  DEBTRACE("Scene::_straightLinks=" << checked);
2209  if (!QtGuiContext::getQtCurrent())
2210  return;
2211  map<Subject*, SchemaItem*>::const_iterator it = QtGuiContext::getQtCurrent()->_mapOfSchemaItem.begin();
2212  for( ; it != QtGuiContext::getQtCurrent()->_mapOfSchemaItem.end(); ++it)
2213  {
2214  Subject* sub = (*it).first;
2215  sub->update(SWITCHSHAPE, 0, 0);
2216  }
2217 }
2218 
2219 void GenericGui::onToggleAutomaticComputeLinks(bool checked)
2220 {
2221  Scene::_autoComputeLinks = checked;
2222  DEBTRACE("Scene::_autoComputeLinks=" << checked);
2223 }
2224 
2225 void GenericGui::onToggleSimplifyLinks(bool checked)
2226 {
2227  Scene::_simplifyLinks = checked;
2228  DEBTRACE("Scene::_simplifyLinks=" << checked);
2229 }
2230 
2231 void GenericGui::onToggleForce2NodesLinks(bool checked)
2232 {
2233  Scene::_force2NodesLink = checked;
2234  DEBTRACE("Scene::_force2NodesLink=" << checked);
2235 }
2236 
2237 void GenericGui::onToggleAddRowCols(bool checked)
2238 {
2239  Scene::_addRowCols = checked;
2240  DEBTRACE("Scene::_addRowCols=" << checked);
2241 }
2242 
2243 void GenericGui::onSelectReference()
2244 {
2245  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2246  if (!sub) return;
2247  SubjectReference *ref = dynamic_cast<SubjectReference*>(sub);
2248  YASSERT(ref);
2249  SubjectServiceNode *snode = dynamic_cast<SubjectServiceNode*>(ref->getReference());
2250  snode->select(true);
2251 }
2252 
2253 void GenericGui::onWhatsThis()
2254 {
2255  DEBTRACE("GenericGui::onWhatsThis");
2256  QWhatsThis::enterWhatsThisMode();
2257 }
2258 
2259 void GenericGui::onWithoutStopMode(bool checked)
2260 {
2261  DEBTRACE("GenericGui::onWithoutStopMode " << checked);
2262  if (!QtGuiContext::getQtCurrent()) return;
2263  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
2264  if (checked) QtGuiContext::getQtCurrent()->getGuiExecutor()->setContinueMode();
2265 }
2266 
2267 void GenericGui::onBreakpointsMode(bool checked)
2268 {
2269  DEBTRACE("GenericGui::onWithoutStopMode " << checked);
2270  if (!QtGuiContext::getQtCurrent()) return;
2271  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
2272  if (checked) QtGuiContext::getQtCurrent()->getGuiExecutor()->setBreakpointMode();
2273 }
2274 
2275 void GenericGui::onStepByStepMode(bool checked)
2276 {
2277  DEBTRACE("GenericGui::onWithoutStopMode " << checked);
2278  if (!QtGuiContext::getQtCurrent()) return;
2279  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
2280  if (checked) QtGuiContext::getQtCurrent()->getGuiExecutor()->setStepByStepMode();
2281 }
2282 
2283 void GenericGui::onToggleStopOnError(bool checked)
2284 {
2285  DEBTRACE("GenericGui::onToggleStopOnError " << checked);
2286  if (!QtGuiContext::getQtCurrent()) return;
2287  if (!QtGuiContext::getQtCurrent()->getGuiExecutor()) return;
2288  if(checked)
2289  QtGuiContext::getQtCurrent()->getGuiExecutor()->setStopOnError(false);
2290  else
2291  QtGuiContext::getQtCurrent()->getGuiExecutor()->unsetStopOnError();
2292 }
2293 
2294 void GenericGui::onToggleSceneItemVisible(bool checked)
2295 {
2296  DEBTRACE("GenericGui::onToggleSceneItemVisible " << checked);
2297  if (!QtGuiContext::getQtCurrent()) return;
2298  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2299  SubjectNode *snode = dynamic_cast<SubjectNode*>(sub);
2300  if (!snode) return;
2301  DEBTRACE("---");
2302  if (!QtGuiContext::getQtCurrent()->_mapOfSceneItem.count(sub)) return;
2303  DEBTRACE("---");
2304  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
2305  item->setVisible(checked);
2306 }
2307 
2308 void GenericGui::displayLinks(bool isShown)
2309 {
2310  if (!QtGuiContext::getQtCurrent()) return;
2311  map<pair<YACS::ENGINE::OutPort*, YACS::ENGINE::InPort*>,YACS::HMI::SubjectLink*>::const_iterator it;
2312  for (it = QtGuiContext::getQtCurrent()->_mapOfSubjectLink.begin();
2313  it != QtGuiContext::getQtCurrent()->_mapOfSubjectLink.end();
2314  ++it)
2315  {
2316  YACS::HMI::SubjectLink* sub = (*it).second;
2317  if (!sub) continue;
2318  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
2319  item->setVisible(isShown);
2320  }
2321 }
2322 
2323 void GenericGui::displayControlLinks(bool isShown)
2324 {
2325  if (!QtGuiContext::getQtCurrent()) return;
2326  map<pair<YACS::ENGINE::Node*, YACS::ENGINE::Node*>,YACS::HMI::SubjectControlLink*>::const_iterator it;
2327  for (it = QtGuiContext::getQtCurrent()->_mapOfSubjectControlLink.begin();
2328  it != QtGuiContext::getQtCurrent()->_mapOfSubjectControlLink.end();
2329  ++it)
2330  {
2331  YACS::HMI::SubjectControlLink* sub = (*it).second;
2332  if (!sub) continue;
2333  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
2334  item->setVisible(isShown);
2335  }
2336 }
2337 
2338 void GenericGui::displayPortLinks(bool isShown)
2339 {
2340  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2341  DEBTRACE("displayPortLinks, subject : " << sub->getName());
2342  SubjectDataPort *sport = dynamic_cast<SubjectDataPort*>(sub);
2343  if (sport)
2344  {
2345  DEBTRACE("dataPort : " << sport->getName());
2346  list<SubjectLink*> linkList = sport->getListOfSubjectLink();
2347  list<SubjectLink*>::const_iterator it = linkList.begin();
2348  for( ; it != linkList.end(); ++it)
2349  {
2350  YACS::HMI::SubjectLink* sub = (*it);
2351  if (!sub) continue;
2352  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
2353  item->setVisible(isShown);
2354  }
2355  return;
2356  }
2357  SubjectNode *snode = dynamic_cast<SubjectNode*>(sub);
2358  if (snode)
2359  {
2360  DEBTRACE("Node : " << snode->getName());
2361  list<SubjectControlLink*> linkList = snode->getSubjectControlLinks();
2362  list<SubjectControlLink*>::const_iterator it = linkList.begin();
2363  for( ; it != linkList.end(); ++it)
2364  {
2365  YACS::HMI::SubjectControlLink* sub = (*it);
2366  if (!sub) continue;
2367  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
2368  item->setVisible(isShown);
2369  }
2370  return;
2371  }
2372 }
2373 
2374 void GenericGui::displayALink(bool isShown)
2375 {
2376  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2377  if (! QtGuiContext::getQtCurrent()->_mapOfSceneItem.count(sub)) return;
2378  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
2379  item->setVisible(isShown);
2380 }
2381 
2382 void GenericGui::onShowAllLinks()
2383 {
2384  DEBTRACE("GenericGui::onShowAllLinks");
2385  displayLinks(true);
2386  displayControlLinks(true);
2387 }
2388 
2389 void GenericGui::onHideAllLinks()
2390 {
2391  DEBTRACE("GenericGui::onHideAllLinks");
2392  displayLinks(false);
2393  displayControlLinks(false);
2394 }
2395 
2396 void GenericGui::onShowOnlyPortLinks()
2397 {
2398  DEBTRACE("GenericGui::onShowOnlyPortLinks");
2399  onHideAllLinks();
2400  displayPortLinks(true);
2401 }
2402 
2403 void GenericGui::onShowPortLinks()
2404 {
2405  DEBTRACE("GenericGui::onShowPortLinks");
2406  displayPortLinks(true);
2407 }
2408 
2409 void GenericGui::onHidePortLinks()
2410 {
2411  DEBTRACE("GenericGui::onHidePortLinks");
2412  displayPortLinks(false);
2413 }
2414 
2415 void GenericGui::onEmphasisPortLinks()
2416 {
2417  DEBTRACE("GenericGui::onEmphasisPortLinks");
2418  if (!QtGuiContext::getQtCurrent()) return;
2419  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2420  DEBTRACE("EmphasizePortLinks, subject : " << sub->getName());
2421  if (!sub)
2422  return;
2423 
2424  SubjectDataPort *sport = dynamic_cast<SubjectDataPort*>(sub);
2425  if (sport)
2426  {
2427  emphasizePortLink(sport, true);
2428  return;
2429  }
2430 
2431  // --- if a Node, explore all data ports
2432 
2433  SubjectNode *snode = dynamic_cast<SubjectNode*>(sub);
2434  if (snode)
2435  {
2436  DEBTRACE("Node : " << snode->getName());
2437  {
2438  list<SubjectInputPort*> linkList = snode->getSubjectInputPorts();
2439  list<SubjectInputPort*>::const_iterator it = linkList.begin();
2440  for( ; it != linkList.end(); ++it)
2441  {
2442  YACS::HMI::SubjectInputPort* sub = (*it);
2443  if (!sub) continue;
2444  emphasizePortLink(sub, true);
2445  }
2446  }
2447  {
2448  list<SubjectOutputPort*> linkList = snode->getSubjectOutputPorts();
2449  list<SubjectOutputPort*>::const_iterator it = linkList.begin();
2450  for( ; it != linkList.end(); ++it)
2451  {
2452  YACS::HMI::SubjectOutputPort* sub = (*it);
2453  if (!sub) continue;
2454  emphasizePortLink(sub, true);
2455  }
2456  }
2457  return;
2458  }
2459 }
2460 
2461 void GenericGui::onShowOnlyCtrlLinks()
2462 {
2463  DEBTRACE("GenericGui::onShowOnlyCtrlLinks");
2464  onHideAllLinks();
2465  displayPortLinks(true);
2466 }
2467 
2468 void GenericGui::onShowCtrlLinks()
2469 {
2470  DEBTRACE("GenericGui::onShowCtrlLinks");
2471  displayPortLinks(true);
2472 }
2473 
2474 void GenericGui::onHideCtrlLinks()
2475 {
2476  DEBTRACE("GenericGui::onHideCtrlLinks");
2477  displayPortLinks(false);
2478 }
2479 
2480 void GenericGui::onEmphasisCtrlLinks()
2481 {
2482  DEBTRACE("GenericGui::onEmphasisCtrlLinks");
2483  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2484  DEBTRACE("Emphasize Ctrl Links, subject : " << sub->getName());
2485  if (!sub)
2486  return;
2487  SubjectNode *snode = dynamic_cast<SubjectNode*>(sub);
2488  if (snode)
2489  {
2490  DEBTRACE("Node : " << snode->getName());
2491  list<SubjectControlLink*> linkList = snode->getSubjectControlLinks();
2492  list<SubjectControlLink*>::const_iterator it = linkList.begin();
2493  for( ; it != linkList.end(); ++it)
2494  {
2495  YACS::HMI::SubjectControlLink* sub = (*it);
2496  if (!sub) continue;
2497  sub->update(EMPHASIZE, true, sub);
2498  Subject *sin = sub->getSubjectInNode();
2499  Subject *sout = sub->getSubjectOutNode();
2500  sin->update(EMPHASIZE, true, sub);
2501  sout->update(EMPHASIZE, true, sub);
2502  }
2503  return;
2504  }
2505 }
2506 
2507 void GenericGui::onShowOnlyLink()
2508 {
2509  DEBTRACE("GenericGui::onShowOnlyLink");
2510  onHideAllLinks();
2511  displayALink(true);
2512 }
2513 
2514 void GenericGui::onShowLink()
2515 {
2516  DEBTRACE("GenericGui::onShowLink");
2517  displayALink(true);
2518 }
2519 
2520 void GenericGui::onHideLink()
2521 {
2522  DEBTRACE("GenericGui::onHideLink");
2523  displayALink(false);
2524 }
2525 
2526 void GenericGui::onEmphasisLink()
2527 {
2528  DEBTRACE("GenericGui::onEmphasisLink");
2529  Subject *sub = QtGuiContext::getQtCurrent()->getSelectedSubject();
2530  if (!sub)
2531  return;
2532  sub->update(EMPHASIZE, true, sub);
2533 }
2534 
2535 void GenericGui::onDeEmphasizeAll()
2536 {
2537  DEBTRACE("GenericGui::onDeEmphasizeAll");
2538  map<Subject*, SchemaItem*>::const_iterator it = QtGuiContext::getQtCurrent()->_mapOfSchemaItem.begin();
2539  for( ; it != QtGuiContext::getQtCurrent()->_mapOfSchemaItem.end(); ++it)
2540  {
2541  Subject* sub = (*it).first;
2542  sub->update(EMPHASIZE, false, sub);
2543  }
2544 }
2545 
2546 void GenericGui::onUndo()
2547 {
2548  DEBTRACE("GenericGui::onUndo");
2549  if (QtGuiContext::getQtCurrent()->_setOfModifiedSubjects.empty())
2550  {
2551  QtGuiContext::getQtCurrent()->getInvoc()->undo();
2552  // Empty the clipboard in order to avoid the copy of a destroyed object.
2553  QtGuiContext::getQtCurrent()->setSubjectToCopy(NULL);
2554  }
2555  else Message("undo not possible when there are local modifications not confirmed");
2556 }
2557 
2558 void GenericGui::onRedo()
2559 {
2560  DEBTRACE("GenericGui::onRedo");
2561  if (QtGuiContext::getQtCurrent()->_setOfModifiedSubjects.empty())
2562  {
2563  QtGuiContext::getQtCurrent()->getInvoc()->redo();
2564  // Empty the clipboard in order to avoid the copy of a destroyed object.
2565  QtGuiContext::getQtCurrent()->setSubjectToCopy(NULL);
2566  }
2567  else Message("redo not possible when there are local modifications not confirmed");
2568 }
2569 
2570 void GenericGui::onShowUndo()
2571 {
2572  _guiEditor->showUndo(_parent);
2573 }
2574 
2575 void GenericGui::onShowRedo()
2576 {
2577  _guiEditor->showRedo(_parent);
2578 }
2579 
2580 void GenericGui::onCleanOnExit()
2581 {
2582  DEBTRACE("GenericGui::onCleanOnExit");
2583  map<QWidget*, YACS::HMI::QtGuiContext*> mapViewContextCopy = _mapViewContext;
2584  map<QWidget*, YACS::HMI::QtGuiContext*>::iterator it = mapViewContextCopy.begin();
2585  for (; it != mapViewContextCopy.end(); ++it)
2586  {
2587  closeContext((*it).first, true);
2588  }
2589 }
2590 
2591 void GenericGui::emphasizePortLink(YACS::HMI::SubjectDataPort* sub, bool emphasize)
2592 {
2593  DEBTRACE("dataPort : " << sub->getName());
2594  list<SubjectLink*> linkList = sub->getListOfSubjectLink();
2595  list<SubjectLink*>::const_iterator it = linkList.begin();
2596  for( ; it != linkList.end(); ++it)
2597  {
2598  YACS::HMI::SubjectLink* subli = (*it);
2599  if (!subli) continue;
2600  subli->update(EMPHASIZE, emphasize, sub);
2601  Subject *sin = subli->getSubjectInPort();
2602  Subject *sout = subli->getSubjectOutPort();
2603  sin->update(EMPHASIZE, emphasize, sub);
2604  sout->update(EMPHASIZE, emphasize, sub);
2605  }
2606 }
2607 
2608 void GenericGui::onHelpContextModule( const QString& theComponentName, const QString& theFileName, const QString& theContext)
2609 {
2610  _wrapper->onHelpContextModule(theComponentName,theFileName,theContext);
2611 }
ListJobs_GUI.hxx
SALOME_NamingService_Wrapper.hxx
YASSERT
#define YASSERT(val)
YASSERT macro is always defined, used like assert, but throw a YACS::Exception instead of abort.
Definition: YacsTrace.hxx:59
DEBTRACE
#define DEBTRACE(msg)
Definition: YacsTrace.hxx:31
ContainerLogViewer::readFile
virtual void readFile(std::string fileName)
Definition: LogViewer.cxx:69
LogViewer::setText
void setText(std::string text)
Definition: LogViewer.cxx:39
LogViewer::readFile
virtual void readFile(std::string fileName)
Definition: LogViewer.cxx:45
SALOME_NamingService_Wrapper
Definition: SALOME_NamingService_Wrapper.hxx:33
SALOME_NamingService_Wrapper::Resolve
CORBA::Object_ptr Resolve(const char *Path) override
Definition: SALOME_NamingService_Wrapper.hxx:41
YACS::ENGINE::ComponentInstance
Base class for all component instances.
Definition: ComponentInstance.hxx:39
YACS::ENGINE::ComponentInstance::getCompoName
const std::string & getCompoName() const
Definition: ComponentInstance.hxx:45
YACS::ENGINE::ComposedNode::checkConsistency
void checkConsistency(LinkInfo &info) const
Definition: ComposedNode.cxx:615
YACS::ENGINE::LinkInfo
Class that deal with list of semantics links for high level analysis.
Definition: LinkInfo.hxx:83
YACS::ENGINE::LinkInfo::ALL_STOP_ASAP
static const unsigned char ALL_STOP_ASAP
Definition: LinkInfo.hxx:126
YACS::ENGINE::LinkInfo::areWarningsOrErrors
bool areWarningsOrErrors() const
Definition: LinkInfo.cxx:199
YACS::ENGINE::Logger
Class for logging error messages.
Definition: Logger.hxx:38
YACS::ENGINE::Logger::isEmpty
virtual bool isEmpty()
Definition: Logger.cxx:96
YACS::ENGINE::Logger::getStr
virtual std::string getStr()
Definition: Logger.cxx:85
YACS::ENGINE::Node
Base class for all nodes.
Definition: Node.hxx:70
YACS::ENGINE::Node::getErrorReport
virtual std::string getErrorReport()
returns a string that contains an error report if the node is in error
Definition: Node.cxx:755
YACS::ENGINE::Node::getErrorDetails
virtual std::string getErrorDetails() const
Definition: Node.hxx:190
YACS::ENGINE::Node::isValid
virtual int isValid()
indicates if the node is valid (returns 1) or not (returns 0)
Definition: Node.cxx:730
YACS::ENGINE::Proc
Base class for all schema objects.
Definition: Proc.hxx:44
YACS::ENGINE::Proc::setEdition
virtual void setEdition(bool edition)
Definition: Proc.cxx:448
YACS::ENGINE::Proc::getLogger
virtual Logger * getLogger(const std::string &name)
Definition: Proc.cxx:431
YACS::ENGINE::Proc::getProc
virtual Proc * getProc()
Return the proc (this)
Definition: Proc.cxx:607
YACS::ENGINE::RuntimeSALOME::setRuntime
static void setRuntime(long flags=UsePython+UseCorba+UseXml+UseCpp+UseSalome, int argc=0, char *argv[]=NULL)
Definition: RuntimeSALOME.cxx:144
YACS::ENGINE::RuntimeSALOME::createProc
virtual Proc * createProc(const std::string &name)
Definition: RuntimeSALOME.cxx:570
YACS::ENGINE::RuntimeSALOME::getOrb
CORBA::ORB_ptr getOrb() const
Definition: RuntimeSALOME.cxx:1909
YACS::ENGINE::Runtime::getBuiltinCatalog
Catalog * getBuiltinCatalog()
Get the catalog of base nodes (elementary and composed)
Definition: Runtime.cxx:314
YACS::ENGINE::Runtime::addCatalog
virtual void addCatalog(Catalog *catalog)
Add a catalog of types and nodes to the runtime.
Definition: Runtime.cxx:323
YACS::ENGINE::Runtime::loadCatalog
virtual Catalog * loadCatalog(const std::string &sourceKind, const std::string &path)
Load a catalog of calculation to use as factory.
Definition: Runtime.cxx:285
YACS::ENGINE::ServiceNode
Class for calculation node associated with a component service.
Definition: ServiceNode.hxx:35
YACS::ENGINE::VisitorSaveSchema::openFileSchema
void openFileSchema(std::string xmlDump)
Definition: VisitorSaveSchema.cxx:74
YACS::HMI::GuiContext::setSessionCatalog
void setSessionCatalog(YACS::ENGINE::Catalog *cata)
Definition: guiContext.hxx:59
YACS::HMI::GuiContext::setCurrentCatalog
void setCurrentCatalog(YACS::ENGINE::Catalog *cata)
Definition: guiContext.hxx:61
YACS::HMI::GuiContext::setLoading
void setLoading(bool isLoading)
Definition: guiContext.hxx:65
YACS::HMI::GuiExecutor::startResumeDataflow
void startResumeDataflow(bool initialize=false)
Definition: GuiExecutor.cxx:85
YACS::HMI::GuiExecutor::setLoadStateFile
void setLoadStateFile(std::string xmlFile)
Definition: GuiExecutor.cxx:299
YACS::HMI::GuiExecutor::setStopOnError
void setStopOnError(bool aMode)
Definition: GuiExecutor.cxx:260
YACS::HMI::QtGuiContext::setEditionRoot
void setEditionRoot(YACS::HMI::ItemEditionRoot *re)
Definition: QtGuiContext.hxx:78
YACS::HMI::QtGuiContext::setSelectionModel
void setSelectionModel(QItemSelectionModel *selmod)
Definition: QtGuiContext.hxx:80
YACS::HMI::QtGuiContext::setView
void setView(YACS::HMI::GraphicsView *view)
Definition: QtGuiContext.hxx:77
YACS::HMI::QtGuiContext::setEditTree
void setEditTree(FormEditTree *editTree)
Definition: QtGuiContext.hxx:75
YACS::HMI::QtGuiContext::setStackedWidget
void setStackedWidget(QStackedWidget *sw)
Definition: QtGuiContext.hxx:81
YACS::HMI::QtGuiContext::setWindow
void setWindow(QWidget *window)
Definition: QtGuiContext.hxx:79
YACS::HMI::QtGuiContext::setGuiExecutor
void setGuiExecutor(YACS::HMI::GuiExecutor *guiEx)
Definition: QtGuiContext.hxx:83
YACS::HMI::QtGuiContext::setFileName
void setFileName(const QString &fileName)
Definition: QtGuiContext.hxx:82
YACS::HMI::QtGuiContext::setScene
void setScene(QGraphicsScene *scene)
Definition: QtGuiContext.hxx:76
YACS::HMI::QtGuiContext::getEditTree
FormEditTree * getEditTree()
Definition: QtGuiContext.hxx:58
YACS::HMI::QtGuiContext::getStackedWidget
QStackedWidget * getStackedWidget()
Definition: QtGuiContext.hxx:64
YACS::HMI::QtGuiContext::setEdition
void setEdition(bool isEdition)
Definition: QtGuiContext.hxx:84
YACS::HMI::QtGuiContext::setSchemaModel
void setSchemaModel(YACS::HMI::SchemaModel *model)
Definition: QtGuiContext.hxx:74
YACS::HMI::QtGuiContext::setProc
virtual void setProc(YACS::ENGINE::Proc *proc)
Definition: QtGuiContext.cxx:80
YACS::HMI::QtGuiContext::getGuiExecutor
YACS::HMI::GuiExecutor * getGuiExecutor()
Definition: QtGuiContext.hxx:66
YACS::HMI::SceneNodeItem::getHeaderBottom
virtual qreal getHeaderBottom()
Definition: SceneNodeItem.cxx:186
YACS::HMI::SceneNodeItem::setHeight
virtual void setHeight(qreal height)
AbstractSceneItem cannot be resized (only ComposedNodeItem can)
Definition: SceneNodeItem.cxx:96
YACS::HMI::SceneNodeItem::getParent
virtual SceneComposedNodeItem * getParent()
Definition: SceneNodeItem.cxx:204
YACS::HMI::SceneNodeItem::setShownState
virtual void setShownState(shownState ss)
Definition: SceneNodeItem.cxx:460
YACS::HMI::SceneNodeItem::setExpandedPos
void setExpandedPos(QPointF epos)
Definition: SceneNodeItem.hxx:83
YACS::HMI::SceneNodeItem::setWidth
virtual void setWidth(qreal width)
AbstractSceneItem cannot be resized (only ComposedNodeItem can)
Definition: SceneNodeItem.cxx:84
YACS::HMI::SchemaModel::setEdition
void setEdition(bool isEdition=true)
Definition: SchemaModel.cxx:230
YACS::HMI::SubjectDataPort::getListOfSubjectLink
std::list< SubjectLink * > getListOfSubjectLink()
Definition: guiObservers.hxx:216
YACS::HMI::SubjectDataPort::getName
virtual std::string getName()
Definition: guiObservers.cxx:3560
YACS::HMI::SubjectNode::getName
virtual std::string getName()
Definition: guiObservers.cxx:858
YACS::HMI::SubjectNode::getSubjectInputPorts
std::list< SubjectInputPort * > getSubjectInputPorts() const
Definition: guiObservers.hxx:307
YACS::HMI::SubjectNode::getSubjectOutputPorts
std::list< SubjectOutputPort * > getSubjectOutputPorts() const
Definition: guiObservers.hxx:308
YACS::HMI::SubjectNode::getSubjectControlLinks
std::list< SubjectControlLink * > getSubjectControlLinks() const
Definition: guiObservers.hxx:306
YACS::HMI::SubjectNode::getNode
virtual YACS::ENGINE::Node * getNode()
Definition: guiObservers.cxx:863
YACS::HMI::Subject::update
virtual void update(GuiEvent event, int type, Subject *son)
Definition: guiObservers.cxx:198
YACS::HMI::Subject::erase
static void erase(Subject *sub, Command *command=0, bool post=false)
Definition: guiObservers.cxx:74
YACS::HMI::Subject::getName
virtual std::string getName()
Definition: guiObservers.cxx:160
YACS::HMI::Subject::select
virtual void select(bool isSelected)
Definition: guiObservers.cxx:187
YACS::HMI::SuitWrapper
viewer QGraphicsScene: deriver SUIT_ViewModel comme QxGraph_Viewer
Definition: SuitWrapper.hxx:43
YACS::ENGINE::getSALOMERuntime
YACSRUNTIMESALOME_EXPORT RuntimeSALOME * getSALOMERuntime()
Definition: RuntimeSALOME.cxx:155
gui.CONNECTOR.ref
def ref(target, callback=None)
Definition: CONNECTOR.py:120
gui.logview.log
string log
Definition: logview.py:23
orb
CORBA::ORB_ptr orb
Definition: yacsSrv.cxx:39