src/VISUGUI/VisuGUI_Tools.cxx

   1 //  VISU VISUGUI : GUI of VISU component
   2 //
   3 //  Copyright (C) 2005  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   : VisuGUI_Tools.cxx
  25 //  Author : Sergey Anikin
  26 //  Module : VISU
  27
  28
  29 #include "VisuGUI_Tools.h"
  30
  31 #include "VISU_Gen_i.hh"
  32 #include "VISU_Prs3d_i.hh"
  33 #include "VISU_Result_i.hh"
  34 #include "VISU_Table_i.hh"
  35 #include "VISU_ViewManager_i.hh"
  36 #include "VISU_Actor.h"
  37
  38 #include "SalomeApp_Module.h"
  39 #include "SalomeApp_Study.h"
  40 #include "SalomeApp_Application.h"
  41 #include "SalomeApp_SelectionMgr.h"
  42
  43 #include "SALOME_ListIO.hxx"
  44 #include "SALOME_ListIteratorOfListIO.hxx"
  45
  46 #include "SVTK_ViewWindow.h"
  47 #include "SVTK_ViewModel.h"
  48 #include "SVTK_Functor.h"
  49
  50 #include "VTKViewer_Algorithm.h"
  51
  52 #include "SPlot2d_ViewModel.h"
  53 #include "Plot2d_ViewFrame.h"
  54
  55 #include "SUIT_Session.h"
  56 #include "SUIT_MessageBox.h"
  57
  58 #include <vtkRenderer.h>
  59 #include <vtkActorCollection.h>
  60
  61
  62 //=============================================================================
  63 namespace VISU
  64 {
  65   SUIT_Desktop*
  66   GetDesktop(const CAM_Module* theModule)
  67   {
  68     return theModule->application()->desktop();
  69   }
  70
  71   SalomeApp_SelectionMgr*
  72   GetSelectionMgr(const SalomeApp_Module* theModule)
  73   {
  74     return theModule->getApp()->selectionMgr();
  75   }
  76
  77   SalomeApp_Study*
  78   GetAppStudy(const CAM_Module* theModule)
  79   {
  80     return
  81       dynamic_cast<SalomeApp_Study*>(theModule->application()->activeStudy());
  82   }
  83
  84   _PTR(Study)
  85   GetCStudy(const SalomeApp_Study* theStudy)
  86   {
  87     return theStudy->studyDS();
  88   }
  89
  90   SALOMEDS::StudyManager_var
  91   GetStudyManager()
  92   {
  93     static SALOMEDS::StudyManager_var aStudyManager;
  94     if(CORBA::is_nil(aStudyManager)){
  95       SALOME_NamingService *aNamingService = SalomeApp_Application::namingService();
  96       CORBA::Object_var anObject = aNamingService->Resolve("/myStudyManager");
  97       aStudyManager = SALOMEDS::StudyManager::_narrow(anObject);
  98     }
  99     return aStudyManager;
 100   }
 101
 102   bool
 103   IsStudyLocked( _PTR(Study) theStudy )
 104   {
 105     if( theStudy )
 106       return theStudy->GetProperties()->IsLocked();
 107     return true;
 108   }
 109
 110   bool
 111   CheckLock( _PTR(Study) theStudy )
 112   {
 113     if(IsStudyLocked(theStudy))
 114       throw std::runtime_error(QObject::tr("WRN_STUDY_LOCKED").latin1());
 115     return false;
 116   }
 117
 118   VISU_Gen_i*
 119   GetVisuGen(const CAM_Module* theModule)
 120   {
 121     static VISU_Gen_i* aGen = NULL;
 122     if(!aGen){
 123       SALOME_LifeCycleCORBA aLCC(SalomeApp_Application::namingService());
 124       Engines::Component_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","VISU");
 125       VISU_Gen_var aVISU = VISU_Gen::_narrow(aComponent);
 126       if(!CORBA::is_nil(aVISU)){
 127         aGen = VISU_Gen_i::GetVisuGenImpl();
 128         aGen->SetCurrentStudy(GetDSStudy(GetCStudy(GetAppStudy(theModule))));
 129       }
 130     }
 131     if(!aGen)
 132       throw std::runtime_error(QObject::tr("ERR_CANT_FIND_VISU_COMPONENT").latin1());
 133     return aGen;
 134   }
 135
 136   SALOME_MED::MED_Gen_var
 137   GetMEDEngine()
 138   {
 139     static SALOME_MED::MED_Gen_var aGen;
 140     if(CORBA::is_nil(aGen)){
 141       SALOME_LifeCycleCORBA aLCC(SalomeApp_Application::namingService());
 142       Engines::Component_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","MED");
 143       aGen = SALOME_MED::MED_Gen::_narrow(aComponent);
 144     }
 145     if(CORBA::is_nil(aGen))
 146       throw std::runtime_error(QObject::tr("ERR_CANT_FIND_MED_COMPONENT").latin1());
 147     return aGen;
 148   }
 149
 150   CORBA::Object_var
 151   GetSelectedObj(const SalomeApp_Study* theStudy,
 152                  const QString& theEntry,
 153                  VISU::Storable::TRestoringMap* theMap)
 154   {
 155     if ( !theStudy || theEntry.isEmpty() )
 156       return CORBA::Object::_nil();
 157
 158     SALOMEDS::Study_var aStudy = GetDSStudy(GetCStudy( theStudy ));
 159     SALOMEDS::SObject_var aSObject = aStudy->FindObjectID( theEntry.latin1() );
 160     if(!aSObject->_is_nil()){
 161       SALOMEDS::GenericAttribute_var anAttr;
 162       if(theMap && aSObject->FindAttribute(anAttr,"AttributeComment")){
 163         SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
 164         std::string aValue = aComment->Value();
 165         QString aString(aValue.c_str());
 166         VISU::Storable::StrToMap(aString,*theMap);
 167       }
 168       return VISU::SObjectToObject(aSObject);
 169     }
 170     return CORBA::Object::_nil();
 171   }
 172
 173   CORBA::Object_var
 174   GetSelectedObj(const SalomeApp_Module* theModule,
 175                  Handle(SALOME_InteractiveObject)* theIO,
 176                  VISU::Storable::TRestoringMap* theMap)
 177   {
 178     SalomeApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
 179     SALOME_ListIO aListIO;
 180     aSelectionMgr->selectedObjects(aListIO);
 181     SALOME_ListIteratorOfListIO anIter(aListIO);
 182     if(anIter.More()){
 183       Handle(SALOME_InteractiveObject) anIO = anIter.Value();
 184       if(theIO)
 185         *theIO = anIO;
 186       if(anIO->hasEntry())
 187         return GetSelectedObj( GetAppStudy(theModule), anIO->getEntry(), theMap );
 188     }
 189     return CORBA::Object::_nil();
 190   }
 191
 192   VISU::Storable::TRestoringMap
 193   getMapOfValue(SALOMEDS::SObject_var theSObject)
 194   {
 195     VISU::Storable::TRestoringMap aMap;
 196     if(!theSObject->_is_nil()){
 197       SALOMEDS::GenericAttribute_var anAttr;
 198       if (theSObject->FindAttribute(anAttr, "AttributeComment")) {
 199         SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
 200         CORBA::String_var aValue = aComment->Value();
 201         QString aString(aValue.in());
 202         VISU::Storable::StrToMap(aString,aMap);
 203       }
 204     }
 205     return aMap;
 206   }
 207
 208   QString
 209   getValue(SALOMEDS::SObject_var theSObject,
 210            QString theKey)
 211   {
 212     QString aStr("");
 213     VISU::Storable::TRestoringMap aMap = getMapOfValue(theSObject);
 214     if(!aMap.empty())
 215       aStr = VISU::Storable::FindValue(aMap,theKey.latin1());
 216     return aStr;
 217   }
 218
 219   VISU::Storable::TRestoringMap getMapOfValue (_PTR(SObject) theSObject)
 220   {
 221     VISU::Storable::TRestoringMap aMap;
 222     if (theSObject) {
 223       _PTR(GenericAttribute) anAttr;
 224       if (theSObject->FindAttribute(anAttr, "AttributeComment")) {
 225         _PTR(AttributeComment) aComment (anAttr);
 226         std::string aValue = aComment->Value();
 227         QString aString (aValue.c_str());
 228         VISU::Storable::StrToMap(aString, aMap);
 229       }
 230     }
 231     return aMap;
 232   }
 233
 234   QString getValue (_PTR(SObject) theSObject, QString theKey)
 235   {
 236     QString aStr("");
 237     VISU::Storable::TRestoringMap aMap = getMapOfValue(theSObject);
 238     if (!aMap.empty())
 239       aStr = VISU::Storable::FindValue(aMap, theKey.latin1());
 240     return aStr;
 241   }
 242
 243
 244   bool
 245   CheckTimeStamp(const SalomeApp_Module* theModule,
 246                  SALOMEDS::SObject_var& theSObject,
 247                  Handle(SALOME_InteractiveObject)* theIO)
 248   {
 249     Handle(SALOME_InteractiveObject) anIO;
 250     CORBA::Object_var anObject = GetSelectedObj(theModule,&anIO);
 251     if(theIO)
 252       *theIO = anIO;
 253     if(!anIO.IsNull() && anIO->hasEntry()){
 254       SALOMEDS::Study_var aStudy = GetDSStudy(GetCStudy(GetAppStudy(theModule)));
 255       theSObject = aStudy->FindObjectID(anIO->getEntry());
 256       QString aValue = getValue(theSObject,"myType");
 257       if(aValue.toInt() == int(VISU::TTIMESTAMP))
 258         return true;
 259     }
 260     SUIT_MessageBox::warn1(GetDesktop(theModule),
 261                            QObject::tr("WRN_VISU"),
 262                            QObject::tr("WRN_NO_AVAILABLE_DATA"),
 263                            QObject::tr("BUT_OK") );
 264     return false;
 265   }
 266
 267
 268   VISU::Result_i*
 269   CheckResult(const SalomeApp_Module* theModule,
 270               SALOMEDS::SObject_var theSource,
 271               VISU::Result_var& theResult)
 272   {
 273     SALOMEDS::SObject_var aSObj;
 274
 275     aSObj = theSource->GetFather();
 276     if (CORBA::is_nil(aSObj))
 277       return NULL;
 278
 279     aSObj = aSObj->GetFather();
 280     if (CORBA::is_nil(aSObj))
 281       return NULL;
 282
 283     aSObj = aSObj->GetFather();
 284     if (CORBA::is_nil(aSObj))
 285       return NULL;
 286
 287     CORBA::Object_var anObject = VISU::SObjectToObject(aSObj);
 288     if (CORBA::is_nil(anObject)) {
 289       aSObj = aSObj->GetFather();
 290       if (CORBA::is_nil(aSObj))
 291         return NULL;
 292       anObject = VISU::SObjectToObject(aSObj);
 293     }
 294
 295     if (CORBA::is_nil(anObject))
 296       return NULL;
 297
 298     theResult = VISU::Result::_narrow(anObject);
 299     VISU::Result_i* pResult = dynamic_cast<VISU::Result_i*>(VISU::GetServant(anObject).in());
 300     if(pResult == NULL)
 301       SUIT_MessageBox::warn1(GetDesktop(theModule),
 302                              QObject::tr("WRN_VISU"),
 303                              QObject::tr("WRN_NO_AVAILABLE_DATA"),
 304                              QObject::tr("BUT_OK"));
 305     return pResult;
 306   }
 307
 308   SVTK_ViewWindow*
 309   GetViewWindow(const SalomeApp_Module* theModule, const bool theCreate )
 310   {
 311     if(SalomeApp_Application* anApp = theModule->getApp()){
 312       if(SUIT_ViewManager* aViewManager = anApp->getViewManager( SVTK_Viewer::Type(), theCreate )){
 313         if(SUIT_ViewWindow* aViewWindow = aViewManager->getActiveView()){
 314           return dynamic_cast<SVTK_ViewWindow*>(aViewWindow);
 315         }
 316       }
 317     }
 318     return NULL;
 319   }
 320
 321   SVTK_ViewWindow*
 322   GetViewWindow()
 323   {
 324     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>
 325       (SUIT_Session::session()->activeApplication());
 326     if (anApp) {
 327       if (SUIT_ViewManager* aViewManager = anApp->activeViewManager()) {
 328         if (aViewManager->getType() == SVTK_Viewer::Type()) {
 329           if (SUIT_ViewWindow* aViewWindow = aViewManager->getActiveView()) {
 330             return dynamic_cast<SVTK_ViewWindow*>(aViewWindow);
 331           }
 332         }
 333       }
 334     }
 335     return NULL;
 336   }
 337
 338   TViewWindows
 339   GetViews(const SalomeApp_Module* theModule)
 340   {
 341     TViewWindows aViewWindows;
 342     if(SalomeApp_Application* anApp = theModule->getApp()){
 343       ViewManagerList aViewManagerList;
 344       anApp->viewManagers(SVTK_Viewer::Type(),aViewManagerList);
 345       QPtrListIterator<SUIT_ViewManager> anIter(aViewManagerList);
 346       while(SUIT_ViewManager* aViewManager = anIter.current()){
 347         QPtrVector<SUIT_ViewWindow> aViews = aViewManager->getViews();
 348         for(int i = 0, iEnd = aViews.size(); i < iEnd; i++){
 349           if(SUIT_ViewWindow* aViewWindow = aViews.at(i))
 350             if(SVTK_ViewWindow* aView = dynamic_cast<SVTK_ViewWindow*>(aViewWindow))
 351               aViewWindows.push_back(aView);
 352         }
 353         ++anIter;
 354       }
 355     }
 356     return aViewWindows;
 357   }
 358
 359   VISU_Actor*
 360   PublishInView(const SalomeApp_Module* theModule,
 361                 VISU::Prs3d_i* thePrs)
 362   {
 363     VISU_Actor* aActor = NULL;
 364     if(!thePrs)
 365       return aActor;
 366     if(SVTK_ViewWindow* aView = GetViewWindow(theModule)){
 367       QApplication::setOverrideCursor( Qt::waitCursor );
 368       if(aActor = thePrs->CreateActor()){
 369         aView->AddActor(aActor);
 370       }
 371       QApplication::restoreOverrideCursor();
 372     }
 373     return aActor;
 374   }
 375
 376   VISU_Actor*
 377   UpdateViewer(const SalomeApp_Module* theModule,
 378                VISU::Prs3d_i* thePrs,
 379                bool theDispOnly)
 380   {
 381     SVTK_ViewWindow* vw = GetViewWindow( theModule );
 382     if (!vw) return NULL;
 383
 384     vtkRenderer *aRen = vw->getRenderer();
 385     vtkActorCollection *anActColl = aRen->GetActors();
 386
 387     vtkActor *anActor;
 388     VISU_Actor* anVISUActor = NULL;
 389     VISU_Actor* aResActor = NULL;
 390     for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL; ){
 391       if(!SALOME_Actor::SafeDownCast(anActor))
 392         continue;
 393       if(anActor->IsA("VISU_Actor")){
 394         anVISUActor = VISU_Actor::SafeDownCast(anActor);
 395         VISU::Prs3d_i* aPrs = anVISUActor->GetPrs3d();
 396         if(aPrs == NULL) continue;
 397         if (thePrs == aPrs) {
 398           aResActor = anVISUActor->GetParent();
 399           thePrs->UpdateActor(aResActor);
 400           aResActor->VisibilityOn();
 401
 402         } else if (theDispOnly) {
 403           anVISUActor->GetParent()->VisibilityOff();
 404         } else {
 405         }
 406       } else if (theDispOnly && anActor->GetVisibility()) {
 407         anActor->VisibilityOff();
 408       } else {
 409       }
 410     }
 411     if (aResActor)
 412       return aResActor;
 413
 414     anVISUActor = PublishInView( theModule, thePrs );
 415     return anVISUActor;
 416   }
 417
 418   VISU_Actor*
 419   FindActor(SVTK_ViewWindow* theViewWindow,
 420             const char* theEntry)
 421   {
 422     using namespace VTK;
 423     if(vtkRenderer* aRenderer = theViewWindow->getRenderer()){
 424       if(vtkActorCollection* aCollection = aRenderer->GetActors()){
 425         if(VISU_Actor* anActor = Find<VISU_Actor>(aCollection,TIsSameEntry<VISU_Actor>(theEntry))){
 426           return anActor->GetParent();
 427         }
 428       }
 429     }
 430     return NULL;
 431   }
 432
 433   VISU_Actor*
 434   FindActor(SVTK_ViewWindow* theViewWindow,
 435             VISU::Prs3d_i* thePrs)
 436   {
 437     SALOMEDS::SObject_var aSObject = thePrs->GetSObject();
 438     CORBA::String_var anEntry = aSObject->GetID();
 439     return FindActor(theViewWindow,anEntry.in());
 440   }
 441
 442   void
 443   RecreateActor (const SalomeApp_Module* theModule,
 444                  VISU::Prs3d_i* thePrs)
 445   {
 446     QApplication::setOverrideCursor(Qt::waitCursor);
 447
 448     SALOMEDS::SObject_var aSObject = thePrs->GetSObject();
 449     CORBA::String_var anEntry = aSObject->GetID();
 450
 451     try {
 452       thePrs->Update();
 453
 454       TViewWindows aViewWindows = GetViews(theModule);
 455       for (int i = 0, iEnd = aViewWindows.size(); i < iEnd; i++) {
 456         SVTK_ViewWindow* aView = aViewWindows[i];
 457         if (VISU_Actor* anActor = FindActor(aView, anEntry.in())) {
 458           thePrs->UpdateActor(anActor);
 459         }
 460       }
 461     } catch (std::runtime_error& ex) {
 462       INFOS(ex.what());
 463       QApplication::restoreOverrideCursor();
 464       SUIT_MessageBox::warn1 (GetDesktop(theModule), QObject::tr("WRN_VISU"),
 465                               QObject::tr("ERR_CANT_BUILD_PRESENTATION") + " " + QObject::tr(ex.what()),
 466                               QObject::tr("BUT_OK"));
 467
 468       TViewWindows aViewWindows = GetViews(theModule);
 469       for (int i = 0, iEnd = aViewWindows.size(); i < iEnd; i++) {
 470         SVTK_ViewWindow* aView = aViewWindows[i];
 471         if (VISU_Actor* anActor = FindActor(aView, anEntry.in())) {
 472           aView->RemoveActor(anActor);
 473           anActor->Delete();
 474         }
 475       }
 476       return;
 477     }
 478     QApplication::restoreOverrideCursor();
 479   }
 480
 481   void
 482   Add(SalomeApp_SelectionMgr* theSelectionMgr,
 483       const Handle(SALOME_InteractiveObject)& theIO)
 484   {
 485     SALOME_ListIO aListIO;
 486     theSelectionMgr->selectedObjects(aListIO);
 487     aListIO.Append(theIO);
 488     theSelectionMgr->setSelectedObjects(aListIO);
 489   }
 490
 491   void
 492   Remove(SalomeApp_SelectionMgr* theSelectionMgr,
 493          const Handle(SALOME_InteractiveObject)& theIO)
 494   {
 495     if (theIO.IsNull()) return;
 496     SALOME_ListIO aListIO, aNewListIO;
 497     theSelectionMgr->selectedObjects(aListIO);
 498     SALOME_ListIteratorOfListIO anIter (aListIO);
 499     for (; anIter.More(); anIter.Next()) {
 500       Handle(SALOME_InteractiveObject) anIO = anIter.Value();
 501       if (!anIO->isSame(theIO)) {
 502         aNewListIO.Append(theIO);
 503       }
 504     }
 505     theSelectionMgr->setSelectedObjects(aNewListIO);
 506   }
 507
 508   void
 509   DeletePrs3d(SalomeApp_Module* theModule,
 510               VISU::Prs3d_i* thePrs,
 511               const Handle(SALOME_InteractiveObject)& theIO)
 512   {
 513     if(!thePrs)
 514       return;
 515     if(CheckLock(GetCStudy(GetAppStudy(theModule))))
 516       return;
 517     SALOMEDS::SObject_var aSObject = thePrs->GetSObject();
 518     CORBA::String_var anEntry = aSObject->GetID();
 519     SalomeApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
 520     Remove(aSelectionMgr,theIO);
 521     TViewWindows aViewWindows = GetViews(theModule);
 522     for(int i = 0, iEnd = aViewWindows.size(); i < iEnd; i++){
 523       SVTK_ViewWindow* aView = aViewWindows[i];
 524       if(VISU_Actor* anActor = FindActor(aView,anEntry.in())){
 525         aView->RemoveActor(anActor);
 526         anActor->Delete();
 527       }
 528     }
 529     thePrs->RemoveFromStudy();
 530     theModule->updateObjBrowser(); //update Object browser
 531   }
 532
 533   void
 534   ErasePrs3d(SalomeApp_Module* theModule,
 535              VISU::Prs3d_i* thePrs)
 536   {
 537     if ( SVTK_ViewWindow* vw = GetViewWindow( theModule ) ){
 538       VISU_Actor* anVISUActor = FindActor( vw, thePrs );
 539       if (anVISUActor) {
 540         anVISUActor->VisibilityOff();
 541       }
 542     }
 543   }
 544
 545   SPlot2d_Viewer*
 546   GetPlot2dViewer(const SalomeApp_Module* theModule, const bool theCreate)
 547   {
 548     if(SalomeApp_Application* anApp = theModule->getApp()){
 549       if(SUIT_ViewManager* aViewManager = anApp->getViewManager( Plot2d_Viewer::Type(), theCreate )){
 550         return dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
 551       }
 552     }
 553     return NULL;
 554   }
 555
 556   // Internal function used by several public functions below
 557   void
 558   UpdateCurve(VISU::Curve_i* theCurve,
 559               Plot2d_ViewFrame* aPlot,
 560               SPlot2d_Curve* plotCurve,
 561               int theDisplaying)
 562   {
 563     if ( theDisplaying == VISU::eErase ) {
 564       if ( plotCurve )
 565         aPlot->eraseCurve( plotCurve, false );
 566     }
 567     else if ( theDisplaying == VISU::eDisplay || theDisplaying == VISU::eDisplayOnly ) {
 568       if ( plotCurve ) {
 569         plotCurve->setHorTitle( theCurve->GetHorTitle().c_str() );
 570         //plotCurve->setVerTitle( ( theCurve->GetVerTitle().c_str() ) );
 571         plotCurve->setVerTitle( theCurve->GetName() );
 572         plotCurve->setHorUnits( theCurve->GetHorUnits().c_str() );
 573         plotCurve->setVerUnits( theCurve->GetVerUnits().c_str() );
 574         double* xList = 0;
 575         double* yList = 0;
 576         int     nbPoints = theCurve->GetData( xList, yList );
 577         if ( nbPoints > 0 && xList && yList ) {
 578           plotCurve->setData( xList, yList, nbPoints );
 579         }
 580         if ( !theCurve->IsAuto() ) {
 581           plotCurve->setLine( (Plot2d_Curve::LineType)theCurve->GetLine(), theCurve->GetLineWidth() );
 582           plotCurve->setMarker( (Plot2d_Curve::MarkerType)theCurve->GetMarker() );
 583           SALOMEDS::Color color = theCurve->GetColor();
 584           plotCurve->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) );
 585         }
 586         plotCurve->setAutoAssign( theCurve->IsAuto() );
 587         aPlot->displayCurve( plotCurve, false );
 588       }
 589       else {
 590         Plot2d_Curve* crv = theCurve->CreatePresentation();
 591         if ( crv ) {
 592           aPlot->displayCurve( crv, false );
 593           theCurve->SetLine( (VISU::Curve::LineType)crv->getLine(), crv->getLineWidth() );
 594           theCurve->SetMarker( (VISU::Curve::MarkerType)crv->getMarker());
 595           SALOMEDS::Color newColor;
 596           newColor.R = crv->getColor().red()/255.;
 597           newColor.G = crv->getColor().green()/255.;
 598           newColor.B = crv->getColor().blue()/255.;
 599           theCurve->SetColor( newColor );
 600           crv->setAutoAssign( theCurve->IsAuto() );
 601         }
 602       }
 603     }
 604   }
 605
 606   void
 607   PlotTable(const SalomeApp_Module* theModule,
 608             VISU::Table_i* table,
 609             int theDisplaying)
 610   {
 611     SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true ); // create if necessary
 612     if ( !aView )
 613       return;
 614     Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
 615     if ( !aPlot )
 616       return;
 617
 618     if ( theDisplaying == VISU::eDisplayOnly )
 619       aPlot->EraseAll();
 620     QList<Plot2d_Curve> clist;
 621     aPlot->getCurves( clist );
 622     _PTR(Study) aStudy = GetCStudy( GetAppStudy( theModule ) );
 623     _PTR(SObject) TableSO = aStudy->FindObjectID( table->GetEntry().latin1() );
 624     if ( TableSO ) {
 625       _PTR(ChildIterator) Iter = aStudy->NewChildIterator( TableSO );
 626       for ( ; Iter->More(); Iter->Next() ) {
 627         CORBA::Object_var childObject = VISU::ClientSObjectToObject( Iter->Value() );
 628         if( !CORBA::is_nil( childObject ) ) {
 629           CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject );
 630           if( !CORBA::is_nil( aCurve ) ) {
 631             VISU::Curve_i* theCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCurve).in());
 632             SPlot2d_Curve* plotCurve = 0;
 633             SPlot2d_Curve* tmpCurve;
 634             for ( int i = 0; i < clist.count(); i++ ) {
 635               tmpCurve = dynamic_cast<SPlot2d_Curve*>( clist.at( i ) );
 636               if ( tmpCurve && tmpCurve->hasIO() && !strcmp( tmpCurve->getIO()->getEntry(), theCurve->GetEntry() ) ) {
 637                 plotCurve = tmpCurve;
 638                 break;
 639               }
 640             }
 641
 642             UpdateCurve( theCurve, aPlot, plotCurve, theDisplaying );
 643
 644             if ( theDisplaying == VISU::eErase && plotCurve ) {
 645               clist.remove( plotCurve );
 646             }
 647           }
 648         }
 649       }
 650       aPlot->Repaint();
 651     }
 652   }
 653
 654   void
 655   PlotCurve(const SalomeApp_Module* theModule,
 656             VISU::Curve_i* theCurve,
 657             int theDisplaying)
 658   {
 659     SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true );
 660     if ( !aView )
 661       return;
 662     Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
 663     if ( !aPlot )
 664       return;
 665
 666 //  if ( theDisplaying == VISU::eDisplayOnly )
 667 //    aPlot->EraseAll();
 668     QList<Plot2d_Curve> clist;
 669     aPlot->getCurves( clist );
 670     SPlot2d_Curve* plotCurve = 0;
 671     SPlot2d_Curve* tmpCurve;
 672     for ( int i = 0; i < clist.count(); i++ ) {
 673       tmpCurve = dynamic_cast<SPlot2d_Curve*>( clist.at( i ) );
 674       if ( tmpCurve && tmpCurve->hasIO() && !strcmp( tmpCurve->getIO()->getEntry(), theCurve->GetEntry() ) ) {
 675         plotCurve = tmpCurve;
 676       }
 677       else if ( theDisplaying == VISU::eDisplayOnly ) {
 678         aPlot->eraseCurve( clist.at( i ) );
 679       }
 680     }
 681
 682     UpdateCurve( theCurve, aPlot, plotCurve, theDisplaying );
 683
 684     aPlot->Repaint();
 685   }
 686
 687   void
 688   PlotContainer(const SalomeApp_Module* theModule,
 689                 VISU::Container_i* container,
 690                 int theDisplaying)
 691   {
 692     SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true );
 693     if ( !aView )
 694       return;
 695     Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
 696     if ( !aPlot )
 697       return;
 698
 699     if ( theDisplaying == VISU::eDisplayOnly )
 700       aPlot->EraseAll();
 701     QList<Plot2d_Curve> clist;
 702     aPlot->getCurves( clist );
 703     if ( container->GetNbCurves() > 0 ) {
 704       int nbCurves = container->GetNbCurves();
 705       for ( int k = 1; k <= nbCurves; k++ ) {
 706         VISU::Curve_i* theCurve = container->GetCurve( k );
 707         if ( theCurve && theCurve->IsValid() ) {
 708           SPlot2d_Curve* plotCurve = dynamic_cast<SPlot2d_Curve*>( aView->getCurveByIO( new SALOME_InteractiveObject( theCurve->GetEntry(), "", "" ) ) );
 709
 710           UpdateCurve( theCurve, aPlot, plotCurve, theDisplaying );
 711
 712           if ( plotCurve && theDisplaying == VISU::eErase ) {
 713             clist.remove( plotCurve );
 714           }
 715         }
 716       }
 717     }
 718     aPlot->Repaint();
 719   }
 720
 721   void
 722   CreatePlot(SalomeApp_Module* theModule,
 723              _PTR(SObject) theTableSO)
 724   {
 725     if ( IsSObjectTable(theTableSO) ) {
 726       CORBA::Object_var aTable = VISU::ClientSObjectToObject(theTableSO);
 727       CORBA::Object_var aContainer = GetVisuGen( theModule )->CreateContainer();
 728       if ( !CORBA::is_nil( aTable ) && !CORBA::is_nil( aContainer ) ) {
 729         VISU::Table_i*     pTable     = dynamic_cast<VISU::Table_i*>( VISU::GetServant(aTable).in() );
 730         VISU::Container_i* pContainer = dynamic_cast<VISU::Container_i*>( VISU::GetServant(aContainer).in() );
 731
 732         if ( pContainer && pTable ) {
 733           for ( int i = 2; i <= pTable->GetNbRows(); i++ ) {
 734             CORBA::Object_var aNewCurve = GetVisuGen( theModule )->CreateCurve( pTable->_this(), 1, i );
 735             if( !CORBA::is_nil( aNewCurve ) ) {
 736               VISU::Curve_i* pCrv = dynamic_cast<VISU::Curve_i*>( VISU::GetServant(aNewCurve).in() );
 737               if ( pCrv ) {
 738                 pContainer->AddCurve( pCrv->_this() );
 739               }
 740             }
 741           }
 742           theModule->updateObjBrowser();
 743           PlotContainer( theModule, pContainer, VISU::eDisplay );
 744         }
 745       }
 746     }
 747   }
 748 }