]> SALOME platform Git repositories - modules/superv.git/blob - src/SUPERVGUI/SUPERVGUI_Main.cxx
Salome HOME
NRI : Merge from V1_2.
[modules/superv.git] / src / SUPERVGUI / SUPERVGUI_Main.cxx
1 //  SUPERV SUPERVGUI : GUI for Supervisor component
2 //
3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
5 // 
6 //  This library is free software; you can redistribute it and/or 
7 //  modify it under the terms of the GNU Lesser General Public 
8 //  License as published by the Free Software Foundation; either 
9 //  version 2.1 of the License. 
10 // 
11 //  This library is distributed in the hope that it will be useful, 
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of 
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
14 //  Lesser General Public License for more details. 
15 // 
16 //  You should have received a copy of the GNU Lesser General Public 
17 //  License along with this library; if not, write to the Free Software 
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
19 // 
20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
21 //
22 //
23 //
24 //  File   : SUPERVGUI_Main.cxx
25 //  Author : Francis KLOSS
26 //  Module : SUPERV
27
28 using namespace std;
29 #include "QAD_Splitter.h"
30 #include "QAD_LeftFrame.h"
31 #include "QAD_ObjectBrowser.h"
32 #include "QAD_ObjectBrowserItem.h"
33 #include "QAD_PyEditor.h"
34 #include "QAD_Message.h"
35 #include "QAD_FileDlg.h"
36 #include "QAD_Application.h"
37 #include "SUPERVGUI_Def.h"
38 #include "QAD_RightFrame.h"
39 #include "SUPERVGraph_ViewFrame.h"
40 #include <qlayout.h>
41 #include <qfile.h>
42 #include "SUPERVGUI_Main.h"
43 #include "SUPERVGUI.h"
44 #include "SUPERVGUI_ComputeNode.h"
45 #include "SUPERVGUI_ControlNode.h"
46 #include "NOTIFICATION.hxx"
47 #include "SUPERVGUI_Notification.h"
48 #include "SALOMEGUI_ImportOperation.h"
49 #include "SUPERVGUI_Information.h"
50
51
52 SUPERVGUI_Main::SUPERVGUI_Main(SUPERVGraph_ViewFrame* theParent, QAD_Desktop* theDesktop, bool fromIOR)
53      : SUPERVGraph_View(theParent), 
54        myLogged( false ),
55        myFiltered( false ),
56        myLogFileName( QString::null ),
57        myLogFile( NULL ),
58        myWarning( false ),
59        myStep( false ),
60        myTrace( false ),
61        myVerbose( false )
62 {
63   Trace("SUPERVGUI_Main::SUPERVGUI_Main (new)");
64   theParent->setViewWidget(this); 
65   if (fromIOR) {
66     //SUPERVGUI_Main* am = Supervision.getMain();
67     QAD_ObjectBrowser* ob = ((QAD_StudyFrame*)(theDesktop->getMainFrame()->activeWindow()))->getLeftFrame()->getObjectBrowser();
68     //        if (am == 0) {
69     //  ob = ((QAD_StudyFrame*)(theDesktop->getMainFrame()->activeWindow()))->getLeftFrame()->getObjectBrowser();
70     //} else {
71     //ob = am->objectBrowser;
72     //}; 
73     QAD_ObjectBrowserItem* item = (QAD_ObjectBrowserItem*)(ob->getListView()->currentItem());
74     SALOMEDS::SObject_var obj = theDesktop->getActiveStudy()->getStudyDocument()->FindObjectID(item->getEntry().latin1());
75     SALOMEDS::GenericAttribute_var anAttr;
76     if (obj->FindAttribute(anAttr, "AttributeIOR")) {
77       SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
78       Standard_CString ior = anIOR->Value();
79       dataflow = (*Supervision.getEngine())->getGraph(ior);
80       if (SUPERV_isNull(dataflow)) {
81         QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_ACCESS_BAD_IOR"));
82         close();
83       } else {
84         init(theDesktop);
85       }
86     } else {
87       QMessageBox::warning(0, tr("ERROR"), tr("MSG_NOACCESS_BY_IOR"));
88       close();
89     }
90   } else {
91     dataflow = (*Supervision.getEngine())->Graph(MAIN_NEW);
92     if (SUPERV_isNull(dataflow)) {
93       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CANT_CREATE_DF"));
94       close();
95     } else {
96       init(theDesktop);
97     }
98   }
99 }
100
101 SUPERVGUI_Main::SUPERVGUI_Main(SUPERVGraph_ViewFrame* theParent, QAD_Desktop* theDesktop, bool isModify, const char* f)
102      : SUPERVGraph_View(theParent),
103        myLogged( false ),
104        myFiltered( false ),
105        myLogFileName( QString::null ),
106        myLogFile( NULL ),
107        myWarning( false ),
108        myStep( false ),
109        myTrace( false ),
110        myVerbose( false )
111 {
112   Trace("SUPERVGUI_Main::SUPERVGUI_Main (file)")
113     theParent->setViewWidget(this);  
114   if (isModify) {
115     dataflow = (*Supervision.getEngine())->Graph(f);
116   } else {
117     dataflow = (*Supervision.getEngine())->GraphE(f);
118   }
119   if (SUPERV_isNull(dataflow)) {
120     QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_BAD_FILE").arg(f));
121     close();
122   } else {
123     init(theDesktop);
124   }
125 }
126
127 SUPERVGUI_Main::SUPERVGUI_Main(SUPERVGraph_ViewFrame* theParent, QAD_Desktop* theDesktop, SUPERV_Graph cp)
128      : SUPERVGraph_View(theParent),
129        myLogged( false ),
130        myFiltered( false ),
131        myLogFileName( QString::null ),
132        myLogFile( NULL ),
133        myWarning( false ),
134        myStep( false ),
135        myTrace( false ),
136        myVerbose( false )
137 {
138   Trace("SUPERVGUI_Main::SUPERVGUI_Main (copy)");
139   theParent->setViewWidget(this);  
140   //  dataflow = cp->Copy();
141   dataflow = cp;
142   if (SUPERV_isNull(dataflow)) {
143     QMessageBox::warning(0, tr("ERROR"), tr("MSG_CANT_COPY"));
144     close();
145   } else {
146     init(theDesktop);
147   }
148 }
149
150 void SUPERVGUI_Main::init(QAD_Desktop* theDesktop) {
151   Trace("SUPERVGUI_Main::init");
152   if (theDesktop) myNService = theDesktop->getNameService();
153   myHashCode = "New";
154   myCopyNum = 0;
155   choosing  = false;
156   myIsLocked = false;
157
158   myIsKilled = false;
159   //myIsRunned = false;
160   myCurrentView = GRAPH;
161   myIsFromStudy = false;
162   study     = theDesktop->getActiveStudy();
163   timer = new QTimer(this);
164   connect(timer, SIGNAL(timeout()), this, SLOT(execute()));
165
166     SALOMEDS::Study_var studyDoc = study->getStudyDocument();
167     SALOMEDS::StudyBuilder_var builder = studyDoc->NewBuilder();
168     SALOMEDS::SComponent_var father = studyDoc->FindComponent(STUDY_SUPERVISION);
169     SALOMEDS::GenericAttribute_var anAttr;
170     SALOMEDS::AttributeName_var    aName;
171     SALOMEDS::AttributePixMap_var  aPixmap;
172     if (father->_is_nil()) {
173         QAD_Operation* op = new SALOMEGUI_ImportOperation( study );
174         op->start();
175         father = builder->NewComponent(STUDY_SUPERVISION);
176         anAttr = builder->FindOrCreateAttribute(father, "AttributeName");
177         aName = SALOMEDS::AttributeName::_narrow(anAttr);
178         //      aName->SetValue("Supervision");
179         aName->SetValue( QAD_Application::getDesktop()->getComponentUserName( "SUPERV" ) );
180         
181
182         
183         anAttr = builder->FindOrCreateAttribute(father, "AttributePixMap");
184         aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
185         aPixmap->SetPixMap( "ICON_OBJBROWSER_Supervision" );
186
187         builder->DefineComponentInstance(father, *Supervision.getEngine());
188         op->finish();
189     };
190
191     objectBrowser = study->getActiveStudyFrame()->getLeftFrame()->getObjectBrowser();
192     
193
194     graph = new SUPERVGUI_Graph(this);
195     array = new SUPERVGUI_Array(this);
196
197     message = study->getActiveStudyFrame()->getRightFrame()->getMessage();
198     notification = new NOTIFICATION_Consumer();
199
200     QBoxLayout * layout = new QVBoxLayout(this);
201     layout->setMargin(0);
202     layout->setSpacing(0);
203     layout->addWidget(graph);
204     layout->addWidget(array);
205
206     sync();
207     show();
208     if ( myLogged && !myLogFileName.isEmpty() && QFile::exists( myLogFileName ) ) {
209       myLogFile = fopen( myLogFileName.latin1(), "a" );
210       if (  myLogFile == NULL )
211         myLogged = false;
212     }
213 }
214
215 SUPERVGUI_Main::~SUPERVGUI_Main() {
216   Trace("SUPERVGUI_Main::~SUPERVGUI_Main");
217   if ( myLogFile != NULL) {
218     fclose( myLogFile );
219   }
220   graph->removeLinks();
221   delete notification; // kloss : nota bene : quand un datalow est detruit : verifier que les canaux de notification sont aussi detruit
222   if (!SUPERV_isNull(dataflow)) {
223     if (dataflow->IsExecuting()) {
224       if (QMessageBox::warning(QAD_Application::getDesktop(), tr("WARNING"), 
225                                tr("MSG_DF_RUNNING"), 
226                                tr("MSG_DF_EXECUTION"), 
227                                tr("MSG_DF_KILL")) == 1) {
228         dataflow->Kill();
229       }
230     }
231   }
232 }
233
234 void SUPERVGUI_Main::StartTimer(const char* m) {
235     Trace("SUPERVGUI_Main::StartTimer")
236     if (!timer->isActive()) {
237         timer->start(5);
238         message->setMessage(m);
239     };
240 }
241
242 void SUPERVGUI_Main::StopTimer(const char* m) {
243     Trace("SUPERVGUI_Main::StopTimer")
244     if (timer->isActive()) {
245         timer->stop();
246         syncNotification();
247         message->setMessage(m);
248         sync();
249     };
250 }
251
252 void SUPERVGUI_Main::filterNotification() {
253   Trace("SUPERVGUI_Main::filterNotification");
254   SUPERVGUI_Notification* dlg = new SUPERVGUI_Notification(this);
255   dlg->setFiltered( myFiltered );
256   dlg->setLogged( myLogged, myLogFileName );
257   dlg->setWarning( myWarning );
258   dlg->setStep( myStep );
259   dlg->setTrace( myTrace );
260   dlg->setVerbose( myVerbose );
261   if ( dlg->exec() == QDialog::Accepted ) {
262     myLogged      = dlg->getLogged();
263     myLogFileName = dlg->getLogFile();
264     myFiltered    = dlg->getFiltered();
265     myWarning     = dlg->getWarning();
266     myStep        = dlg->getStep();
267     myTrace       = dlg->getTrace();
268     myVerbose     = dlg->getVerbose();
269     delete dlg;
270     if ( myLogFile != NULL) {
271       fclose( myLogFile );
272     }
273     myLogFile = NULL;
274     if ( myLogged && !myLogFileName.isEmpty() && QFile::exists( myLogFileName ) ) {
275       myLogFile = fopen( myLogFileName.latin1(), "a" );
276       if (  myLogFile == NULL ) {
277         myLogged = false;
278         QMessageBox::warning( QAD_Application::getDesktop(), tr("ERROR"), tr( "ERR_CANT_OPEN_LOG_FILE" ) );
279       }
280     }
281   }
282 }
283
284 void SUPERVGUI_Main::syncAsync() {
285     Trace("SUPERVGUI_Main::syncAsync")
286     QTimer::singleShot(1, this, SLOT(sync()));
287 }
288
289
290 /**
291  * Called by timer when dataflow is executing
292  */
293 void SUPERVGUI_Main::execute() {
294   SUPERV_CNode aNode;
295   SUPERV::GraphEvent aEvent;
296   SUPERV::GraphState aState;
297   dataflow->EventNoW(aNode, aEvent, aState);
298   if ((aEvent == SUPERV::NoEvent) && (aState == SUPERV::NoState)) return;
299
300   if (!SUPERV_isNull(aNode)) {
301     SUPERVGUI_Node* aNodePrs; 
302     if (myCurrentView == TABLE) {
303       aNodePrs = (SUPERVGUI_Node*) array->child(aNode->Name(), "SUPERVGUI_Node");
304     } else {
305       aNodePrs = (SUPERVGUI_Node*) graph->child(aNode->Name(), "SUPERVGUI_Node");
306     }
307     if (aNodePrs)
308       aNodePrs->sync();
309   }
310   switch (dataflow->State()) {
311   case SUPERV_Editing : 
312     StopTimer(dataflow->IsReadOnly()? tr("MSG_GRAPH_READONLY"): tr("MSG_GRAPH_EDITING"));
313     break;
314   
315   case SUPERV_Suspend : 
316     StopTimer(tr("MSG_GRAPH_SUSPENDED"));
317     break;
318  
319   case SUPERV_Done : 
320     StopTimer(tr("MSG_GRAPH_FINISHED"));
321     break;
322   
323   case SUPERV_Error : 
324     StopTimer(tr("MSG_GRAPH_ABORTED"));
325     break;
326     
327   case SUPERV_Kill : 
328     StopTimer(tr("MSG_GRAPH_KILLED"));
329     break;
330     
331   }
332 }
333
334
335
336 void SUPERVGUI_Main::sync() {
337     Trace("SUPERVGUI_Main::sync")
338     if ((SUPERV_isNull(dataflow))) return;
339     QString t = tr("GRAPH_TITLE");
340     
341     t += dataflow->Name();
342     setCaption(t);
343
344     study->updateObjBrowser();
345     if (myCurrentView == TABLE) {
346         array->sync();
347     } else {
348         graph->sync();
349     }
350 }
351
352
353 void SUPERVGUI_Main::showTable() {
354   if (myCurrentView == TABLE) return;
355
356   if (array->create()) {
357     myCurrentView = TABLE;
358     graph->hide();
359   }
360   sync();
361 }
362
363
364 void SUPERVGUI_Main::showFullGraph() {
365   if (myCurrentView == TABLE) {
366     array->destroy();
367     graph->show();    
368   }
369   myCurrentView = GRAPH;
370   graph->sync();
371   graph->setFullView();
372 }
373
374
375 void SUPERVGUI_Main::showContolFlow() {
376   if (myCurrentView == TABLE) {
377     array->destroy();
378     graph->show();    
379   }
380   myCurrentView = CONTROLFLOW;
381   graph->sync();
382   graph->setControlView();
383 }
384
385
386 bool SUPERVGUI_Main::exportDataflow(QString theFile) {
387   Trace("SUPERVGUI_Main::exportDataflow");
388   if ((SUPERV_isNull(dataflow))) return false;
389
390   if (!theFile.isEmpty()) {
391     if (!dataflow->Export(theFile.latin1())) {
392       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_BAD_WRITING"));
393       return false;
394     }
395   }
396   return true;
397 }
398
399 void SUPERVGUI_Main::insertFile() {
400     Trace("SUPERVGUI_Main::insertFile")
401     if ((SUPERV_isNull(dataflow))) return;
402
403     QString f = QAD_FileDlg::getFileName(QAD_Application::getDesktop(),
404                                          "",
405                                          "*.xml",
406                                          tr("MSG_GRAPH_INSERT"),
407                                          true);
408     if (!f.isEmpty()) {
409         if (dataflow->Import(f.latin1())) {
410           if (myCurrentView == TABLE) {
411             array->destroy();
412             array->create();
413           }
414           sync();
415         } else {
416             QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_BAD_FILE").arg(f));
417         };
418     };
419 }
420
421 void SUPERVGUI_Main::copy() {
422   Trace("SUPERVGUI_Main::copy");
423   if (dataflow->ThreadsMax() == 0) {
424     QMessageBox::warning(QAD_Application::getDesktop(), tr("WARNING"), tr("MSG_NOTHING_COPY"));
425     return;
426   }
427   QAD_StudyFrame* aStudyFrame = Supervision.createGraph();
428   SUPERVGraph_ViewFrame* aViewFrame = dynamic_cast<SUPERVGraph_ViewFrame*>
429     (aStudyFrame->getRightFrame()->getViewFrame());
430   if(aViewFrame){
431     SUPERV_Graph aNewGraph = dataflow->Copy();
432     QString aNewName(tr("MSG_COPY_PREFIX").arg(++myCopyNum));
433     aNewName += dataflow->Name();
434     aNewGraph->SetName(aNewName);
435     SUPERVGUI_Main* m = new SUPERVGUI_Main(aViewFrame, 
436                                            Supervision.getDesktop(), 
437                                            aNewGraph);
438     study->showFrame(aStudyFrame);
439   }
440 }
441
442 void SUPERVGUI_Main::run() {
443   Trace("SUPERVGUI_Main::run")
444     if ((SUPERV_isNull(dataflow))) return;
445   
446   if (dataflow->IsEditing()) {
447     if (!dataflow->IsValid()) {
448       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_NOTVALID"));
449     } else if (!dataflow->IsExecutable()) {
450       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_NOTEXECUTABLE"));
451     } else if (graph->isAnyLinkCreating()) {
452       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CRL_NOTCOMPLETE"));
453     } else {
454       myRunTime = QDateTime::currentDateTime();
455       if (myIsKilled) {
456       //if (myIsRunned) {
457         if (!dataflow->ReRun()) {
458           QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_BADEXECUTE"));
459         } else {
460           StartTimer(tr("MSG_GRAPH_STARTED"));
461           syncNotification();
462           sync();
463         }
464       } else {
465         if (!dataflow->Run()) {
466           QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_BADEXECUTE"));
467         } else {
468           StartTimer(tr("MSG_GRAPH_STARTED"));
469           syncNotification();
470           //myIsRunned = true;
471           sync();
472         }
473       }
474     }
475   } else {
476     QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_RUNNING"));
477   }
478 }
479
480
481
482 void SUPERVGUI_Main::startExecute() {
483   Trace("SUPERVGUI_Main::startExecute")
484   if ((SUPERV_isNull(dataflow))) return;
485   
486   if (dataflow->IsEditing()) {
487     if (!dataflow->IsValid()) {
488       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_NOTVALID"));
489     } else if (!dataflow->IsExecutable()) {
490       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_NOTEXECUTABLE"));
491     } else if (graph->isAnyLinkCreating()) {
492       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CRL_NOTCOMPLETE"));
493     } else {
494       myRunTime = QDateTime::currentDateTime();
495       if (myIsKilled) {
496       //if (myIsRunned) {
497         if (!dataflow->ReStart()) {
498           QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_BADEXECUTE"));
499         } else {
500           StartTimer(tr("MSG_GRAPH_STARTED"));
501           syncNotification();
502         }
503       }
504       else {
505         if (!dataflow->Start()) {
506           QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_BADEXECUTE"));
507         } else {
508           StartTimer(tr("MSG_GRAPH_STARTED"));
509           syncNotification();
510         }
511       }
512     }
513   } else {
514     QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_RUNNING"));
515   }
516 }
517
518
519 void SUPERVGUI_Main::kill() {
520     Trace("SUPERVGUI_Main::kill")
521     if ((SUPERV_isNull(dataflow))) return;
522
523     if (dataflow->IsEditing()) {
524       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_NOTRUNNING"));
525     } else if (dataflow->Kill()) {
526       myIsKilled = true;
527       sync();
528     } else {
529       QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CANTKILL_DF"));
530     }
531 }
532
533 void SUPERVGUI_Main::suspendResume() {
534     Trace("SUPERVGUI_Main::suspendResume")
535     if ((SUPERV_isNull(dataflow))) return;
536
537     if (dataflow->IsEditing()) {
538         QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_DF_NOTRUNNING"));
539     } else if (dataflow->State() == SUPERV_Suspend) {
540       if (dataflow->Resume()) {
541         message->setMessage(tr("MSG_DF_RESUMED"));
542         sync();
543       } else {
544         QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CANT_RESUME"));
545       }
546     } else {
547       if (dataflow->Suspend()) {
548         sync();
549       } else {
550         QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CANT_SUSPEND"));
551       }
552     }
553 }
554
555 void SUPERVGUI_Main::stopRestart() { // kloss : a reviser et a connecter dans le popup du dataflow (pas de creation de bouton)
556     Trace("SUPERVGUI_Main::stopRestart")
557     if ((SUPERV_isNull(dataflow))) return;
558
559     if (dataflow->IsEditing()) {
560         QMessageBox::warning(0, tr("ERROR"),  tr("MSG_DF_NOTRUNNING"));
561     } else if (dataflow->State() == SUPERV_Stop) {
562         if (dataflow->ReStart()) {
563             message->setMessage(tr("MSG_DF_RESTARTED"));
564             sync();
565         } else {
566             QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CANT_RESTART"));
567         };
568     } else {
569         if (dataflow->Stop()) {
570             sync();
571         } else {
572             QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_CANT_STOP"));
573         };
574     };
575 }
576
577 void SUPERVGUI_Main::addNode() {
578   Trace("SUPERVGUI_Main::addNode");
579   if (SUPERV_isNull(dataflow)) return;
580
581   if (dataflow->IsExecuting()) {
582     if (QMessageBox::warning(QAD_Application::getDesktop(), 
583                              tr("WARNING"), tr("MSG_GRAPH_ISRUN"),
584                              QMessageBox::Yes, QMessageBox::No) == QMessageBox::No) {
585       return;        
586     } else {
587       kill();
588     }
589   }
590   Supervision.getBrowser()->choose();
591 }
592
593
594
595 /**
596  * Add Computation node
597  */
598 void SUPERVGUI_Main::addComputeNode(SUPERV_CNode theNode) {
599   //cout<<"### X="<<theNode->X()<<"  Y="<<theNode->Y()<<endl;
600   switch (myCurrentView) {
601   case GRAPH:
602     {
603       SUPERVGUI_Node* aNode = new SUPERVGUI_ComputeNode(graph->viewport(), this, theNode);
604       graph->ResizeGraph(aNode, theNode->X(), theNode->Y());
605       graph->addChild(aNode, theNode->X(), theNode->Y());
606       aNode->sync();
607     }
608     break;
609   case CONTROLFLOW: 
610     {
611       SUPERVGUI_Node* aNode = new SUPERVGUI_ComputeNode(graph->viewport(), this, theNode);
612       aNode->hideAll();
613       graph->ResizeGraph(aNode, theNode->X(), theNode->Y());
614       graph->addChild(aNode, theNode->X(), theNode->Y());
615       aNode->sync();
616     }
617     break;
618   case TABLE:
619     array->destroy();
620     array->create();
621     break;
622   }
623 }
624
625 /**
626  * Add GOTO node
627  */
628 void SUPERVGUI_Main::addGOTONode(SUPERV_CNode theNode) {
629   switch (myCurrentView) {
630   case GRAPH:
631     {
632       SUPERVGUI_Node* aNode = new SUPERVGUI_GotoNode(graph->viewport(), this, theNode);
633       graph->ResizeGraph(aNode, theNode->X(), theNode->Y());
634       graph->addChild(aNode, theNode->X(), theNode->Y());
635       aNode->sync();
636     }
637     break;
638   case CONTROLFLOW: 
639     {
640       SUPERVGUI_Node* aNode = new SUPERVGUI_GotoNode(graph->viewport(), this, theNode);
641       aNode->hideAll();
642       graph->ResizeGraph(aNode, theNode->X(), theNode->Y());
643       graph->addChild(aNode, theNode->X(), theNode->Y());
644       aNode->sync();
645     }
646     break;
647   case TABLE:
648     array->destroy();
649     array->create();
650     break;
651   }
652 }
653
654 /**
655  * Add Control node
656  */
657 void SUPERVGUI_Main::addControlNode(SUPERV_CNode theStartNode, SUPERV_CNode theEndNode, bool Update) {
658   switch (myCurrentView) {
659   case GRAPH:
660     {
661       SUPERVGUI_StartControlNode* aStartPrs = 
662         new SUPERVGUI_StartControlNode(graph->viewport(), this, theStartNode);
663       SUPERVGUI_EndControlNode* aEndPrs = 
664         new SUPERVGUI_EndControlNode(graph->viewport(), this, theEndNode, aStartPrs);
665
666       graph->ResizeGraph(aStartPrs, theStartNode->X(), theStartNode->Y());            
667       graph->addChild(aStartPrs, theStartNode->X(), theStartNode->Y());
668       graph->ResizeGraph(aEndPrs, theEndNode->X(), theEndNode->Y());
669       graph->addChild(aEndPrs, theEndNode->X(), theEndNode->Y());
670       if (Update) {
671         aStartPrs->updateLinksPrs();
672         aEndPrs->updateLinksPrs();
673       }
674       aStartPrs->sync();
675       aEndPrs->sync();
676       graph->repaintContents();
677     }
678     break;
679   case CONTROLFLOW: 
680     {
681       SUPERVGUI_StartControlNode* aStartPrs = 
682         new SUPERVGUI_StartControlNode(graph->viewport(), this, theStartNode);
683       SUPERVGUI_EndControlNode* aEndPrs = 
684         new SUPERVGUI_EndControlNode(graph->viewport(), this, theEndNode, aStartPrs);
685       
686       aStartPrs->hideAll();
687       aEndPrs->hideAll();
688       
689       graph->ResizeGraph(aStartPrs, theStartNode->X(), theStartNode->Y());
690       graph->addChild(aStartPrs, theStartNode->X(), theStartNode->Y());
691       graph->ResizeGraph(aEndPrs, theEndNode->X(), theEndNode->Y());
692       graph->addChild(aEndPrs, theEndNode->X(), theEndNode->Y());
693       if (Update) {
694         aStartPrs->updateLinksPrs();
695         aEndPrs->updateLinksPrs();
696       }
697       aStartPrs->sync();
698       aEndPrs->sync();
699       graph->repaintContents();
700     }
701     break;
702   case TABLE:
703     array->destroy();
704     array->create();
705     break;
706   }
707 }
708
709
710
711 SUPERVGUI_Graph* SUPERVGUI_Main::getGraph() {
712     Trace("SUPERVGUI_Main::getGraph")
713     return(graph);
714 }
715
716 SUPERVGUI_Array* SUPERVGUI_Main::getArray() {
717     Trace("SUPERVGUI_Main::getArray")
718     return(array);
719 }
720
721 SUPERV_Graph SUPERVGUI_Main::getDataflow() {
722     Trace("SUPERVGUI_Main::getDataflow")
723     return(dataflow);
724 }
725
726 QAD_Message* SUPERVGUI_Main::getMessage() {
727     Trace("SUPERVGUI_Main::getMessage")
728     return(message);
729 }
730
731 QAD_Study* SUPERVGUI_Main::getStudy() {
732     Trace("SUPERVGUI_Main::getStudy")
733     return(study);
734 }
735
736 bool SUPERVGUI_Main::isArrayShown() {
737     Trace("SUPERVGUI_Main::isArrayShown")
738     return(myCurrentView == TABLE);
739 }
740
741 void SUPERVGUI_Main::showPopup(QPopupMenu* p, QMouseEvent* e) {
742   Trace("SUPERVGUI_Main::showPopup");
743   // To check is Supervision active?
744   if (myIsLocked) return;
745
746   //  if (QAD_Application::getDesktop()->getActiveComponent().compare(STUDY_SUPERVISION) !=0) return;
747   if (QAD_Application::getDesktop()->getActiveComponent().compare( QAD_Application::getDesktop()->getComponentUserName( "SUPERV" ) ) !=0) return;
748
749   checkIsInStudy();
750   if (e->button() == RightButton) {
751     p->exec(e->globalPos());
752   }
753 }
754
755
756
757 void SUPERVGUI_Main::changeInformation() {
758   SUPERVGUI_Information* aDlg = new SUPERVGUI_Information(SUPERV::CNode::_narrow(dataflow), dataflow->IsReadOnly());
759   if (aDlg->exec() )
760     sync();
761   delete aDlg;
762   /*    Trace("SUPERVGUI_Main::changeInformation")
763     if (Supervision.information(SUPERV::CNode::_narrow(dataflow), dataflow->IsReadOnly())) {
764       sync();
765       }*/
766 }
767
768 // returns false, if can't add dataflow into the study
769 bool SUPERVGUI_Main::addStudy() {
770   Trace("SUPERVGUI_Main::addStudy");
771   if (myIsFromStudy) return false;
772   if ((SUPERV_isNull(dataflow))) return false;
773   
774   SALOMEDS::Study_var            aStudy = study->getStudyDocument();
775   SALOMEDS::StudyBuilder_var     aBuilder  = aStudy->NewBuilder();
776   SALOMEDS::GenericAttribute_var anAttr;
777   SALOMEDS::AttributeName_var    aName;
778   SALOMEDS::AttributeIOR_var     anIORAttr;
779   SALOMEDS::AttributePixMap_var  aPixmap;
780   bool                           aLocked = aStudy->GetProperties()->IsLocked();
781   QAD_Operation*                 op = new SALOMEGUI_ImportOperation( study );
782   
783   // searching dataflow
784   SALOMEDS::SObject_var aSO = aStudy->FindObjectIOR(dataflow->getIOR());
785   if (aSO->_is_nil()) { // create new dataflow SObject
786     SALOMEDS::SComponent_ptr aComponent = aStudy->FindComponent(STUDY_SUPERVISION);
787     if (aComponent->_is_nil()) { // is supervision component not found, then create it
788       QAD_Operation* anOperation = new SALOMEGUI_ImportOperation( study );
789       anOperation->start();
790       if (aLocked) aStudy->GetProperties()->SetLocked(false);
791       aComponent = aBuilder->NewComponent(STUDY_SUPERVISION);
792       anAttr = aBuilder->FindOrCreateAttribute(aComponent, "AttributeName");
793       aName = SALOMEDS::AttributeName::_narrow(anAttr);
794       //aName->SetValue("Supervision");
795       aName->SetValue( QAD_Application::getDesktop()->getComponentUserName( "SUPERV" ) );
796         
797       anAttr = aBuilder->FindOrCreateAttribute(aComponent, "AttributePixMap");
798       aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
799       aPixmap->SetPixMap( "ICON_OBJBROWSER_Supervision" );
800       aBuilder->DefineComponentInstance(aComponent, *Supervision.getEngine());
801       if (aLocked) aStudy->GetProperties()->SetLocked(true);
802       anOperation->finish();
803     }
804     op->start();
805     aSO = aBuilder->NewObject(aComponent);
806     anAttr =  aBuilder->FindOrCreateAttribute(aSO, "AttributeName");
807     aName = SALOMEDS::AttributeName::_narrow(anAttr);
808     aName->SetValue(dataflow->Name());
809     anAttr =  aBuilder->FindOrCreateAttribute(aSO, "AttributeIOR");
810     anIORAttr = SALOMEDS::AttributeIOR::_narrow(anAttr);
811     anIORAttr->SetValue(dataflow->getIOR());
812     op->finish();
813     if (aLocked) return false;
814   }
815
816   sync();
817   Supervision.unregisterGraph(this);
818   Supervision.registerGraph(dataflow->getIOR(), this);
819   myIsFromStudy = true;
820   return true;
821 }
822
823
824 void SUPERVGUI_Main::chooseData(QListViewItem* item) {
825     Trace("SUPERVGUI_Main::chooseData")
826     if (choosing) {
827         QString id = ((QAD_ObjectBrowserItem*)item)->getEntry();
828         if (!id.isEmpty()) {
829             SALOMEDS::SObject_var object = study->getStudyDocument()->FindObjectID(id.latin1());
830             SALOMEDS::GenericAttribute_var anAttr;
831             SALOMEDS::AttributeIOR_var     anIOR;
832             Standard_CString      ior    = "";
833             if (object->FindAttribute(anAttr, "AttributeIOR")) {
834               anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
835               ior = anIOR->Value();
836               portIn->setValue(ior);
837
838               // stop selection
839               choosing = false;
840               setCursor(Supervision.getCursor());
841               objectBrowser->setCursor(Supervision.getCursor());
842               Supervision.putInfo("");
843             }
844         }
845     }
846 }
847
848 void SUPERVGUI_Main::setData(SUPERVGUI_PortIn* p) {
849     Trace("SUPERVGUI_Main::setData")
850     portIn   = p;
851     choosing = true;
852     setCursor(forbiddenCursor);
853     objectBrowser->setCursor(pointingHandCursor);
854     Supervision.putInfo(tr("MSG_CHOOSE_DATA"));
855 }
856
857 SALOMEDS::SObject_var SearchOrCreateSOWithName(const SALOMEDS::Study_var theStudy,
858                                                const SALOMEDS::SObject_var theSO,
859                                                const char* theName,
860                                                QAD_Operation* theOperation,
861                                                bool* theStarted) {
862   SALOMEDS::SObject_var aResult;
863   SALOMEDS::AttributeName_var aName;
864   SALOMEDS::GenericAttribute_var anAttr;
865   if (!*theStarted) { // optimisation
866     SALOMEDS::ChildIterator_var anIterator = theStudy->NewChildIterator(theSO);
867     for (; anIterator->More(); anIterator->Next()) {
868       if (anIterator->Value()->FindAttribute(anAttr, "AttributeName")) {
869         aName = SALOMEDS::AttributeName::_narrow(anAttr);
870         if (strcmp(aName->Value(), theName) == 0) {
871           aResult = anIterator->Value();
872           break;
873         }
874       }
875     }
876   }
877   if (!aResult->_is_nil()) return aResult;
878   // add new SObject
879   if (!*theStarted) {
880     *theStarted = true;
881     theOperation->start();
882   }
883   SALOMEDS::StudyBuilder_var aBuilder = theStudy->NewBuilder();
884   aResult = aBuilder->NewObject(theSO);
885   anAttr = aBuilder->FindOrCreateAttribute(aResult, "AttributeName");
886   aName = SALOMEDS::AttributeName::_narrow(anAttr);
887   aName->SetValue(theName);
888   return aResult;
889 }
890
891 bool SUPERVGUI_Main::putDataStudy(SUPERV_Port p, const char* inout) {
892   Trace("SUPERVGUI_Main::putDataStudy");
893
894   static bool isIn = false;
895   if (isIn) return true; else isIn = true;
896
897   SALOMEDS::Study_var            aStudy = study->getStudyDocument();
898   SALOMEDS::StudyBuilder_var     aBuilder  = aStudy->NewBuilder();
899   SALOMEDS::GenericAttribute_var anAttr;
900   SALOMEDS::AttributeName_var    aName;
901   SALOMEDS::AttributeIOR_var     anIORAttr;
902   SALOMEDS::AttributePixMap_var  aPixmap;
903   bool                           aTransaction = false;
904   bool                           aLocked = aStudy->GetProperties()->IsLocked();
905   QAD_Operation*                 op = new SALOMEGUI_ImportOperation( study );
906   
907   // searching dataflow
908   SALOMEDS::SObject_var aSO = aStudy->FindObjectIOR(dataflow->getIOR());
909   if (aSO->_is_nil()) { // create new dataflow SObject
910     SALOMEDS::SComponent_ptr aComponent = aStudy->FindComponent(STUDY_SUPERVISION);
911     if (aComponent->_is_nil()) { // is supervision component not found, then create it
912       QAD_Operation* anOperation = new SALOMEGUI_ImportOperation( study );
913       anOperation->start();
914       if (aLocked) aStudy->GetProperties()->SetLocked(false);
915       aComponent = aBuilder->NewComponent(STUDY_SUPERVISION);
916       anAttr = aBuilder->FindOrCreateAttribute(aComponent, "AttributeName");
917       aName = SALOMEDS::AttributeName::_narrow(anAttr);
918       aName->SetValue( QAD_Application::getDesktop()->getComponentUserName( "SUPERV" ) );
919         
920       anAttr = aBuilder->FindOrCreateAttribute(aComponent, "AttributePixMap");
921       aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
922       aPixmap->SetPixMap( "ICON_OBJBROWSER_Supervision" );
923       aBuilder->DefineComponentInstance(aComponent, *Supervision.getEngine());
924       if (aLocked) aStudy->GetProperties()->SetLocked(true);
925       anOperation->finish();
926     }
927     aTransaction = true;
928     op->start();
929     aSO = aBuilder->NewObject(aComponent);
930     anAttr =  aBuilder->FindOrCreateAttribute(aSO, "AttributeName");
931     aName = SALOMEDS::AttributeName::_narrow(anAttr);
932     aName->SetValue(dataflow->Name());
933     anAttr =  aBuilder->FindOrCreateAttribute(aSO, "AttributeIOR");
934     anIORAttr = SALOMEDS::AttributeIOR::_narrow(anAttr);
935     anIORAttr->SetValue(dataflow->getIOR());
936   }
937   aSO = SearchOrCreateSOWithName(aStudy, aSO,  // get run time SO
938                                  QString("Run ") + myRunTime.toString() , op, &aTransaction);
939   aSO = SearchOrCreateSOWithName(aStudy, aSO, p->Node()->Name(), op, &aTransaction); // get node SO
940   aSO = SearchOrCreateSOWithName(aStudy, aSO, inout, op, &aTransaction); // get in/out SO
941   aSO = SearchOrCreateSOWithName(aStudy, aSO, p->Name(), op, &aTransaction); // get port SO
942
943   if (aLocked) {
944     if (aTransaction) op->finish();
945     isIn = false;
946     return false;
947   }
948
949   anAttr = aBuilder->FindOrCreateAttribute(aSO, "AttributeIOR");
950   anIORAttr  = SALOMEDS::AttributeIOR::_narrow(anAttr);
951   if (!aTransaction && strcmp(anIORAttr->Value(), p->ToString()) == 0) {
952     isIn = false;
953     return true;
954   }
955   // set object value to the study: if object is external, then put it with
956   //                                 help of the specific component - owner
957   if (p->IsIOR()) {
958     // get according component driver for result object
959     SALOME_LifeCycleCORBA aLCC(myNService);
960     SUPERV_FNode aFNode = SUPERV::FNode::_narrow(p->Node());
961     if (!aFNode->_is_nil()) {
962       Engines::Component_var aComponent = aLCC.FindOrLoad_Component(aFNode->GetContainer(),
963                                                                     aFNode->GetComponentName());
964       SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(aComponent);
965       if (!CORBA::is_nil(aDriver)) { // if driver was found, publish object
966         CORBA::Object_ptr anObject = new CORBA::Object();
967         CORBA::Any* anAny = p->ToAny();
968         (*anAny) >>= anObject;
969         
970         if (aDriver->CanPublishInStudy(anObject)) {
971           SALOMEDS::SObject_var aTmpSO;
972           if (!aTransaction) {
973             aTmpSO = aSO;
974             aTransaction = true;
975             op->start();
976           }
977           aTmpSO = aDriver->PublishInStudy(aStudy, aTmpSO, anObject, "");
978           aBuilder->Addreference(aSO, aTmpSO);
979         } else { // can't publish object: abort transaction
980           if (aTransaction) op->abort();
981           isIn = false;
982           return false;
983         }
984       } else { // component has no drivel, but could store IORs (like Calculator)
985         SALOMEDS::SObject_var anIORSO = aStudy->FindObjectIOR(p->ToString());
986         if (!CORBA::is_nil(anIORSO)) aBuilder->Addreference(aSO, anIORSO);
987       }
988     }
989   } else {
990     if (!aTransaction) {
991       aTransaction = true;
992       op->start();
993     }
994     anIORAttr->SetValue(p->ToString()); // ior attribute already set for the prevoius condition
995   }
996   
997   if (aTransaction) op->finish();
998   study->updateObjBrowser();
999   isIn = false;
1000   return true;
1001 }
1002
1003
1004 void SUPERVGUI_Main::ActivatePanning()
1005 {
1006   if (graph->isVisible()) {
1007     graph->ActivatePanning();
1008   } else if (array->isVisible()) {
1009     array->ActivatePanning();
1010   }
1011 }
1012
1013
1014 void SUPERVGUI_Main::ResetView()
1015 {
1016   if (graph->isVisible()) {
1017     graph->ResetView();
1018   } else if (array->isVisible()) {
1019     array->ResetView();
1020   }
1021 }
1022
1023
1024 void SUPERVGUI_Main::setAsFromStudy(bool theToStudy) {
1025   myIsFromStudy = theToStudy;
1026   graph->setAsFromStudy(theToStudy);
1027   array->setAsFromStudy(theToStudy);
1028 }
1029
1030 void SUPERVGUI_Main::checkIsInStudy() {
1031   if (!myIsFromStudy) return;
1032
1033   SALOMEDS::Study_var aStudyDoc = study->getStudyDocument();
1034   SALOMEDS::SComponent_var aFatherLbl = aStudyDoc->FindComponent(STUDY_SUPERVISION);
1035   SALOMEDS::ChildIterator_var aChildIterator = aStudyDoc->NewChildIterator(aFatherLbl);
1036   SALOMEDS::SObject_var aDataflowLbl;
1037   SALOMEDS::GenericAttribute_var anAttr;
1038
1039   for (; aChildIterator->More(); aChildIterator->Next()) {
1040     aDataflowLbl = aChildIterator->Value();
1041     if (!aDataflowLbl->FindAttribute(anAttr, "AttributeIOR"))
1042       continue;
1043
1044     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
1045     if (strcmp(anIOR->Value(), dataflow->getIOR()) == 0) return;
1046   }
1047   // This Graph considered as in study but in study it is not exists
1048   Supervision.unregisterGraph(this);
1049   setAsFromStudy(false);
1050 }
1051
1052 void SUPERVGUI_Main::syncNotification() {
1053   char* graph;
1054   char* node;
1055   char* type;
1056   char* message;
1057   char* sender;
1058   long  counter;
1059   char* date;
1060   long  stamp;
1061   
1062   while (notification->Receive(&graph, &node, &type, &message, &sender, &counter, &date, &stamp)) {
1063     if (isFiltered(graph, node, type, message, sender, counter, date, stamp)) {
1064       QString mess("");
1065       mess += "NOTIF: "; mess += graph;
1066       mess += " / "    ; mess += node;
1067       mess += " / "    ; mess += type;
1068       mess += " / "    ; mess += message;
1069       getMessage()->setMessage(mess.latin1());
1070     };
1071   };
1072 }
1073   
1074 bool SUPERVGUI_Main::isFiltered(char* graph,  char* node,   char* type, char* message, 
1075                                 char* sender, long counter, char* date, long stamp) {
1076   Trace("SUPERVGUI_Main::isFiltered");
1077   bool b = false;
1078   if (strcmp(getDataflow()->Name(), graph) == 0) {
1079     SUPERVGUI_Node* n;
1080     QObjectList* nodes = queryList("SUPERVGUI_Node");
1081     QObjectListIt i(*nodes);
1082     while ((n=(SUPERVGUI_Node*)i.current()) != 0) {
1083       ++i;
1084       if (strcmp(n->name(), node) == 0) {
1085         if (strcmp(type, NOTIF_WARNING) == 0) {
1086           b = n->isWarning();
1087         } else if (strcmp(type, NOTIF_STEP) == 0) {
1088           b = n->isStep();
1089         } else if (strcmp(type, NOTIF_TRACE) == 0) {
1090           b = n->isTrace();
1091         } else if (strcmp(type, NOTIF_VERBOSE) == 0) {
1092           b = n->isVerbose();
1093         };
1094         break;
1095       };
1096     };
1097     delete nodes;
1098     if ( myLogged && myLogFile && ( ( !myFiltered ) || b ) ) {
1099       fprintf( myLogFile, "NOTIF %ld\t%s\t%s\t%ld\t%s\t%s\t%s\t%s\n", stamp, date, sender, counter, graph, node, type, message );
1100       fflush( myLogFile );
1101     };
1102   };
1103   return( b );
1104 }
1105
1106
1107
1108 void SUPERVGUI_Main::setPaletteBackgroundColor(const QColor& color) { 
1109   array->setPaletteBackgroundColor(color);
1110   graph->setPaletteBackgroundColor(color);
1111   
1112   SUPERVGraph_View::setPaletteBackgroundColor(color); 
1113 }
1114