src/genericgui/GenericGui.cxx

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