src/gui/YACSGui_Module.cxx

   1 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 //  This library is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU Lesser General Public
   6 //  License as published by the Free Software Foundation; either
   7 //  version 2.1 of the License.
   8 //
   9 //  This library is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 //  Lesser General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU Lesser General Public
  15 //  License along with this library; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 //
  20
  21 #include <RuntimeSALOME.hxx>
  22
  23 #include <yacs.hh>
  24
  25 #include <YACSGui_Module.h>
  26 #include <YACSGui_Graph.h>
  27 #include <YACSGui_DataModel.h>
  28 #include <YACSGui_DataObject.h>
  29 #include <YACSGui_Executor.h>
  30 #include <YACSGui_XMLDriver.h>
  31 #include <YACSGui_Observer.h>
  32 #include "YACSGui_RunMode.h"
  33
  34 #include <YACSPrs_ElementaryNode.h>
  35 #include <YACSPrs_BlocNode.h>
  36 #include <YACSPrs_Link.h>
  37
  38 #include <SUIT_Session.h>
  39 #include <SUIT_ResourceMgr.h>
  40 #include <SUIT_FileDlg.h>
  41 #include <SUIT_MessageBox.h>
  42 #include <CAM_Application.h>
  43 #include <SalomeApp_Application.h>
  44 #include <QxGraph_ViewModel.h>
  45 #include <QxGraph_ViewWindow.h>
  46 #include <QxGraph_ViewManager.h>
  47 #include <QxGraph_Canvas.h> // for test presentations
  48 #include <QxGraph_Prs.h> // for test presentations
  49
  50 #include <Node.hxx>
  51 #include <SALOME_LifeCycleCORBA.hxx>
  52
  53 #include <qapplication.h>
  54
  55 #include <iostream> // for debug only
  56 #include "utilities.h"
  57
  58 using namespace YACS;
  59 using namespace YACS::ENGINE;
  60
  61
  62 extern "C"
  63 {
  64   CAM_Module* createModule()
  65   {
  66     return new YACSGui_Module();
  67   }
  68 }
  69
  70 //! Constructor.
  71 /*!
  72  */
  73 YACSGui_Module::YACSGui_Module() : SalomeApp_Module( "YACS" )
  74 {
  75   MESSAGE("YACSGui_Module::YACSGui_Module()");
  76   _myRunMode = 0;
  77 }
  78
  79 //! Destructor.
  80 /*!
  81  */
  82 YACSGui_Module::~YACSGui_Module()
  83 {
  84   MESSAGE("YACSGui_Module::~YACSGui_Module()");
  85 }
  86
  87 //! Initialize module.
  88 /*!
  89  */
  90 void YACSGui_Module::initialize( CAM_Application* theApp )
  91 {
  92   MESSAGE("YACSGui_Module::initialize");
  93   SalomeApp_Module::initialize(theApp);
  94   InitYACSGuiGen( dynamic_cast<SalomeApp_Application*>( theApp ) );
  95
  96   createActions();
  97   createMenus();
  98 }
  99
 100 //! Creates module actions.
 101 /*!
 102  */
 103 void YACSGui_Module::createActions()
 104 {
 105   MESSAGE("YACSGui_Module::createActions()");
 106   QPixmap aPixmap;
 107   QWidget* aDesktop = application()->desktop();
 108   SUIT_ResourceMgr* aResourceMgr =  SUIT_Session::session()->resourceMgr();
 109
 110   if (!aDesktop || !aResourceMgr)
 111     return;
 112
 113   // Menu "File"
 114   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_NEW_DATAFLOW"));
 115   createAction( NewDataflowId, tr("TOP_NEW_DATAFLOW"), QIconSet(aPixmap),
 116                 tr("MEN_NEW_DATAFLOW"), tr("STB_NEW_DATAFLOW"),
 117                 0, aDesktop, false, this, SLOT(onNewDataflow()));
 118
 119   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_MODIFY_DATAFLOW"));
 120   createAction( ModifyDataflowId, tr("TOP_MODIFY_DATAFLOW"), QIconSet(aPixmap),
 121                 tr("MEN_MODIFY_DATAFLOW"), tr("STB_MODIFY_DATAFLOW"),
 122                 0, aDesktop, false, this, SLOT(onModifyDataflow()));
 123
 124   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_MODIFY_SUPERV_DATAFLOW"));
 125   createAction( ModifySupervDataflowId, tr("TOP_MODIFY_SUPERV_DATAFLOW"), QIconSet(aPixmap),
 126                 tr("MEN_MODIFY_SUPERV_DATAFLOW"), tr("STB_MODIFY_SUPERV_DATAFLOW"),
 127                 0, aDesktop, false, this, SLOT(onModifySupervDataflow()));
 128
 129   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_IMPORT_DATAFLOW"));
 130   createAction( ImportDataflowId, tr("TOP_IMPORT_DATAFLOW"), QIconSet(aPixmap),
 131                 tr("MEN_IMPORT_DATAFLOW"), tr("STB_IMPORT_DATAFLOW"),
 132                 0, aDesktop, false, this, SLOT(onImportDataflow()));
 133
 134   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_IMPORT_SUPERV_DATAFLOW"));
 135   createAction( ImportSupervDataflowId, tr("TOP_IMPORT_SUPERV_DATAFLOW"), QIconSet(aPixmap),
 136                 tr("MEN_IMPORT_SUPERV_DATAFLOW"), tr("STB_IMPORT_SUPERV_DATAFLOW"),
 137                 0, aDesktop, false, this, SLOT(onImportSupervDataflow()));
 138
 139   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_EXPORT_DATAFLOW"));
 140   createAction( ExportDataflowId, tr("TOP_EXPORT_DATAFLOW"), QIconSet(aPixmap),
 141                 tr("MEN_EXPORT_DATAFLOW"), tr("STB_EXPORT_DATAFLOW"),
 142                 0, aDesktop, false, this, SLOT(onExportDataflow()));
 143
 144   // Menu "Supervisor"
 145   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_ADD_NODE"));
 146   createAction( AddNodeId, tr("TOP_ADD_NODE"), QIconSet(aPixmap),
 147                 tr("MEN_ADD_NODE"), tr("STB_ADD_NODE"),
 148                 0, aDesktop, false, this, SLOT(onAddNode()));
 149
 150   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_SUSPEND_RESUME_DATAFLOW"));
 151   createAction( SuspendResumeDataflowId, tr("TOP_SUSPEND_RESUME_DATAFLOW"), QIconSet(aPixmap),
 152                 tr("MEN_SUSPEND_RESUME_DATAFLOW"), tr("STB_SUSPEND_RESUME_DATAFLOW"),
 153                 0, aDesktop, false, this, SLOT(onSuspendResumeDataflow()));
 154
 155   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_RUN_DATAFLOW"));
 156   createAction( RunDataflowId, tr("TOP_RUN_DATAFLOW"), QIconSet(aPixmap),
 157                 tr("MEN_RUN_DATAFLOW"), tr("STB_RUN_DATAFLOW"),
 158                 0, aDesktop, false, this, SLOT(onRunDataflow()));
 159
 160   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_REMOTE_RUN_DATAFLOW"));
 161   createAction( RemoteRunDataflowId, tr("TOP_REMOTE_RUN_DATAFLOW"), QIconSet(aPixmap),
 162                 tr("MEN_REMOTE_RUN_DATAFLOW"), tr("STB_REMOTE_RUN_DATAFLOW"),
 163                 0, aDesktop, false, this, SLOT(onRemoteRunDataflow()));
 164
 165   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_KILL_DATAFLOW"));
 166   createAction( KillDataflowId, tr("TOP_KILL_DATAFLOW"), QIconSet(aPixmap),
 167                 tr("MEN_KILL_DATAFLOW"), tr("STB_KILL_DATAFLOW"),
 168                 0, aDesktop, false, this, SLOT(onKillDataflow()));
 169
 170   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_TOGGLESTOPONERROR"));
 171   createAction( ToggleStopOnErrorId, tr("TOP_TOGGLESTOPONERROR"), QIconSet(aPixmap),
 172                 tr("MEN_TOGGLESTOPONERROR"), tr("STB_TOGGLESTOPONERROR"),
 173                 0, aDesktop, false, this, SLOT(onToggleStopOnError()));
 174
 175   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_FILTERNEXTSTEPS"));
 176   createAction( FilterNextStepsId, tr("TOP_FILTERNEXTSTEPS"), QIconSet(aPixmap),
 177                 tr("MEN_FILTERNEXTSTEPS"), tr("STB_FILTERNEXTSTEPS"),
 178                 0, aDesktop, false, this, SLOT(onFilterNextSteps()));
 179
 180   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_ADD_DATAFLOW_IN_STUDY"));
 181   createAction( AddDataflowInStudyId, tr("TOP_ADD_DATAFLOW_IN_STUDY"), QIconSet(aPixmap),
 182                 tr("MEN_ADD_DATAFLOW_IN_STUDY"), tr("STB_ADD_DATAFLOW_IN_STUDY"),
 183                 0, aDesktop, false, this, SLOT(onAddDataflowInStudy()));
 184
 185   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_CHANGE_INFORMATIONS"));
 186   createAction( ChangeInformationsId, tr("TOP_CHANGE_INFORMATIONS"), QIconSet(aPixmap),
 187                 tr("MEN_CHANGE_INFORMATIONS"), tr("STB_CHANGE_INFORMATIONS"),
 188                 0, aDesktop, false, this, SLOT(onChangeInformations()));
 189
 190   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_SAVEDATAFLOWSTATE"));
 191   createAction( SaveDataflowStateId, tr("TOP_SAVEDATAFLOWSTATE"), QIconSet(aPixmap),
 192                 tr("MEN_SAVEDATAFLOWSTATE"), tr("STB_SAVEDATAFLOWSTATE"),
 193                 0, aDesktop, false, this, SLOT(onSaveDataflowState()));
 194
 195   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_RELOAD_DATAFLOW"));
 196   createAction( ReloadDataflowId, tr("TOP_RELOAD_DATAFLOW"), QIconSet(aPixmap),
 197                 tr("MEN_RELOAD_DATAFLOW"), tr("STB_RELOAD_DATAFLOW"),
 198                 0, aDesktop, false, this, SLOT(onReloadDataflow()));
 199
 200   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_REBUILD_LINKS"));
 201   createAction( RebuildLinksId, tr("TOP_REBUILD_LINKS"), QIconSet(aPixmap),
 202                 tr("MEN_REBUILD_LINKS"), tr("STB_REBUILD_LINKS"),
 203                 0, aDesktop, false, this, SLOT(onRebuildLinks()));
 204
 205   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_FULL_VIEW"));
 206   createAction( FullViewId, tr("TOP_FULL_VIEW"), QIconSet(aPixmap),
 207                 tr("MEN_FULL_VIEW"), tr("STB_FULL_VIEW"),
 208                 0, aDesktop, false, this, SLOT(onFullView()));
 209
 210   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_CONTROL_VIEW"));
 211   createAction( ControlViewId, tr("TOP_CONTROL_VIEW"), QIconSet(aPixmap),
 212                 tr("MEN_CONTROL_VIEW"), tr("STB_CONTROL_VIEW"),
 213                 0, aDesktop, false, this, SLOT(onControlView()));
 214
 215   aPixmap = aResourceMgr->loadPixmap("YACSGui", tr("ICON_TABLE_VIEW"));
 216   createAction( TableViewId, tr("TOP_TABLE_VIEW"), QIconSet(aPixmap),
 217                 tr("MEN_TABLE_VIEW"), tr("STB_TABLE_VIEW"),
 218                 0, aDesktop, false, this, SLOT(onTableView()));
 219
 220 }
 221
 222 //! Creates module menus.
 223 /*!
 224  */
 225 void YACSGui_Module::createMenus()
 226 {
 227   MESSAGE("YACSGui_Module::createMenus");
 228   int fileId = createMenu( tr( "MEN_FILE" ), -1, -1 );
 229   createMenu( NewDataflowId,    fileId, 10 );
 230   createMenu( ModifyDataflowId, fileId, 10 );
 231   createMenu( ModifySupervDataflowId, fileId, 10 );
 232   createMenu( ImportDataflowId, fileId, 10 );
 233   createMenu( ImportSupervDataflowId, fileId, 10 );
 234   createMenu( ExportDataflowId, fileId, 10 );
 235
 236   int supervisorId = createMenu( tr( "MEN_SUPERVISOR" ), -1, -1, 10 );
 237   createMenu( AddNodeId,               supervisorId, -1 );
 238   createMenu( separator(),             supervisorId, -1 );
 239   createMenu( SuspendResumeDataflowId, supervisorId, -1 );
 240   createMenu( RemoteRunDataflowId,     supervisorId, -1 );
 241   createMenu( RunDataflowId,           supervisorId, -1 );
 242   createMenu( KillDataflowId,          supervisorId, -1 );
 243   createMenu( separator(),             supervisorId, -1 );
 244   createMenu( ToggleStopOnErrorId,     supervisorId, -1 );
 245   createMenu( separator(),             supervisorId, -1 );
 246   createMenu( AddDataflowInStudyId,    supervisorId, -1 );
 247   createMenu( ChangeInformationsId,    supervisorId, -1 );
 248   createMenu( separator(),             supervisorId, -1 );
 249   createMenu( SaveDataflowStateId,     supervisorId, -1 );
 250   createMenu( ReloadDataflowId,        supervisorId, -1 );
 251   createMenu( RebuildLinksId,          supervisorId, -1 );
 252
 253   int dataflowTbId = createTool( tr("TOOLBAR_DATAFLOW") );
 254   createTool( NewDataflowId,          dataflowTbId );
 255   createTool( ModifyDataflowId,       dataflowTbId );
 256   createTool( ModifySupervDataflowId, dataflowTbId );
 257   createTool( ImportDataflowId,       dataflowTbId );
 258   createTool( ImportSupervDataflowId, dataflowTbId );
 259   createTool( ExportDataflowId,       dataflowTbId );
 260   createTool( separator(),            dataflowTbId );
 261   createTool( AddDataflowInStudyId,   dataflowTbId );
 262   createTool( separator(),            dataflowTbId );
 263   createTool( ReloadDataflowId,       dataflowTbId );
 264   createTool( RebuildLinksId,         dataflowTbId );
 265   createTool( separator(),            dataflowTbId );
 266   createTool( FullViewId,             dataflowTbId );
 267   createTool( ControlViewId,          dataflowTbId );
 268   createTool( TableViewId,            dataflowTbId );
 269   createTool( separator(),            dataflowTbId );
 270   createTool( SaveDataflowStateId,    dataflowTbId );
 271
 272   int executionTbId = createTool( tr("TOOLBAR_EXECUTION") );
 273   createTool( SuspendResumeDataflowId, executionTbId );
 274   createTool( RemoteRunDataflowId,     executionTbId );
 275   createTool( RunDataflowId,           executionTbId );
 276   createTool( separator(),             executionTbId );
 277   createTool( KillDataflowId,          executionTbId );
 278   createTool( ToggleStopOnErrorId,     executionTbId );
 279 }
 280
 281 //! Defines which windows should be created.
 282 /*!
 283  */
 284 void YACSGui_Module::windows( QMap<int, int>& mappa ) const
 285 {
 286   MESSAGE("YACSGui_Module::windows");
 287   mappa.insert( LightApp_Application::WT_ObjectBrowser, Qt::DockLeft );
 288   mappa.insert( LightApp_Application::WT_PyConsole, Qt::DockBottom );
 289 }
 290
 291 //! Defines viewer type.
 292 /*!
 293  */
 294 void YACSGui_Module::viewManagers( QStringList& lst ) const
 295 {
 296   MESSAGE("YACSGui_Module::viewManagers");
 297   lst.append( QxGraph_Viewer::Type() );
 298 }
 299
 300
 301 //! Inherited public slot. Called on a module activating.
 302 /*!
 303  */
 304 bool YACSGui_Module::activateModule( SUIT_Study* theStudy )
 305 {
 306   MESSAGE("YACSGui_Module::activateModule");
 307   bool bOk = SalomeApp_Module::activateModule( theStudy );
 308   setMenuShown( true );
 309   setToolShown( true );
 310
 311   RuntimeSALOME::setRuntime();
 312   return bOk;
 313 }
 314
 315 //! Inherited public slot. Called on a module deactivating.
 316 /*!
 317  */
 318 bool YACSGui_Module::deactivateModule( SUIT_Study* theStudy )
 319 {
 320   MESSAGE("YACSGui_Module::deactivateModule");
 321   setMenuShown( false );
 322   setToolShown( false );
 323   return SalomeApp_Module::deactivateModule( theStudy );
 324 }
 325
 326 //! Module's engine IOR
 327 /*!
 328  */
 329 QString YACSGui_Module::engineIOR() const
 330 {
 331   MESSAGE("YACSGui_Module::engineIOR");
 332   CORBA::String_var anIOR = getApp()->orb()->object_to_string( InitYACSGuiGen( getApp() ) );
 333   return QString( anIOR.in() );
 334 }
 335
 336 //! Gets a reference to the module's engine
 337 /*!
 338  */
 339 YACSGui_ORB::YACSGui_Gen_ptr YACSGui_Module::InitYACSGuiGen( SalomeApp_Application* app )
 340 {
 341   MESSAGE("YACSGui_Module::InitYACSGuiGen");
 342   Engines::Component_var comp = app->lcc()->FindOrLoad_Component( "YACSContainer","YACSGui" );
 343   YACSGui_ORB::YACSGui_Gen_ptr clr = YACSGui_ORB::YACSGui_Gen::_narrow(comp);
 344   ASSERT(!CORBA::is_nil(clr));
 345   return clr;
 346 }
 347
 348
 349 void YACSGui_Module::createGraph( SUIT_ViewManager* theVM )
 350 {
 351   MESSAGE("YACSGui_Module::createGraph");
 352   QxGraph_ViewWindow* aVW = dynamic_cast<QxGraph_ViewWindow*>( theVM->getActiveView() );
 353   if ( aVW )
 354   {
 355     // create graph with null Proc : waiting for import operation!
 356     YACS::ENGINE::Proc* aProc = 0;
 357     YACSGui_Loader::PrsDataMap aPrsData;
 358     YACSGui_Loader::PortLinkDataMap aPortLinkData;
 359     YACSGui_Loader::LabelLinkDataMap aLabelLinkData;
 360     displayGraph( aProc, aPrsData, aPortLinkData, aLabelLinkData );
 361   }
 362 }
 363
 364 //! Private slot. Creates a new empty dataflow.
 365 /*!
 366  */
 367 void YACSGui_Module::onNewDataflow()
 368 {
 369   MESSAGE("YACSGui_Module::onNewDataflow");
 370   printf("YACSGui_Module::newDataflow\n");
 371   SUIT_ViewManager* aVM  = getApp()->createViewManager( QxGraph_Viewer::Type() );
 372   createGraph(aVM);
 373 }
 374
 375 //! Private slot. Imports uneditable dataflow from the XML file(choosing via a file dialog)
 376 /*!
 377  */
 378 void YACSGui_Module::onImportDataflow()
 379 {
 380   MESSAGE("YACSGui_Module::onImportDataflow");
 381   ImportDataflowFromFile(false);
 382 }
 383
 384 //! Private slot. Imports editable dataflow from the XML file(choosing via a file dialog)
 385 /*!
 386  */
 387 void YACSGui_Module::onModifyDataflow()
 388 {
 389   MESSAGE("YACSGui_Module::onModifyDataflow");
 390   ImportDataflowFromFile(true);
 391 }
 392
 393 //! Private slot. Imports uneditable SUPERV dataflow from the XML file(choosing via a file dialog)
 394 /*!
 395  */
 396 void YACSGui_Module::onImportSupervDataflow()
 397 {
 398   MESSAGE("YACSGui_Module::onImportSupervDataflow");
 399   ImportDataflowFromFile(false, true);
 400 }
 401
 402 //! Private slot. Imports editable SUPERV dataflow from the XML file(choosing via a file dialog)
 403 /*!
 404  */
 405 void YACSGui_Module::onModifySupervDataflow()
 406 {
 407   MESSAGE("YACSGui_Module::onModifySupervDataflow");
 408   ImportDataflowFromFile(true, true);
 409 }
 410
 411 //! Private slot. Exports current dataflow to XML file.
 412 /*!
 413  */
 414 void YACSGui_Module::onExportDataflow()
 415 {
 416   MESSAGE("YACSGui_Module::onExportDataflow");
 417   if ( !activeGraph() )
 418     return;
 419   Proc* aProc = activeGraph()->getProc();
 420   if ( !aProc )
 421     return;
 422
 423   QString aFileName = SUIT_FileDlg::getFileName( application()->desktop(), aProc->getName(), "*.xml", tr("TLT_EXPORT_DATAFLOW"), false );
 424   if (aFileName.isEmpty())
 425     return;
 426
 427   YACSGui_VisitorSaveSchema aWriter( this, aProc );
 428   aWriter.openFileSchema( aFileName );
 429   aWriter.visitProc( aProc );
 430   aWriter.closeFileSchema();
 431 }
 432
 433 //! Private slot. Reloads current dataflow.
 434 /*!
 435  */
 436 void YACSGui_Module::onReloadDataflow()
 437 {
 438   MESSAGE("YACSGui_Module::onReloadDataflow");
 439   YACSGui_Graph* aGraph = activeGraph();
 440   if (aGraph)
 441   {
 442     aGraph->setToUpdate(true);
 443     aGraph->update();
 444   }
 445 }
 446
 447 //! Private slot. Rebuilds dataflow links.
 448 /*!
 449  */
 450 void YACSGui_Module::onRebuildLinks()
 451 {
 452   MESSAGE("YACSGui_Module::onRebuildLinks");
 453   YACSGui_Graph* aGraph = activeGraph();
 454   if (aGraph) aGraph->rebuildLinks();
 455 }
 456
 457 //! Private slot. Open dialog for add node to current dataflow.
 458 /*!
 459  */
 460 void YACSGui_Module::onAddNode()
 461 {
 462   MESSAGE("YACSGui_Module::onAddNode");
 463   YACSGui_Graph* aGraph = activeGraph();
 464   if (!aGraph)
 465     {
 466       SUIT_MessageBox::warn1(getApp()->desktop(),
 467                              tr("WARNING"),
 468                              tr("MSG_NO_DATAFLOW_SELECTED"),
 469                              tr("BUT_OK"));
 470       return;
 471     }
 472
 473   YACSGui_DataModel* aModel = getDataModel();
 474   if ( aModel && !aModel->isEditable(activeGraph()->getProc()) )
 475     {
 476       SUIT_MessageBox::warn1(getApp()->desktop(),
 477                              tr("WARNING"),
 478                              tr("MSG_DATAFLOW_NOT_EDITABLE"),
 479                              tr("BUT_OK"));
 480       return;
 481     }
 482 }
 483
 484 //! Private slot. Starts dataflow execution.
 485 /*!
 486  */
 487 void YACSGui_Module::onRunDataflow()
 488 {
 489   MESSAGE("YACSGui_Module::onRunDataflow");
 490   YACSGui_Executor* anExecutor = findExecutor();
 491   if (anExecutor)
 492     anExecutor->runDataflow();
 493 }
 494
 495 //! Private slot. Starts remote dataflow execution.
 496 /*!
 497  */
 498 void YACSGui_Module::onRemoteRunDataflow()
 499 {
 500   MESSAGE("YACSGui_Module::onRemoteRunDataflow");
 501   YACSGui_Executor* anExecutor = findExecutor();
 502   if (anExecutor)
 503     anExecutor->runDataflow(true);
 504 }
 505
 506 //! Private slot. Kills dataflow execution.
 507 /*!
 508  */
 509 void YACSGui_Module::onKillDataflow()
 510 {
 511   MESSAGE("YACSGui_Module::onKillDataflow");
 512   YACSGui_Executor* anExecutor = findExecutor();
 513   if (anExecutor)
 514     {
 515       if (!anExecutor->isRunning())
 516         {
 517           SUIT_MessageBox::warn1(getApp()->desktop(),
 518                                  tr("WARNING"),
 519                                  tr("MSG_DATAFLOW_IS_NOT_RUNNING"),
 520                                  tr("BUT_OK"));
 521           return;
 522         }
 523     }
 524   anExecutor->stopDataflow();
 525   //myExecutors[aProc] = 0; //@
 526 }
 527
 528 //! Private slot. Suspends or resumes dataflow execution.
 529 /*!
 530  */
 531 void YACSGui_Module::onSuspendResumeDataflow()
 532 {
 533   MESSAGE("YACSGui_Module::onSuspendResumeDataflow");
 534   YACSGui_Executor* anExecutor = findExecutor();
 535   if (anExecutor)
 536     {
 537       RunModeMap::iterator anIterator = _runModeMap.find(anExecutor);
 538       YACSGui_RunMode* aRunMode = 0;
 539       if (anIterator != _runModeMap.end())
 540         aRunMode = (*anIterator).second;
 541       else
 542         {
 543           aRunMode = new YACSGui_RunMode(anExecutor, application()->desktop());
 544           _runModeMap[anExecutor] = aRunMode;
 545         }
 546       if (!aRunMode->isShown())
 547         aRunMode->show();
 548     }
 549 }
 550
 551 void YACSGui_Module::onFilterNextSteps()
 552 {
 553   MESSAGE("YACSGui_Module::onFilterNextSteps --- NOT YET IMPLEMENTED!");
 554   YACSGui_Executor* anExecutor = findExecutor();
 555   if (anExecutor)
 556     {
 557     }
 558 }
 559
 560 void YACSGui_Module::onSaveDataflowState()
 561 {
 562   MESSAGE("YACSGui_Module::onSaveDataflowState --- NOT YET IMPLEMENTED!");
 563   YACSGui_Executor* anExecutor = findExecutor();
 564   if (anExecutor)
 565     {
 566     }
 567 }
 568
 569 void YACSGui_Module::onToggleStopOnError()
 570 {
 571   MESSAGE("YACSGui_Module::onToggleStopOnError");
 572   YACSGui_Executor* anExecutor = findExecutor();
 573   if (anExecutor)
 574     {
 575       anExecutor->setStopOnError(true);
 576     }
 577 }
 578
 579 //! Private slot. Add current dataflow to study.
 580 /*!
 581  */
 582 void YACSGui_Module::onAddDataflowInStudy()
 583 {
 584   MESSAGE("YACSGui_Module::onAddDataflowInStudy");
 585   YACSGui_Graph* aGraph = activeGraph();
 586
 587   if (aGraph) {
 588     Proc* aProc = aGraph->getProc();
 589     if (!aProc)
 590       aProc = new Proc("NewDataflow");
 591     YACSGui_DataModel* aModel = getDataModel();
 592     if (aModel)
 593       aModel->addData(aProc);
 594   }
 595 }
 596
 597 //! Private slot. TD: what's this ?
 598 /*!
 599  */
 600 void YACSGui_Module::onChangeInformations()
 601 {
 602   MESSAGE("YACSGui_Module::onChangeInformations --- NOT YET IMPLEMENTED!");
 603 }
 604
 605 //! Private slot. Switch current dataflow to full view mode.
 606 /*!
 607  */
 608 void YACSGui_Module::onFullView()
 609 {
 610   MESSAGE("YACSGui_Module::onFullView --- NOT YET IMPLEMENTED!");
 611 }
 612
 613 //! Private slot.  Switch current dataflow to control view mode.
 614 /*!
 615  */
 616 void YACSGui_Module::onControlView()
 617 {
 618   MESSAGE("YACSGui_Module::onControlView --- NOT YET IMPLEMENTED!");
 619 }
 620
 621 //! Private slot.  Switch current dataflow to table view mode.
 622 /*!
 623  */
 624 void YACSGui_Module::onTableView()
 625 {
 626   MESSAGE("YACSGui_Module::onTableView --- NOT YET IMPLEMENTED!");
 627 }
 628
 629 //! Creates and displays presentation of a calculation graph.
 630 /*!
 631  *  \param theGraph - graph to be displayed
 632  *  \param thePrsData - map of node coordinates and dimensions
 633  */
 634 YACSGui_Graph* YACSGui_Module::displayGraph( YACS::ENGINE::Proc* theGraph,
 635                                              const YACSGui_Loader::PrsDataMap& thePrsData,
 636                                              const YACSGui_Loader::PortLinkDataMap& thePortLinkData,
 637                                              const YACSGui_Loader::LabelLinkDataMap& theLabelLinkData)
 638 {
 639   MESSAGE("YACSGui_Module::displayGraph");
 640   YACSGui_Graph* aGraph = 0;
 641
 642   QxGraph_Canvas* aCanvas = getCanvas();
 643   if ( !aCanvas )
 644     return aGraph;
 645
 646   aGraph = new YACSGui_Graph( this, aCanvas, theGraph );
 647   aGraph->show();
 648
 649   // Update node geometry
 650   // TODO: not optimal, graph is redrawn twice -
 651   // before and after node geometry is applied - to be improved...
 652   bool needToUpdate = false;
 653   if ( thePrsData.size() )
 654   {
 655     for ( YACSGui_Loader::PrsDataMap::const_iterator it = thePrsData.begin(); it != thePrsData.end(); it++ )
 656     {
 657       YACSPrs_ElementaryNode* anItem = aGraph->getItem( (*it).first );
 658       YACSGui_Loader::PrsData aData  = (*it).second;
 659
 660       if ( !anItem )
 661         continue;
 662
 663       YACSPrs_BlocNode* aBloc = dynamic_cast<YACSPrs_BlocNode*>(anItem);
 664       if ( aBloc )
 665       {
 666         aBloc->resize( (int)aData.width, (int)aData.height );
 667       }
 668
 669       anItem->setIsCheckAreaNeeded(false);
 670       anItem->move( aData.x, aData.y );
 671       anItem->setIsCheckAreaNeeded(true);
 672       anItem->setZ( aData.z );
 673     }
 674     needToUpdate = true;
 675   }
 676
 677   // Update port links presentations
 678   if ( thePortLinkData.size() )
 679   {
 680     for ( YACSGui_Loader::PortLinkDataMap::const_iterator it = thePortLinkData.begin(); it != thePortLinkData.end(); it++ )
 681     {
 682       // (*it).first.first is an output port engine
 683       // (*it).first.second is an input port engine
 684       YACSPrs_ElementaryNode* aFromNodePrs = aGraph->getItem( (*it).first.first->getNode() );
 685       if ( !aFromNodePrs ) continue;
 686
 687       std::list<YACSPrs_Link*> aLinksPrs = aFromNodePrs->getPortPrs( (*it).first.first )->getLinks();
 688       for ( std::list<YACSPrs_Link*>::iterator itL = aLinksPrs.begin(); itL != aLinksPrs.end(); itL++ )
 689       {
 690         if ( YACSPrs_PortLink* aPortLink = dynamic_cast<YACSPrs_PortLink*>( *itL ) )
 691         {
 692           if ( aPortLink->getInputPort()->getEngine() == (*it).first.second )
 693           {
 694             aPortLink->setPoints((*it).second);
 695             aPortLink->merge();
 696           }
 697         }
 698       }
 699     }
 700     needToUpdate = true;
 701   }
 702
 703   // Update label links presentations
 704   if ( theLabelLinkData.size() )
 705   {
 706     for ( YACSGui_Loader::LabelLinkDataMap::const_iterator it = theLabelLinkData.begin(); it != theLabelLinkData.end(); it++ )
 707     {
 708       YACSPrs_ElementaryNode* aSlaveNodePrs = aGraph->getItem( (*it).first );
 709       if ( !aSlaveNodePrs ) continue;
 710
 711       if ( YACSPrs_LabelLink* aLinkPrs = aSlaveNodePrs->getLabelLink() )
 712       {
 713         aLinkPrs->setPoints((*it).second);
 714         aLinkPrs->merge();
 715       }
 716     }
 717     needToUpdate = true;
 718   }
 719
 720   if ( needToUpdate ) aCanvas->update();
 721 }
 722
 723 //! Returns the presentation of a given calculation graph.
 724 /*!
 725  */
 726 YACSGui_Graph* YACSGui_Module::getGraph( YACS::ENGINE::Proc* theGraph )
 727 {
 728   MESSAGE("YACSGui_Module::getGraph");
 729   YACSGui_Graph* aGraph = 0;
 730   // TODO - find a graph in all viewers
 731   // ...
 732   // TEMPORARY solution:
 733   if ( activeGraph() && activeGraph()->getProc() == theGraph )
 734   {
 735     aGraph = activeGraph();
 736   }
 737
 738   return aGraph;
 739 }
 740
 741 //! Returns the presentation of a the calculation graph corresponding to the active view.
 742 /*!
 743  */
 744 YACSGui_Graph* YACSGui_Module::activeGraph()
 745 {
 746   MESSAGE("YACSGui_Module::activeGraph");
 747   YACSGui_Graph* aGraph = 0;
 748   QxGraph_Canvas* aCanvas = getCanvas();
 749   if ( aCanvas )
 750     // Assume that there's the one and only prs per a canvas
 751     aGraph = dynamic_cast<YACSGui_Graph*>( aCanvas->getPrs() );
 752   return aGraph;
 753 }
 754
 755 //! Returns the graph viewer instance
 756 /*!
 757  */
 758 QxGraph_Viewer* YACSGui_Module::getViewer()
 759 {
 760   MESSAGE("YACSGui_Module::getViewer");
 761   QxGraph_Viewer* aViewer = 0;
 762   QxGraph_ViewManager* aVM =
 763     dynamic_cast<QxGraph_ViewManager*>( getApp()->getViewManager( QxGraph_Viewer::Type(), true ) );
 764   if ( aVM )
 765     aViewer = dynamic_cast<QxGraph_Viewer*>( aVM->getViewModel() );
 766   return aViewer;
 767 }
 768
 769 //! Returns the canvas for graph drawing
 770 /*!
 771  */
 772 QxGraph_Canvas* YACSGui_Module::getCanvas()
 773 {
 774   MESSAGE("YACSGui_Module::getCanvas");
 775   QxGraph_Canvas* aCanvas = 0;
 776   QxGraph_Viewer* aViewer = getViewer();
 777   if ( aViewer )
 778     aCanvas = aViewer->getCanvas();
 779   return aCanvas;
 780 }
 781
 782 void YACSGui_Module::createElementaryNodePrs()
 783 {
 784   MESSAGE("YACSGui_Module::createElementaryNodePrs --- NOT YET IMPLEMENTED!");
 785   /*  if ( myGraph )
 786   {
 787     YACS::ENGINE::Node* aNode = 0; // temporary solution for test
 788     YACSPrs_ElementaryNode* anElemNode =
 789       new YACSPrs_ElementaryNode(SUIT_Session::session()->resourceMgr(), myGraph->getCanvas(), aNode);
 790     myGraph->getCanvas()->getPrs()->addItem(anElemNode); // add item for the current display mode
 791     anElemNode->show();
 792     myGraph->getCanvas()->update();
 793     }*/
 794 }
 795
 796 //! Create new instance of data model and return it.
 797 /*!
 798  */
 799 CAM_DataModel* YACSGui_Module::createDataModel()
 800 {
 801   MESSAGE("YACSGui_Module::createDataModel");
 802   return new YACSGui_DataModel( this );
 803 }
 804
 805 //! Retuns data model.
 806 /*!
 807  */
 808 YACSGui_DataModel* YACSGui_Module::getDataModel() const
 809 {
 810   MESSAGE("YACSGui_Module::getDataModel");
 811   YACSGui_DataModel* aModel = dynamic_cast<YACSGui_DataModel*>( dataModel() );
 812   return aModel;
 813 }
 814
 815 //! Load dataflow from file.
 816 /*!
 817  *  \param setEditable - define if the dataflow wiil be editable.
 818  */
 819 void YACSGui_Module::ImportDataflowFromFile(const bool setEditable, bool fromSuperv)
 820 {
 821   MESSAGE("YACSGui_Module::ImportDataflowFromFile");
 822   QString caption;
 823   if (fromSuperv)
 824     {
 825       if (setEditable)
 826         caption = QString(tr("TLT_MODIFY_SUPERV_DATAFLOW"));
 827       else
 828         caption = QString(tr("TLT_IMPORT_SUPERV_DATAFLOW"));
 829     }
 830   else
 831     {
 832       if (setEditable)
 833         caption = QString(tr("TLT_MODIFY_DATAFLOW"));
 834       else
 835         caption = QString(tr("TLT_IMPORT_DATAFLOW"));
 836     }
 837   QString aFileName = SUIT_FileDlg::getFileName( application()->desktop(), "", "*.xml", caption, true );
 838
 839   if (aFileName.isEmpty())
 840     return;
 841   QString tmpFileName = aFileName;
 842
 843   if (fromSuperv)
 844     {
 845       YACSGui_ORB::YACSGui_Gen_ptr engineRef = InitYACSGuiGen(getApp());
 846       try
 847         {
 848           tmpFileName = engineRef->convertSupervFile(aFileName);
 849         }
 850       catch(...)
 851         {
 852           std::cerr<<"Unexpected exception in convertSupervFile " <<std::endl;
 853           SUIT_MessageBox::warn1(getApp()->desktop(),
 854                                  tr("WARNING"),
 855                                  tr("Unexpected exception in convertSupervFile"),
 856                                  tr("BUT_OK"));
 857           return;
 858         }
 859     }
 860
 861   //TD: Here check if the study already contains a graph imported from the same file
 862
 863   YACSGui_Loader aLoader;
 864
 865   try
 866     {
 867       Proc* aProc = 0;
 868       if (!tmpFileName.isEmpty())
 869         aProc = aLoader.load(tmpFileName);
 870
 871       //TD: Check the result of file loading
 872       if (!aProc)
 873         {
 874           SUIT_MessageBox::error1(getApp()->desktop(),
 875                                   tr("ERROR"),
 876                                   tr("MSG_IMPORT_FILE_ERROR"),
 877                                   tr("BUT_OK"));
 878           return;
 879         }
 880
 881       aProc->setName(QFileInfo(aFileName).fileName ());
 882
 883       SUIT_ViewManager* aVM  = getApp()->createViewManager( QxGraph_Viewer::Type() );
 884
 885       // set caption for graph's view window
 886       QxGraph_ViewWindow* aVW = dynamic_cast<QxGraph_ViewWindow*>( aVM->getActiveView() );
 887       if ( aVW ) aVW->setCaption(QFileInfo(aFileName).fileName ());
 888
 889       YACSGui_DataModel* aModel = getDataModel();
 890       if (aModel)
 891         aModel->add(aProc, setEditable);
 892       // TD: add graph to study.
 893
 894       int w, h;
 895       const YACSGui_Loader::PrsDataMap& aPrsData = aLoader.getPrsData( aProc, w, h );
 896       const YACSGui_Loader::PortLinkDataMap& aPortLinkData = aLoader.getPortLinkData( aProc );
 897       const YACSGui_Loader::LabelLinkDataMap& aLabelLinkData = aLoader.getLabelLinkData( aProc );
 898       if ( aVW )
 899       {
 900         if ( w > 0 && h > 0 )
 901           aVW->getViewModel()->getCanvas()->resize( w, h );
 902         displayGraph( aProc, aPrsData, aPortLinkData, aLabelLinkData );
 903       }
 904     }
 905   catch (YACS::Exception& ex)
 906     {
 907       std::cerr<<"YACSGui_Module::importDataflow: " <<ex.what()<<std::endl;
 908     }
 909 }
 910
 911 //! Returns or create executor for a given graph.
 912 /*!
 913  */
 914 YACSGui_Executor* YACSGui_Module::getExecutor( YACS::ENGINE::Proc* theProc )
 915 {
 916   MESSAGE("YACSGui_Module::getExecutor");
 917   YACSGui_Executor* anExecutor = 0;
 918
 919   ExecutorMap::iterator anIterator = myExecutors.find(theProc);
 920   if (anIterator != myExecutors.end())
 921     anExecutor = (*anIterator).second;
 922
 923   if (!anExecutor)
 924     {
 925       anExecutor = new YACSGui_Executor(this, theProc);
 926       anExecutor->setGraph(activeGraph());
 927       myExecutors[theProc] = anExecutor;
 928     }
 929
 930   return anExecutor;
 931 }
 932
 933 //! Returns executor for active graph or nul if no active graph
 934 /*!
 935  */
 936 YACSGui_Executor* YACSGui_Module::findExecutor()
 937 {
 938   MESSAGE("YACSGui_Module::findExecutor");
 939   YACSGui_Graph* aGraph = activeGraph();
 940   YACSGui_Executor* anExecutor = 0;
 941   Proc* aProc = 0;
 942   if (aGraph)
 943     aProc = aGraph->getProc();
 944
 945   if (!aGraph || !aProc)
 946     {
 947       SUIT_MessageBox::warn1(getApp()->desktop(),
 948                              tr("WARNING"),
 949                              tr("MSG_NO_DATAFLOW_LOADED"),
 950                              tr("BUT_OK"));
 951       return 0;
 952     }
 953
 954   anExecutor = getExecutor(aProc);
 955   return anExecutor;
 956 }
 957
 958 YACSGui_RunMode* YACSGui_Module::getRunMode(YACSGui_Executor* executor)
 959 {
 960   RunModeMap::iterator anIterator = _runModeMap.find(executor);
 961   YACSGui_RunMode* aRunMode = 0;
 962   if (anIterator != _runModeMap.end())
 963     aRunMode = _runModeMap[executor];
 964   //SCRUTE(aRunMode);
 965   return aRunMode;
 966 }