src/SMESHGUI/SMESHGUI.cxx

   1 //  SMESH SMESHGUI : GUI for SMESH 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   : SMESHGUI.cxx
  25 //  Author : Nicolas REJNERI
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 using namespace std;
  30 #include "SMESHGUI.h"
  31 #include "SMESHGUI_AddHypothesisDlg.h"
  32 #include "SMESHGUI_AddAlgorithmDlg.h"
  33 #include "SMESHGUI_InitMeshDlg.h"
  34 #include "SMESHGUI_LocalLengthDlg.h"
  35 #include "SMESHGUI_NbSegmentsDlg.h"
  36 #include "SMESHGUI_AddSubMeshDlg.h"
  37 #include "SMESHGUI_NodesDlg.h"
  38 #include "SMESHGUI_TransparencyDlg.h"
  39 #include "SMESHGUI_RemoveNodesDlg.h"
  40 #include "SMESHGUI_RemoveElementsDlg.h"
  41 #include "SMESHGUI_MeshInfosDlg.h"
  42 #include "SMESHGUI_Preferences_ColorDlg.h"
  43 #include "SMESHGUI_MaxElementAreaDlg.h"
  44 #include "SMESHGUI_MaxElementVolumeDlg.h"
  45 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  46 #include "SMESHGUI_EditScalarBarDlg.h"
  47 #include "SMESHGUI_aParameterDlg.h"
  48 #include "SMESHGUI_ComputeScalarValue.h"
  49 #include "SMESHGUI_MoveNodesDlg.h"
  50 #include "SMESHGUI_OrientationElementsDlg.h"
  51 #include "SMESHGUI_DiagonalInversionDlg.h"
  52 #include "SMESHGUI_EdgesConnectivityDlg.h"
  53 #include "SMESHGUI_AddFaceDlg.h"
  54 #include "SMESHGUI_AddEdgeDlg.h"
  55 #include "SMESHGUI_AddVolumeDlg.h"
  56 #include "SMESHGUI_EditHypothesesDlg.h"
  57
  58 #include "SMESH_Grid.h"
  59
  60 // SALOME Includes
  61 #include "Utils_ORB_INIT.hxx"
  62 #include "Utils_SINGLETON.hxx"
  63
  64 #include "QAD.h"
  65 #include "QAD_Tools.h"
  66 #include "QAD_Config.h"
  67 #include "QAD_Settings.h"
  68 #include "QAD_RightFrame.h"
  69 #include "QAD_MessageBox.h"
  70 #include "QAD_Resource.h"
  71 #include "QAD_FileDlg.h"
  72 #include "SALOMEGUI_Desktop.h"
  73 #include "SALOMEGUI_NameDlg.h"
  74
  75 #include "OCCViewer_ViewPort.h"
  76 #include "OCCViewer_ViewPort3d.h"
  77 #include "OCCViewer_Viewer3d.h"
  78
  79 #include "GEOM_Client.hxx"
  80 #include "GEOM_InteractiveObject.hxx"
  81
  82 #include "SALOME_NamingService.hxx"
  83 #include "SALOME_ListIteratorOfListIO.hxx"
  84 #include "SALOME_InteractiveObject.hxx"
  85
  86 #include "SALOMEGUI_ImportOperation.h"
  87 #include "SALOMEGUI_QtCatchCorbaException.hxx"
  88 #include "utilities.h"
  89
  90 #include "SMDS_Mesh.hxx"
  91 #include "SMESHDS_Document.hxx"
  92 #include "Document_Reader.h"
  93 #include "Document_Writer.h"
  94 #include "Mesh_Reader.h"
  95 #include "Mesh_Writer.h"
  96
  97 #include "DriverDAT_R_SMESHDS_Document.h"
  98 #include "DriverMED_R_SMESHDS_Document.h"
  99 #include "DriverUNV_R_SMESHDS_Document.h"
 100 #include "DriverDAT_W_SMESHDS_Document.h"
 101 #include "DriverMED_W_SMESHDS_Document.h"
 102 #include "DriverUNV_W_SMESHDS_Document.h"
 103 #include "DriverDAT_R_SMESHDS_Mesh.h"
 104 #include "DriverMED_R_SMESHDS_Mesh.h"
 105 #include "DriverUNV_R_SMESHDS_Mesh.h"
 106 #include "DriverDAT_W_SMESHDS_Mesh.h"
 107 #include "DriverMED_W_SMESHDS_Mesh.h"
 108 #include "DriverUNV_W_SMESHDS_Mesh.h"
 109
 110 // QT Includes
 111 #define  INCLUDE_MENUITEM_DEF
 112 #include <qapplication.h>
 113 #include <qlineedit.h>
 114 #include <qmenudata.h>
 115 #include <qmenubar.h>
 116 #include <qpopupmenu.h>
 117 #include <qfont.h>
 118 #include <qstring.h>
 119 #include <qcheckbox.h>
 120 #include <qcolordialog.h>
 121 #include <qmessagebox.h>
 122 #include <qspinbox.h>
 123 #include <qlist.h>
 124 #include <qwidget.h>
 125 #include <qevent.h>
 126 #include <qradiobutton.h>
 127
 128 // VTK Includes
 129 #include "VTKViewer_Common.h"
 130 #include "VTKViewer_ViewFrame.h"
 131 #include <vtkLegendBoxActor.h>
 132 #include <vtkFeatureEdges.h>
 133 #include <vtkDoubleArray.h>
 134
 135 // Open CASCADE Includes
 136 #include <gp_Pnt.hxx>
 137 #include <gp_Vec.hxx>
 138
 139 static GEOM_Client ShapeReader;
 140 static SMESHGUI *smeshGUI = 0;
 141 static CORBA::ORB_var _orb;
 142
 143 //=============================================================================
 144 /*!
 145  *
 146  */
 147 //=============================================================================
 148 class CustomItem:public QCustomMenuItem
 149 {
 150   public:
 151         CustomItem(const QString & s, const QFont & f):string(s), font(f)
 152         {
 153         };
 154         ~CustomItem()
 155         {
 156         }
 157
 158         void paint(QPainter * p, const QColorGroup & /*cg */ , bool /*act */ ,
 159                 bool /*enabled */ , int x, int y, int w, int h)
 160         {
 161                 p->setFont(font);
 162                 p->drawText(x, y, w, h,
 163                         AlignHCenter | AlignVCenter | ShowPrefix | DontClip, string);
 164         }
 165
 166         QSize sizeHint()
 167         {
 168                 return QFontMetrics(font).
 169                         size(AlignHCenter | AlignVCenter | ShowPrefix | DontClip, string);
 170         }
 171   private:
 172         QString string;
 173         QFont font;
 174 };
 175
 176 //=============================================================================
 177 /*!
 178  *
 179  */
 180 //=============================================================================
 181 SMESHGUI::SMESHGUI():
 182 QObject()
 183 {
 184 }
 185
 186 //=============================================================================
 187 /*!
 188  *
 189  */
 190 //=============================================================================
 191 SMESHGUI::~SMESHGUI()
 192 {
 193 }
 194
 195 //=============================================================================
 196 /*!
 197  *
 198  */
 199 //=============================================================================
 200 SMESHGUI *SMESHGUI::GetSMESHGUI()
 201 {
 202         return smeshGUI;
 203 }
 204
 205 //=============================================================================
 206 /*!
 207  *
 208  */
 209 //=============================================================================
 210 SMESHGUI *SMESHGUI::GetOrCreateSMESHGUI(QAD_Desktop * desktop)
 211 {
 212         if (smeshGUI == 0)
 213         {
 214                 setOrb();
 215                 smeshGUI = new SMESHGUI;
 216                 smeshGUI->myActiveDialogBox = 0;
 217                 smeshGUI->myState = -1;
 218                 smeshGUI->myDesktop = desktop;
 219                 smeshGUI->myActiveStudy = desktop->getActiveStudy();
 220
 221                 Engines::Component_var comp =
 222                         desktop->getEngine("FactoryServer", "SMESH");
 223                 smeshGUI->myComponentMesh = SMESH::SMESH_Gen::_narrow(comp);
 224
 225                 Engines::Component_var comp1 =
 226                         desktop->getEngine("FactoryServer", "GEOM");
 227                 smeshGUI->myComponentGeom = GEOM::GEOM_Gen::_narrow(comp1);
 228
 229                 /* GetCurrentStudy */
 230                 smeshGUI->myStudyId = smeshGUI->myActiveStudy->getStudyId();
 231
 232                 smeshGUI->myComponentGeom->GetCurrentStudy(smeshGUI->myStudyId);
 233                 //    smeshGUI->myComponentGeom->NbLabels();
 234
 235                 smeshGUI->myStudy = smeshGUI->myActiveStudy->getStudyDocument();
 236
 237                 smeshGUI->myStudyAPI =
 238                         SMESHGUI_StudyAPI(smeshGUI->myStudy, smeshGUI->myComponentMesh);
 239
 240                 smeshGUI->myDocument = new SMESHDS_Document(1); //NBU
 241
 242                 smeshGUI->mySimulationActors = vtkActorCollection::New();
 243                 smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
 244         }
 245         else
 246         {
 247                 /* study may have changed */
 248                 smeshGUI->myActiveStudy = desktop->getActiveStudy();
 249                 smeshGUI->myStudyAPI.Update(smeshGUI->myComponentMesh);
 250         }
 251
 252         /* Automatic Update */
 253         if (desktop->menuBar()->isItemChecked(1001))
 254                 smeshGUI->myAutomaticUpdate = true;
 255         else
 256                 smeshGUI->myAutomaticUpdate = false;
 257
 258         return smeshGUI;
 259 }
 260
 261 //=============================================================================
 262 /*!
 263  *
 264  */
 265 //=============================================================================
 266 void SMESHGUI::SetState(int aState)
 267 {
 268         this->myState = aState;
 269         return;
 270 }
 271
 272 //=============================================================================
 273 /*!
 274  *
 275  */
 276 //=============================================================================
 277 void SMESHGUI::ResetState()
 278 {
 279         this->myState = -1;
 280         return;
 281 }
 282
 283 //=============================================================================
 284 /*!
 285  *
 286  */
 287 //=============================================================================
 288 void SMESHGUI::EmitSignalDeactivateDialog()
 289 {
 290         emit this->SignalDeactivateActiveDialog();
 291         return;
 292 }
 293
 294 //=============================================================================
 295 /*!
 296  *
 297  */
 298 //=============================================================================
 299 void SMESHGUI::EmitSignalCloseAllDialogs()
 300 {
 301         emit this->SignalCloseAllDialogs();
 302         return;
 303 }
 304
 305 //=============================================================================
 306 /*!
 307  *
 308  */
 309 //=============================================================================
 310 QDialog *SMESHGUI::GetActiveDialogBox()
 311 {
 312         return this->myActiveDialogBox;
 313 }
 314
 315 //=============================================================================
 316 /*!
 317  *
 318  */
 319 //=============================================================================
 320 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
 321 {
 322         this->myActiveDialogBox = (QDialog *) aDlg;
 323         return;
 324 }
 325
 326 //=============================================================================
 327 /*!
 328  *
 329  */
 330 //=============================================================================
 331 QAD_Study *SMESHGUI::GetActiveStudy()
 332 {
 333         return this->myActiveStudy;
 334 }
 335
 336 //=============================================================================
 337 /*!
 338  *
 339  */
 340 //=============================================================================
 341 SALOMEDS::Study_ptr SMESHGUI::GetStudy()
 342 {
 343         return SALOMEDS::Study::_narrow(myStudy);
 344 }
 345
 346 //=============================================================================
 347 /*!
 348  *
 349  */
 350 //=============================================================================
 351 SMESHGUI_StudyAPI SMESHGUI::GetStudyAPI()
 352 {
 353         return myStudyAPI;
 354 }
 355
 356 //=============================================================================
 357 /*!
 358  *
 359  */
 360 //=============================================================================
 361 QAD_Desktop *SMESHGUI::GetDesktop()
 362 {
 363         return this->myDesktop;
 364 }
 365
 366 //=============================================================================
 367 /*!
 368  *
 369  */
 370 //=============================================================================
 371 vtkScalarBarActor *SMESHGUI::GetScalarBar()
 372 {
 373         vtkRenderer *aRenderer =
 374                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
 375                 getRightFrame()->getViewFrame())->getRenderer();
 376         vtkActor2DCollection *actor2DList = aRenderer->GetActors2D();
 377         actor2DList->InitTraversal();
 378         vtkActor2D *aActor2d = actor2DList->GetNextActor2D();
 379         while (aActor2d != NULL)
 380         {
 381                 if (aActor2d->IsA("vtkScalarBarActor"))
 382                         return vtkScalarBarActor::SafeDownCast(aActor2d);
 383                 actor2DList->GetNextActor2D();
 384         }
 385         return NULL;
 386 }
 387
 388 //=============================================================================
 389 /*!
 390  *
 391  */
 392 //=============================================================================
 393 void SMESHGUI::activeStudyChanged(QAD_Desktop * parent)
 394 {
 395         MESSAGE("SMESHGUI::activeStudyChanged init.")
 396                 /* Create or retrieve an object SMESHGUI */
 397                 SMESHGUI::GetOrCreateSMESHGUI(parent);
 398         if (smeshGUI != 0)
 399         {
 400                 smeshGUI->EmitSignalCloseAllDialogs();
 401                 MESSAGE("Active study changed : SMESHGUI nullified" << endl);
 402                 smeshGUI = 0;
 403         }
 404
 405         //smeshGUI->SetSettings( parent ); //DCQ : Pb. Multi-Etudes
 406         MESSAGE("SMESHGUI::activeStudyChanged done.") return;
 407 }
 408
 409 //=============================================================================
 410 /*!
 411  *
 412  */
 413 //=============================================================================
 414 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
 415 {
 416         /* Here the position is on the bottom right corner - 10 */
 417         aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
 418         QAD_Desktop *PP = QAD_Application::getDesktop();
 419         x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
 420         y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
 421         return true;
 422 }
 423
 424 //=============================================================================
 425 /*!
 426  *
 427  */
 428 //=============================================================================
 429 void SMESHGUI::EraseSimulationActors()
 430 {
 431         if (myActiveStudy->getActiveStudyFrame()->getTypeView() == VIEW_VTK)
 432         {                                                       //VTK
 433                 vtkRenderer *theRenderer =
 434                         ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
 435                         getRightFrame()->getViewFrame())->getRenderer();
 436                 vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
 437
 438                 if (mySimulationActors != NULL)
 439                 {
 440
 441                         mySimulationActors->InitTraversal();
 442                         vtkActor *ac = mySimulationActors->GetNextActor();
 443                         while (!(ac == NULL))
 444                         {
 445                                 theRenderer->RemoveActor(ac);
 446                                 ac = mySimulationActors->GetNextActor();
 447                         }
 448                         mySimulationActors->RemoveAllItems();
 449                 }
 450                 if (mySimulationActors2D != NULL)
 451                 {
 452                         mySimulationActors2D->InitTraversal();
 453                         vtkActor2D *ac = mySimulationActors2D->GetNextActor2D();
 454                         while (!(ac == NULL))
 455                         {
 456                                 theRenderer->RemoveActor2D(ac);
 457                                 ac = mySimulationActors2D->GetNextActor2D();
 458                         }
 459                         mySimulationActors2D->RemoveAllItems();
 460                 }
 461                 renWin->Render();
 462         }
 463 }
 464
 465 //=============================================================================
 466 /*!
 467  *
 468  */
 469 //=============================================================================
 470 SMESH::SMESH_Mesh_ptr SMESHGUI::InitMesh(GEOM::GEOM_Shape_ptr aShape,
 471         QString NameMesh)
 472 {
 473         try
 474         {
 475                 if (!myComponentMesh->_is_nil() && !aShape->_is_nil())
 476                 {
 477                         SMESH::SMESH_Mesh_var aMesh =
 478                                 myComponentMesh->Init(myComponentGeom, myStudyId, aShape);
 479
 480                         if (!aMesh->_is_nil())
 481                         {
 482                                 SALOMEDS::SObject_var SM = myStudyAPI.AddNewMesh(aMesh);
 483                                 myStudyAPI.SetName(SM, NameMesh);
 484
 485                                 // GEOM::GEOM_Shape has non-empty StudyShapeId only after AddInStudy operation,
 486                                 // not after loading from file, so let's use more reliable way to retrieve SObject
 487                                 Standard_CString ShapeIOR = _orb->object_to_string(aShape);
 488                                 SALOMEDS::SObject_var SObject =
 489                                         myStudy->FindObjectIOR(ShapeIOR);
 490                                 if (!SObject->_is_nil() && !SM->_is_nil())
 491                                 {
 492                                         myStudyAPI.SetShape(SM, SObject);
 493                                 }
 494                                 return SMESH::SMESH_Mesh::_narrow(aMesh);
 495                         }
 496                 }
 497         }
 498         catch(const SALOME::SALOME_Exception & S_ex)
 499         {
 500                 QtCatchCorbaException(S_ex);
 501         }
 502         myActiveStudy->updateObjBrowser(true);
 503         return SMESH::SMESH_Mesh::_nil();
 504 }
 505
 506 //=============================================================================
 507 /*!
 508  *
 509  */
 510 //=============================================================================
 511 SMESH::SMESH_subMesh_ptr SMESHGUI::AddSubMesh(SMESH::SMESH_Mesh_ptr aMesh,
 512         GEOM::GEOM_Shape_ptr aShape, QString NameMesh)
 513 {
 514         try
 515         {
 516                 SMESH::SMESH_subMesh_var aSubMesh = aMesh->GetElementsOnShape(aShape);
 517                 SALOMEDS::SObject_var SO_Mesh = myStudyAPI.FindMesh(aMesh);
 518                 Standard_CString ShapeIOR = _orb->object_to_string(aShape);
 519                 SALOMEDS::SObject_var SO_GeomShape = myStudy->FindObjectIOR(ShapeIOR);
 520
 521                 if (!SO_GeomShape->_is_nil() && !SO_Mesh->_is_nil() &&
 522                         !aSubMesh->_is_nil() && !aMesh->_is_nil())
 523                 {
 524                         SALOMEDS::SObject_var SO =
 525                                 myStudyAPI.AddSubMeshOnShape(SO_Mesh, SO_GeomShape, aSubMesh,
 526                                 aShape->ShapeType());
 527                         myStudyAPI.SetName(SO, NameMesh);
 528
 529                         SMESH_Actor *amesh = SMESH_Actor::New();
 530                         Handle(SALOME_InteractiveObject) IO =
 531                                 new SALOME_InteractiveObject(SO->GetID(), "MESH",
 532                                 strdup(NameMesh));
 533                         amesh->setIO(IO);
 534                         amesh->setName(strdup(NameMesh));
 535                         DisplayActor(amesh, false);
 536                         return SMESH::SMESH_subMesh::_narrow(aSubMesh);
 537                 }
 538         }
 539         catch(const SALOME::SALOME_Exception & S_ex)
 540         {
 541                 QtCatchCorbaException(S_ex);
 542         }
 543         myActiveStudy->updateObjBrowser(true);
 544         return SMESH::SMESH_subMesh::_nil();
 545 }
 546
 547 //=============================================================================
 548 /*!
 549  *
 550  */
 551 //=============================================================================
 552 SMESH::SMESH_Hypothesis_ptr SMESHGUI::CreateHypothesis(QString TypeHypothesis,
 553         QString NameHypothesis)
 554 {
 555         SMESH::SMESH_Hypothesis_var Hyp;
 556         try
 557         {
 558                 Hyp = myComponentMesh->CreateHypothesis(TypeHypothesis, myStudyId);
 559                 if (!Hyp->_is_nil())
 560                 {
 561                         SALOMEDS::SObject_var SHyp = myStudyAPI.AddNewHypothesis(Hyp);
 562                         myStudyAPI.SetName(SHyp, NameHypothesis);
 563                 }
 564         }
 565         catch(const SALOME::SALOME_Exception & S_ex)
 566         {
 567                 QtCatchCorbaException(S_ex);
 568         }
 569
 570         return SMESH::SMESH_Hypothesis::_narrow(Hyp);
 571 }
 572
 573 //=============================================================================
 574 /*!
 575  *
 576  */
 577 //=============================================================================
 578 void SMESHGUI::AddHypothesisOnMesh(SMESH::SMESH_Mesh_ptr aMesh,
 579         SMESH::SMESH_Hypothesis_ptr aHyp)
 580 {
 581         if (!aMesh->_is_nil())
 582         {
 583                 QApplication::setOverrideCursor(Qt::waitCursor);
 584                 SALOMEDS::SObject_var SM = myStudyAPI.FindMesh(aMesh);
 585                 GEOM::GEOM_Shape_var aShape = myStudyAPI.GetShapeOnMeshOrSubMesh(SM);
 586                 try
 587                 {
 588                         bool res = aMesh->AddHypothesis(aShape, aHyp);
 589                         if (res)
 590                         {
 591                                 SALOMEDS::SObject_var SH =
 592                                         myStudyAPI.FindHypothesisOrAlgorithms(aHyp);
 593                                 if (!SM->_is_nil() && !SH->_is_nil())
 594                                 {
 595                                         myStudyAPI.SetHypothesis(SM, SH);
 596                                         myStudyAPI.ModifiedMesh(SM, false);
 597                                 }
 598                                 QApplication::restoreOverrideCursor();
 599                         }
 600                         else
 601                         {
 602                                 QApplication::restoreOverrideCursor();
 603                                 QAD_MessageBox::warn1(QAD_Application::getDesktop(),
 604                                         tr("SMESH_WRN_WARNING"),
 605                                         tr("SMESH_WRN_HYPOTHESIS_ALREADYEXIST"),
 606                                         tr("SMESH_BUT_YES"));
 607                         }
 608                 }
 609                 catch(const SALOME::SALOME_Exception & S_ex)
 610                 {
 611                         QtCatchCorbaException(S_ex);
 612                 }
 613         }
 614         myActiveStudy->updateObjBrowser(true);
 615         QApplication::restoreOverrideCursor();
 616 }
 617
 618 //=============================================================================
 619 /*!
 620  *
 621  */
 622 //=============================================================================
 623 void SMESHGUI::
 624 RemoveHypothesisOrAlgorithmOnMesh(const Handle(SALOME_InteractiveObject) &
 625         IObject)
 626 {
 627         if (IObject->hasReference())
 628         {
 629                 SMESH::SMESH_Hypothesis_var anHyp;
 630                 SALOMEDS::SObject_var SO_Hypothesis =
 631                         smeshGUI->myStudy->FindObjectID(IObject->getEntry());
 632                 SALOMEDS::GenericAttribute_var anAttr;
 633                 SALOMEDS::AttributeIOR_var anIOR;
 634
 635                 if (!SO_Hypothesis->_is_nil())
 636                 {
 637                         QApplication::setOverrideCursor(Qt::waitCursor);
 638                         if (SO_Hypothesis->FindAttribute(anAttr, "AttributeIOR"))
 639                         {
 640                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 641                                 anHyp =
 642                                         SMESH::SMESH_Hypothesis::_narrow(_orb->
 643                                         string_to_object(anIOR->Value()));
 644                         }
 645
 646                         SALOMEDS::SObject_var SO_Applied_Hypothesis =
 647                                 smeshGUI->myStudy->FindObjectID(IObject->getReference());
 648                         if (!SO_Applied_Hypothesis->_is_nil())
 649                         {
 650                                 SALOMEDS::SObject_var MorSM =
 651                                         smeshGUI->myStudyAPI.
 652                                         GetMeshOrSubmesh(SO_Applied_Hypothesis);
 653                                 if (!MorSM->_is_nil())
 654                                 {
 655                                         smeshGUI->myStudyAPI.ModifiedMesh(MorSM, false);
 656
 657                                         GEOM::GEOM_Shape_var aShape =
 658                                                 smeshGUI->myStudyAPI.GetShapeOnMeshOrSubMesh(MorSM);
 659                                         if (!aShape->_is_nil())
 660                                         {
 661                                                 if (MorSM->FindAttribute(anAttr, "AttributeIOR"))
 662                                                 {
 663                                                         anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 664                                                         SMESH::SMESH_Mesh_var aMesh =
 665                                                                 SMESH::SMESH_Mesh::_narrow(_orb->
 666                                                                 string_to_object(anIOR->Value()));
 667                                                         SMESH::SMESH_subMesh_var aSubMesh =
 668                                                                 SMESH::SMESH_subMesh::_narrow(_orb->
 669                                                                 string_to_object(anIOR->Value()));
 670                                                         if (!aMesh->_is_nil())
 671                                                         {
 672                                                                 bool res =
 673                                                                         aMesh->RemoveHypothesis(aShape, anHyp);
 674                                                                 if (!res)
 675                                                                 {
 676                                                                         QApplication::restoreOverrideCursor();
 677                                                                         QAD_MessageBox::warn1(QAD_Application::
 678                                                                                 getDesktop(), tr("SMESH_WRN_WARNING"),
 679                                                                                 tr("SMESH_WRN_HYPOTHESIS_NOTEXIST"),
 680                                                                                 tr("SMESH_BUT_YES"));
 681                                                                 }
 682                                                         }
 683                                                         else if (!aSubMesh->_is_nil())
 684                                                         {
 685                                                                 aMesh = aSubMesh->GetFather();
 686                                                                 if (!aMesh->_is_nil())
 687                                                                 {
 688                                                                         bool res =
 689                                                                                 aMesh->RemoveHypothesis(aShape, anHyp);
 690                                                                         if (!res)
 691                                                                         {
 692                                                                                 QApplication::restoreOverrideCursor();
 693                                                                                 QAD_MessageBox::warn1(QAD_Application::
 694                                                                                         getDesktop(),
 695                                                                                         tr("SMESH_WRN_WARNING"),
 696                                                                                         tr("SMESH_WRN_HYPOTHESIS_NOTEXIST"),
 697                                                                                         tr("SMESH_BUT_YES"));
 698                                                                         }
 699                                                                 }
 700                                                         }
 701                                                         if (myAutomaticUpdate)
 702                                                         {
 703                                                                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
 704                                                                 if (Mesh != NULL)
 705                                                                 {
 706 #ifdef TRACE
 707                                                                         Dump(Mesh);
 708 #endif
 709                                                                         DisplayActor(Mesh);
 710                                                                         DisplayEdges(Mesh);
 711                                                                         smeshGUI->ChangeRepresentation(Mesh,
 712                                                                                 Mesh->getDisplayMode());
 713                                                                 }
 714                                                         }
 715                                                 }
 716                                         }
 717                                 }
 718                                 smeshGUI->myStudyAPI.UnSetHypothesis(SO_Applied_Hypothesis);
 719                         }
 720                 }
 721         }
 722         else if (IObject->hasEntry())
 723         {
 724         MESSAGE("IObject entry " << IObject->getEntry())}
 725         QApplication::restoreOverrideCursor();
 726 }
 727
 728 //=============================================================================
 729 /*!
 730  *
 731  */
 732 //=============================================================================
 733 void SMESHGUI::RemoveHypothesisOrAlgorithmOnMesh(SALOMEDS::SObject_ptr MorSM,
 734         SMESH::SMESH_Hypothesis_ptr anHyp)
 735 {
 736         SALOMEDS::SObject_var AHR, aRef;
 737         SALOMEDS::GenericAttribute_var anAttr;
 738         SALOMEDS::AttributeIOR_var anIOR;
 739
 740         if (!MorSM->_is_nil())
 741         {
 742                 GEOM::GEOM_Shape_var aShape =
 743                         smeshGUI->myStudyAPI.GetShapeOnMeshOrSubMesh(MorSM);
 744                 if (!aShape->_is_nil())
 745                 {
 746                         if (MorSM->FindAttribute(anAttr, "AttributeIOR"))
 747                         {
 748                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 749                                 SMESH::SMESH_Mesh_var aMesh =
 750                                         SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->
 751                                                 Value()));
 752                                 SMESH::SMESH_subMesh_var aSubMesh =
 753                                         SMESH::SMESH_subMesh::_narrow(_orb->string_to_object(anIOR->
 754                                                 Value()));
 755                                 if (!aMesh->_is_nil())
 756                                 {
 757                                         bool res = aMesh->RemoveHypothesis(aShape, anHyp);
 758                                         if (!res)
 759                                         {
 760                                                 QApplication::restoreOverrideCursor();
 761                                                 QAD_MessageBox::warn1(QAD_Application::getDesktop(),
 762                                                         tr("SMESH_WRN_WARNING"),
 763                                                         tr("SMESH_WRN_HYPOTHESIS_NOTEXIST"),
 764                                                         tr("SMESH_BUT_YES"));
 765                                         }
 766                                 }
 767                                 else if (!aSubMesh->_is_nil())
 768                                 {
 769                                         aMesh = aSubMesh->GetFather();
 770                                         if (!aMesh->_is_nil())
 771                                         {
 772                                                 bool res = aMesh->RemoveHypothesis(aShape, anHyp);
 773                                                 if (!res)
 774                                                 {
 775                                                         QApplication::restoreOverrideCursor();
 776                                                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
 777                                                                 tr("SMESH_WRN_WARNING"),
 778                                                                 tr("SMESH_WRN_HYPOTHESIS_NOTEXIST"),
 779                                                                 tr("SMESH_BUT_YES"));
 780                                                 }
 781                                         }
 782                                 }
 783                                 if (myAutomaticUpdate)
 784                                 {
 785                                         SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
 786                                         if (Mesh != NULL)
 787                                         {
 788 #ifdef TRACE
 789                                                 Dump(Mesh);
 790 #endif
 791                                                 DisplayActor(Mesh);
 792                                                 DisplayEdges(Mesh);
 793                                                 // smeshGUI->ChangeRepresentation( Mesh, Mesh->getDisplayMode() );
 794                                         }
 795                                 }
 796                         }
 797                 }
 798
 799                 if (MorSM->FindSubObject(2, AHR))
 800                 {
 801                         SALOMEDS::ChildIterator_var it = myStudy->NewChildIterator(AHR);
 802                         for (; it->More(); it->Next())
 803                         {
 804                                 SALOMEDS::SObject_var Obj = it->Value();
 805                                 if (Obj->ReferencedObject(aRef))
 806                                 {
 807                                         if (aRef->FindAttribute(anAttr, "AttributeIOR"))
 808                                         {
 809                                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 810                                                 if (strcmp(anIOR->Value(),
 811                                                                 _orb->object_to_string(anHyp)) == 0)
 812                                                 {
 813                                                         smeshGUI->myStudyAPI.UnSetHypothesis(Obj);
 814                                                         break;
 815                                                 }
 816                                         }
 817                                 }
 818                         }
 819                 }
 820                 if (MorSM->FindSubObject(3, AHR))
 821                 {
 822                         SALOMEDS::ChildIterator_var it = myStudy->NewChildIterator(AHR);
 823                         for (; it->More(); it->Next())
 824                         {
 825                                 SALOMEDS::SObject_var Obj = it->Value();
 826                                 if (Obj->ReferencedObject(aRef))
 827                                 {
 828                                         if (aRef->FindAttribute(anAttr, "AttributeIOR"))
 829                                         {
 830                                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 831                                                 if (strcmp(anIOR->Value(),
 832                                                                 _orb->object_to_string(anHyp)) == 0)
 833                                                 {
 834                                                         smeshGUI->myStudyAPI.UnSetAlgorithm(Obj);
 835                                                         break;
 836                                                 }
 837                                         }
 838                                 }
 839                         }
 840                 }
 841                 smeshGUI->myStudyAPI.ModifiedMesh(MorSM, false);
 842         }
 843         QApplication::restoreOverrideCursor();
 844 }
 845
 846 //=============================================================================
 847 /*!
 848  *
 849  */
 850 //=============================================================================
 851 void SMESHGUI::AddAlgorithmOnMesh(SMESH::SMESH_Mesh_ptr aMesh,
 852         SMESH::SMESH_Hypothesis_ptr aHyp)
 853 {
 854         if (!aMesh->_is_nil())
 855         {
 856                 QApplication::setOverrideCursor(Qt::waitCursor);
 857                 SALOMEDS::SObject_var SM = myStudyAPI.FindMesh(aMesh);
 858                 GEOM::GEOM_Shape_var aShape = myStudyAPI.GetShapeOnMeshOrSubMesh(SM);
 859                 try
 860                 {
 861                         bool res = aMesh->AddHypothesis(aShape, aHyp);
 862                         if (res)
 863                         {
 864                                 SALOMEDS::SObject_var SH =
 865                                         myStudyAPI.FindHypothesisOrAlgorithms(aHyp);
 866                                 if (!SM->_is_nil() && !SH->_is_nil())
 867                                 {
 868                                         myStudyAPI.SetAlgorithms(SM, SH);
 869                                         myStudyAPI.ModifiedMesh(SM, false);
 870                                 }
 871                         }
 872                         else
 873                         {
 874                                 QApplication::restoreOverrideCursor();
 875                                 QAD_MessageBox::warn1(QAD_Application::getDesktop(),
 876                                         tr("SMESH_WRN_WARNING"),
 877                                         tr("SMESH_WRN_ALGORITHM_ALREADYEXIST"),
 878                                         tr("SMESH_BUT_YES"));
 879                         }
 880                 }
 881                 catch(const SALOME::SALOME_Exception & S_ex)
 882                 {
 883                         QtCatchCorbaException(S_ex);
 884                 }
 885         }
 886         myActiveStudy->updateObjBrowser(true);
 887         QApplication::restoreOverrideCursor();
 888 }
 889
 890 //=============================================================================
 891 /*!
 892  *
 893  */
 894 //=============================================================================
 895 void SMESHGUI::AddHypothesisOnSubMesh(SMESH::SMESH_subMesh_ptr aSubMesh,
 896         SMESH::SMESH_Hypothesis_ptr aHyp)
 897 {
 898         if (!aSubMesh->_is_nil())
 899         {
 900                 QApplication::setOverrideCursor(Qt::waitCursor);
 901                 try
 902                 {
 903                         SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
 904                         SALOMEDS::SObject_var SsubM = myStudyAPI.FindSubMesh(aSubMesh);
 905                         GEOM::GEOM_Shape_var aShape =
 906                                 myStudyAPI.GetShapeOnMeshOrSubMesh(SsubM);
 907                         if (!aMesh->_is_nil())
 908                         {
 909                                 bool res = aMesh->AddHypothesis(aShape, aHyp);
 910                                 if (res)
 911                                 {
 912                                         SALOMEDS::SObject_var SH =
 913                                                 myStudyAPI.FindHypothesisOrAlgorithms(aHyp);
 914                                         if (!SsubM->_is_nil() && !SH->_is_nil())
 915                                         {
 916                                                 myStudyAPI.SetHypothesis(SsubM, SH);
 917                                                 myStudyAPI.ModifiedMesh(SsubM, false);
 918                                         }
 919                                 }
 920                                 else
 921                                 {
 922                                         QApplication::restoreOverrideCursor();
 923                                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
 924                                                 tr("SMESH_WRN_WARNING"),
 925                                                 tr("SMESH_WRN_HYPOTHESIS_ALREADYEXIST"),
 926                                                 tr("SMESH_BUT_YES"));
 927                                 }
 928                         }
 929                 }
 930                 catch(const SALOME::SALOME_Exception & S_ex)
 931                 {
 932                         QtCatchCorbaException(S_ex);
 933                 }
 934         }
 935         myActiveStudy->updateObjBrowser(true);
 936         QApplication::restoreOverrideCursor();
 937 }
 938
 939 //=============================================================================
 940 /*!
 941  *
 942  */
 943 //=============================================================================
 944 void SMESHGUI::AddAlgorithmOnSubMesh(SMESH::SMESH_subMesh_ptr aSubMesh,
 945         SMESH::SMESH_Hypothesis_ptr aHyp)
 946 {
 947         if (!aSubMesh->_is_nil())
 948         {
 949                 QApplication::setOverrideCursor(Qt::waitCursor);
 950                 try
 951                 {
 952                         SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
 953                         SALOMEDS::SObject_var SsubM = myStudyAPI.FindSubMesh(aSubMesh);
 954                         GEOM::GEOM_Shape_var aShape =
 955                                 myStudyAPI.GetShapeOnMeshOrSubMesh(SsubM);
 956                         if (!aMesh->_is_nil())
 957                         {
 958                                 bool res = aMesh->AddHypothesis(aShape, aHyp);
 959                                 if (res)
 960                                 {
 961                                         SALOMEDS::SObject_var SH =
 962                                                 myStudyAPI.FindHypothesisOrAlgorithms(aHyp);
 963                                         if (!SsubM->_is_nil() && !SH->_is_nil())
 964                                         {
 965                                                 myStudyAPI.SetAlgorithms(SsubM, SH);
 966                                                 myStudyAPI.ModifiedMesh(SsubM, false);
 967                                         }
 968                                 }
 969                                 else
 970                                 {
 971                                         QApplication::restoreOverrideCursor();
 972                                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
 973                                                 tr("SMESH_WRN_WARNING"),
 974                                                 tr("SMESH_WRN_ALGORITHM_ALREADYEXIST"),
 975                                                 tr("SMESH_BUT_YES"));
 976                                 }
 977                         }
 978                 }
 979                 catch(const SALOME::SALOME_Exception & S_ex)
 980                 {
 981                         QtCatchCorbaException(S_ex);
 982                 }
 983         }
 984         myActiveStudy->updateObjBrowser(true);
 985         QApplication::restoreOverrideCursor();
 986 }
 987
 988 //=============================================================================
 989 /*!
 990  *
 991  */
 992 //=============================================================================
 993 void SMESHGUI::CreateAlgorithm(QString TypeAlgo, QString NameAlgo)
 994 {
 995         SMESH::SMESH_Hypothesis_var Hyp;
 996         try
 997         {
 998                 if (TypeAlgo.compare("Regular_1D") == 0)
 999                         Hyp = myComponentMesh->CreateHypothesis(TypeAlgo, myStudyId);
1000                 else if (TypeAlgo.compare("MEFISTO_2D") == 0)
1001                         Hyp = myComponentMesh->CreateHypothesis(TypeAlgo, myStudyId);
1002                 else if (TypeAlgo.compare("Quadrangle_2D") == 0)
1003                         Hyp = myComponentMesh->CreateHypothesis(TypeAlgo, myStudyId);
1004                 else if (TypeAlgo.compare("Hexa_3D") == 0)
1005                         Hyp = myComponentMesh->CreateHypothesis(TypeAlgo, myStudyId);
1006                 else if (TypeAlgo.compare("NETGEN_3D") == 0)
1007                         Hyp = myComponentMesh->CreateHypothesis(TypeAlgo, myStudyId);
1008
1009                 if (!Hyp->_is_nil())
1010                 {
1011                         SALOMEDS::SObject_var SHyp = myStudyAPI.AddNewAlgorithms(Hyp);
1012                         myStudyAPI.SetName(SHyp, NameAlgo);
1013                 }
1014         }
1015         catch(const SALOME::SALOME_Exception & S_ex)
1016         {
1017                 QtCatchCorbaException(S_ex);
1018         }
1019         myActiveStudy->updateObjBrowser(true);
1020 }
1021
1022 //=============================================================================
1023 /*!
1024  *
1025  */
1026 //=============================================================================
1027 void SMESHGUI::CreateLocalLength(QString TypeHypothesis, QString NameHypothesis,
1028         double Length)
1029 {
1030         QApplication::setOverrideCursor(Qt::waitCursor);
1031         try
1032         {
1033                 SMESH::SMESH_Hypothesis_var Hyp =
1034                         SMESH::SMESH_Hypothesis::_narrow(CreateHypothesis(TypeHypothesis,
1035                                 NameHypothesis));
1036                 SMESH::SMESH_LocalLength_var LL =
1037                         SMESH::SMESH_LocalLength::_narrow(Hyp);
1038                 if (!LL->_is_nil())
1039                         LL->SetLength(Length);
1040         }
1041         catch(const SALOME::SALOME_Exception & S_ex)
1042         {
1043                 QtCatchCorbaException(S_ex);
1044         }
1045         myActiveStudy->updateObjBrowser(true);
1046         QApplication::restoreOverrideCursor();
1047 }
1048
1049 //=============================================================================
1050 /*!
1051  *
1052  */
1053 //=============================================================================
1054 void SMESHGUI::CreateMaxElementArea(QString TypeHypothesis,
1055         QString NameHypothesis, double MaxArea)
1056 {
1057         QApplication::setOverrideCursor(Qt::waitCursor);
1058         try
1059         {
1060                 SMESH::SMESH_Hypothesis_var Hyp =
1061                         SMESH::SMESH_Hypothesis::_narrow(CreateHypothesis(TypeHypothesis,
1062                                 NameHypothesis));
1063                 SMESH::SMESH_MaxElementArea_var MaxElArea =
1064                         SMESH::SMESH_MaxElementArea::_narrow(Hyp);
1065                 if (!MaxElArea->_is_nil())
1066                         MaxElArea->SetMaxElementArea(MaxArea);
1067         }
1068         catch(SALOME::SALOME_Exception & S_ex)
1069         {
1070                 QtCatchCorbaException(S_ex);
1071         }
1072
1073         myActiveStudy->updateObjBrowser(true);
1074         QApplication::restoreOverrideCursor();
1075 }
1076
1077 //=============================================================================
1078 /*!
1079  *
1080  */
1081 //=============================================================================
1082 void SMESHGUI::CreateMaxElementVolume(QString TypeHypothesis,
1083         QString NameHypothesis, double MaxVolume)
1084 {
1085         QApplication::setOverrideCursor(Qt::waitCursor);
1086         try
1087         {
1088                 SMESH::SMESH_Hypothesis_var Hyp =
1089                         SMESH::SMESH_Hypothesis::_narrow(CreateHypothesis(TypeHypothesis,
1090                                 NameHypothesis));
1091                 SMESH::SMESH_MaxElementVolume_var MaxElVolume =
1092                         SMESH::SMESH_MaxElementVolume::_narrow(Hyp);
1093                 if (!MaxElVolume->_is_nil())
1094                         MaxElVolume->SetMaxElementVolume(MaxVolume);
1095         }
1096         catch(const SALOME::SALOME_Exception & S_ex)
1097         {
1098                 QtCatchCorbaException(S_ex);
1099         }
1100         myActiveStudy->updateObjBrowser(true);
1101         QApplication::restoreOverrideCursor();
1102 }
1103
1104 //=============================================================================
1105 /*!
1106  *
1107  */
1108 //=============================================================================
1109 void SMESHGUI::CreateNbSegments(QString TypeHypothesis, QString NameHypothesis,
1110         int nbSegments)
1111 {
1112         QApplication::setOverrideCursor(Qt::waitCursor);
1113         try
1114         {
1115                 SMESH::SMESH_Hypothesis_var Hyp =
1116                         SMESH::SMESH_Hypothesis::_narrow(CreateHypothesis(TypeHypothesis,
1117                                 NameHypothesis));
1118                 SMESH::SMESH_NumberOfSegments_var NbS =
1119                         SMESH::SMESH_NumberOfSegments::_narrow(Hyp);
1120                 if (!NbS->_is_nil())
1121                         NbS->SetNumberOfSegments(nbSegments);
1122         }
1123         catch(const SALOME::SALOME_Exception & S_ex)
1124         {
1125                 QtCatchCorbaException(S_ex);
1126         }
1127         myActiveStudy->updateObjBrowser(true);
1128         QApplication::restoreOverrideCursor();
1129 }
1130
1131 //=============================================================================
1132 /*!
1133  *
1134  */
1135 //=============================================================================
1136 int SMESHGUI::GetNameOfSelectedIObjects(SALOME_Selection * Sel, QString & aName)
1137 {
1138         int nbSel = Sel->IObjectCount();
1139         if (nbSel == 1)
1140         {
1141                 Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
1142                 aName = IObject->getName();
1143         }
1144         else
1145         {
1146                 aName = tr("SMESH_OBJECTS_SELECTED").arg(nbSel);
1147         }
1148         return nbSel;
1149 }
1150
1151 //=============================================================================
1152 /*!
1153  *
1154  */
1155 //=============================================================================
1156 int SMESHGUI::GetNameOfSelectedNodes(SALOME_Selection * Sel, QString & aName)
1157 {
1158         int nbNodes = 0;
1159         int nbSel = Sel->IObjectCount();
1160         if (nbSel == 1)
1161         {
1162                 Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
1163                 if (!IObject->hasEntry())
1164                         return -1;
1165
1166                 Standard_Boolean res;
1167                 SMESH_Actor *ac = FindActorByEntry(IObject->getEntry(), res, true);
1168                 if (!res)
1169                         return -1;
1170
1171                 TColStd_MapOfInteger MapIndex;
1172                 Sel->GetIndex(IObject, MapIndex);
1173                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
1174                 aName = " ";
1175                 nbNodes = MapIndex.Extent();
1176                 for (; ite.More(); ite.Next())
1177                 {
1178                         aName =
1179                                 aName + QString("%1").arg(ac->GetIdSMESHDSNode(ite.Key())) +
1180                                 " ";
1181                 }
1182         }
1183         else
1184         {
1185                 aName = "";
1186         }
1187         return nbNodes;
1188 }
1189
1190 //=============================================================================
1191 /*!
1192  *
1193  */
1194 //=============================================================================
1195 int SMESHGUI::GetNameOfSelectedElements(SALOME_Selection * Sel, QString & aName)
1196 {
1197         int nbElements = 0;
1198         int nbSel = Sel->IObjectCount();
1199         if (nbSel == 1)
1200         {
1201                 Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
1202                 if (!IObject->hasEntry())
1203                         return -1;
1204
1205                 Standard_Boolean res;
1206                 SMESH_Actor *ac = FindActorByEntry(IObject->getEntry(), res, true);
1207                 if (!res)
1208                         return -1;
1209
1210                 TColStd_MapOfInteger MapIndex;
1211                 Sel->GetIndex(IObject, MapIndex);
1212                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
1213                 aName = " ";
1214                 nbElements = MapIndex.Extent();
1215                 MESSAGE("GetNameOfSelectedElements(): number = " << nbElements);
1216                 for (; ite.More(); ite.Next())
1217                 {
1218                         int idVTK = ite.Key();
1219                         MESSAGE("GetNameOfSelectedElements(): VTK Id = " << idVTK);
1220                         aName =
1221                                 aName + QString("%1").arg(ac->GetIdSMESHDSElement(idVTK)) + " ";
1222                 }
1223         }
1224         else
1225         {
1226                 aName = "";
1227         }
1228         return nbElements;
1229 }
1230
1231 //=============================================================================
1232 /*!
1233  *
1234  */
1235 //=============================================================================
1236 int SMESHGUI::GetNameOfSelectedEdges(SALOME_Selection * Sel, QString & aName)
1237 {
1238         int nbElements = 0;
1239         int nbSel = Sel->IObjectCount();
1240         if (nbSel == 1)
1241         {
1242                 Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
1243                 if (!IObject->hasEntry())
1244                         return -1;
1245
1246                 Standard_Boolean res;
1247                 SMESH_Actor *ac = FindActorByEntry(IObject->getEntry(), res, true);
1248                 if (!res)
1249                         return -1;
1250
1251                 TColStd_MapOfInteger MapIndex;
1252                 Sel->GetIndex(IObject, MapIndex);
1253                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
1254                 aName = " ";
1255                 nbElements = MapIndex.Extent();
1256                 for (; ite.More(); ite.Next())
1257                 {
1258                         aName = aName + QString("%1").arg(ite.Key()) + " ";
1259                 }
1260         }
1261         else
1262         {
1263                 aName = "";
1264         }
1265         return nbElements;
1266 }
1267
1268 //=============================================================================
1269 /*!
1270  *
1271  */
1272 //=============================================================================
1273 SMESH_Actor *SMESHGUI::FindActorByEntry(QString entry,
1274         Standard_Boolean & testResult, bool onlyInActiveView)
1275 {
1276         int nbSf = myActiveStudy->getStudyFramesCount();
1277         for (int i = 0; i < nbSf; i++)
1278         {
1279                 QAD_StudyFrame *sf = myActiveStudy->getStudyFrame(i);
1280                 if (sf->getTypeView() == VIEW_VTK)
1281                 {
1282                         vtkRenderer *Renderer =
1283                                 ((VTKViewer_ViewFrame *) sf->getRightFrame()->getViewFrame())->
1284                                 getRenderer();
1285                         vtkActorCollection *theActors = Renderer->GetActors();
1286                         theActors->InitTraversal();
1287                         vtkActor *ac = theActors->GetNextActor();
1288                         while (!(ac == NULL))
1289                         {
1290                                 if (ac->IsA("SMESH_Actor"))
1291                                 {
1292                                         SMESH_Actor *anActor = SMESH_Actor::SafeDownCast(ac);
1293                                         if (anActor->hasIO())
1294                                         {
1295                                                 Handle(SALOME_InteractiveObject) IO = anActor->getIO();
1296                                                 if (strcmp(IO->getEntry(), entry) == 0)
1297                                                 {
1298                                                         if (onlyInActiveView)
1299                                                         {
1300                                                                 if (sf == myActiveStudy->getActiveStudyFrame())
1301                                                                 {
1302                                                                         testResult = true;
1303                                                                         return anActor;
1304                                                                 }
1305                                                         }
1306                                                         else
1307                                                         {
1308                                                                 testResult = true;
1309                                                                 return anActor;
1310                                                         }
1311                                                 }
1312                                         }
1313                                 }
1314                                 ac = theActors->GetNextActor();
1315                         }
1316                 }
1317         }
1318
1319         MESSAGE(" Actor Not Found ") testResult = false;
1320         return SMESH_Actor::New();
1321 }
1322
1323 //=============================================================================
1324 /*!
1325  *
1326  */
1327 //=============================================================================
1328 SMESH_Actor *SMESHGUI::FindActor(SMESH::SMESH_Mesh_ptr aMesh,
1329         Standard_Boolean & testResult, bool onlyInActiveView)
1330 {
1331         SALOMEDS::SObject_var SM = myStudyAPI.FindMesh(aMesh);
1332         if (SM->_is_nil())
1333         {
1334                 MESSAGE(" Actor Not Found ") testResult = false;
1335                 return SMESH_Actor::New();
1336         }
1337
1338         return FindActorByEntry(SM->GetID(), testResult, onlyInActiveView);
1339 }
1340
1341 //=============================================================================
1342 /*!
1343  *
1344  */
1345 //=============================================================================
1346 SMESH::SMESH_Mesh_ptr SMESHGUI::
1347 ConvertIOinMesh(const Handle(SALOME_InteractiveObject) & IO,
1348         Standard_Boolean & testResult)
1349 {
1350         SMESH::SMESH_Mesh_var aMesh;
1351         testResult = false;
1352
1353         /* case SObject */
1354         if (IO->hasEntry())
1355         {
1356                 SALOMEDS::SObject_var obj = myStudy->FindObjectID(IO->getEntry());
1357                 SALOMEDS::GenericAttribute_var anAttr;
1358                 SALOMEDS::AttributeIOR_var anIOR;
1359                 if (!obj->_is_nil())
1360                 {
1361                         if (obj->FindAttribute(anAttr, "AttributeIOR"))
1362                         {
1363                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
1364                                 aMesh =
1365                                         SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->
1366                                                 Value()));
1367                                 if (!aMesh->_is_nil())
1368                                 {
1369                                         testResult = true;
1370                                         return SMESH::SMESH_Mesh::_duplicate(aMesh);
1371                                 }
1372                         }
1373                 }
1374         }
1375         return SMESH::SMESH_Mesh::_nil();
1376 }
1377
1378 //=============================================================================
1379 /*!
1380  *
1381  */
1382 //=============================================================================
1383 SMESH::SMESH_subMesh_ptr SMESHGUI::
1384 ConvertIOinSubMesh(const Handle(SALOME_InteractiveObject) & IO,
1385         Standard_Boolean & testResult)
1386 {
1387         SMESH::SMESH_subMesh_var aSubMesh;
1388         testResult = false;
1389
1390         /* case SObject */
1391         if (IO->hasEntry())
1392         {
1393                 SALOMEDS::SObject_var obj = myStudy->FindObjectID(IO->getEntry());
1394                 SALOMEDS::GenericAttribute_var anAttr;
1395                 SALOMEDS::AttributeIOR_var anIOR;
1396                 if (!obj->_is_nil())
1397                 {
1398                         if (obj->FindAttribute(anAttr, "AttributeIOR"))
1399                         {
1400                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
1401                                 aSubMesh =
1402                                         SMESH::SMESH_subMesh::_narrow(_orb->string_to_object(anIOR->
1403                                                 Value()));
1404                                 if (!aSubMesh->_is_nil())
1405                                 {
1406                                         testResult = true;
1407                                         return SMESH::SMESH_subMesh::_duplicate(aSubMesh);
1408                                 }
1409                         }
1410                 }
1411         }
1412         return SMESH::SMESH_subMesh::_nil();
1413 }
1414
1415 //=============================================================================
1416 /*!
1417  *
1418  */
1419 //=============================================================================
1420 SMESH::SMESH_Hypothesis_ptr SMESHGUI::
1421 ConvertIOinSMESHHypothesis(const Handle(SALOME_InteractiveObject) & IO,
1422         Standard_Boolean & testResult)
1423 {
1424         SMESH::SMESH_Hypothesis_var aHyp;
1425         testResult = false;
1426
1427         /* case SObject */
1428         if (IO->hasEntry())
1429         {
1430                 SALOMEDS::SObject_var obj = myStudy->FindObjectID(IO->getEntry());
1431                 SALOMEDS::GenericAttribute_var anAttr;
1432                 SALOMEDS::AttributeIOR_var anIOR;
1433                 if (!obj->_is_nil())
1434                 {
1435                         if (obj->FindAttribute(anAttr, "AttributeIOR"))
1436                         {
1437                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
1438                                 aHyp =
1439                                         SMESH::SMESH_Hypothesis::_narrow(_orb->
1440                                         string_to_object(anIOR->Value()));
1441                                 if (!aHyp->_is_nil())
1442                                 {
1443                                         testResult = true;
1444                                         return SMESH::SMESH_Hypothesis::_duplicate(aHyp);
1445                                 }
1446                         }
1447                 }
1448         }
1449         return SMESH::SMESH_Hypothesis::_nil();
1450 }
1451
1452 //=============================================================================
1453 /*!
1454  *
1455  */
1456 //=============================================================================
1457 GEOM::GEOM_Shape_ptr SMESHGUI::
1458 ConvertIOinGEOMShape(const Handle(SALOME_InteractiveObject) & IO,
1459         Standard_Boolean & testResult)
1460 {
1461         GEOM::GEOM_Shape_var aShape;
1462         testResult = false;
1463
1464         /* case SObject */
1465         if (IO->hasEntry())
1466         {
1467                 SALOMEDS::SObject_var obj = myStudy->FindObjectID(IO->getEntry());
1468                 SALOMEDS::GenericAttribute_var anAttr;
1469                 SALOMEDS::AttributeIOR_var anIOR;
1470                 if (!obj->_is_nil())
1471                 {
1472                         if (obj->FindAttribute(anAttr, "AttributeIOR"))
1473                         {
1474                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
1475                                 aShape = myComponentGeom->GetIORFromString(anIOR->Value());
1476                                 if (!aShape->_is_nil())
1477                                 {
1478                                         testResult = true;
1479                                         return GEOM::GEOM_Shape::_duplicate(aShape);
1480                                 }
1481                         }
1482                 }
1483         }
1484         return GEOM::GEOM_Shape::_nil();
1485 }
1486
1487 //=============================================================================
1488 /*!
1489  *
1490  */
1491 //=============================================================================
1492 void SMESHGUI::SetViewMode(int commandId)
1493 {
1494         SALOME_Selection *Sel =
1495                 SALOME_Selection::Selection(myActiveStudy->getSelection());
1496         int nbSel = Sel->IObjectCount();
1497         if (nbSel >= 1)
1498         {
1499                 SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
1500                 for (; It.More(); It.Next())
1501                 {
1502                         Handle(SALOME_InteractiveObject) IObject = It.Value();
1503                         if (IObject->hasEntry())
1504                         {
1505                                 Standard_Boolean res;
1506                                 SMESH_Actor *ac =
1507                                         FindActorByEntry(IObject->getEntry(), res, true);
1508                                 if (res)
1509                                 {
1510                                         switch (commandId)
1511                                         {
1512                                         case 211:
1513                                         {
1514                                                 ChangeRepresentation(ac, 0);
1515                                                 break;
1516                                         }
1517                                         case 212:
1518                                         {
1519                                                 ChangeRepresentation(ac, 1);
1520                                                 break;
1521                                         }
1522                                         case 213:
1523                                         {
1524                                                 ChangeRepresentation(ac, 2);
1525                                                 break;
1526                                         }
1527                                         case 1132:
1528                                         {
1529                                                 ChangeRepresentation(ac, 3);
1530                                                 break;
1531                                         }
1532                                         }
1533                                 }
1534                         }
1535                 }
1536                 if (commandId == 1133)
1537                 {
1538                         ChangeRepresentation(SMESH_Actor::New(), 4);
1539                 }
1540         }
1541 }
1542
1543 //=============================================================================
1544 /*!
1545  *
1546  */
1547 //=============================================================================
1548 void SMESHGUI::ChangeRepresentation(SMESH_Actor * ac, int type)
1549 {
1550         if (ac->DataSource == NULL && type != 4)
1551                 return;
1552
1553         if (type != 4)
1554         {
1555                 if (ac->getMapper() == NULL)
1556                 {
1557                         return;
1558                 }
1559         }
1560         switch (type)
1561         {
1562         case 0:
1563         {
1564                 QApplication::setOverrideCursor(Qt::waitCursor);
1565                 if (ac->getDisplayMode() == 2)
1566                 {
1567                         bool isColored = ac->getMapper()->GetScalarVisibility();        //SAL3899
1568                         vtkDataSetMapper *meshMapper =
1569                                 (vtkDataSetMapper *) (ac->getMapper());
1570                         meshMapper->SetInput(ac->DataSource);
1571                         meshMapper->SetScalarVisibility(isColored);     //SAL3899
1572                 }
1573                 ac->setDisplayMode(0);
1574                 ac->GetProperty()->SetRepresentationToWireframe();
1575                 //    ac->SetActorProperty( ac->GetProperty() );
1576                 QApplication::restoreOverrideCursor();
1577                 break;
1578         }
1579         case 1:
1580         {
1581                 QApplication::setOverrideCursor(Qt::waitCursor);
1582                 if (ac->getDisplayMode() == 2)
1583                 {
1584                         bool isColored = ac->getMapper()->GetScalarVisibility();        //SAL3899
1585                         vtkDataSetMapper *meshMapper =
1586                                 (vtkDataSetMapper *) (ac->getMapper());
1587                         meshMapper->SetInput(ac->DataSource);
1588                         meshMapper->SetScalarVisibility(isColored);     //SAL3899
1589                 }
1590                 ac->setDisplayMode(1);
1591                 ac->GetProperty()->SetRepresentationToSurface();
1592                 QApplication::restoreOverrideCursor();
1593                 //    ac->SetActorProperty( ac->GetProperty() );
1594                 break;
1595         }
1596         case 2:
1597         {
1598                 //    if (!(ac->getDisplayMode()==2)) {
1599                 //    ChangeRepresentation(ac, 1);
1600                 QApplication::setOverrideCursor(Qt::waitCursor);
1601                 ac->setDisplayMode(2);
1602                 bool isColored = ac->getMapper()->GetScalarVisibility();        //SAL3899
1603                 vtkDataSetMapper *meshMapper = (vtkDataSetMapper *) (ac->getMapper());
1604                 vtkShrinkFilter *shrink = vtkShrinkFilter::New();
1605                 shrink->SetInput(ac->DataSource);
1606                 shrink->SetShrinkFactor(ac->GetShrinkFactor());
1607
1608                 meshMapper->SetInput(shrink->GetOutput());
1609                 meshMapper->SetScalarVisibility(isColored);     //SAL3899
1610                 ac->SetMapper(meshMapper);
1611                 QApplication::restoreOverrideCursor();
1612                 //    }
1613                 break;
1614         }
1615         case 3:
1616         {
1617                 float color[3];
1618                 float edgecolor[3];
1619                 float backfacecolor[3];
1620                 float nodecolor[3];
1621                 ac->GetColor(color[0], color[1], color[2]);
1622 //       QColor c(color[0]*255,color[1]*255,color[2]*255);
1623                 int c0 = int (color[0] * 255);
1624                 int c1 = int (color[1] * 255);
1625                 int c2 = int (color[2] * 255);
1626                 QColor c(c0, c1, c2);
1627                 ac->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
1628 //       QColor e(edgecolor[0]*255,edgecolor[1]*255,edgecolor[2]*255);
1629                 c0 = int (edgecolor[0] * 255);
1630                 c1 = int (edgecolor[1] * 255);
1631                 c2 = int (edgecolor[2] * 255);
1632                 QColor e(c0, c1, c2);
1633                 ac->GetBackfaceProperty()->GetColor(backfacecolor);
1634 //       QColor b(backfacecolor[0]*255,backfacecolor[1]*255,backfacecolor[2]*255);
1635                 c0 = int (backfacecolor[0] * 255);
1636                 c1 = int (backfacecolor[1] * 255);
1637                 c2 = int (backfacecolor[2] * 255);
1638                 QColor b(c0, c1, c2);
1639                 ac->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
1640 //       QColor n(nodecolor[0]*255, nodecolor[1]*255, nodecolor[2]*255 ) ;
1641                 c0 = int (nodecolor[0] * 255);
1642                 c1 = int (nodecolor[1] * 255);
1643                 c2 = int (nodecolor[2] * 255);
1644                 QColor n(c0, c1, c2);
1645
1646                 int Edgewidth = (int)ac->EdgeDevice->GetProperty()->GetLineWidth();
1647                 if (Edgewidth == 0)
1648                         Edgewidth = 1;
1649                 int intValue = ac->GetNodeSize();
1650                 float Shrink = ac->GetShrinkFactor();
1651
1652                 SMESHGUI_Preferences_ColorDlg *aDlg =
1653                         new SMESHGUI_Preferences_ColorDlg(QAD_Application::getDesktop(),
1654                         "");
1655                 aDlg->SetColor(1, c);
1656                 aDlg->SetColor(2, e);
1657                 aDlg->SetColor(3, n);
1658                 aDlg->SetColor(4, b);
1659                 aDlg->SetIntValue(1, Edgewidth);
1660                 aDlg->SetIntValue(2, intValue);
1661                 aDlg->SetIntValue(3, int (Shrink * 100.));
1662
1663                 if (aDlg->exec())
1664                 {
1665                         QApplication::setOverrideCursor(Qt::waitCursor);
1666                         QColor color = aDlg->GetColor(1);
1667                         QColor edgecolor = aDlg->GetColor(2);
1668                         QColor nodecolor = aDlg->GetColor(3);
1669                         QColor backfacecolor = aDlg->GetColor(4);
1670                         /* actor color and backface color */
1671                         ac->GetProperty()->SetColor(float (color.red()) / 255.,
1672                                 float (color.green()) / 255., float (color.blue()) / 255.);
1673                         ac->SetColor(float (color.red()) / 255.,
1674                                 float (color.green()) / 255., float (color.blue()) / 255.);
1675                         ac->GetBackfaceProperty()->SetColor(float (backfacecolor.red()) /
1676                                 255., float (backfacecolor.green()) / 255.,
1677                                 float (backfacecolor.blue()) / 255.);
1678
1679                         /* edge color */
1680                         ac->EdgeDevice->GetProperty()->SetColor(float (edgecolor.red()) /
1681                                 255., float (edgecolor.green()) / 255.,
1682                                 float (edgecolor.blue()) / 255.);
1683                         ac->EdgeShrinkDevice->GetProperty()->SetColor(float (edgecolor.
1684                                         red()) / 255., float (edgecolor.green()) / 255.,
1685                                 float (edgecolor.blue()) / 255.);
1686                         ac->SetEdgeColor(float (edgecolor.red()) / 255.,
1687                                 float (edgecolor.green()) / 255.,
1688                                 float (edgecolor.blue()) / 255.);
1689
1690                         /* Shrink factor and size edges */
1691                         ac->SetShrinkFactor(aDlg->GetIntValue(3) / 100.);
1692                         ac->EdgeDevice->GetProperty()->SetLineWidth(aDlg->GetIntValue(1));
1693                         ac->EdgeShrinkDevice->GetProperty()->SetLineWidth(aDlg->
1694                                 GetIntValue(1));
1695
1696                         /* Nodes color and size */
1697                         ac->SetNodeColor(float (nodecolor.red()) / 255.,
1698                                 float (nodecolor.green()) / 255.,
1699                                 float (nodecolor.blue()) / 255.);
1700                         ac->SetNodeSize(aDlg->GetIntValue(2));
1701
1702                         if (ac->getDisplayMode() == 2)
1703                         {
1704                                 bool isColored = ac->getMapper()->GetScalarVisibility();        //SAL3899
1705                                 vtkDataSetMapper *meshMapper =
1706                                         (vtkDataSetMapper *) (ac->getMapper());
1707                                 meshMapper->SetInput(ac->DataSource);
1708                                 vtkShrinkFilter *shrink = vtkShrinkFilter::New();
1709                                 shrink->SetInput(meshMapper->GetInput());
1710                                 shrink->SetShrinkFactor(ac->GetShrinkFactor());
1711
1712                                 meshMapper->SetInput(shrink->GetOutput());
1713                                 meshMapper->SetScalarVisibility(isColored);     //SAL3899
1714                                 ac->SetMapper(meshMapper);
1715                         }
1716                 }
1717                 delete aDlg;
1718                 QApplication::restoreOverrideCursor();
1719                 break;
1720         }
1721         case 4:
1722         {
1723                 EmitSignalDeactivateDialog();
1724                 SALOME_Selection *Sel =
1725                         SALOME_Selection::Selection(myActiveStudy->getSelection());
1726                 SMESHGUI_TransparencyDlg *aDlg =
1727                         new SMESHGUI_TransparencyDlg(QAD_Application::getDesktop(), "",
1728                         Sel);
1729                 break;
1730         }
1731         case 5:
1732         {
1733                 QApplication::setOverrideCursor(Qt::waitCursor);
1734                 ac->GetProperty()->SetRepresentationToPoints();
1735                 QApplication::restoreOverrideCursor();
1736                 break;
1737         }
1738         }
1739
1740         QApplication::setOverrideCursor(Qt::waitCursor);
1741         if (myActiveStudy->getActiveStudyFrame()->getTypeView() == VIEW_VTK)
1742         {                                                       //VTK
1743                 vtkRenderer *theRenderer =
1744                         ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
1745                         getRightFrame()->getViewFrame())->getRenderer();
1746                 theRenderer->Render();
1747         }
1748         QApplication::restoreOverrideCursor();
1749 }
1750
1751 //=============================================================================
1752 /*!
1753  *
1754  */
1755 //=============================================================================
1756 void SMESHGUI::UpdateView()
1757 {
1758         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
1759                 return;
1760
1761         vtkRenderer *theRenderer =
1762                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
1763                 getRightFrame()->getViewFrame())->getRenderer();
1764         theRenderer->Render();
1765 }
1766
1767 //=============================================================================
1768 /*!
1769  *
1770  */
1771 //=============================================================================
1772 void SMESHGUI::DisplayActor(SMESH_Actor * ac, bool visibility)
1773 {
1774         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
1775                 return;
1776
1777         MESSAGE("DisplayActor(): DataSource = " << ac->DataSource);
1778
1779         vtkRenderer *theRenderer =
1780                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
1781                 getRightFrame()->getViewFrame())->getRenderer();
1782         vtkActorCollection *theActors = theRenderer->GetActors();
1783         theActors->InitTraversal();
1784         if (theActors->IsItemPresent(ac) == 0)
1785         {
1786                 vtkProperty *prop = vtkProperty::New();
1787                 prop->SetColor(QAD_CONFIG->getSetting("SMESH:SettingsFillColorRed").
1788                         toFloat() / 255.,
1789                         QAD_CONFIG->getSetting("SMESH:SettingsFillColorGreen").toFloat() /
1790                         255.,
1791                         QAD_CONFIG->getSetting("SMESH:SettingsFillColorBlue").toFloat() /
1792                         255.);
1793
1794                 prop->SetPointSize(QAD_CONFIG->getSetting("SMESH:SettingsNodesSize").
1795                         toInt());
1796                 prop->SetLineWidth(QAD_CONFIG->getSetting("SMESH:SettingsWidth").
1797                         toInt());
1798                 ac->SetProperty(prop);
1799                 ac->SetColor(QAD_CONFIG->getSetting("SMESH:SettingsFillColorRed").
1800                         toFloat() / 255.,
1801                         QAD_CONFIG->getSetting("SMESH:SettingsFillColorGreen").toFloat() /
1802                         255.,
1803                         QAD_CONFIG->getSetting("SMESH:SettingsFillColorBlue").toFloat() /
1804                         255.);
1805
1806                 //    prop->BackfaceCullingOn();
1807                 vtkProperty *backprop = vtkProperty::New();
1808                 backprop->SetColor(QAD_CONFIG->
1809                         getSetting("SMESH:SettingsBackFaceColorRed").toFloat() / 255.,
1810                         QAD_CONFIG->getSetting("SMESH:SettingsBackFaceColorGreen").
1811                         toFloat() / 255.,
1812                         QAD_CONFIG->getSetting("SMESH:SettingsBackFaceColorBlue").
1813                         toFloat() / 255.);
1814                 ac->SetBackfaceProperty(backprop);
1815
1816                 int intValue =
1817                         QAD_CONFIG->getSetting("SMESH:SettingsShrinkCoeff").toInt();
1818                 if (intValue == 0)
1819                         intValue = 80;
1820                 ac->SetShrinkFactor(intValue / 100.);
1821
1822                 ac->GetMapper()->SetResolveCoincidentTopologyToShiftZBuffer();
1823                 ac->GetMapper()->SetResolveCoincidentTopologyZShift(0.02);
1824
1825                 QString DisplayMode = QAD_CONFIG->getSetting("SMESH:DisplayMode");
1826                 if (DisplayMode.compare("Wireframe") == 0)
1827                 {
1828                         ac->setDisplayMode(0);
1829                         ChangeRepresentation(ac, 0);
1830                 }
1831                 else if (DisplayMode.compare("Shading") == 0)
1832                 {
1833                         ac->setDisplayMode(1);
1834                         ChangeRepresentation(ac, 1);
1835                 }
1836                 else if (DisplayMode.compare("Shrink") == 0)
1837                 {
1838                         ac->setDisplayMode(2);
1839                         ChangeRepresentation(ac, 2);
1840                 }
1841                 theRenderer->AddActor(ac);
1842         }
1843         else
1844         {
1845                 if (ac->GetMapper())
1846                         ac->GetMapper()->Update();
1847         }
1848
1849 //  if ( visibility )
1850         ac->SetVisibility(visibility);
1851 //    ac->VisibilityOn();
1852 //  else
1853 //    ac->VisibilityOff();
1854
1855         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
1856         renWin->Render();
1857 }
1858
1859 //=============================================================================
1860 /*!
1861  *
1862  */
1863 //=============================================================================
1864 void SMESHGUI::EraseActor(SMESH_Actor * ac)
1865 {
1866         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
1867                 return;
1868
1869         vtkRenderer *theRenderer =
1870                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
1871                 getRightFrame()->getViewFrame())->getRenderer();
1872
1873         //NRI- : 02/12/2002 : Fixed bugId 882
1874         //  ac->EdgeDevice->VisibilityOff();
1875         //  ac->EdgeShrinkDevice->VisibilityOff();
1876         //  ac->VisibilityOff();
1877         ac->SetVisibility(false);
1878
1879         theRenderer->Render();
1880 }
1881
1882 //=============================================================================
1883 /*!
1884  *
1885  */
1886 //=============================================================================
1887 bool SMESHGUI::AddActorInSelection(SMESH_Actor * ac)
1888 {
1889         SALOME_Selection *Sel =
1890                 SALOME_Selection::Selection(myActiveStudy->getSelection());
1891         Sel->ClearIObjects();
1892         if (ac->hasIO())
1893                 return Sel->AddIObject(ac->getIO());
1894         else
1895                 return -1;
1896 }
1897
1898 //=============================================================================
1899 /*!
1900  *
1901  */
1902 //=============================================================================
1903 QString SMESHGUI::CheckHomogeneousSelection()
1904 {
1905         SALOME_Selection *Sel =
1906                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->getSelection());
1907         /* copy the list */
1908         SALOME_ListIO List;
1909         SALOME_ListIteratorOfListIO Itinit(Sel->StoredIObjects());
1910         for (; Itinit.More(); Itinit.Next())
1911         {
1912                 List.Append(Itinit.Value());
1913         }
1914
1915         QString RefType = CheckTypeObject(Sel->firstIObject());
1916         SALOME_ListIteratorOfListIO It(List);
1917         for (; It.More(); It.Next())
1918         {
1919                 Handle(SALOME_InteractiveObject) IObject = It.Value();
1920                 QString Type = CheckTypeObject(IObject);
1921                 if (Type.compare(RefType) != 0)
1922                         return "Heterogeneous Selection";
1923         }
1924
1925         Sel->ClearIObjects();
1926         SALOME_ListIteratorOfListIO It1(List);
1927         for (; It1.More(); It1.Next())
1928         {
1929                 int res = Sel->AddIObject(It1.Value());
1930                 if (res == -1)
1931                         myActiveStudy->highlight(It1.Value(), false);
1932                 if (res == 0)
1933                         myActiveStudy->highlight(It1.Value(), true);
1934         }
1935         return RefType;
1936 }
1937
1938 //=============================================================================
1939 /*!
1940  *
1941  */
1942 //=============================================================================
1943 QString SMESHGUI::CheckTypeObject(const Handle(SALOME_InteractiveObject) & IO)
1944 {
1945         SALOMEDS::SObject_var sobj =
1946                 smeshGUI->myActiveStudy->getStudyDocument()->FindObjectID(IO->
1947                 getEntry());
1948         if (!sobj->_is_nil())
1949         {
1950                 SALOMEDS::SComponent_var scomp = sobj->GetFatherComponent();
1951                 if (strcmp(scomp->GetID(), IO->getEntry()) == 0)
1952                 {                                               // component is selected
1953                         return "Component";
1954                 }
1955         }
1956
1957         SALOME_Selection *Sel =
1958                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->getSelection());
1959         Sel->ClearIObjects();
1960
1961         Handle(SMESH_TypeFilter) aHypFilter = new SMESH_TypeFilter(HYPOTHESIS);
1962         Handle(SMESH_TypeFilter) anAlgoFilter = new SMESH_TypeFilter(ALGORITHM);
1963         Handle(SMESH_TypeFilter) aMeshFilter = new SMESH_TypeFilter(MESH);
1964         Handle(SMESH_TypeFilter) aSubMeshFilter = new SMESH_TypeFilter(SUBMESH);
1965         Handle(SMESH_TypeFilter) aMeshOrSubMeshFilter =
1966                 new SMESH_TypeFilter(MESHorSUBMESH);
1967         Handle(SMESH_TypeFilter) aSubMeshVextexFilter =
1968                 new SMESH_TypeFilter(SUBMESH_VERTEX);
1969         Handle(SMESH_TypeFilter) aSubMeshEdgeFilter =
1970                 new SMESH_TypeFilter(SUBMESH_EDGE);
1971         Handle(SMESH_TypeFilter) aSubMeshFaceFilter =
1972                 new SMESH_TypeFilter(SUBMESH_FACE);
1973         Handle(SMESH_TypeFilter) aSubMeshSolidFilter =
1974                 new SMESH_TypeFilter(SUBMESH_SOLID);
1975         Handle(SMESH_TypeFilter) aSubMeshCompoundFilter =
1976                 new SMESH_TypeFilter(SUBMESH_COMPOUND);
1977
1978         Sel->AddFilter(aHypFilter);
1979         if (Sel->AddIObject(IO) != -1)
1980         {
1981                 Sel->ClearFilters();
1982                 return "Hypothesis";
1983         }
1984
1985         Sel->ClearFilters();
1986         Sel->AddFilter(anAlgoFilter);
1987         if (Sel->AddIObject(IO) != -1)
1988         {
1989                 Sel->ClearFilters();
1990                 return "Algorithm";
1991         }
1992
1993         Sel->ClearFilters();
1994         Sel->AddFilter(aMeshFilter);
1995         if (Sel->AddIObject(IO) != -1)
1996         {
1997                 Sel->ClearFilters();
1998                 return "Mesh";
1999         }
2000
2001         Sel->ClearFilters();
2002         Sel->AddFilter(aSubMeshFilter);
2003         if (Sel->AddIObject(IO) != -1)
2004         {
2005                 Sel->ClearFilters();
2006                 return "SubMesh";
2007         }
2008
2009         Sel->ClearFilters();
2010         Sel->AddFilter(aSubMeshVextexFilter);
2011         if (Sel->AddIObject(IO) != -1)
2012         {
2013                 Sel->ClearFilters();
2014                 return "SubMeshVertex";
2015         }
2016
2017         Sel->ClearFilters();
2018         Sel->AddFilter(aSubMeshEdgeFilter);
2019         if (Sel->AddIObject(IO) != -1)
2020         {
2021                 Sel->ClearFilters();
2022                 return "SubMeshEdge";
2023         }
2024
2025         Sel->ClearFilters();
2026         Sel->AddFilter(aSubMeshFaceFilter);
2027         if (Sel->AddIObject(IO) != -1)
2028         {
2029                 Sel->ClearFilters();
2030                 return "SubMeshFace";
2031         }
2032
2033         Sel->ClearFilters();
2034         Sel->AddFilter(aSubMeshSolidFilter);
2035         if (Sel->AddIObject(IO) != -1)
2036         {
2037                 Sel->ClearFilters();
2038                 return "SubMeshSolid";
2039         }
2040
2041         Sel->ClearFilters();
2042         Sel->AddFilter(aSubMeshCompoundFilter);
2043         if (Sel->AddIObject(IO) != -1)
2044         {
2045                 Sel->ClearFilters();
2046                 return "SubMeshCompound";
2047         }
2048
2049         Sel->ClearFilters();
2050         Sel->AddIObject(IO);
2051         return "NoType";
2052 }
2053
2054 //=============================================================================
2055 /*!
2056  *
2057  */
2058 //=============================================================================
2059 bool SMESHGUI::OnGUIEvent(int theCommandID, QAD_Desktop * parent)
2060 {
2061         /* Create or retrieve an object SMESHGUI */
2062         SMESHGUI::GetOrCreateSMESHGUI(parent);
2063
2064         // NRI : Temporary added
2065         if (smeshGUI->myStudy->GetProperties()->IsLocked())
2066         {
2067                 return false;
2068         }
2069         //NRI
2070
2071         //  QAD_Viewer3d* v3d;
2072         OCCViewer_Viewer3d *v3d;
2073
2074         Handle(AIS_InteractiveContext) ic;
2075         vtkRenderer *Renderer;
2076         vtkRenderWindow *RenWin;
2077
2078         if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2079                 VIEW_OCC)
2080         {
2081                 v3d =
2082                         ((OCCViewer_ViewFrame *) smeshGUI->myActiveStudy->
2083                         getActiveStudyFrame()->getRightFrame()->getViewFrame())->
2084                         getViewer();
2085                 ic = v3d->getAISContext();
2086         }
2087         else if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2088                 VIEW_VTK)
2089         {
2090                 Renderer =
2091                         ((VTKViewer_ViewFrame *) smeshGUI->myActiveStudy->
2092                         getActiveStudyFrame()->getRightFrame()->getViewFrame())->
2093                         getRenderer();
2094                 RenWin = Renderer->GetRenderWindow();
2095         }
2096
2097         switch (theCommandID)
2098         {
2099         case 33:                                        // DELETE
2100                 smeshGUI->OnEditDelete();
2101                 break;
2102
2103         case 113:                                       // IMPORT
2104         case 112:
2105         case 111:
2106         {
2107                 Import_Document(parent, theCommandID);  //NBU
2108                 //Import_Mesh(parent,theCommandID);
2109                 break;
2110         }
2111
2112         case 122:                                       // EXPORT MED
2113         case 121:
2114         case 123:
2115         {
2116                 Export_Mesh(parent, theCommandID);
2117                 break;
2118         }
2119
2120         case 200:                                       // SCALAR BAR
2121         {
2122                 smeshGUI->DisplayScalarBar(false);
2123                 break;
2124         }
2125         case 201:
2126         {
2127                 SMESHGUI_EditScalarBarDlg *aDlg =
2128                         new SMESHGUI_EditScalarBarDlg(parent, "", false);
2129                 aDlg->show();
2130                 break;
2131         }
2132         case 202:
2133         {
2134                 smeshGUI->DisplayScalarBar(true);
2135                 break;
2136         }
2137
2138         case 1133:                                      // DISPLAY MODE : WireFrame, Surface, Shrink
2139         case 1132:
2140         case 213:
2141         case 212:
2142         case 211:
2143         {
2144                 smeshGUI->SetViewMode(theCommandID);
2145                 break;
2146         }
2147
2148         case 214:                                       // UPDATE
2149         {
2150                 smeshGUI->Update();
2151                 break;
2152         }
2153
2154         case 300:                                       // ERASE
2155         {
2156                 SALOME_Selection *Sel =
2157                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2158                         getSelection());
2159                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2160                         VIEW_VTK)
2161                 {
2162                         // VTK
2163                         SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
2164                         for (; It.More(); It.Next())
2165                         {
2166                                 Handle(SALOME_InteractiveObject) IOS = It.Value();
2167                                 if (IOS->hasEntry())
2168                                 {
2169                                         Standard_Boolean res;
2170                                         SMESH_Actor *ac =
2171                                                 smeshGUI->FindActorByEntry(IOS->getEntry(), res, true);
2172                                         if (res)
2173                                                 smeshGUI->EraseActor(ac);
2174                                 }
2175                         }
2176                 }
2177                 Sel->ClearIObjects();
2178                 smeshGUI->myActiveStudy->updateObjBrowser(true);
2179         }
2180
2181         case 301:                                       // DISPLAY
2182         {
2183                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2184                         VIEW_VTK)
2185                 {
2186                         // VTK
2187                         QApplication::setOverrideCursor(Qt::waitCursor);
2188                         SALOMEDS::SObject_var fatherSF =
2189                                 smeshGUI->myStudy->FindObjectID(smeshGUI->myActiveStudy->
2190                                 getActiveStudyFrame()->entry());
2191
2192                         SALOME_Selection *Sel =
2193                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2194                                 getSelection());
2195                         SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
2196
2197                         for (; It.More(); It.Next())
2198                         {
2199                                 Handle(SALOME_InteractiveObject) IObject = It.Value();
2200                                 if (IObject->hasEntry())
2201                                 {
2202                                         Standard_Boolean res;
2203                                         SMESH_Actor *ac =
2204                                                 smeshGUI->FindActorByEntry(IObject->getEntry(), res,
2205                                                 true);
2206                                         if (res)
2207                                         {
2208                                                 smeshGUI->DisplayActor(ac, true);
2209                                                 smeshGUI->DisplayEdges(ac);
2210                                                 smeshGUI->ChangeRepresentation(ac,
2211                                                         ac->getDisplayMode());
2212                                         }
2213                                 }
2214                         }
2215                         QApplication::restoreOverrideCursor();
2216                 }
2217                 break;
2218         }
2219
2220         case 302:                                       // DISPLAY ONLY
2221         {
2222                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2223                         VIEW_VTK)
2224                 {
2225                         QApplication::setOverrideCursor(Qt::waitCursor);
2226                         vtkActorCollection *theActors = Renderer->GetActors();
2227                         theActors->InitTraversal();
2228                         vtkActor *ac = theActors->GetNextActor();
2229                         while (!(ac == NULL))
2230                         {
2231                                 if (ac->IsA("SMESH_Actor"))
2232                                 {
2233                                         SMESH_Actor *anActor = SMESH_Actor::SafeDownCast(ac);
2234                                         if (!anActor->isHighlighted())
2235                                         {
2236                                                 //anActor->VisibilityOff();
2237                                                 //NRI- : 02/12/2002 : Fixed bugId 882
2238                                                 //      anActor->EdgeDevice->VisibilityOff();
2239                                                 //      anActor->EdgeShrinkDevice->VisibilityOff();
2240                                                 anActor->SetVisibility(false);
2241                                         }
2242                                 }
2243                                 ac = theActors->GetNextActor();
2244                         }
2245
2246                         // Display selection
2247                         SALOMEDS::SObject_var fatherSF =
2248                                 smeshGUI->myStudy->FindObjectID(smeshGUI->myActiveStudy->
2249                                 getActiveStudyFrame()->entry());
2250
2251                         SALOME_Selection *Sel =
2252                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2253                                 getSelection());
2254                         SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
2255
2256                         for (; It.More(); It.Next())
2257                         {
2258                                 Handle(SALOME_InteractiveObject) IObject = It.Value();
2259                                 SALOMEDS::SObject_var obj =
2260                                         smeshGUI->myStudy->FindObjectID(IObject->getEntry());
2261
2262                                 VTKViewer_RenderWindowInteractor *myRenderInter =
2263                                         ((VTKViewer_ViewFrame *) smeshGUI->myActiveStudy->
2264                                         getActiveStudyFrame()->getRightFrame()->getViewFrame())->
2265                                         getRWInteractor();
2266                                 //      vtkQGLRenderWindowInteractor* myRenderInter= smeshGUI->myActiveStudy->getActiveStudyFrame()->getRightFrame()->getVTKView()->getRWInteractor();
2267
2268                                 if (myRenderInter->isInViewer(IObject))
2269                                 {
2270                                         if (IObject->hasEntry())
2271                                         {
2272                                                 Standard_Boolean res;
2273                                                 SMESH_Actor *ac =
2274                                                         smeshGUI->FindActorByEntry(IObject->getEntry(), res,
2275                                                         true);
2276                                                 if (res)
2277                                                 {
2278                                                         smeshGUI->DisplayActor(ac, true);
2279                                                         smeshGUI->DisplayEdges(ac);
2280                                                         smeshGUI->ChangeRepresentation(ac,
2281                                                                 ac->getDisplayMode());
2282                                                 }
2283                                         }
2284                                 }
2285                         }
2286                         smeshGUI->myActiveStudy->updateObjBrowser(true);
2287                         QApplication::restoreOverrideCursor();
2288                 }
2289                 break;
2290         }
2291
2292         case 400:                                       // NODES
2293         {
2294                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2295                         VIEW_VTK)
2296                 {                                               //VTK
2297                         smeshGUI->EmitSignalDeactivateDialog();
2298                         SALOME_Selection *Sel =
2299                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2300                                 getSelection());
2301                         Sel->ClearIObjects();
2302                         smeshGUI->myDesktop->SetSelectionMode(1, true);
2303                         parent->menuBar()->setItemChecked(9010, false);
2304                         parent->menuBar()->setItemChecked(9011, false);
2305                         smeshGUI->ViewNodes();
2306                         SMESHGUI_NodesDlg *aDlg = new SMESHGUI_NodesDlg(parent, "", Sel);
2307                 }
2308                 else
2309                 {
2310                         QApplication::restoreOverrideCursor();
2311                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
2312                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
2313                                 tr("SMESH_BUT_YES"));
2314                 }
2315                 break;
2316         }
2317
2318         case 405:                                       // MOVE NODE
2319         {
2320                 smeshGUI->myDesktop->SetSelectionMode(1, true);
2321                 SALOME_Selection *Sel =
2322                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2323                         getSelection());
2324                 SMESHGUI_MoveNodesDlg *aDlg =
2325                         new SMESHGUI_MoveNodesDlg(parent, "", Sel);
2326                 break;
2327         }
2328
2329         case 701:                                       // COMPUTE MESH
2330         {
2331                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2332                         VIEW_VTK)
2333                 {                                               //VTK
2334                         SALOME_Selection *Sel =
2335                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2336                                 getSelection());
2337                         int nbSel = Sel->IObjectCount();
2338                         if (nbSel != 1)
2339                         {
2340                                 QApplication::restoreOverrideCursor();
2341                                 break;
2342                         }
2343
2344                         SMESH::SMESH_Mesh_var aM;
2345                         SMESH::SMESH_subMesh_var aSubM;
2346                         Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
2347                         if (IObject->hasEntry())
2348                         {
2349                                 SALOMEDS::SObject_var aMorSM =
2350                                         smeshGUI->myStudy->FindObjectID(IObject->getEntry());
2351                                 SALOMEDS::GenericAttribute_var anAttr;
2352                                 SALOMEDS::AttributeIOR_var anIOR;
2353                                 if (!aMorSM->_is_nil())
2354                                 {
2355                                         if (aMorSM->FindAttribute(anAttr, "AttributeIOR"))
2356                                         {
2357                                                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
2358                                                 MESSAGE("SMESHGUI::OnGUIEvent - Compute mesh : IOR = "
2359                                                         << anIOR->Value())CORBA::Object_var cobj;
2360                                                 try
2361                                                 {
2362                                                         cobj = _orb->string_to_object(anIOR->Value());
2363                                                         if (CORBA::is_nil(cobj))
2364                                                         {
2365                                                         MESSAGE
2366                                                                         ("SMESHGUI::OnGUIEvent - Compute mesh : nil object")}
2367                                                 }
2368                                                 catch(CORBA::COMM_FAILURE & ex)
2369                                                 {
2370                                                 MESSAGE
2371                                                                 ("SMESHGUI::OnGUIEvent - Compute mesh : exception (1)")}
2372                                                 aM = SMESH::SMESH_Mesh::_narrow(cobj);
2373                                                 //aM = SMESH::SMESH_Mesh::_narrow( _orb->string_to_object(anIOR->Value()) );
2374                                                 aSubM =
2375                                                         SMESH::SMESH_subMesh::_narrow(_orb->
2376                                                         string_to_object(anIOR->Value()));
2377                                                 if (!aM->_is_nil())
2378                                                 {
2379                                                         GEOM::GEOM_Shape_var refShape =
2380                                                                 smeshGUI->myStudyAPI.
2381                                                                 GetShapeOnMeshOrSubMesh(aMorSM);
2382                                                         if (!refShape->_is_nil())
2383                                                         {
2384                                                                 bool compute =
2385                                                                         smeshGUI->myComponentMesh->
2386                                                                         IsReadyToCompute(aM, refShape);
2387                                                                 if (!compute)
2388                                                                 {
2389                                                                         QApplication::restoreOverrideCursor();
2390                                                                         QAD_MessageBox::warn1(QAD_Application::
2391                                                                                 getDesktop(), tr("SMESH_WRN_WARNING"),
2392                                                                                 tr("SMESH_WRN_MISSING_PARAMETERS"),
2393                                                                                 tr("SMESH_BUT_YES"));
2394                                                                         break;
2395                                                                 }
2396                                                                 try
2397                                                                 {
2398                                                                         smeshGUI->myComponentMesh->Compute(aM,
2399                                                                                 refShape);
2400                                                                         smeshGUI->myStudyAPI.ModifiedMesh(aMorSM,
2401                                                                                 true);
2402                                                                         // TO Do : change icon of all submeshes
2403                                                                 }
2404                                                                 catch(const SALOME::SALOME_Exception & S_ex)
2405                                                                 {
2406                                                                         QtCatchCorbaException(S_ex);
2407                                                                 }
2408                                                         }
2409                                                 }
2410                                                 else if (!aSubM->_is_nil())
2411                                                 {
2412                                                         aM = aSubM->GetFather();
2413                                                         GEOM::GEOM_Shape_var refShape =
2414                                                                 smeshGUI->myStudyAPI.
2415                                                                 GetShapeOnMeshOrSubMesh(aMorSM);
2416                                                         if (!refShape->_is_nil())
2417                                                         {
2418                                                                 bool compute =
2419                                                                         smeshGUI->myComponentMesh->
2420                                                                         IsReadyToCompute(aM, refShape);
2421                                                                 if (!compute)
2422                                                                 {
2423                                                                         QApplication::restoreOverrideCursor();
2424                                                                         QAD_MessageBox::warn1(QAD_Application::
2425                                                                                 getDesktop(), tr("SMESH_WRN_WARNING"),
2426                                                                                 tr("SMESH_WRN_MISSING_PARAMETERS"),
2427                                                                                 tr("SMESH_BUT_YES"));
2428                                                                         break;
2429                                                                 }
2430                                                                 try
2431                                                                 {
2432                                                                         smeshGUI->myComponentMesh->Compute(aM,
2433                                                                                 refShape);
2434                                                                         smeshGUI->myStudyAPI.ModifiedMesh(aMorSM,
2435                                                                                 true);
2436                                                                         // TO Do : change icon of all submeshes
2437                                                                 }
2438                                                                 catch(const SALOME::SALOME_Exception & S_ex)
2439                                                                 {
2440                                                                         QtCatchCorbaException(S_ex);
2441                                                                 }
2442                                                         }
2443                                                 }
2444                                         }
2445                                 }
2446                         }
2447
2448                         // Check whether the actor for the mesh exists at least in one view
2449                         Standard_Boolean res;
2450                         SMESH_Actor *ac =
2451                                 smeshGUI->FindActorByEntry(IObject->getEntry(), res, false);
2452                         if (!res)
2453                                 smeshGUI->InitActor(aM);
2454                         else
2455                         {
2456                                 // Check whether the actor belongs to the active view
2457                                 VTKViewer_RenderWindowInteractor *rwInter =
2458                                         ((VTKViewer_ViewFrame *) smeshGUI->myActiveStudy->
2459                                         getActiveStudyFrame()->getRightFrame()->getViewFrame())->
2460                                         getRWInteractor();
2461
2462                                 // The actor belongs to inactive view -> create a copy and add it in the active view
2463                                 if (!rwInter->isInViewer(IObject))
2464                                 {
2465                                         SMESH_Actor *acCopy = SMESH_Actor::New();
2466                                         acCopy->ShallowCopy(ac);
2467
2468                                         smeshGUI->DisplayActor(acCopy, false);
2469                                 }
2470                         }
2471
2472                         if (smeshGUI->myAutomaticUpdate)
2473                         {
2474                                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aM);
2475                                 if (Mesh != NULL)
2476                                 {
2477 #ifdef TRACE
2478                                         Dump(Mesh);
2479 #endif
2480                                         smeshGUI->DisplayActor(Mesh, true);
2481                                         smeshGUI->DisplayEdges(Mesh, true);
2482                                         smeshGUI->ChangeRepresentation(Mesh,
2483                                                 Mesh->getDisplayMode());
2484                                 }
2485                         }
2486                 }
2487                 else
2488                 {
2489                         QApplication::restoreOverrideCursor();
2490                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
2491                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
2492                                 tr("SMESH_BUT_YES"));
2493                 }
2494                 QApplication::restoreOverrideCursor();
2495                 break;
2496         }
2497
2498         case 702:                                       // ADD SUB MESH
2499         {
2500                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2501                         VIEW_VTK)
2502                 {                                               //VTK
2503                         smeshGUI->EmitSignalDeactivateDialog();
2504                         SALOME_Selection *Sel =
2505                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2506                                 getSelection());
2507                         SMESHGUI_AddSubMeshDlg *aDlg =
2508                                 new SMESHGUI_AddSubMeshDlg(parent, "", Sel);
2509                 }
2510                 else
2511                 {
2512                         QApplication::restoreOverrideCursor();
2513                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
2514                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
2515                                 tr("SMESH_BUT_YES"));
2516                 }
2517                 break;
2518         }
2519
2520         case 703:                                       // INIT MESH
2521         {
2522                 smeshGUI->EmitSignalDeactivateDialog();
2523                 SALOME_Selection *Sel =
2524                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2525                         getSelection());
2526                 SMESHGUI_InitMeshDlg *aDlg = new SMESHGUI_InitMeshDlg(parent, "", Sel);
2527                 break;
2528         }
2529
2530         case 704:                                       // EDIT Hypothesis
2531         {
2532                 smeshGUI->EmitSignalDeactivateDialog();
2533                 SALOME_Selection *Sel =
2534                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2535                         getSelection());
2536                 SMESHGUI_EditHypothesesDlg *aDlg =
2537                         new SMESHGUI_EditHypothesesDlg(parent, "", Sel);
2538                 break;
2539         }
2540
2541         case 705:                                       //  EDIT Global Hypothesis
2542         {
2543                 smeshGUI->EmitSignalDeactivateDialog();
2544                 SALOME_Selection *Sel =
2545                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2546                         getSelection());
2547                 SMESHGUI_EditHypothesesDlg *aDlg =
2548                         new SMESHGUI_EditHypothesesDlg(parent, "", Sel);
2549                 break;
2550         }
2551
2552         case 706:                                       //  EDIT Local Hypothesis
2553         {
2554                 smeshGUI->EmitSignalDeactivateDialog();
2555                 SALOME_Selection *Sel =
2556                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2557                         getSelection());
2558                 SMESHGUI_EditHypothesesDlg *aDlg =
2559                         new SMESHGUI_EditHypothesesDlg(parent, "", Sel);
2560                 break;
2561         }
2562
2563         case 806:                                       // ORIENTATION ELEMENTS
2564         {
2565                 smeshGUI->EmitSignalDeactivateDialog();
2566                 SALOME_Selection *Sel =
2567                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2568                         getSelection());
2569                 smeshGUI->myDesktop->SetSelectionMode(3, true);
2570                 SMESHGUI_OrientationElementsDlg *aDlg =
2571                         new SMESHGUI_OrientationElementsDlg(parent, "", Sel);
2572                 break;
2573         }
2574
2575         case 807:                                       // DIAGONAL INVERSION
2576         {
2577                 smeshGUI->EmitSignalDeactivateDialog();
2578                 SALOME_Selection *Sel =
2579                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2580                         getSelection());
2581                 Sel->ClearIObjects();
2582                 smeshGUI->myDesktop->SetSelectionMode(2, true);
2583                 SMESHGUI_DiagonalInversionDlg *aDlg =
2584                         new SMESHGUI_DiagonalInversionDlg(parent, "", Sel);
2585                 break;
2586         }
2587
2588         case 900:                                       // MESH INFOS
2589         {
2590                 smeshGUI->EmitSignalDeactivateDialog();
2591                 SALOME_Selection *Sel =
2592                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2593                         getSelection());
2594                 SMESHGUI_MeshInfosDlg *aDlg =
2595                         new SMESHGUI_MeshInfosDlg(parent, "", Sel);
2596                 break;
2597         }
2598
2599         case 1001:                                      // AUTOMATIC UPDATE PREFERENCES
2600         {
2601                 parent->menuBar()->setItemChecked(1001,
2602                         !parent->menuBar()->isItemChecked(1001));
2603                 if (parent->menuBar()->isItemChecked(1001))
2604                 {
2605                         QAD_CONFIG->addSetting("SMESH:AutomaticUpdate", "true");
2606                         smeshGUI->myAutomaticUpdate = true;
2607                 }
2608                 else
2609                 {
2610                         QAD_CONFIG->addSetting("SMESH:AutomaticUpdate", "false");
2611                         smeshGUI->myAutomaticUpdate = false;
2612                 }
2613                 break;
2614         }
2615
2616         case 1003:                                      // MESH PREFERENCES
2617         {
2618                 smeshGUI->SetDisplaySettings();
2619                 break;
2620         }
2621
2622         case 1005:
2623         {
2624                 QString Bold = QAD_CONFIG->getSetting("ScalarBar:Bold");
2625                 QString Italic = QAD_CONFIG->getSetting("ScalarBar:Italic");
2626                 QString Shadow = QAD_CONFIG->getSetting("ScalarBar:Shadow");
2627                 QString FontFamily = QAD_CONFIG->getSetting("ScalarBar:FontFamily");
2628                 QString Orientation = QAD_CONFIG->getSetting("ScalarBar:Orientation");
2629                 float Width = QAD_CONFIG->getSetting("ScalarBar:Width").toFloat();
2630                 float Height = QAD_CONFIG->getSetting("ScalarBar:Height").toFloat();
2631                 int NumberOfLabels =
2632                         QAD_CONFIG->getSetting("ScalarBar:NumberOfLabels").toInt();
2633                 int NumberOfColors =
2634                         QAD_CONFIG->getSetting("ScalarBar:NumberOfColors").toInt();
2635
2636                 if (Width == 0)
2637                         Width = 0.17;
2638                 if (Height == 0)
2639                         Height = 0.8;
2640                 if (NumberOfLabels == 0)
2641                         NumberOfLabels = 5;
2642                 if (NumberOfColors == 0)
2643                         NumberOfColors = 64;
2644
2645                 SMESHGUI_Preferences_ScalarBarDlg *aDlg =
2646                         new SMESHGUI_Preferences_ScalarBarDlg(parent, "", true);
2647
2648                 if (Bold.compare("true") == 0)
2649                         aDlg->Bold->setChecked(true);
2650                 else
2651                         aDlg->Bold->setChecked(false);
2652                 if (Italic.compare("true") == 0)
2653                         aDlg->Italic->setChecked(true);
2654                 else
2655                         aDlg->Italic->setChecked(false);
2656                 if (Shadow.compare("true") == 0)
2657                         aDlg->Shadow->setChecked(true);
2658                 else
2659                         aDlg->Shadow->setChecked(false);
2660
2661                 if (Orientation.compare("Horizontal") == 0)
2662                         aDlg->RadioHoriz->setChecked(true);
2663                 else
2664                         aDlg->RadioVert->setChecked(true);
2665
2666                 int NbItems = aDlg->ComboBox1->count();
2667                 int i = 0;
2668                 aDlg->ComboBox1->setCurrentItem(i);
2669                 while (i < NbItems)
2670                 {
2671                         if (FontFamily.compare(aDlg->ComboBox1->text(i)) == 0)
2672                                 aDlg->ComboBox1->setCurrentItem(i);
2673                         i++;
2674                 }
2675
2676                 aDlg->LineEditWidth->setText(QString("%1").arg(Width));
2677                 aDlg->LineEditHeight->setText(QString("%1").arg(Height));
2678
2679                 aDlg->SpinBoxLabels->setValue(NumberOfLabels);
2680                 aDlg->SpinBoxColors->setValue(NumberOfColors);
2681
2682                 aDlg->show();
2683                 if (aDlg->result())
2684                 {
2685                         if (aDlg->RadioHoriz->isChecked())
2686                                 Orientation = "Horizontal";
2687                         else
2688                                 Orientation = "Vertical";
2689                         if (aDlg->Bold->isChecked())
2690                                 Bold = "true";
2691                         else
2692                                 Bold = "false";
2693                         if (aDlg->Italic->isChecked())
2694                                 Italic = "true";
2695                         else
2696                                 Italic = "false";
2697                         if (aDlg->Shadow->isChecked())
2698                                 Shadow = "true";
2699                         else
2700                                 Shadow = "false";
2701
2702                         FontFamily = aDlg->ComboBox1->currentText();
2703                         Width = aDlg->LineEditWidth->text().toFloat();
2704                         Height = aDlg->LineEditHeight->text().toFloat();
2705                         NumberOfColors = aDlg->SpinBoxColors->text().toInt();
2706                         NumberOfLabels = aDlg->SpinBoxLabels->text().toInt();
2707
2708                         vtkScalarBarActor *aScalarBar = smeshGUI->GetScalarBar();
2709                         if (aScalarBar != NULL)
2710                         {
2711                                 smeshGUI->SetSettingsScalarBar(aScalarBar, Bold, Italic, Shadow,
2712                                         FontFamily, Orientation,
2713                                         Width, Height, NumberOfColors, NumberOfLabels);
2714                         }
2715
2716                         QAD_CONFIG->addSetting("ScalarBar:Bold", Bold);
2717                         QAD_CONFIG->addSetting("ScalarBar:Italic", Italic);
2718                         QAD_CONFIG->addSetting("ScalarBar:Shadow", Shadow);
2719                         QAD_CONFIG->addSetting("ScalarBar:FontFamily", FontFamily);
2720                         QAD_CONFIG->addSetting("ScalarBar:Orientation", Orientation);
2721                         QAD_CONFIG->addSetting("ScalarBar:Width", Width);
2722                         QAD_CONFIG->addSetting("ScalarBar:Height", Height);
2723                         QAD_CONFIG->addSetting("ScalarBar:NumberOfLabels", NumberOfLabels);
2724                         QAD_CONFIG->addSetting("ScalarBar:NumberOfColors", NumberOfColors);
2725                 }
2726                 break;
2727         }
2728
2729         case 1100:                                      // EDIT HYPOTHESIS
2730         {
2731                 SALOME_Selection *Sel =
2732                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2733                         getSelection());
2734                 int nbSel = Sel->IObjectCount();
2735
2736                 if (nbSel == 1)
2737                 {
2738                         Standard_Boolean res;
2739                         SMESH::SMESH_Hypothesis_var Hyp =
2740                                 smeshGUI->ConvertIOinSMESHHypothesis(Sel->firstIObject(), res);
2741
2742                         /* Look for all mesh objects that have this hupothesis affected in order to flag as ModifiedMesh */
2743                         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
2744                         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
2745                         SALOMEDS::Study::ListOfSObject_var listSOmesh =
2746                                 smeshGUI->GetMeshesUsingAlgoOrHypothesis(Hyp);
2747
2748                         if (res)
2749                         {
2750                                 QString Name = Hyp->GetName();
2751
2752                                 if (Name.compare("LocalLength") == 0)
2753                                 {
2754                                         SMESH::SMESH_LocalLength_var LL =
2755                                                 SMESH::SMESH_LocalLength::_narrow(Hyp);
2756                                         double beforeLength = LL->GetLength();
2757                                         double Length = smeshGUI->Parameter(res,
2758                                                 beforeLength,
2759                                                 tr("SMESH_LOCAL_LENGTH_HYPOTHESIS"),
2760                                                 tr("SMESH_VALUE"),
2761                                                 1.0E-5, 1E6, 6);
2762                                         if (res && Length != beforeLength)
2763                                         {
2764                                                 LL->SetLength(Length);
2765                                                 for (int i = 0; i < listSOmesh->length(); i++)
2766                                                 {
2767                                                         smeshGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i],
2768                                                                 false);
2769                                                 }
2770                                                 break;
2771                                         }
2772
2773                                 }
2774                                 else if (Name.compare("NumberOfSegments") == 0)
2775                                 {
2776                                         SMESH::SMESH_NumberOfSegments_var NOS =
2777                                                 SMESH::SMESH_NumberOfSegments::_narrow(Hyp);
2778                                         int beforeNbSeg = NOS->GetNumberOfSegments();
2779                                         int NbSeg = smeshGUI->Parameter(res,
2780                                                 beforeNbSeg,
2781                                                 tr("SMESH_NB_SEGMENTS_HYPOTHESIS"),
2782                                                 tr("SMESH_VALUE"),
2783                                                 1, 1000000);
2784
2785                                         if (res && NbSeg != beforeNbSeg)
2786                                         {
2787                                                 NOS->SetNumberOfSegments(NbSeg);
2788                                                 for (int i = 0; i < listSOmesh->length(); i++)
2789                                                 {
2790                                                         SALOMEDS::SObject_var SO = listSOmesh[i];
2791                                                         smeshGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i],
2792                                                                 false);
2793                                                 }
2794                                                 break;
2795                                         }
2796
2797                                 }
2798                                 else if (Name.compare("MaxElementArea") == 0)
2799                                 {
2800                                         SMESH::SMESH_MaxElementArea_var MEA =
2801                                                 SMESH::SMESH_MaxElementArea::_narrow(Hyp);
2802                                         double beforeMaxArea = MEA->GetMaxElementArea();
2803                                         double MaxArea = smeshGUI->Parameter(res,
2804                                                 beforeMaxArea,
2805                                                 tr("SMESH_MAX_ELEMENT_AREA_HYPOTHESIS"),
2806                                                 tr("SMESH_VALUE"),
2807                                                 1.0E-5, 1E6, 6);
2808                                         if (res && MaxArea != beforeMaxArea)
2809                                         {
2810                                                 MEA->SetMaxElementArea(MaxArea);
2811                                                 for (int i = 0; i < listSOmesh->length(); i++)
2812                                                 {
2813                                                         smeshGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i],
2814                                                                 false);
2815                                                 }
2816                                                 break;
2817                                         }
2818
2819                                 }
2820                                 else if (Name.compare("MaxElementVolume") == 0)
2821                                 {
2822                                         SMESH::SMESH_MaxElementVolume_var MEV =
2823                                                 SMESH::SMESH_MaxElementVolume::_narrow(Hyp);
2824                                         double beforeMaxVolume = MEV->GetMaxElementVolume();
2825                                         double MaxVolume = smeshGUI->Parameter(res,
2826                                                 beforeMaxVolume,
2827                                                 tr("SMESH_MAX_ELEMENT_VOLUME_HYPOTHESIS"),
2828                                                 tr("SMESH_VALUE"),
2829                                                 1.0E-5, 1E6, 6);
2830                                         if (res && MaxVolume != beforeMaxVolume)
2831                                         {
2832                                                 MEV->SetMaxElementVolume(MaxVolume);
2833                                                 for (int i = 0; i < listSOmesh->length(); i++)
2834                                                 {
2835                                                         smeshGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i],
2836                                                                 false);
2837                                                 }
2838                                                 break;
2839                                         }
2840
2841                                 }
2842                                 else if (Name.compare("Regular_1D") == 0)
2843                                 {
2844                                 }
2845                                 else if (Name.compare("MEFISTO_2D") == 0)
2846                                 {
2847                                 }
2848                                 else
2849                                 {
2850                                 }
2851
2852                         }
2853                 }
2854                 break;
2855         }
2856
2857         case 1101:                                      // RENAME
2858         {
2859                 SALOME_Selection *Sel =
2860                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2861                         getSelection());
2862                 SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
2863                 for (; It.More(); It.Next())
2864                 {
2865                         Handle(SALOME_InteractiveObject) IObject = It.Value();
2866
2867                         SALOMEDS::SObject_var obj =
2868                                 smeshGUI->myStudy->FindObjectID(IObject->getEntry());
2869                         SALOMEDS::GenericAttribute_var anAttr;
2870                         SALOMEDS::AttributeName_var aName;
2871                         if (!obj->_is_nil())
2872                         {
2873                                 if (obj->FindAttribute(anAttr, "AttributeName"))
2874                                 {
2875                                         aName = SALOMEDS::AttributeName::_narrow(anAttr);
2876                                         QString newName = QString(aName->Value());
2877                                         newName =
2878                                                 SALOMEGUI_NameDlg::getName(QAD_Application::
2879                                                 getDesktop(), newName);
2880                                         if (!newName.isEmpty())
2881                                         {
2882                                                 QApplication::setOverrideCursor(Qt::waitCursor);
2883                                                 smeshGUI->myActiveStudy->renameIObject(IObject,
2884                                                         newName);
2885                                         }
2886                                         QApplication::restoreOverrideCursor();
2887                                 }
2888                         }
2889                 }
2890                 break;
2891         }
2892
2893         case 1102:                                      // REMOVE HYPOTHESIS / ALGORITHMS
2894         {
2895                 QApplication::setOverrideCursor(Qt::waitCursor);
2896                 SALOME_Selection *Sel =
2897                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2898                         getSelection());
2899                 SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
2900                 for (int i = 0; It.More(); It.Next(), i++)
2901                 {
2902                         Handle(SALOME_InteractiveObject) IObject = It.Value();
2903                         smeshGUI->RemoveHypothesisOrAlgorithmOnMesh(IObject);
2904                 }
2905                 Sel->ClearIObjects();
2906                 smeshGUI->myActiveStudy->updateObjBrowser(true);
2907                 QApplication::restoreOverrideCursor();
2908                 break;
2909         }
2910
2911         case 401:                                       // GEOM::EDGE
2912         {
2913                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2914                         VIEW_VTK)
2915                 {                                               //VTK
2916                         smeshGUI->EmitSignalDeactivateDialog();
2917                         SALOME_Selection *Sel =
2918                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2919                                 getSelection());
2920                         Sel->ClearIObjects();
2921                         smeshGUI->myDesktop->SetSelectionMode(1, true);
2922                         parent->menuBar()->setItemChecked(9010, false);
2923                         parent->menuBar()->setItemChecked(9011, false);
2924                         smeshGUI->ViewNodes();
2925                         SMESHGUI_AddEdgeDlg *aDlg =
2926                                 new SMESHGUI_AddEdgeDlg(parent, "", Sel);
2927                 }
2928                 else
2929                 {
2930                         QApplication::restoreOverrideCursor();
2931                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
2932                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
2933                                 tr("SMESH_BUT_YES"));
2934                 }
2935                 break;
2936         }
2937         case 4021:                                      // TRIANGLE
2938         {
2939                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2940                         VIEW_VTK)
2941                 {                                               //VTK
2942                         smeshGUI->EmitSignalDeactivateDialog();
2943                         SALOME_Selection *Sel =
2944                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2945                                 getSelection());
2946                         Sel->ClearIObjects();
2947                         smeshGUI->myDesktop->SetSelectionMode(1, true);
2948                         parent->menuBar()->setItemChecked(9010, false);
2949                         parent->menuBar()->setItemChecked(9011, false);
2950                         smeshGUI->ViewNodes();
2951                         SMESHGUI_AddFaceDlg *aDlg =
2952                                 new SMESHGUI_AddFaceDlg(parent, "", Sel, 3);
2953                 }
2954                 else
2955                 {
2956                         QApplication::restoreOverrideCursor();
2957                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
2958                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
2959                                 tr("SMESH_BUT_YES"));
2960                 }
2961                 break;
2962         }
2963         case 4022:                                      // QUAD
2964         {
2965                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2966                         VIEW_VTK)
2967                 {                                               //VTK
2968                         smeshGUI->EmitSignalDeactivateDialog();
2969                         SALOME_Selection *Sel =
2970                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2971                                 getSelection());
2972                         Sel->ClearIObjects();
2973                         smeshGUI->myDesktop->SetSelectionMode(1, true);
2974                         parent->menuBar()->setItemChecked(9010, false);
2975                         parent->menuBar()->setItemChecked(9011, false);
2976                         smeshGUI->ViewNodes();
2977                         SMESHGUI_AddFaceDlg *aDlg =
2978                                 new SMESHGUI_AddFaceDlg(parent, "", Sel, 4);
2979                 }
2980                 else
2981                 {
2982                         QApplication::restoreOverrideCursor();
2983                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
2984                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
2985                                 tr("SMESH_BUT_YES"));
2986                 }
2987                 break;
2988         }
2989         case 4031:                                      // TETRA
2990         {
2991                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
2992                         VIEW_VTK)
2993                 {                                               //VTK
2994                         smeshGUI->EmitSignalDeactivateDialog();
2995                         SALOME_Selection *Sel =
2996                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
2997                                 getSelection());
2998                         Sel->ClearIObjects();
2999                         smeshGUI->myDesktop->SetSelectionMode(1, true);
3000                         parent->menuBar()->setItemChecked(9010, false);
3001                         parent->menuBar()->setItemChecked(9011, false);
3002                         smeshGUI->ViewNodes();
3003                         SMESHGUI_AddVolumeDlg *aDlg =
3004                                 new SMESHGUI_AddVolumeDlg(parent, "", Sel, 4);
3005                 }
3006                 else
3007                 {
3008                         QApplication::restoreOverrideCursor();
3009                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
3010                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
3011                                 tr("SMESH_BUT_YES"));
3012                 }
3013                 break;
3014         }
3015         case 4032:                                      // HEXA
3016         {
3017                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
3018                         VIEW_VTK)
3019                 {                                               //VTK
3020                         smeshGUI->EmitSignalDeactivateDialog();
3021                         SALOME_Selection *Sel =
3022                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3023                                 getSelection());
3024                         Sel->ClearIObjects();
3025                         smeshGUI->myDesktop->SetSelectionMode(1, true);
3026                         parent->menuBar()->setItemChecked(9010, false);
3027                         parent->menuBar()->setItemChecked(9011, false);
3028                         smeshGUI->ViewNodes();
3029                         SMESHGUI_AddVolumeDlg *aDlg =
3030                                 new SMESHGUI_AddVolumeDlg(parent, "", Sel, 8);
3031                 }
3032                 else
3033                 {
3034                         QApplication::restoreOverrideCursor();
3035                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
3036                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
3037                                 tr("SMESH_BUT_YES"));
3038                 }
3039                 break;
3040         }
3041
3042         case 4041:                                      // REMOVES NODES
3043         {
3044                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
3045                         VIEW_VTK)
3046                 {                                               //VTK
3047                         smeshGUI->EmitSignalDeactivateDialog();
3048                         SALOME_Selection *Sel =
3049                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3050                                 getSelection());
3051                         Sel->ClearIObjects();
3052                         smeshGUI->myDesktop->SetSelectionMode(1, true);
3053                         parent->menuBar()->setItemChecked(9010, false);
3054                         parent->menuBar()->setItemChecked(9011, false);
3055                         smeshGUI->ViewNodes();
3056                         SMESHGUI_RemoveNodesDlg *aDlg =
3057                                 new SMESHGUI_RemoveNodesDlg(parent, "", Sel);
3058                 }
3059                 else
3060                 {
3061                         QApplication::restoreOverrideCursor();
3062                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
3063                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
3064                                 tr("SMESH_BUT_YES"));
3065                 }
3066                 break;
3067         }
3068         case 4042:                                      // REMOVES ELEMENTS
3069         {
3070                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
3071                         VIEW_VTK)
3072                 {                                               //VTK
3073                         smeshGUI->EmitSignalDeactivateDialog();
3074                         SALOME_Selection *Sel =
3075                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3076                                 getSelection());
3077                         Sel->ClearIObjects();
3078                         smeshGUI->myDesktop->SetSelectionMode(3, true);
3079                         SMESHGUI_RemoveElementsDlg *aDlg =
3080                                 new SMESHGUI_RemoveElementsDlg(parent, "", Sel);
3081                 }
3082                 else
3083                 {
3084                         QApplication::restoreOverrideCursor();
3085                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
3086                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
3087                                 tr("SMESH_BUT_YES"));
3088                 }
3089                 break;
3090         }
3091
3092         case 5000:                                      // HYPOTHESIS - ALGO
3093         {
3094                 smeshGUI->CreateAlgorithm("Regular_1D", "Wire Discretisation");
3095                 break;
3096         }
3097         case 5010:
3098         {
3099                 smeshGUI->CreateAlgorithm("MEFISTO_2D", "Triangle (Mefisto)");
3100                 break;
3101         }
3102         case 5011:
3103         {
3104                 smeshGUI->CreateAlgorithm("Quadrangle_2D", "Quadrangle (Mapping)");
3105                 break;
3106         }
3107         case 5020:
3108         {
3109                 smeshGUI->CreateAlgorithm("Hexa_3D", "Hexahedron (i,j,k)");
3110                 break;
3111         }
3112         case 5021:
3113         {
3114                 smeshGUI->CreateAlgorithm("NETGEN_3D", "Tetrahedron (Netgen)");
3115                 break;
3116         }
3117
3118         case 5030:                                      // HYPOTHESIS - LOCAL LENGTH
3119         {
3120                 smeshGUI->EmitSignalDeactivateDialog();
3121                 SALOME_Selection *Sel =
3122                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3123                         getSelection());
3124                 SMESHGUI_LocalLengthDlg *aDlg = new SMESHGUI_LocalLengthDlg(parent, "");
3125                 break;
3126         }
3127         case 5031:                                      // HYPOTHESIS - NB SEGMENTS
3128         {
3129                 smeshGUI->EmitSignalDeactivateDialog();
3130                 SALOME_Selection *Sel =
3131                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3132                         getSelection());
3133                 SMESHGUI_NbSegmentsDlg *aDlg = new SMESHGUI_NbSegmentsDlg(parent, "");
3134                 break;
3135         }
3136
3137         case 5032:                                      // HYPOTHESIS - MAX ELEMENT AREA
3138         {
3139                 smeshGUI->EmitSignalDeactivateDialog();
3140                 SALOME_Selection *Sel =
3141                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3142                         getSelection());
3143                 SMESHGUI_MaxElementAreaDlg *aDlg =
3144                         new SMESHGUI_MaxElementAreaDlg(parent, "");
3145                 break;
3146         }
3147
3148         case 5033:                                      // HYPOTHESIS - MAX ELEMENT VOLUME
3149         {
3150                 smeshGUI->EmitSignalDeactivateDialog();
3151                 SALOME_Selection *Sel =
3152                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3153                         getSelection());
3154                 SMESHGUI_MaxElementVolumeDlg *aDlg =
3155                         new SMESHGUI_MaxElementVolumeDlg(parent, "");
3156                 break;
3157         }
3158
3159         case 6016:                                      // CONTROLS
3160         case 6015:
3161         case 6014:
3162         case 6013:
3163         case 6012:
3164         case 6011:
3165         case 6001:
3166         {
3167                 SALOME_Selection *Sel =
3168                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3169                         getSelection());
3170                 int nbSel = Sel->IObjectCount();
3171                 if (nbSel != 1)
3172                         break;
3173                 smeshGUI->Control(theCommandID);
3174                 break;
3175         }
3176
3177         case 6002:
3178         {
3179                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
3180                         VIEW_VTK)
3181                 {                                               //VTK
3182                         SALOME_Selection *Sel =
3183                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3184                                 getSelection());
3185                         SMESHGUI_EdgesConnectivityDlg *Dlg =
3186                                 new SMESHGUI_EdgesConnectivityDlg(parent, "", Sel);
3187                 }
3188                 else
3189                 {
3190                         QApplication::restoreOverrideCursor();
3191                         QAD_MessageBox::warn1(QAD_Application::getDesktop(),
3192                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"),
3193                                 tr("SMESH_BUT_YES"));
3194                 }
3195                 break;
3196         }
3197
3198         case 9010:
3199         {
3200                 if (!parent->menuBar()->isItemChecked(9010))
3201                 {
3202                         QApplication::setOverrideCursor(Qt::waitCursor);
3203                         parent->menuBar()->setItemChecked(9011, false);
3204
3205                         smeshGUI->EraseSimulationActors();
3206                         smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
3207
3208                         SALOME_Selection *Sel =
3209                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3210                                 getSelection());
3211                         int nbSel = Sel->IObjectCount();
3212                         if (nbSel == 1)
3213                         {
3214                                 Standard_Boolean res;
3215                                 SMESH_Actor *MeshActor =
3216                                         smeshGUI->FindActorByEntry(Sel->firstIObject()->getEntry(),
3217                                         res, true);
3218                                 if (res)
3219                                 {
3220                                         parent->menuBar()->setItemChecked(9010,
3221                                                 !parent->menuBar()->isItemChecked(9010));
3222
3223                                         // It's necessary to display SMDS IDs instead of VTK ones, so
3224                                         // vtkIdFilter is unacceptable here. We have to do it manually :(
3225                                         vtkUnstructuredGrid *ptGrid = vtkUnstructuredGrid::New();
3226                                         ptGrid->CopyStructure(MeshActor->DataSource);
3227
3228                                         int numPts = MeshActor->DataSource->GetNumberOfPoints();
3229
3230                                         // Loop over points and generate ids
3231                                         vtkIntArray *ptIds = vtkIntArray::New();
3232                                         ptIds->SetNumberOfValues(numPts);
3233
3234                                         for (int id = 0; id < numPts; id++)
3235                                         {
3236                                                 int idSMDS = MeshActor->GetIdSMESHDSNode(id);
3237                                                 ptIds->SetValue(id, idSMDS);
3238                                         }
3239
3240 // mpv porting vtk4.2.2
3241                                         //          vtkScalars* newScalars = vtkScalars::New();
3242                                         //          newScalars->SetData(ptIds);
3243                                         //          ptGrid->GetPointData()->SetScalars(newScalars);
3244                                         ptGrid->GetPointData()->SetScalars(ptIds);
3245                                         //          newScalars->Delete();
3246 // mpv
3247                                         ptIds->Delete();
3248
3249                                         vtkMaskPoints *mask = vtkMaskPoints::New();
3250                                         mask->SetInput(ptGrid);
3251                                         mask->SetOnRatio(1);
3252                                         //        mask->SetMaximumNumberOfPoints( 50 );
3253                                         //        mask->RandomModeOn();
3254
3255                                         vtkSelectVisiblePoints *visPts =
3256                                                 vtkSelectVisiblePoints::New();
3257                                         visPts->SetInput(mask->GetOutput());
3258                                         visPts->SetRenderer(((VTKViewer_ViewFrame *) smeshGUI->
3259                                                         myActiveStudy->getActiveStudyFrame()->
3260                                                         getRightFrame()->getViewFrame())->getRenderer());
3261                                         //visPts->SetSelectInvisible(1);
3262                                         visPts->SelectInvisibleOff();
3263                                         visPts->SetTolerance(0.1);
3264
3265                                         vtkLabeledDataMapper *ldm = vtkLabeledDataMapper::New();
3266                                         ldm->SetInput(visPts->GetOutput());
3267                                         ldm->SetLabelFormat("%g");
3268                                         ldm->SetLabelModeToLabelScalars();
3269                                         //ldm->SetLabelModeToLabelFieldData();
3270
3271                                         ldm->SetFontFamilyToTimes();
3272                                         ldm->SetFontSize(6 * parent->font().pointSize() / 5);
3273                                         ldm->SetBold(1);
3274                                         ldm->SetItalic(0);
3275                                         ldm->SetShadow(0);
3276
3277                                         vtkActor2D *pointLabels = vtkActor2D::New();
3278                                         pointLabels->SetMapper(ldm);
3279                                         pointLabels->GetProperty()->SetColor(0, 1, 0);
3280
3281                                         visPts->Delete();
3282                                         ldm->Delete();
3283                                         smeshGUI->mySimulationActors2D->AddItem(pointLabels);
3284                                         ((VTKViewer_ViewFrame *) smeshGUI->myActiveStudy->
3285                                                 getActiveStudyFrame()->getRightFrame()->
3286                                                 getViewFrame())->getRenderer()->AddActor2D(pointLabels);
3287                                 }
3288                         }
3289                 }
3290                 else
3291                 {
3292                         QApplication::setOverrideCursor(Qt::waitCursor);
3293                         parent->menuBar()->setItemChecked(9010,
3294                                 !parent->menuBar()->isItemChecked(9010));
3295                         smeshGUI->EraseSimulationActors();
3296                         smeshGUI->ScalarVisibilityOff();
3297                 }
3298                 QApplication::restoreOverrideCursor();
3299                 break;
3300         }
3301         case 9011:
3302         {
3303                 if (!parent->menuBar()->isItemChecked(9011))
3304                 {
3305                         QApplication::setOverrideCursor(Qt::waitCursor);
3306                         parent->menuBar()->setItemChecked(9010, false);
3307
3308                         smeshGUI->EraseSimulationActors();
3309                         smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
3310
3311                         SALOME_Selection *Sel =
3312                                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->
3313                                 getSelection());
3314                         int nbSel = Sel->IObjectCount();
3315                         if (nbSel == 1)
3316                         {
3317                                 Standard_Boolean res;
3318                                 SMESH_Actor *MeshActor =
3319                                         smeshGUI->FindActorByEntry(Sel->firstIObject()->getEntry(),
3320                                         res, true);
3321                                 if (res)
3322                                 {
3323                                         parent->menuBar()->setItemChecked(9011,
3324                                                 !parent->menuBar()->isItemChecked(9011));
3325
3326                                         // It's necessary to display SMDS IDs instead of VTK ones, so
3327                                         // vtkIdFilter is unacceptable here. We have to do it manually :(
3328                                         vtkUnstructuredGrid *elGrid = vtkUnstructuredGrid::New();
3329                                         elGrid->CopyStructure(MeshActor->DataSource);
3330
3331                                         int numCells = MeshActor->DataSource->GetNumberOfCells();
3332
3333                                         // Loop over points and generate ids
3334                                         vtkIntArray *cellIds = vtkIntArray::New();
3335                                         cellIds->SetNumberOfValues(numCells);
3336
3337                                         for (int id = 0; id < numCells; id++)
3338                                         {
3339                                                 int idSMDS = MeshActor->GetIdSMESHDSElement(id);
3340                                                 cellIds->SetValue(id, idSMDS);
3341                                         }
3342
3343 // mpv porting vk4.2.2
3344                                         //          vtkScalars* newScalars = vtkScalars::New();
3345                                         //          newScalars->SetData(cellIds);
3346                                         elGrid->GetCellData()->SetScalars(cellIds);
3347                                         //          elGrid->GetCellData()->SetScalars(newScalars);
3348                                         //          newScalars->Delete();
3349 //mpv
3350
3351                                         cellIds->Delete();
3352
3353                                         vtkCellCenters *cc = vtkCellCenters::New();
3354                                         cc->SetInput(elGrid);
3355
3356                                         vtkSelectVisiblePoints *visCells =
3357                                                 vtkSelectVisiblePoints::New();
3358                                         visCells->SetInput(cc->GetOutput());
3359                                         visCells->SetRenderer(((VTKViewer_ViewFrame *) smeshGUI->
3360                                                         myActiveStudy->getActiveStudyFrame()->
3361                                                         getRightFrame()->getViewFrame())->getRenderer());
3362                                         visCells->SelectInvisibleOff();
3363                                         visCells->SetTolerance(0.1);
3364                                         //        visCells->SetSelectInvisible(1);
3365
3366                                         vtkLabeledDataMapper *ldm = vtkLabeledDataMapper::New();
3367                                         ldm->SetInput(visCells->GetOutput());
3368                                         ldm->SetLabelFormat("%g");
3369                                         ldm->SetLabelModeToLabelScalars();
3370
3371                                         ldm->SetFontFamilyToTimes();
3372                                         ldm->SetFontSize(6 * parent->font().pointSize() / 5);
3373                                         ldm->SetBold(1);
3374                                         ldm->SetItalic(0);
3375                                         ldm->SetShadow(0);
3376
3377                                         vtkActor2D *cellLabels = vtkActor2D::New();
3378                                         cellLabels->SetMapper(ldm);
3379                                         cellLabels->GetProperty()->SetColor(1, 0, 0);
3380
3381                                         cc->Delete();
3382                                         visCells->Delete();
3383                                         ldm->Delete();
3384                                         smeshGUI->mySimulationActors2D->AddItem(cellLabels);
3385                                         ((VTKViewer_ViewFrame *) smeshGUI->myActiveStudy->
3386                                                 getActiveStudyFrame()->getRightFrame()->
3387                                                 getViewFrame())->getRenderer()->AddActor2D(cellLabels);
3388                                 }
3389                         }
3390                 }
3391                 else
3392                 {
3393                         QApplication::setOverrideCursor(Qt::waitCursor);
3394                         parent->menuBar()->setItemChecked(9011,
3395                                 !parent->menuBar()->isItemChecked(9011));
3396                         smeshGUI->EraseSimulationActors();
3397                         smeshGUI->ScalarVisibilityOff();
3398                 }
3399                 QApplication::restoreOverrideCursor();
3400                 break;
3401         }
3402
3403         case 10001:                             // DISPLAY MODE PREFERENCE
3404         {
3405                 parent->menuBar()->setItemChecked(10001,
3406                         !parent->menuBar()->isItemChecked(10001));
3407                 parent->menuBar()->setItemChecked(10002, false);
3408                 parent->menuBar()->setItemChecked(10003, false);
3409                 QAD_CONFIG->addSetting("SMESH:DisplayMode", "Wireframe");
3410                 break;
3411         }
3412         case 10002:
3413         {
3414                 parent->menuBar()->setItemChecked(10002,
3415                         !parent->menuBar()->isItemChecked(10002));
3416                 parent->menuBar()->setItemChecked(10001, false);
3417                 parent->menuBar()->setItemChecked(10003, false);
3418                 QAD_CONFIG->addSetting("SMESH:DisplayMode", "Shading");
3419                 break;
3420         }
3421         case 10003:
3422         {
3423                 parent->menuBar()->setItemChecked(10003,
3424                         !parent->menuBar()->isItemChecked(10003));
3425                 parent->menuBar()->setItemChecked(10002, false);
3426                 parent->menuBar()->setItemChecked(10001, false);
3427                 QAD_CONFIG->addSetting("SMESH:DisplayMode", "Shrink");
3428                 break;
3429         }
3430
3431         }
3432
3433         smeshGUI->myActiveStudy->updateObjBrowser(true);
3434         return true;
3435 }
3436
3437 //=============================================================================
3438 /*! function : GetMeshesUsingAlgoOrHypothesis()
3439  *  purpose  : return a list of Study objects (mesh kind) that have 'AlgoOrHyp' affected.
3440  *           : However is supposed here that father of father of an hypothesis is a Mesh Object.
3441  */
3442 //=============================================================================
3443 SALOMEDS::Study::ListOfSObject *
3444         SMESHGUI::GetMeshesUsingAlgoOrHypothesis(SMESH::
3445         SMESH_Hypothesis_ptr AlgoOrHyp)
3446 {
3447         SALOMEDS::Study::ListOfSObject_var listSOmesh =
3448                 new SALOMEDS::Study::ListOfSObject;
3449         listSOmesh->length(0);
3450         unsigned int index = 0;
3451         if (!AlgoOrHyp->_is_nil())
3452         {
3453                 SALOMEDS::SObject_var SO_Hypothesis =
3454                         smeshGUI->GetStudyAPI().FindHypothesisOrAlgorithms(AlgoOrHyp);
3455                 if (!SO_Hypothesis->_is_nil())
3456                 {
3457                         SALOMEDS::Study::ListOfSObject_var listSO =
3458                                 smeshGUI->myStudy->FindDependances(SO_Hypothesis);
3459                         for (unsigned int i = 0; i < listSO->length(); i++)
3460                         {
3461                                 SALOMEDS::SObject_var SO = listSO[i];
3462                                 if (!SO->_is_nil())
3463                                 {
3464                                         SALOMEDS::SObject_var SOfatherFather =
3465                                                 SO->GetFather()->GetFather();
3466                                         if (!SOfatherFather->_is_nil())
3467                                         {
3468                                                 index++;
3469                                                 listSOmesh->length(index);
3470                                                 listSOmesh[index - 1] = SOfatherFather;
3471                                         }
3472                                 }
3473                         }
3474                 }
3475         }
3476         return listSOmesh._retn();
3477 }
3478
3479 //=============================================================================
3480 /*!
3481  *
3482  */
3483 //=============================================================================
3484 void SMESHGUI::Import_Mesh(QAD_Desktop * parent, int theCommandID)
3485 {
3486         QString filter;
3487         string myExtension;
3488         Mesh_Reader *myReader;
3489
3490         if (theCommandID == 113)
3491         {
3492                 filter = tr("MED files (*.med)");
3493                 myExtension = string("MED");
3494                 myReader = new DriverMED_R_SMESHDS_Mesh;
3495         }
3496         else if (theCommandID == 112)
3497         {
3498                 filter = tr("IDEAS files (*.unv)");
3499                 myExtension = string("UNV");
3500         }
3501         else if (theCommandID == 111)
3502         {
3503                 filter = tr("DAT files (*.dat)");
3504                 myExtension = string("MED");
3505                 myReader = new DriverDAT_R_SMESHDS_Mesh;
3506         }
3507
3508         QString filename = QAD_FileDlg::getFileName(parent,
3509                 "",
3510                 filter,
3511                 tr("Import mesh"),
3512                 true);
3513         if (!filename.isEmpty())
3514         {
3515                 QApplication::setOverrideCursor(Qt::waitCursor);
3516                 string myClass = string("SMESHDS_Mesh");
3517 //    Mesh_Reader* myReader = SMESHDriver::GetMeshReader(myExtension, myClass);
3518
3519                 int myMeshId = (smeshGUI->myDocument)->NewMesh();
3520                 SMDS_Mesh *myMesh = (smeshGUI->myDocument)->GetMesh(myMeshId);
3521
3522                 myReader->SetFile(string(filename.latin1()));
3523                 myReader->SetMesh(myMesh);
3524                 myReader->SetMeshId(myMeshId);
3525                 myReader->Read();
3526
3527                 QApplication::restoreOverrideCursor();
3528         }
3529 }
3530
3531 //=============================================================================
3532 /*!
3533  *
3534  */
3535 //=============================================================================
3536 void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
3537 {
3538         SALOME_Selection *Sel =
3539                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->getSelection());
3540         int nbSel = Sel->IObjectCount();
3541         if (nbSel == 1)
3542         {
3543                 Standard_Boolean res;
3544                 Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
3545                 SMESH::SMESH_Mesh_var aMesh = smeshGUI->ConvertIOinMesh(IObject, res);
3546                 if (res)
3547                 {
3548                         if (theCommandID == 122)
3549                         {                                       // EXPORT MED
3550                                 QString filename = QAD_FileDlg::getFileName(parent,
3551                                         "",
3552                                         tr("MED files (*.med)"),
3553                                         tr("Export mesh"),
3554                                         false);
3555                                 if (!filename.isEmpty())
3556                                 {
3557                                         QApplication::setOverrideCursor(Qt::waitCursor);
3558                                         aMesh->ExportMED(filename.latin1());
3559                                         QApplication::restoreOverrideCursor();
3560                                 }
3561                         }
3562                         else if (theCommandID == 121)
3563                         {                                       // EXPORT DAT
3564                                 QString filename = QAD_FileDlg::getFileName(parent,
3565                                         "",
3566                                         tr("DAT files (*.dat)"),
3567                                         tr("Export mesh"),
3568                                         false);
3569                                 if (!filename.isEmpty())
3570                                 {
3571                                         QApplication::setOverrideCursor(Qt::waitCursor);
3572                                         aMesh->ExportDAT(filename.latin1());
3573                                         QApplication::restoreOverrideCursor();
3574                                 }
3575                         }
3576                         else if (theCommandID == 123)
3577                         {                                       // EXPORT UNV
3578                                 QString filename = QAD_FileDlg::getFileName(parent,
3579                                         "",
3580                                         tr("IDEAS files (*.unv)"),
3581                                         tr("Export mesh"),
3582                                         false);
3583                                 if (!filename.isEmpty())
3584                                 {
3585                                         QApplication::setOverrideCursor(Qt::waitCursor);
3586                                         aMesh->ExportUNV(filename.latin1());
3587                                         QApplication::restoreOverrideCursor();
3588                                 }
3589                                 else
3590                                         aMesh->ExportDAT(filename.latin1());
3591
3592                                 QApplication::restoreOverrideCursor();
3593
3594                                 if (IObject->hasEntry())
3595                                 {
3596                                         MESSAGE("---");
3597                                         SALOMEDS::SObject_var SO =
3598                                                 smeshGUI->myStudy->FindObjectID(IObject->getEntry());
3599                                         SALOMEDS::GenericAttribute_var anAttr;
3600                                         SALOMEDS::AttributeComment_var aFileName;
3601                                         SALOMEDS::StudyBuilder_var aStudyBuilder =
3602                                                 smeshGUI->myStudy->NewBuilder();
3603                                         anAttr =
3604                                                 aStudyBuilder->FindOrCreateAttribute(SO,
3605                                                 "AttributeComment");
3606                                         aFileName = SALOMEDS::AttributeComment::_narrow(anAttr);
3607                                         aFileName->SetValue(filename.latin1());
3608                                 }
3609                         }
3610                 }
3611         }
3612 }
3613
3614 //=============================================================================
3615 /*!
3616  *
3617  */
3618 //=============================================================================
3619 void SMESHGUI::Import_Document(QAD_Desktop * parent, int theCommandID)
3620 {
3621         QString filter;
3622         string myExtension;
3623         Document_Reader *myReader;
3624
3625         if (theCommandID == 113)
3626         {
3627                 filter = tr("MED files (*.med)");
3628                 myExtension = string("MED");
3629                 myReader = new DriverMED_R_SMESHDS_Document;
3630         }
3631         else if (theCommandID == 112)
3632         {
3633                 filter = tr("IDEAS files (*.unv)");
3634                 myExtension = string("UNV");
3635                 myReader = new DriverUNV_R_SMESHDS_Document;
3636         }
3637         else if (theCommandID == 111)
3638         {
3639                 filter = tr("DAT files (*.dat)");
3640                 myExtension = string("DAT");
3641                 myReader = new DriverDAT_R_SMESHDS_Document;
3642         }
3643
3644         QString filename = QAD_FileDlg::getFileName(parent,
3645                 "",
3646                 filter,
3647                 tr("Import document"),
3648                 true);
3649         if (!filename.isEmpty())
3650         {
3651                 QApplication::setOverrideCursor(Qt::waitCursor);
3652                 string myClass = string("SMESHDS_Document");
3653 //    Document_Reader* myReader = SMESHDriver::GetDocumentReader(myExtension, myClass);
3654                 SMESHDS_Document *newDocument = new SMESHDS_Document(1);
3655
3656                 myReader->SetFile(string(filename.latin1()));
3657                 myReader->SetDocument(smeshGUI->myDocument);
3658                 myReader->Read();
3659                 QApplication::restoreOverrideCursor();
3660         }
3661 }
3662
3663 void SMESHGUI::Export_Document(QAD_Desktop * parent, int theCommandID)
3664 {
3665         QString filter;
3666         Document_Writer *myWriter;
3667         string myExtension;
3668
3669         if (theCommandID == 122)
3670         {
3671                 filter = tr("MED files (*.med)");
3672                 myExtension = string("MED");
3673                 myWriter = new DriverMED_W_SMESHDS_Document;
3674         }
3675         else if (theCommandID == 121)
3676         {
3677                 filter = tr("DAT files (*.dat)");
3678                 myExtension = string("DAT");
3679                 myWriter = new DriverDAT_W_SMESHDS_Document;
3680         }
3681         else if (theCommandID == 123)
3682         {
3683                 filter = tr("IDEAS files (*.unv)");
3684                 myExtension = string("UNV");
3685                 myWriter = new DriverUNV_W_SMESHDS_Document;
3686         }
3687
3688         QString filename = QAD_FileDlg::getFileName(parent,
3689                 "",
3690                 filter,
3691                 tr("Export document"),
3692                 false);
3693         if (!filename.isEmpty())
3694         {
3695                 QApplication::setOverrideCursor(Qt::waitCursor);
3696                 string myClass = string("SMESHDS_Document");
3697                 //Document_Writer* myWriter = SMESHDriver::GetDocumentWriter(myExtension, myClass);
3698
3699                 myWriter->SetFile(string(filename.latin1()));
3700                 myWriter->SetDocument(smeshGUI->myDocument);
3701
3702                 //StudyContextStruct* myStudyContext = _impl.GetStudyContext(myStudyId);
3703                 //Handle(SMESHDS_Document) myDocument = myStudyContext->myDocument;
3704                 //myWriter->SetDocument(myDocument);
3705
3706                 myWriter->Write();
3707                 QApplication::restoreOverrideCursor();
3708         }
3709 }
3710
3711 //=============================================================================
3712 /*!
3713  *
3714  */
3715 //=============================================================================
3716 bool SMESHGUI::OnMousePress(QMouseEvent * pe, QAD_Desktop * parent,
3717         QAD_StudyFrame * studyFrame)
3718 {
3719         SMESHGUI::GetOrCreateSMESHGUI(parent);
3720         return false;
3721 }
3722
3723 //=============================================================================
3724 /*!
3725  *
3726  */
3727 //=============================================================================
3728 bool SMESHGUI::OnMouseMove(QMouseEvent * pe, QAD_Desktop * parent,
3729         QAD_StudyFrame * studyFrame)
3730 {
3731         SMESHGUI::GetOrCreateSMESHGUI(parent);
3732
3733         return true;
3734 }
3735
3736 //=============================================================================
3737 /*!
3738  *
3739  */
3740 //=============================================================================
3741 bool SMESHGUI::OnKeyPress(QKeyEvent * pe, QAD_Desktop * parent,
3742         QAD_StudyFrame * studyFrame)
3743 {
3744         SMESHGUI::GetOrCreateSMESHGUI(parent);
3745
3746         return true;
3747 }
3748
3749 //=============================================================================
3750 /*!
3751  *
3752  */
3753 //=============================================================================
3754 bool SMESHGUI::SetSettings(QAD_Desktop * parent)
3755 {
3756         SMESHGUI::GetOrCreateSMESHGUI(parent);
3757
3758         /* Display mode */
3759         QString DisplayMode = QAD_CONFIG->getSetting("SMESH:DisplayMode");
3760         if (DisplayMode.compare("") == 0)
3761         {
3762                 DisplayMode = "Shading";
3763                 QAD_CONFIG->addSetting("SMESH:DisplayMode", "Shading");
3764         }
3765
3766         if (DisplayMode.compare("Wireframe") == 0)
3767         {
3768                 parent->menuBar()->setItemChecked(10003, false);
3769                 parent->menuBar()->setItemChecked(10002, false);
3770                 parent->menuBar()->setItemChecked(10001, true);
3771         }
3772         else if (DisplayMode.compare("Shading") == 0)
3773         {
3774                 parent->menuBar()->setItemChecked(10003, false);
3775                 parent->menuBar()->setItemChecked(10002, true);
3776                 parent->menuBar()->setItemChecked(10001, false);
3777         }
3778         else if (DisplayMode.compare("Shrink") == 0)
3779         {
3780                 parent->menuBar()->setItemChecked(10003, true);
3781                 parent->menuBar()->setItemChecked(10002, false);
3782                 parent->menuBar()->setItemChecked(10001, false);
3783         }
3784
3785         /* Automatic Update */
3786         QString AutoUpdate = QAD_CONFIG->getSetting("SMESH:AutomaticUpdate");
3787         if (AutoUpdate.compare("true") == 0)
3788         {
3789                 parent->menuBar()->setItemChecked(1001, true);
3790                 smeshGUI->myAutomaticUpdate = true;
3791         }
3792         else
3793         {
3794                 parent->menuBar()->setItemChecked(1001, false);
3795                 smeshGUI->myAutomaticUpdate = false;
3796         }
3797
3798         /* menus disable */
3799         parent->menuBar()->setItemEnabled(11, false);   // IMPORT
3800
3801         return true;
3802 }
3803
3804 //=============================================================================
3805 /*!
3806  *
3807  */
3808 //=============================================================================
3809 void SMESHGUI::DefinePopup(QString & theContext, QString & theParent,
3810         QString & theObject)
3811 {
3812         /* Create or retrieve an object SMESHGUI */
3813         SMESHGUI::GetOrCreateSMESHGUI(QAD_Application::getDesktop());
3814
3815         // NRI : Temporary added
3816         //  if ( smeshGUI->myStudy->GetProperties()->IsLocked() ) {
3817         //    theObject = "NothingSelected";
3818         //    theContext = "NothingSelected";
3819         //  }
3820         // NRI
3821
3822         SALOME_Selection *Sel =
3823                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->getSelection());
3824         int nbSel = Sel->IObjectCount();
3825         if (nbSel == 0)
3826         {
3827                 if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() ==
3828                         VIEW_VTK)
3829                 {
3830                         vtkScalarBarActor *aScalarBar = smeshGUI->GetScalarBar();
3831                         if ((aScalarBar != NULL) && (aScalarBar->GetVisibility() == 1))
3832                         {
3833                                 theObject = "ScalarBar";
3834                                 theContext = "";
3835                         }
3836                         else
3837                         {
3838                                 theObject = "NothingSelected";
3839                                 theContext = "NothingSelected";
3840                         }
3841                 }
3842                 else
3843                 {
3844                         theObject = "NothingSelected";
3845                         theContext = "NothingSelected";
3846                 }
3847         }
3848         else if (nbSel == 1)
3849         {
3850                 theObject = smeshGUI->CheckTypeObject(Sel->firstIObject());
3851                 theContext = "";
3852         }
3853         else
3854         {
3855                 theObject = smeshGUI->CheckHomogeneousSelection();
3856                 theContext = "";
3857         }
3858 }
3859
3860 //=============================================================================
3861 /*!
3862  *
3863  */
3864 //=============================================================================
3865 bool SMESHGUI::CustomPopup(QAD_Desktop * parent,
3866         QPopupMenu * popup,
3867         const QString & theContext,
3868         const QString & theParent, const QString & theObject)
3869 {
3870         // Popup should be customized for any viewer since some meaningless commands may be present in the popup
3871         //if (smeshGUI->myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK) //Test du type de viewer true=OCC false=VTK
3872         //  return false;
3873         /* Create or retrieve an object SMESHGUI */
3874         SMESHGUI::GetOrCreateSMESHGUI(parent);
3875
3876         // NRI : Temporary added
3877         //  if ( smeshGUI->myStudy->GetProperties()->IsLocked() ) {
3878         //    return false;
3879         //  }
3880         // NRI
3881
3882         SALOME_Selection *Sel =
3883                 SALOME_Selection::Selection(smeshGUI->myActiveStudy->getSelection());
3884         QAD_StudyFrame *studyFrame = smeshGUI->myActiveStudy->getActiveStudyFrame();
3885         int nbSel = Sel->IObjectCount();
3886
3887         if (nbSel == 0)
3888         {
3889                 if (studyFrame->getTypeView() != VIEW_VTK)
3890                         popup->clear();
3891                 return false;
3892         }
3893         else if (nbSel == 1)
3894         {
3895                 QString parentComp =
3896                         ((SALOMEGUI_Desktop *) parent)->getComponentFromSelection();
3897                 // First check type of active viewer (VTK required)
3898                 if ( /*studyFrame->getTypeView() != VIEW_VTK || */ parentComp !=
3899                         parent->getActiveComponent())
3900                 {
3901                         //MESSAGE("CustomPopup(): VTK viewer required, removing all SMESH-specific popup menu items")
3902                         while (1)
3903                         {
3904                                 int id = popup->idAt(0);
3905                                 if (id <= QAD_TopLabel_Popup_ID)
3906                                         popup->removeItemAt(0);
3907                                 else
3908                                         break;
3909                         }
3910                         if (theObject.compare("Component") == 0)
3911                         {
3912                                 popup->removeItem(QAD_DisplayOnly_Popup_ID);
3913                         }
3914                         return false;
3915                 }
3916
3917                 // Remove common popup items for Submesh, Hypothesis and Algorithm
3918                 if (theObject.compare("SubMesh") == 0 ||
3919                         theObject.compare("Hypothesis") == 0 ||
3920                         theObject.compare("Algorithm") == 0)
3921                 {
3922                         popup->removeItem(QAD_Display_Popup_ID);
3923                         popup->removeItem(QAD_DisplayOnly_Popup_ID);
3924                         popup->removeItem(QAD_Erase_Popup_ID);
3925                         int id = popup->idAt(popup->count() - 1);       // last item
3926                         if (id < 0 && id != -1)
3927                                 popup->removeItem(id);  // separator
3928                 }
3929
3930                 if (theObject.compare("Component") == 0)
3931                 {
3932                         popup->removeItem(QAD_DisplayOnly_Popup_ID);
3933                         return true;
3934                 }
3935
3936                 int id = QAD_TopLabel_Popup_ID; //popup->idAt(0);
3937                 QFont f = QApplication::font();
3938                 f.setBold(TRUE);
3939
3940                 Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
3941
3942                 if (theParent.compare("Viewer") == 0)
3943                 {
3944                         if (popup->idAt(0) == id)
3945                         {
3946                                 popup->removeItem(id);
3947                                 popup->insertItem(new CustomItem(QString(IObject->getName()),
3948                                                 f), id, 0);
3949                         }
3950
3951                         Standard_Boolean res;
3952                         SMESH_Actor *ac =
3953                                 smeshGUI->FindActorByEntry(IObject->getEntry(), res, false);
3954                         if (res && studyFrame->getTypeView() == VIEW_VTK)
3955                         {
3956                                 VTKViewer_RenderWindowInteractor *myRenderInter =
3957                                         ((VTKViewer_ViewFrame *) studyFrame->getRightFrame()->
3958                                         getViewFrame())->getRWInteractor();
3959                                 if (myRenderInter->isVisible(IObject))
3960                                 {
3961                                         popup->removeItem(QAD_Display_Popup_ID);
3962                                 }
3963                                 else
3964                                 {
3965                                         popup->removeItem(QAD_Erase_Popup_ID);
3966                                 }
3967                         }
3968                         else
3969                         {
3970                                 popup->removeItem(QAD_Erase_Popup_ID);
3971                                 if (!res)
3972                                 {                               // mesh not computed -> can't display it
3973                                         popup->removeItem(QAD_Display_Popup_ID);
3974                                         popup->removeItem(QAD_DisplayOnly_Popup_ID);
3975                                         popup->removeItemAt(popup->count() - 1);        //separator
3976                                 }
3977                         }
3978                 }
3979                 else if (theParent.compare("ObjectBrowser") == 0)
3980                 {
3981                         if (theObject.compare("Mesh") == 0 ||
3982                                 theObject.compare("SubMesh") == 0 ||
3983                                 theObject.compare("Hypothesis") == 0 ||
3984                                 theObject.compare("Algorithm") == 0)
3985                         {
3986                                 popup->removeItemAt(0);
3987                         }
3988                         else
3989                         {
3990                                 if (popup->idAt(0) == id)
3991                                 {
3992                                         popup->removeItem(id);
3993                                         popup->removeItemAt(0); //separator
3994                                 }
3995                         }
3996
3997                         Standard_Boolean res;
3998                         SMESH_Actor *ac =
3999                                 smeshGUI->FindActorByEntry(IObject->getEntry(), res, false);
4000                         if (res && studyFrame->getTypeView() == VIEW_VTK)
4001                         {
4002                                 VTKViewer_RenderWindowInteractor *myRenderInter =
4003                                         ((VTKViewer_ViewFrame *) studyFrame->getRightFrame()->
4004                                         getViewFrame())->getRWInteractor();
4005                                 if (myRenderInter->isVisible(IObject))
4006                                 {
4007                                         popup->removeItem(QAD_Display_Popup_ID);
4008                                 }
4009                                 else
4010                                 {
4011                                         popup->removeItem(QAD_Erase_Popup_ID);
4012                                 }
4013                         }
4014                         else
4015                         {
4016                                 if (theObject.compare("Mesh") == 0 ||
4017                                         theObject.compare("SubMesh") == 0 ||
4018                                         theObject.compare("Hypothesis") == 0 ||
4019                                         theObject.compare("Algorithm") == 0)
4020                                 {
4021                                 }
4022                                 else
4023                                 {
4024                                         popup->removeItem(QAD_Erase_Popup_ID);
4025                                         if (!res)
4026                                         {                       // mesh not computed -> can't display it
4027                                                 popup->removeItem(QAD_Display_Popup_ID);
4028                                                 popup->removeItem(QAD_DisplayOnly_Popup_ID);
4029                                                 popup->removeItemAt(popup->count() - 1);        //separator
4030                                         }
4031                                 }
4032                         }
4033                 }
4034         }
4035         else
4036         {
4037                 QString parentComp =
4038                         ((SALOMEGUI_Desktop *) parent)->getComponentFromSelection();
4039                 QAD_StudyFrame *studyFrame =
4040                         smeshGUI->myActiveStudy->getActiveStudyFrame();
4041                 if ( /*studyFrame->getTypeView() != VIEW_VTK || */ parentComp !=
4042                         parent->getActiveComponent())
4043                 {
4044                         //MESSAGE("CustomPopup(): VTK viewer required, removing all SMESH-specific popup menu items")
4045                         while (1)
4046                         {
4047                                 int id = popup->idAt(0);
4048                                 if (id <= QAD_TopLabel_Popup_ID && id != -1)
4049                                         popup->removeItemAt(0);
4050                                 else
4051                                         break;
4052                         }
4053                         if (parentComp.isNull())
4054                         {                                       // objects from several components are selected
4055                                 popup->removeItem(QAD_DisplayOnly_Popup_ID);
4056                                 popup->removeItem(QAD_Display_Popup_ID);
4057                                 popup->removeItem(QAD_Erase_Popup_ID);
4058                                 int id = popup->idAt(popup->count() - 1);       // last item
4059                                 if (id < 0 && id != -1)
4060                                         popup->removeItem(id);  // separator
4061                         }
4062                         return false;
4063                 }
4064
4065                 QString type = smeshGUI->CheckHomogeneousSelection();
4066                 if (type.compare("Heterogeneous Selection") != 0)
4067                 {
4068                         int id = QAD_TopLabel_Popup_ID; //popup->idAt(0);
4069                         QFont f = QApplication::font();
4070                         f.setBold(TRUE);
4071                         popup->removeItem(id);
4072                         popup->insertItem(new CustomItem(QString("%1 ").arg(nbSel) + type +
4073                                         " (s) ", f), id, 0);
4074                 }
4075         }
4076         return false;
4077 }
4078
4079 //=============================================================================
4080 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4081  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4082  */
4083 //=============================================================================
4084 void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
4085 {
4086         /* Create or retrieve an object SMESHGUI */
4087         SMESHGUI::GetOrCreateSMESHGUI(QAD_Application::getDesktop());
4088
4089         QAD_StudyFrame *activeFrame =
4090                 smeshGUI->myActiveStudy->getActiveStudyFrame();
4091         if (activeFrame->getTypeView() == VIEW_VTK)
4092         {
4093                 // VTK
4094                 SALOMEDS::SObject_var fatherSF =
4095                         smeshGUI->myStudy->FindObjectID(activeFrame->entry());
4096
4097                 SALOME_Selection *Sel =
4098                         SALOME_Selection::Selection(smeshGUI->myActiveStudy->
4099                         getSelection());
4100                 SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
4101
4102 //    for(;It.More();It.Next()) {
4103 //      Handle(SALOME_InteractiveObject) IObject = It.Value();
4104                 Handle(SALOME_InteractiveObject) IObject = theIO;
4105                 if (IObject->hasEntry())
4106                 {
4107                         // Look for the actor in all views
4108                         Standard_Boolean res;
4109                         SMESH_Actor *ac =
4110                                 smeshGUI->FindActorByEntry(IObject->getEntry(), res, false);
4111
4112                         // Actor not found at all -> mesh is not computed -> do nothing!!!
4113                         if (!res)
4114                         {
4115                                 /*SMESH::SMESH_Mesh_var aM;
4116                                  * SALOMEDS::SObject_var aMorSM = smeshGUI->myStudy->FindObjectID( IObject->getEntry() );
4117                                  * SALOMEDS::SObject_var father = aMorSM->GetFather();
4118                                  * SALOMEDS::SObject_var fatherComp = aMorSM->GetFatherComponent();
4119                                  *
4120                                  * // Non-displayable objects (Hypo, Algo) have tags < 3 or have a father different from component
4121                                  * if (aMorSM->Tag() < 3 || strcmp(father->GetID(), fatherComp->GetID()) != 0)
4122                                  * continue;
4123                                  *
4124                                  * SALOMEDS::GenericAttribute_var anAttr;
4125                                  * SALOMEDS::AttributeIOR_var     anIOR;
4126                                  * if ( !aMorSM->_is_nil() ) {
4127                                  * if (aMorSM->FindAttribute(anAttr, "AttributeIOR") ) {
4128                                  * anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
4129                                  * aM = SMESH::SMESH_Mesh::_narrow( _orb->string_to_object(anIOR->Value()) );
4130                                  * }
4131                                  * }
4132                                  *
4133                                  * if (!aM->_is_nil()) {
4134                                  * smeshGUI->InitActor(aM);
4135                                  * ac = smeshGUI->ReadScript(aM);
4136                                  * }
4137                                  *
4138                                  * if (ac) {
4139                                  * smeshGUI->DisplayActor( ac, true );
4140                                  * smeshGUI->DisplayEdges( ac );
4141                                  * smeshGUI->ChangeRepresentation( ac, ac->getDisplayMode() );
4142                                  * } */
4143 //    continue;
4144                         }
4145                         else
4146                         {                                       // The actor exists in some view
4147                                 // Check whether the actor belongs to the active view
4148                                 VTKViewer_RenderWindowInteractor *rwInter =
4149                                         ((VTKViewer_ViewFrame *) activeFrame->getRightFrame()->
4150                                         getViewFrame())->getRWInteractor();
4151
4152                                 // The actor belongs to inactive view -> create a copy and display it in the active view
4153                                 if (!rwInter->isInViewer(IObject))
4154                                 {
4155                                         SMESH_Actor *acCopy = SMESH_Actor::New();
4156                                         acCopy->ShallowCopy(ac);
4157                                         ac = acCopy;
4158                                 }
4159                                 smeshGUI->DisplayActor(ac, false);
4160                                 smeshGUI->DisplayEdges(ac);
4161                                 smeshGUI->ChangeRepresentation(ac, ac->getDisplayMode());
4162                         }
4163                 }
4164 //    }
4165         }
4166         else
4167         {
4168         MESSAGE
4169                         ("BuildPresentation() must not be called while non-VTK view is active")}
4170 }
4171
4172 //=============================================================================
4173 /*!
4174  *
4175  */
4176 //=============================================================================
4177 void SMESHGUI::setOrb()
4178 {
4179         try
4180         {
4181                 ORB_INIT & init = *SINGLETON_ < ORB_INIT >::Instance();
4182                 ASSERT(SINGLETON_ < ORB_INIT >::IsAlreadyExisting());
4183                 _orb = init(0, 0);
4184         } catch(...)
4185         {
4186                 INFOS("internal error : orb not found");
4187                 _orb = 0;
4188         }
4189         ASSERT(!CORBA::is_nil(_orb));
4190 }
4191
4192 //=============================================================================
4193 /*!
4194  *
4195  */
4196 //=============================================================================
4197 SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
4198 {
4199         SMESH_Actor *MeshActor;
4200         if (!aMesh->_is_nil())
4201         {
4202                 Standard_Boolean result;
4203                 MeshActor = FindActor(aMesh, result, true);
4204                 if (result)
4205                 {
4206                         SMESH::log_array_var aSeq = aMesh->GetLog(true);
4207
4208                         if (aSeq->length() == 0)
4209                         {
4210                                 MESSAGE("ReadScript(): log is empty") return MeshActor;
4211                         }
4212
4213                         for (unsigned int ind = 0; ind < aSeq->length(); ind++)
4214                         {
4215                                 switch (aSeq[ind].commandType)
4216                                 {
4217                                 case SMESH::ADD_NODE:
4218                                 {
4219                                         AddNodes(MeshActor, aSeq[ind].number, aSeq[ind].coords,
4220                                                 aSeq[ind].indexes);
4221                                         break;
4222                                 }
4223                                 case SMESH::ADD_EDGE:
4224                                 {
4225                                         //          AddEdges( MeshActor, aSeq[ind].number, aSeq[ind].coords, aSeq[ind].indexes );
4226                                         break;
4227                                 }
4228                                 case SMESH::ADD_TRIANGLE:
4229                                 {
4230                                         AddTriangles(MeshActor, aSeq[ind].number, aSeq[ind].coords,
4231                                                 aSeq[ind].indexes);
4232                                         break;
4233                                 }
4234                                 case SMESH::ADD_QUADRANGLE:
4235                                 {
4236                                         AddQuadrangles(MeshActor, aSeq[ind].number,
4237                                                 aSeq[ind].coords, aSeq[ind].indexes);
4238                                         break;
4239                                 }
4240                                 case SMESH::ADD_TETRAHEDRON:
4241                                 {
4242                                         AddTetras(MeshActor, aSeq[ind].number, aSeq[ind].coords,
4243                                                 aSeq[ind].indexes);
4244                                         break;
4245                                 }
4246                                 case SMESH::ADD_PYRAMID:
4247                                 {
4248                                         break;
4249                                 }
4250                                 case SMESH::ADD_PRISM:
4251                                 {
4252                                         break;
4253                                 }
4254                                 case SMESH::ADD_HEXAHEDRON:
4255                                 {
4256                                         AddHexaedres(MeshActor, aSeq[ind].number, aSeq[ind].coords,
4257                                                 aSeq[ind].indexes);
4258                                         break;
4259                                 }
4260                                 case SMESH::REMOVE_NODE:
4261                                 {
4262                                         RemoveNodes(MeshActor, aSeq[ind].number, aSeq[ind].coords,
4263                                                 aSeq[ind].indexes);
4264                                         break;
4265                                 }
4266                                 case SMESH::REMOVE_ELEMENT:
4267                                 {
4268                                         RemoveElements(MeshActor, aSeq[ind].number,
4269                                                 aSeq[ind].coords, aSeq[ind].indexes);
4270                                         break;
4271                                 }
4272                                 }
4273                         }
4274                         return MeshActor;
4275                 }
4276         }
4277         return NULL;
4278 }
4279
4280 //=============================================================================
4281 /*!
4282  *
4283  */
4284 //=============================================================================
4285 void SMESHGUI::Dump(SMESH_Actor * Mactor)
4286 {
4287         vtkUnstructuredGrid *ugrid =
4288                 vtkUnstructuredGrid::SafeDownCast(Mactor->DataSource);
4289         vtkPoints *Pts = ugrid->GetPoints();
4290         int nbPts = Pts->GetNumberOfPoints();
4291         int nbCells = ugrid->GetNumberOfCells();
4292
4293         FILE *In;
4294         int i, j;
4295         In = fopen("/tmp/dumpMesh", "w+");
4296         fprintf(In, "%d %d\n", nbPts, nbCells);
4297         for (int i = 0; i < nbPts; i++)
4298         {
4299                 float *p = ugrid->GetPoint(i);
4300                 fprintf(In, "%d %e %e %e\n", i, p[0], p[1], p[2]);
4301         }
4302
4303         for (int i = 0; i < nbCells; i++)
4304         {
4305                 fprintf(In, "%d %d", i, ugrid->GetCell(i)->GetCellType());
4306                 vtkIdList *Id = ugrid->GetCell(i)->GetPointIds();
4307                 for (j = 0; j < Id->GetNumberOfIds(); j++)
4308                 {
4309                         fprintf(In, " %d", Id->GetId(j));
4310                 }
4311                 fprintf(In, "\n");
4312         }
4313         fclose(In);
4314 }
4315
4316 //=============================================================================
4317 /*!
4318  *
4319  */
4320 //=============================================================================
4321 void SMESHGUI::AddNodes(SMESH_Actor * Mactor, int number,
4322         const SMESH::double_array & coords, const SMESH::long_array & indexes)
4323 {
4324         QApplication::setOverrideCursor(Qt::waitCursor);
4325         if (Mactor->GetMapper() == NULL)
4326         {
4327                 vtkPoints *Pts = vtkPoints::New();
4328                 SMESH_Grid *ugrid = SMESH_Grid::New();
4329                 ugrid->Allocate();
4330
4331                 int i = 1;
4332                 int j = 1;
4333                 while (i <= number)
4334                 {
4335                         int idVTK =
4336                                 Pts->InsertNextPoint(coords[j - 1], coords[j], coords[j + 1]);
4337                         //Mactor->AddNode( indexes[i-1], idVTK );
4338                         ugrid->AddNode(indexes[i - 1], idVTK);
4339                         i++;
4340                         j = j + 3;
4341                 }
4342                 //vtkUnstructuredGrid *ugrid = vtkUnstructuredGrid::New();
4343                 ugrid->SetPoints(Pts);
4344                 vtkDataSetMapper *PtsMapper = vtkDataSetMapper::New();
4345                 PtsMapper->SetInput(ugrid);
4346                 Mactor->DataSource = PtsMapper->GetInput();
4347                 Mactor->SetMapper(PtsMapper);
4348         }
4349         else
4350         {
4351                 //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
4352                 SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
4353                 int i = 1;
4354                 int j = 1;
4355                 while (i <= number)
4356                 {
4357                         int idVTK =
4358                                 ugrid->GetPoints()->InsertNextPoint(coords[j - 1], coords[j],
4359                                 coords[j + 1]);
4360                         ugrid->AddNode(indexes[i - 1], idVTK);
4361                         i++;
4362                         j = j + 3;
4363                 }
4364                 vtkDataSetMapper *PtsMapper = vtkDataSetMapper::New();
4365                 PtsMapper->SetInput(ugrid);
4366                 Mactor->DataSource = PtsMapper->GetInput();
4367                 Mactor->SetMapper(PtsMapper);
4368         }
4369         QApplication::restoreOverrideCursor();
4370 }
4371
4372 //=============================================================================
4373 /*!
4374  *
4375  */
4376 //=============================================================================
4377 void SMESHGUI::AddNode(SMESH_Actor * Mactor, int idnode, float x, float y,
4378         float z)
4379 {
4380         QApplication::setOverrideCursor(Qt::waitCursor);
4381         MESSAGE("SMESHGUI::AddNode " << idnode << " : " << x << ";" << y << ";" <<
4382                 z) if (Mactor->GetMapper() == NULL)
4383         {
4384                 vtkPoints *Pts = vtkPoints::New();
4385                 int idVTK = Pts->InsertNextPoint(x, y, z);
4386                 //Mactor->AddNode( idnode, idVTK );
4387                 //vtkUnstructuredGrid *ugrid = vtkUnstructuredGrid::New();
4388                 SMESH_Grid *ugrid = SMESH_Grid::New();
4389                 ugrid->Allocate();
4390                 ugrid->AddNode(idnode, idVTK);
4391                 ugrid->SetPoints(Pts);
4392                 vtkDataSetMapper *PtsMapper = vtkDataSetMapper::New();
4393                 PtsMapper->SetInput(ugrid);
4394                 Mactor->DataSource = PtsMapper->GetInput();
4395                 Mactor->SetMapper(PtsMapper);
4396         }
4397         else
4398         {
4399                 //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
4400                 SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
4401                 int idVTK = ugrid->GetPoints()->InsertNextPoint(x, y, z);
4402                 //Mactor->AddNode( idnode, idVTK );
4403                 ugrid->AddNode(idnode, idVTK);
4404                 vtkDataSetMapper *PtsMapper = vtkDataSetMapper::New();
4405                 PtsMapper->SetInput(ugrid);
4406                 Mactor->DataSource = PtsMapper->GetInput();
4407                 Mactor->SetMapper(PtsMapper);
4408         }
4409         QApplication::restoreOverrideCursor();
4410 }
4411
4412 //=============================================================================
4413 /*!
4414  *
4415  */
4416 //=============================================================================
4417 void SMESHGUI::RemoveNode(SMESH_Actor * Mactor, int idnode)
4418 {
4419         MESSAGE(" OLD RemoveNode method ")
4420 //   int id = Mactor->GetIdVTKNode( idnode );
4421 //    MESSAGE ( " RemoveNode id VTK " << id )
4422 //    if ( Mactor->GetMapper() != NULL ) {
4423 //      vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
4424 //      vtkUnstructuredGrid* newUgrid = vtkUnstructuredGrid::New();
4425 //      vtkPoints *Pts = ugrid->GetPoints();
4426 //      vtkPoints *newPts = vtkPoints::New();
4427 //      int nbPts = Pts->GetNumberOfPoints();
4428 //      bool findPt = false;
4429 //      for ( int i = 0; i < nbPts; i++ ) {
4430 //        if ( id != i ) {
4431 //      if ( !findPt)
4432 //        newPts->InsertPoint(i, Pts->GetPoint(i) );
4433 //      else
4434 //        newPts->InsertPoint(i-1, Pts->GetPoint(i) );
4435 //        } else {
4436 //      findPt = true;
4437 //      Mactor->RemoveNode( idnode );
4438 //        }
4439 //      }
4440 //      newUgrid->SetPoints(newPts);
4441 //      int nbCells = ugrid->GetNumberOfCells();
4442 //      for ( int i = 0; i < nbCells; i++ ) {
4443 //        vtkIdList *Ids = ugrid->GetCell(i)->GetPointIds();
4444 //        vtkIdList *newIds = vtkIdList::New();
4445 //        int nbIds = Ids->GetNumberOfIds();
4446 //        newIds->SetNumberOfIds(nbIds);
4447 //        for ( int j = 0; j < nbIds; j++ ) {
4448 //      int theid = Ids->GetId(j);
4449 //      if ( theid > id ) {
4450 //        newIds->SetId( j, theid-1 );
4451 //      } else
4452 //        newIds->SetId( j, theid );
4453 //        }
4454 //        int idSMDSel = Mactor->GetIdSMESHDSElement( i );
4455 //        Mactor->RemoveElement( idSMDSel, false );
4456 //        int idVTKel = newUgrid->InsertNextCell( ugrid->GetCell(i)->GetCellType(), newIds );
4457 //        Mactor->AddElement( idSMDSel, idVTKel );
4458 //      }
4459 //      vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
4460 //      Mapper->SetInput( newUgrid );
4461 //      Mactor->DataSource = Mapper->GetInput();
4462 //      Mactor->SetMapper(Mapper);
4463 //      UpdateView();
4464 //    }
4465 }
4466
4467 //=============================================================================
4468 /*!
4469  *
4470  */
4471 //=============================================================================
4472 void SMESHGUI::RemoveNodes(SMESH_Actor * Mactor, int number,
4473         const SMESH::double_array & coords, const SMESH::long_array & indexes)
4474 {
4475         QApplication::setOverrideCursor(Qt::waitCursor);
4476         int i = 1;
4477         while (i <= number)
4478         {
4479                 Mactor->RemoveNode(indexes[i - 1]);
4480                 i++;
4481         }
4482
4483         TColStd_DataMapOfIntegerInteger newMapVTKNodes;
4484         TColStd_DataMapOfIntegerInteger newMapSMESHDSNodes;
4485         TColStd_DataMapOfIntegerInteger MapOldNodesToNewNodes;
4486
4487         if (Mactor->GetMapper() != NULL)
4488         {
4489                 SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
4490                 SMESH_Grid *newUgrid = SMESH_Grid::New();
4491                 newUgrid->CopyMaps(ugrid);
4492
4493                 vtkPoints *Pts = ugrid->GetPoints();
4494                 vtkPoints *newPts = vtkPoints::New();
4495                 int nbPts = Pts->GetNumberOfPoints();
4496                 int j = 0;
4497                 for (int i = 0; i < nbPts; i++)
4498                 {
4499                         int idSMESHDSNode = Mactor->GetIdSMESHDSNode(i);
4500                         if (idSMESHDSNode != -1)
4501                         {
4502                                 newPts->InsertPoint(j, Pts->GetPoint(i));
4503
4504                                 newMapVTKNodes.Bind(j, idSMESHDSNode);
4505                                 newMapSMESHDSNodes.Bind(idSMESHDSNode, j);
4506
4507                                 MapOldNodesToNewNodes.Bind(i, j);
4508                                 j++;
4509                         }
4510                 }
4511
4512                 newUgrid->SetIdsVTKNode(newMapVTKNodes);
4513                 newUgrid->SetIdsSMESHDSNode(newMapSMESHDSNodes);
4514                 newUgrid->SetPoints(newPts);
4515
4516                 TColStd_DataMapOfIntegerInteger newMapElementSMDStoVTK;
4517                 TColStd_DataMapOfIntegerInteger newMapElementVTKtoSMDS;
4518
4519                 int nbCells = ugrid->GetNumberOfCells();
4520                 for (int i = 0; i < nbCells; i++)
4521                 {
4522                         vtkIdList *Ids = ugrid->GetCell(i)->GetPointIds();
4523                         vtkIdList *newIds = vtkIdList::New();
4524                         int nbIds = Ids->GetNumberOfIds();
4525                         newIds->SetNumberOfIds(nbIds);
4526                         bool isGood = true;
4527                         for (int j = 0; j < nbIds; j++)
4528                         {
4529                                 int theid = Ids->GetId(j);
4530                                 if (MapOldNodesToNewNodes.IsBound(theid))
4531                                 {
4532                                         newIds->SetId(j, MapOldNodesToNewNodes.Find(theid));
4533                                 }
4534                                 else
4535                                 {
4536                                         isGood = false;
4537                                         break;
4538                                 }
4539                         }
4540
4541                         // Filtering out cells based on non-existing nodes
4542                         if (isGood)
4543                         {
4544                                 int idSMDSel = Mactor->GetIdSMESHDSElement(i);
4545                                 int idVTKel =
4546                                         newUgrid->InsertNextCell(ugrid->GetCell(i)->GetCellType(),
4547                                         newIds);
4548
4549                                 newMapElementSMDStoVTK.Bind(idSMDSel, idVTKel);
4550                                 newMapElementVTKtoSMDS.Bind(idVTKel, idSMDSel);
4551                         }
4552                 }
4553
4554                 newUgrid->SetIdsVTKElement(newMapElementVTKtoSMDS);
4555                 newUgrid->SetIdsSMESHDSElement(newMapElementSMDStoVTK);
4556
4557                 // Copy new data to the old DatSource: keep the single DataSource for all actors
4558                 ugrid->DeepCopy(newUgrid);
4559
4560                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
4561                 Mapper->SetInput(ugrid);
4562                 Mactor->SetMapper(Mapper);
4563
4564                 // Commented to avoid multiple viewer updates when called by ReadScript()
4565                 //UpdateView();
4566
4567         }
4568         QApplication::restoreOverrideCursor();
4569 }
4570
4571 //=============================================================================
4572 /*!
4573  *
4574  */
4575 //=============================================================================
4576 void SMESHGUI::RemoveNodes(SMESH::SMESH_Mesh_ptr aMesh,
4577         const TColStd_MapOfInteger & MapIndex)
4578 {
4579         QApplication::setOverrideCursor(Qt::waitCursor);
4580         Standard_Boolean result;
4581         SMESH_Actor *ac = FindActor(aMesh, result, true);
4582         if (result)
4583         {
4584                 SMESH::long_array_var anArrayOfIdeces = new SMESH::long_array;
4585                 anArrayOfIdeces->length(MapIndex.Extent());
4586                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
4587                 int i = 0;
4588                 for (; ite.More(); ite.Next())
4589                 {
4590                         //      MESSAGE ( " RemoveNode : id " << ac->GetIdSMESHDSNode(ite.Key()) )
4591                         anArrayOfIdeces[i] = ac->GetIdSMESHDSNode(ite.Key());
4592                         i++;
4593                 }
4594                 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
4595                 aMeshEditor->RemoveNodes(anArrayOfIdeces);
4596
4597         }
4598         if (myAutomaticUpdate)
4599         {
4600                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
4601                 if (Mesh != NULL)
4602                 {
4603                         smeshGUI->DisplayActor(Mesh);
4604                         smeshGUI->DisplayEdges(Mesh);
4605                         smeshGUI->ChangeRepresentation(Mesh, Mesh->getDisplayMode());
4606                         AddActorInSelection(Mesh);
4607                 }
4608         }
4609         QApplication::restoreOverrideCursor();
4610 }
4611
4612 //=============================================================================
4613 /*!
4614  *
4615  */
4616 //=============================================================================
4617 void SMESHGUI::RemoveElement(SMESH_Actor * Mactor, int idelement)
4618 {
4619         MESSAGE(" OLD RemoveElement method ")
4620 //    int id = Mactor->GetIdVTKElement( idelement );
4621 //    MESSAGE ( " RemoveElement id VTK : " << id )
4622 //    if ( Mactor->GetMapper() != NULL ) {
4623 //      vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
4624 //      vtkUnstructuredGrid* newUgrid = vtkUnstructuredGrid::New();
4625 //      int nbCells = ugrid->GetNumberOfCells();
4626 //      for ( int i = 0; i < nbCells; i++ ) {
4627 //        if ( id != i ) {
4628 //      newUgrid->InsertNextCell( ugrid->GetCell(i)->GetCellType(),
4629 //                    ugrid->GetCell(i)->GetPointIds() );
4630 //        } else
4631 //      Mactor->RemoveElement( idelement );
4632 //      }
4633 //      newUgrid->SetPoints(ugrid->GetPoints());
4634 //      vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
4635 //      Mapper->SetInput( newUgrid );
4636 //      Mactor->DataSource = Mapper->GetInput();
4637 //      Mactor->SetMapper(Mapper);
4638 //      UpdateView();
4639 //    }
4640 }
4641
4642 //=============================================================================
4643 /*!
4644  *
4645  */
4646 //=============================================================================
4647 void SMESHGUI::RemoveElements(SMESH_Actor * Mactor, int number,
4648         const SMESH::double_array & coords, const SMESH::long_array & indexes)
4649 {
4650         QApplication::setOverrideCursor(Qt::waitCursor);
4651         int i = 1;
4652         while (i <= number)
4653         {
4654                 Mactor->RemoveElement(indexes[i - 1]);
4655                 i++;
4656         }
4657         TColStd_DataMapOfIntegerInteger newMapElementSMDStoVTK;
4658         TColStd_DataMapOfIntegerInteger newMapElementVTKtoSMDS;
4659
4660         if (Mactor->GetMapper() != NULL)
4661         {
4662                 SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
4663                 SMESH_Grid *newUgrid = SMESH_Grid::New();
4664                 newUgrid->CopyMaps(ugrid);
4665
4666                 int nbCells = ugrid->GetNumberOfCells();
4667                 for (int i = 0; i < nbCells; i++)
4668                 {
4669                         int idSMESHDSElement = Mactor->GetIdSMESHDSElement(i);
4670                         if (idSMESHDSElement != -1)
4671                         {
4672                                 int newId =
4673                                         newUgrid->InsertNextCell(ugrid->GetCell(i)->GetCellType(),
4674                                         ugrid->GetCell(i)->GetPointIds());
4675                                 newMapElementSMDStoVTK.Bind(idSMESHDSElement, newId);
4676                                 newMapElementVTKtoSMDS.Bind(newId, idSMESHDSElement);
4677                         }
4678                 }
4679
4680                 newUgrid->SetIdsVTKElement(newMapElementVTKtoSMDS);
4681                 newUgrid->SetIdsSMESHDSElement(newMapElementSMDStoVTK);
4682
4683                 newUgrid->SetPoints(ugrid->GetPoints());
4684
4685                 // Copy new data to the old DatSource: keep the single DataSource for all actors
4686                 ugrid->DeepCopy(newUgrid);
4687
4688                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
4689                 Mapper->SetInput(ugrid);
4690                 Mactor->SetMapper(Mapper);
4691
4692                 // Commented to avoid multiple viewer updates when called by ReadScript()
4693                 //UpdateView();
4694         }
4695         QApplication::restoreOverrideCursor();
4696 }
4697
4698 //=============================================================================
4699 /*!
4700  *
4701  */
4702 //=============================================================================
4703 void SMESHGUI::RemoveElements(SMESH::SMESH_Mesh_ptr aMesh,
4704         const TColStd_MapOfInteger & MapIndex)
4705 {
4706         QApplication::setOverrideCursor(Qt::waitCursor);
4707         Standard_Boolean result;
4708         SMESH_Actor *ac = FindActor(aMesh, result, true);
4709         if (result)
4710         {
4711                 SMESH::long_array_var anArrayOfIdeces = new SMESH::long_array;
4712                 anArrayOfIdeces->length(MapIndex.Extent());
4713                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
4714                 int i = 0;
4715                 for (; ite.More(); ite.Next())
4716                 {
4717                         //      MESSAGE ( " RemoveElement : id " << ite.Key() << "," << ac->GetIdSMESHDSElement(ite.Key()) )
4718                         anArrayOfIdeces[i] = ac->GetIdSMESHDSElement(ite.Key());
4719                         i++;
4720                 }
4721
4722                 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
4723                 aMeshEditor->RemoveElements(anArrayOfIdeces);
4724         }
4725
4726         if (myAutomaticUpdate)
4727         {
4728                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
4729                 if (Mesh != NULL)
4730                 {
4731                         smeshGUI->DisplayActor(Mesh);
4732                         smeshGUI->DisplayEdges(Mesh);
4733                         smeshGUI->ChangeRepresentation(Mesh, Mesh->getDisplayMode());
4734                         AddActorInSelection(Mesh);
4735 #ifdef TRACE
4736                         Dump(Mesh);
4737 #endif
4738                 }
4739         }
4740         QApplication::restoreOverrideCursor();
4741 }
4742
4743 //=============================================================================
4744 /*!
4745  *
4746  */
4747 //=============================================================================
4748 void SMESHGUI::OrientationElements(SMESH::SMESH_Mesh_ptr aMesh,
4749         const TColStd_MapOfInteger & MapIndex)
4750 {
4751         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
4752                 return;
4753
4754         vtkRenderer *theRenderer =
4755                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
4756                 getRightFrame()->getViewFrame())->getRenderer();
4757         Standard_Boolean result;
4758         SMESH_Actor *ac = FindActor(aMesh, result, true);
4759         if (result)
4760         {
4761                 //vtkUnstructuredGrid* UGrid = vtkUnstructuredGrid::New();
4762                 SMESH_Grid *UGrid = SMESH_Grid::New();
4763                 SMESH_Grid *oldGrid = SMESH_Grid::SafeDownCast(ac->DataSource);
4764                 UGrid->CopyMaps(oldGrid);
4765
4766                 vtkGeometryFilter *gf = vtkGeometryFilter::New();
4767                 gf->SetInput(ac->DataSource);
4768
4769                 vtkPolyDataMapper *Mapper = vtkPolyDataMapper::New();
4770                 Mapper->SetInput(gf->GetOutput());
4771                 Mapper->Update();
4772
4773                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
4774                 for (; ite.More(); ite.Next())
4775                 {
4776                         Mapper->GetInput()->ReverseCell(ite.Key());
4777                 }
4778
4779                 UGrid->SetPoints(Mapper->GetInput()->GetPoints());
4780                 int nbCells = Mapper->GetInput()->GetNumberOfCells();
4781                 for (int i = 0; i < nbCells; i++)
4782                 {
4783                         UGrid->InsertNextCell(Mapper->GetInput()->GetCellType(i),
4784                                 Mapper->GetInput()->GetCell(i)->GetPointIds());
4785                 }
4786
4787                 // Copy new data to the old DatSource: keep the single DataSource for all actors
4788                 oldGrid->DeepCopy(UGrid);
4789
4790                 vtkDataSetMapper *NewMapper = vtkDataSetMapper::New();
4791                 //NewMapper->SetInput( UGrid );
4792                 NewMapper->SetInput(oldGrid);
4793                 NewMapper->Update();
4794
4795                 //ac->DataSource = NewMapper->GetInput();
4796                 ac->SetMapper(NewMapper);
4797         }
4798         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
4799         renWin->Render();
4800         QApplication::restoreOverrideCursor();
4801 }
4802
4803 //=============================================================================
4804 /*!
4805  *
4806  */
4807 //=============================================================================
4808 void SMESHGUI::DiagonalInversion(SMESH::SMESH_Mesh_ptr aMesh,
4809         const TColStd_MapOfInteger & MapIndex)
4810 {
4811         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
4812                 return;
4813
4814         QApplication::setOverrideCursor(Qt::waitCursor);
4815         vtkRenderer *theRenderer =
4816                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
4817                 getRightFrame()->getViewFrame())->getRenderer();
4818         Standard_Boolean result;
4819
4820         SMESH_Actor *ac = FindActor(aMesh, result, true);
4821         if (result)
4822         {
4823                 //vtkUnstructuredGrid* UGrid = vtkUnstructuredGrid::New();
4824                 SMESH_Grid *UGrid = SMESH_Grid::New();
4825                 vtkGeometryFilter *gf = vtkGeometryFilter::New();
4826                 gf->SetInput(ac->DataSource);
4827
4828                 vtkExtractEdges *edges = vtkExtractEdges::New();
4829                 edges->SetInput(ac->DataSource);
4830
4831                 vtkPolyDataMapper *Mapper = vtkPolyDataMapper::New();
4832                 Mapper->SetInput(edges->GetOutput());
4833                 Mapper->Update();
4834
4835                 int nb = Mapper->GetInput()->GetNumberOfCells();
4836                 //MESSAGE ( "nb : " << nb )
4837
4838                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
4839                 for (; ite.More(); ite.Next())
4840                 {
4841                         vtkCell *StartEdge = Mapper->GetInput()->GetCell(ite.Key());
4842                         //MESSAGE( "DCQ : Edge Id = " << ite.Key())
4843                         int CellType = StartEdge->GetCellType();
4844                         //MESSAGE( "DCQ : Cell Type = " << CellType)
4845                         int nbPoints = StartEdge->GetNumberOfPoints();
4846
4847                         //MESSAGE( "DCQ : Nb Point = " << nbPoints)
4848                         if (nbPoints == 2)
4849                         {
4850                                 vtkUnstructuredGrid *StartUGrid =
4851                                         vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
4852
4853                                 vtkIdList *IdCells = vtkIdList::New();
4854                                 vtkIdList *IdPoints = StartEdge->GetPointIds();
4855                                 float p1[3];
4856                                 float p2[3];
4857
4858                                 Mapper->GetInput()->GetPoints()->GetPoint(IdPoints->GetId(0),
4859                                         p1);
4860                                 Mapper->GetInput()->GetPoints()->GetPoint(IdPoints->GetId(1),
4861                                         p2);
4862
4863                                 int idp1 = StartUGrid->FindPoint(p1);
4864                                 int idp2 = StartUGrid->FindPoint(p2);
4865
4866                                 StartUGrid->GetPointCells(idp1, IdCells);
4867
4868                                 //MESSAGE ( " pt 0 : " << IdPoints->GetId(0) )
4869                                 //MESSAGE ( " pt 1 : " << IdPoints->GetId(1) )
4870
4871                                 //MESSAGE ( " pt 0 : " << idp1 )
4872                                 //MESSAGE ( " pt 1 : " << idp2 )
4873
4874                                 vtkIdList *IdPts = vtkIdList::New();
4875                                 if (IdCells->GetNumberOfIds() >= 2)
4876                                 {
4877                                         int nbCells = IdCells->GetNumberOfIds();
4878                                         //MESSAGE ( " nbCells : " << nbCells )
4879                                         for (int j = 0; j < nbCells; j++)
4880                                         {
4881                                                 StartUGrid->GetCellPoints(IdCells->GetId(j), IdPts);
4882                                                 if (IdPts->IsId(idp2) == -1)
4883                                                 {
4884                                                         IdCells->DeleteId(IdCells->GetId(j));
4885                                                 }
4886                                         }
4887
4888                                         //MESSAGE ( " IdCells " << IdCells->GetNumberOfIds() )
4889
4890                                         vtkIdList *IdPts0 = vtkIdList::New();
4891                                         vtkIdList *IdPts1 = vtkIdList::New();
4892
4893                                         if (IdCells->GetNumberOfIds() == 2)
4894                                         {
4895                                                 StartUGrid->GetCellPoints(IdCells->GetId(0), IdPts0);
4896                                                 StartUGrid->GetCellPoints(IdCells->GetId(1), IdPts1);
4897
4898                                                 //Create new faces
4899                                                 TColStd_MapOfInteger EndMapIndex;
4900                                                 for (int j = 0; j < 3; j++)
4901                                                 {
4902                                                         if (IdPts0->GetId(j) != idp1 &&
4903                                                                 IdPts0->GetId(j) != idp2)
4904                                                         {
4905                                                                 EndMapIndex.Add(IdPts0->GetId(j));
4906                                                         }
4907                                                         if (IdPts1->GetId(j) != idp1 &&
4908                                                                 IdPts1->GetId(j) != idp2)
4909                                                         {
4910                                                                 EndMapIndex.Add(IdPts1->GetId(j));
4911                                                         }
4912                                                 }
4913
4914                                                 bool MyAU = myAutomaticUpdate;
4915                                                 myAutomaticUpdate = false;
4916
4917                                                 EndMapIndex.Add(idp1);
4918                                                 TColStd_MapIteratorOfMapOfInteger ite1(EndMapIndex);
4919                                                 int i = 1;
4920                                                 while (ite1.More())
4921                                                 {
4922                                                         if (ite1.Key() == idp1)
4923                                                                 break;
4924                                                         i++;
4925                                                         ite1.Next();
4926                                                 }
4927                                                 bool reverse1 = (i == 2);
4928                                                 this->AddFace(aMesh, EndMapIndex, reverse1);
4929
4930                                                 EndMapIndex.Remove(idp1);
4931                                                 EndMapIndex.Add(idp2);
4932                                                 TColStd_MapIteratorOfMapOfInteger ite2(EndMapIndex);
4933                                                 i = 1;
4934                                                 while (ite2.More())
4935                                                 {
4936                                                         if (ite2.Key() == idp2)
4937                                                                 break;
4938                                                         i++;
4939                                                         ite2.Next();
4940                                                 }
4941                                                 bool reverse2 = (i == 2);
4942                                                 this->AddFace(aMesh, EndMapIndex,
4943                                                         !(reverse1 == reverse2));
4944
4945                                                 myAutomaticUpdate = MyAU;
4946                                                 //MESSAGE ( " myAutomaticUpdate = " << MyAU )
4947                                                 Mapper->Update();
4948                                                 //Remove old faces
4949                                                 TColStd_MapOfInteger StartMapIndex;
4950                                                 StartMapIndex.Add(IdCells->GetId(0));
4951                                                 StartMapIndex.Add(IdCells->GetId(1));
4952                                                 this->RemoveElements(aMesh, StartMapIndex);
4953
4954                                                 Mapper->Update();
4955                                         }
4956                                 }
4957                         }
4958                 }
4959
4960                 //      UGrid->SetPoints( Mapper->GetInput()->GetPoints() );
4961                 //      int nbCells = Mapper->GetInput()->GetNumberOfCells();
4962                 //      for ( int i = 0; i < nbCells; i++ ) {
4963                 //        UGrid->InsertNextCell( Mapper->GetInput()->GetCellType(i), Mapper->GetInput()->GetCell(i)->GetPointIds() );
4964                 //      }
4965
4966                 //      vtkDataSetMapper *NewMapper = vtkDataSetMapper::New();
4967                 //      NewMapper->SetInput( UGrid );
4968                 //      NewMapper->Update();
4969
4970                 //      ac->DataSource = NewMapper->GetInput();
4971                 //      ac->SetMapper( NewMapper );
4972         }
4973         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
4974         renWin->Render();
4975         QApplication::restoreOverrideCursor();
4976 }
4977
4978 //=============================================================================
4979 /*!
4980  *
4981  */
4982 //=============================================================================
4983 void SMESHGUI::AddEdges(SMESH_Actor * Mactor, int number,
4984         const SMESH::double_array & coords, const SMESH::long_array & indexes)
4985 {
4986         QApplication::setOverrideCursor(Qt::waitCursor);
4987         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
4988         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
4989         int i = 1;
4990         int j = 1;
4991         while (i <= number)
4992         {
4993                 vtkIdList *Ids = vtkIdList::New();
4994                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j]));
4995                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 1]));
4996                 int id = ugrid->InsertNextCell(VTK_LINE, Ids);
4997                 Mactor->AddElement(indexes[j - 1], id);
4998                 i++;
4999                 j = j + 3;
5000         }
5001         vtkDataSetMapper *EdgeMapper = vtkDataSetMapper::New();
5002         EdgeMapper->SetInput(ugrid);
5003         Mactor->DataSource = EdgeMapper->GetInput();
5004         Mactor->SetMapper(EdgeMapper);
5005         QApplication::restoreOverrideCursor();
5006 }
5007
5008 //=============================================================================
5009 /*!
5010  *
5011  */
5012 //=============================================================================
5013 void SMESHGUI::AddEdge(SMESH_Actor * Mactor, int idedge, int idnode1,
5014         int idnode2)
5015 {
5016         QApplication::setOverrideCursor(Qt::waitCursor);
5017         MESSAGE("SMESHGUI::AddEdge " << idedge << " : " << idnode1 << ";" <<
5018                 idnode2) vtkIdList *Ids = vtkIdList::New();
5019         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode1));
5020         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode2));
5021
5022         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5023         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5024         int id = ugrid->InsertNextCell(VTK_LINE, Ids);
5025         Mactor->AddElement(idedge, id);
5026
5027         MESSAGE(" Edge VTK id " << id)
5028                 vtkDataSetMapper *EdgeMapper = vtkDataSetMapper::New();
5029         EdgeMapper->SetInput(ugrid);
5030         Mactor->DataSource = EdgeMapper->GetInput();
5031         Mactor->SetMapper(EdgeMapper);
5032         QApplication::restoreOverrideCursor();
5033 }
5034
5035 //=============================================================================
5036 /*!
5037  *
5038  */
5039 //=============================================================================
5040 void SMESHGUI::AddTriangles(SMESH_Actor * Mactor, int number,
5041         const SMESH::double_array & coords, const SMESH::long_array & indexes)
5042 {
5043         QApplication::setOverrideCursor(Qt::waitCursor);
5044         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5045         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5046         int i = 1;
5047         int j = 1;
5048         while (i <= number)
5049         {
5050                 vtkIdList *Ids = vtkIdList::New();
5051                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j]));
5052                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 1]));
5053                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 2]));
5054                 int id = ugrid->InsertNextCell(VTK_TRIANGLE, Ids);
5055                 Mactor->AddElement(indexes[j - 1], id);
5056                 i++;
5057                 j = j + 4;
5058         }
5059         vtkDataSetMapper *TriMapper = vtkDataSetMapper::New();
5060         TriMapper->SetInput(ugrid);
5061         Mactor->DataSource = TriMapper->GetInput();
5062         Mactor->SetMapper(TriMapper);
5063         QApplication::restoreOverrideCursor();
5064 }
5065 void SMESHGUI::AddTriangle(SMESH_Actor * Mactor, int idtri, int idnode1,
5066         int idnode2, int idnode3)
5067 {
5068         QApplication::setOverrideCursor(Qt::waitCursor);
5069         vtkIdList *Ids = vtkIdList::New();
5070         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode1));
5071         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode2));
5072         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode3));
5073
5074         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5075         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5076         int id = ugrid->InsertNextCell(VTK_TRIANGLE, Ids);
5077         Mactor->AddElement(idtri, id);
5078
5079         vtkDataSetMapper *TriMapper = vtkDataSetMapper::New();
5080         TriMapper->SetInput(ugrid);
5081         Mactor->DataSource = TriMapper->GetInput();
5082         Mactor->SetMapper(TriMapper);
5083         QApplication::restoreOverrideCursor();
5084 }
5085
5086 //=============================================================================
5087 /*!
5088  *
5089  */
5090 //=============================================================================
5091 void SMESHGUI::AddQuadrangles(SMESH_Actor * Mactor, int number,
5092         const SMESH::double_array & coords, const SMESH::long_array & indexes)
5093 {
5094         QApplication::setOverrideCursor(Qt::waitCursor);
5095         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5096         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5097         int i = 1;
5098         int j = 1;
5099         while (i <= number)
5100         {
5101                 vtkIdList *Ids = vtkIdList::New();
5102                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j]));
5103                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 1]));
5104                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 2]));
5105                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 3]));
5106                 int id = ugrid->InsertNextCell(VTK_QUAD, Ids);
5107                 Mactor->AddElement(indexes[j - 1], id);
5108                 i++;
5109                 j = j + 5;
5110         }
5111         vtkDataSetMapper *QuadMapper = vtkDataSetMapper::New();
5112         QuadMapper->SetInput(ugrid);
5113         Mactor->DataSource = QuadMapper->GetInput();
5114         Mactor->SetMapper(QuadMapper);
5115         QApplication::restoreOverrideCursor();
5116 }
5117
5118 //=============================================================================
5119 /*!
5120  *
5121  */
5122 //=============================================================================
5123 void SMESHGUI::AddQuadrangle(SMESH_Actor * Mactor, int idquad, int idnode1,
5124         int idnode2, int idnode3, int idnode4)
5125 {
5126         QApplication::setOverrideCursor(Qt::waitCursor);
5127         vtkIdList *Ids = vtkIdList::New();
5128         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode1));
5129         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode2));
5130         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode3));
5131         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode4));
5132
5133         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5134         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5135         int id = ugrid->InsertNextCell(VTK_QUAD, Ids);
5136         Mactor->AddElement(idquad, id);
5137
5138         vtkDataSetMapper *QuadMapper = vtkDataSetMapper::New();
5139         QuadMapper->SetInput(ugrid);
5140         Mactor->DataSource = QuadMapper->GetInput();
5141         Mactor->SetMapper(QuadMapper);
5142         QApplication::restoreOverrideCursor();
5143 }
5144
5145 //=============================================================================
5146 /*!
5147  *
5148  */
5149 //=============================================================================
5150 void SMESHGUI::AddTetras(SMESH_Actor * Mactor, int number,
5151         const SMESH::double_array & coords, const SMESH::long_array & indexes)
5152 {
5153         QApplication::setOverrideCursor(Qt::waitCursor);
5154         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5155         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5156         int i = 1;
5157         int j = 1;
5158         while (i <= number)
5159         {
5160                 vtkIdList *Ids = vtkIdList::New();
5161                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j]));
5162                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 1]));
5163                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 2]));
5164                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 3]));
5165                 int id = ugrid->InsertNextCell(VTK_TETRA, Ids);
5166                 Mactor->AddElement(indexes[j - 1], id);
5167                 i++;
5168                 j = j + 5;
5169         }
5170         vtkDataSetMapper *TetraMapper = vtkDataSetMapper::New();
5171         TetraMapper->SetInput(ugrid);
5172         Mactor->DataSource = TetraMapper->GetInput();
5173         Mactor->SetMapper(TetraMapper);
5174         QApplication::restoreOverrideCursor();
5175 }
5176
5177 //=============================================================================
5178 /*!
5179  *
5180  */
5181 //=============================================================================
5182 void SMESHGUI::AddTetra(SMESH_Actor * Mactor, int idtetra, int idnode1,
5183         int idnode2, int idnode3, int idnode4)
5184 {
5185         QApplication::setOverrideCursor(Qt::waitCursor);
5186         MESSAGE("SMESHGUI::AddTetra " << idtetra << " : " << idnode1 << ";" <<
5187                 idnode2 << ";" << idnode3 << ";" << idnode4) vtkIdList *Ids =
5188                 vtkIdList::New();
5189         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode1));
5190         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode2));
5191         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode3));
5192         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode4));
5193
5194         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5195         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5196         int id = ugrid->InsertNextCell(VTK_TETRA, Ids);
5197         Mactor->AddElement(idtetra, id);
5198
5199         MESSAGE(" Tetra VTK id " << id)
5200                 vtkDataSetMapper *TetraMapper = vtkDataSetMapper::New();
5201         TetraMapper->SetInput(ugrid);
5202         Mactor->DataSource = TetraMapper->GetInput();
5203         Mactor->SetMapper(TetraMapper);
5204         QApplication::restoreOverrideCursor();
5205 }
5206
5207 //=============================================================================
5208 /*!
5209  *
5210  */
5211 //=============================================================================
5212 void SMESHGUI::AddHexaedres(SMESH_Actor * Mactor, int number,
5213         const SMESH::double_array & coords, const SMESH::long_array & indexes)
5214 {
5215         QApplication::setOverrideCursor(Qt::waitCursor);
5216         //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5217         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5218         int i = 1;
5219         int j = 1;
5220         while (i <= number)
5221         {
5222                 vtkIdList *Ids = vtkIdList::New();
5223                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j]));
5224                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 1]));
5225                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 2]));
5226                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 3]));
5227                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 4]));
5228                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 5]));
5229                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 6]));
5230                 Ids->InsertNextId(Mactor->GetIdVTKNode(indexes[j + 7]));
5231                 int id = ugrid->InsertNextCell(VTK_HEXAHEDRON, Ids);
5232                 Mactor->AddElement(indexes[j - 1], id);
5233                 i++;
5234                 j = j + 9;
5235         }
5236         vtkDataSetMapper *HexaMapper = vtkDataSetMapper::New();
5237         HexaMapper->SetInput(ugrid);
5238         Mactor->DataSource = HexaMapper->GetInput();
5239         Mactor->SetMapper(HexaMapper);
5240         QApplication::restoreOverrideCursor();
5241 }
5242
5243 //=============================================================================
5244 /*!
5245  *
5246  */
5247 //=============================================================================
5248 void SMESHGUI::AddHexaedre(SMESH_Actor * Mactor, int idhexa, int idnode1,
5249         int idnode2, int idnode3, int idnode4, int idnode5, int idnode6,
5250         int idnode7, int idnode8)
5251 {
5252         QApplication::setOverrideCursor(Qt::waitCursor);
5253         MESSAGE("SMESHGUI::AddHexaedre " << idhexa << " : " << idnode1 << ";" <<
5254                 idnode2 << ";" << idnode3 << ";" << idnode4 << ";" << idnode5 << ";" <<
5255                 idnode6 << ";" << idnode7 << ";" << idnode8) vtkIdList *Ids =
5256                 vtkIdList::New();
5257         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode1));
5258         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode2));
5259         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode3));
5260         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode4));
5261         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode5));
5262         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode6));
5263         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode7));
5264         Ids->InsertNextId(Mactor->GetIdVTKNode(idnode8));
5265
5266         //vtkUnstructuredGrid *ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
5267         SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
5268         int id = ugrid->InsertNextCell(VTK_HEXAHEDRON, Ids);
5269         Mactor->AddElement(idhexa, id);
5270
5271         MESSAGE(" Hexa VTK id " << id)
5272                 vtkDataSetMapper *HexaMapper = vtkDataSetMapper::New();
5273         HexaMapper->SetInput(ugrid);
5274         Mactor->DataSource = HexaMapper->GetInput();
5275         Mactor->SetMapper(HexaMapper);
5276         QApplication::restoreOverrideCursor();
5277 }
5278
5279 //=====================================================================================
5280 // EXPORTED METHODS
5281 //=====================================================================================
5282 extern "C"
5283 {
5284         bool OnGUIEvent(int theCommandID, QAD_Desktop * parent)
5285         {
5286                 return SMESHGUI::OnGUIEvent(theCommandID, parent);
5287         }
5288
5289         bool OnKeyPress(QKeyEvent * pe, QAD_Desktop * parent,
5290                 QAD_StudyFrame * studyFrame)
5291         {
5292                 return SMESHGUI::OnKeyPress(pe, parent, studyFrame);
5293         }
5294
5295         bool OnMousePress(QMouseEvent * pe, QAD_Desktop * parent,
5296                 QAD_StudyFrame * studyFrame)
5297         {
5298                 return SMESHGUI::OnMousePress(pe, parent, studyFrame);
5299         }
5300
5301         bool OnMouseMove(QMouseEvent * pe, QAD_Desktop * parent,
5302                 QAD_StudyFrame * studyFrame)
5303         {
5304                 return SMESHGUI::OnMouseMove(pe, parent, studyFrame);
5305         }
5306
5307         bool SetSettings(QAD_Desktop * parent)
5308         {
5309                 return SMESHGUI::SetSettings(parent);
5310         }
5311
5312         bool customPopup(QAD_Desktop * parent, QPopupMenu * popup,
5313                 const QString & theContext, const QString & theParent,
5314                 const QString & theObject)
5315         {
5316                 return SMESHGUI::CustomPopup(parent, popup, theContext, theParent,
5317                         theObject);
5318         }
5319
5320         void definePopup(QString & theContext, QString & theParent,
5321                 QString & theObject)
5322         {
5323                 SMESHGUI::DefinePopup(theContext, theParent, theObject);
5324         }
5325
5326         bool activeStudyChanged(QAD_Desktop * parent)
5327         {
5328                 SMESHGUI::activeStudyChanged(parent);
5329         }
5330
5331         void buildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
5332         {
5333                 SMESHGUI::BuildPresentation(theIO);
5334         }
5335
5336         void supportedViewType(int *buffer, int bufferSize)
5337         {
5338                 if (!buffer || !bufferSize)
5339                         return;
5340                 buffer[0] = (int)VIEW_VTK;
5341         }
5342
5343 }
5344
5345 //=============================================================================
5346 /*!
5347  *
5348  */
5349 //=============================================================================
5350 void SMESHGUI::ViewNodes()
5351 {
5352         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
5353                 return;
5354
5355         EraseSimulationActors();
5356         mySimulationActors = vtkActorCollection::New();
5357         vtkRenderer *theRenderer =
5358                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
5359                 getRightFrame()->getViewFrame())->getRenderer();
5360         vtkActorCollection *theActors = theRenderer->GetActors();
5361         theActors->InitTraversal();
5362         vtkActor *ac = theActors->GetNextActor();
5363         while (!(ac == NULL))
5364         {
5365                 if (ac->IsA("SMESH_Actor"))
5366                 {
5367                         SMESH_Actor *anActor = SMESH_Actor::SafeDownCast(ac);
5368                         if (anActor->GetVisibility() == 1)
5369                         {
5370                                 vtkGeometryFilter *gf = vtkGeometryFilter::New();
5371                                 gf->SetInput(anActor->DataSource);
5372                                 vtkMaskPoints *verts = vtkMaskPoints::New();
5373                                 verts->SetInput(gf->GetOutput());
5374                                 verts->GenerateVerticesOn();
5375                                 verts->SetOnRatio(1);
5376
5377                                 vtkPolyDataMapper *vertMapper = vtkPolyDataMapper::New();
5378                                 vertMapper->SetInput(verts->GetOutput());
5379                                 vertMapper->ScalarVisibilityOff();
5380
5381                                 vtkActor *vertActor = vtkActor::New();
5382                                 vertActor->SetMapper(vertMapper);
5383
5384                                 float r, g, b;
5385                                 anActor->GetNodeColor(r, g, b);
5386                                 vertActor->GetProperty()->SetColor(r, g, b);
5387
5388                                 vertActor->GetProperty()->SetPointSize(anActor->GetNodeSize());
5389
5390                                 vertActor->PickableOff();
5391
5392                                 mySimulationActors->AddItem(vertActor);
5393                                 theRenderer->AddActor(vertActor);
5394                         }
5395                 }
5396                 ac = theActors->GetNextActor();
5397         }
5398
5399         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
5400         renWin->Render();
5401 }
5402
5403 //=============================================================================
5404 /*!
5405  *
5406  */
5407 //=============================================================================
5408 void SMESHGUI::Control(int theCommandID)
5409 {
5410         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
5411                 return;
5412
5413         QApplication::setOverrideCursor(Qt::waitCursor);
5414         DisplayScalarBar(false);
5415
5416         vtkDoubleArray *scalars = vtkDoubleArray::New();
5417         scalars->SetNumberOfComponents(1);
5418
5419         vtkDataSetMapper *meshMapper = 0;
5420         SALOME_Selection *Sel =
5421                 SALOME_Selection::Selection(myActiveStudy->getSelection());
5422         int nbSel = Sel->IObjectCount();
5423         Standard_Boolean result;
5424         Handle(SALOME_InteractiveObject) IObject = Sel->firstIObject();
5425         SMESH_Actor *MeshActor =
5426                 FindActorByEntry(IObject->getEntry(), result, true);
5427
5428         // Mesh may be not updated after Compute
5429         if (!MeshActor->DataSource || !MeshActor->GetMapper())
5430         {
5431                 QApplication::restoreOverrideCursor();
5432                 return;
5433         }
5434
5435         vtkDataSet *aDataSet = MeshActor->DataSource;
5436         typedef double (*TScalarFun) (vtkCell * theCell);
5437         TScalarFun aScalarFun;
5438         if (result)
5439         {
5440                 QString type;
5441                 switch (theCommandID)
5442                 {
5443                 case 6001:
5444                 {
5445                         type = tr("SMESH_CONTROL_LENGTH_EDGES");
5446                         aDataSet = MeshActor->EdgeDevice->GetMapper()->GetInput();
5447                         aScalarFun = &(SMESHGUI_ComputeScalarValue::LengthEdges);
5448                         MESSAGE(" init minimum length " << aDataSet->GetNumberOfCells());
5449                         if (MeshActor->getDisplayMode() != 0)
5450                                 ChangeRepresentation(MeshActor, 1);     // limitation; in Wireframe, colored edges are not visible
5451                         break;
5452                 }
5453                 case 6011:
5454                 {
5455                         type = tr("SMESH_CONTROL_AREA_ELEMENTS");
5456                         aScalarFun = &(SMESHGUI_ComputeScalarValue::AreaElements);
5457                         if (MeshActor->getDisplayMode() != 1)
5458                                 ChangeRepresentation(MeshActor, 1);
5459                         break;
5460                 }
5461                 case 6012:
5462                 {
5463                         type = tr("SMESH_CONTROL_TAPER_ELEMENTS");
5464                         aScalarFun = &(SMESHGUI_ComputeScalarValue::Taper);
5465                         break;
5466                 }
5467                 case 6013:
5468                 {
5469                         type = tr("SMESH_CONTROL_ASPECTRATIO_ELEMENTS");
5470                         aScalarFun = &(SMESHGUI_ComputeScalarValue::AspectRatio);
5471                         if (MeshActor->getDisplayMode() != 1)
5472                                 ChangeRepresentation(MeshActor, 1);
5473                         break;
5474                 }
5475                 case 6014:
5476                 {
5477                         type = tr("SMESH_CONTROL_MINIMUMANGLE_ELEMENTS");
5478                         aScalarFun = &(SMESHGUI_ComputeScalarValue::MinimumAngle);
5479                         if (MeshActor->getDisplayMode() != 1)
5480                                 ChangeRepresentation(MeshActor, 1);
5481                         break;
5482                 }
5483                 case 6015:
5484                 {
5485                         type = tr("SMESH_CONTROL_WARP_ELEMENTS");
5486                         aScalarFun = &(SMESHGUI_ComputeScalarValue::Warp);
5487                         break;
5488                 }
5489                 case 6016:
5490                 {
5491                         type = tr("SMESH_CONTROL_SKEW_ELEMENTS");
5492                         aScalarFun = &(SMESHGUI_ComputeScalarValue::Skew);
5493                         break;
5494                 }
5495                 }
5496
5497                 for (int i = 0, iEnd = aDataSet->GetNumberOfCells(); i < iEnd; i++)
5498                         scalars->InsertTuple1(i, aScalarFun(aDataSet->GetCell(i)));
5499
5500                 float range[2];
5501                 scalars->GetRange(range);
5502
5503                 vtkLookupTable *wat = vtkLookupTable::New();
5504                 wat->SetRange(range);
5505                 wat->Build();
5506
5507                 scalars->SetLookupTable(wat);
5508
5509                 if (!meshMapper)
5510                         meshMapper = (vtkDataSetMapper *) (MeshActor->getMapper());
5511                 meshMapper->SetScalarModeToUseCellData();
5512                 MeshActor->DataSource->GetCellData()->SetScalars(scalars);
5513                 meshMapper->SetScalarRange(range);
5514                 meshMapper->ScalarVisibilityOn();
5515
5516                 vtkScalarBarActor *aScalarBar = GetScalarBar();
5517                 if (aScalarBar == NULL)
5518                 {
5519                         aScalarBar = vtkScalarBarActor::New();
5520                         QString Bold = QAD_CONFIG->getSetting("ScalarBar:Bold");
5521                         QString Italic = QAD_CONFIG->getSetting("ScalarBar:Italic");
5522                         QString Shadow = QAD_CONFIG->getSetting("ScalarBar:Shadow");
5523                         QString FontFamily = QAD_CONFIG->getSetting("ScalarBar:FontFamily");
5524                         QString Orientation =
5525                                 QAD_CONFIG->getSetting("ScalarBar:Orientation");
5526                         float Width = QAD_CONFIG->getSetting("ScalarBar:Width").toFloat();
5527                         float Height = QAD_CONFIG->getSetting("ScalarBar:Height").toFloat();
5528                         int NumberOfLabels =
5529                                 QAD_CONFIG->getSetting("ScalarBar:NumberOfLabels").toInt();
5530                         int NumberOfColors =
5531                                 QAD_CONFIG->getSetting("ScalarBar:NumberOfColors").toInt();
5532
5533                         SetSettingsScalarBar(aScalarBar, Bold, Italic, Shadow, FontFamily,
5534                                 Orientation, Width, Height, NumberOfColors, NumberOfLabels);
5535                         vtkRenderer *theRenderer =
5536                                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
5537                                 getRightFrame()->getViewFrame())->getRenderer();
5538                         theRenderer->AddActor2D(aScalarBar);
5539                 }
5540                 aScalarBar->SetLookupTable(wat);
5541                 aScalarBar->SetTitle(type.latin1());
5542
5543                 scalars->Delete();
5544                 //    wat->Delete();
5545                 DisplayScalarBar(true);
5546         }
5547         QApplication::restoreOverrideCursor();
5548 }
5549
5550 //=============================================================================
5551 /*!
5552  *
5553  */
5554 //=============================================================================
5555 void SMESHGUI::SetSettingsScalarBar(vtkScalarBarActor * theScalarBar,
5556         QString Bold, QString Italic,
5557         QString Shadow, QString FontFamily,
5558         QString Orientation, float Width, float Height, int NbColors, int NbLabels)
5559 {
5560         if (Bold.isNull() || Bold.isEmpty() || (Bold.compare("true") == 0))
5561                 theScalarBar->BoldOn();
5562         else
5563                 theScalarBar->BoldOff();
5564
5565         if (Italic.isNull() || Italic.isEmpty() || (Italic.compare("true") == 0))
5566                 theScalarBar->ItalicOn();
5567         else
5568                 theScalarBar->ItalicOff();
5569
5570         if (Shadow.isNull() || Shadow.isEmpty() || (Shadow.compare("true") == 0))
5571                 theScalarBar->ShadowOn();
5572         else
5573                 theScalarBar->ShadowOff();
5574
5575         if (FontFamily.compare("Arial") == 0)
5576                 theScalarBar->SetFontFamilyToArial();
5577         else if (FontFamily.compare("Courier") == 0)
5578                 theScalarBar->SetFontFamilyToCourier();
5579         else if (FontFamily.compare("Times") == 0)
5580                 theScalarBar->SetFontFamilyToTimes();
5581         else
5582                 theScalarBar->SetFontFamilyToArial();
5583
5584         if (Orientation.isNull() || Orientation.isEmpty() ||
5585                 (Orientation.compare("Vertical") == 0))
5586                 theScalarBar->SetOrientationToVertical();
5587         else
5588                 theScalarBar->SetOrientationToHorizontal();
5589
5590         theScalarBar->SetWidth((Width == 0) ? 0.17 : Width);
5591         theScalarBar->SetHeight((Height == 0) ? 0.8 : Height);
5592
5593         theScalarBar->SetNumberOfLabels((NbLabels == 0) ? 5 : NbLabels);
5594         theScalarBar->SetMaximumNumberOfColors((NbColors == 0) ? 64 : NbColors);
5595 }
5596
5597 //=============================================================================
5598 /*!
5599  *
5600  */
5601 //=============================================================================
5602 void SMESHGUI::DisplayScalarBar(bool visibility)
5603 {
5604         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
5605                 return;
5606
5607         vtkRenderer *theRenderer =
5608                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
5609                 getRightFrame()->getViewFrame())->getRenderer();
5610         vtkScalarBarActor *aScalarBar = GetScalarBar();
5611
5612         if (aScalarBar == NULL)
5613         {
5614                 MESSAGE("myScalarBar is NULL");
5615                 return;
5616         }
5617
5618         if (visibility)
5619                 aScalarBar->VisibilityOn();
5620         else
5621         {
5622                 aScalarBar->VisibilityOff();
5623                 //Turn off mesh coloring (influences on all views)
5624                 vtkActorCollection *actorList = theRenderer->GetActors();
5625                 actorList->InitTraversal();
5626                 vtkActor *ac = actorList->GetNextActor();
5627                 while (ac != NULL)
5628                 {
5629                         if (ac->GetMapper() != NULL)
5630                         {
5631                                 ac->GetMapper()->ScalarVisibilityOff();
5632                         }
5633                         ac = actorList->GetNextActor();
5634                 }
5635                 // Turn off ScalarBar in all views
5636                 /*QList<QAD_StudyFrame> aFrames = myActiveStudy->getStudyFrames();
5637                  * for ( QAD_StudyFrame* aFrame = aFrames.first(); aFrame; aFrame = aFrames.next() ) {
5638                  * if (aFrame->getTypeView() == VIEW_VTK) {
5639                  * vtkRenderer *aRenderer = ((VTKViewer_ViewFrame*) aFrame->getRightFrame()->getViewFrame())->getRenderer();
5640                  * vtkActor2DCollection* actor2DList = aRenderer->GetActors2D();
5641                  * actor2DList->InitTraversal();
5642                  * vtkActor2D* aActor2d =  actor2DList->GetNextActor2D();
5643                  * while (aActor2d != NULL) {
5644                  * if (aActor2d->IsA("vtkScalarBarActor")) {
5645                  * aActor2d->VisibilityOff();
5646                  * break;
5647                  * }
5648                  * actor2DList->GetNextActor2D();
5649                  * }
5650                  * }
5651                  * } */
5652         }
5653         myActiveStudy->update3dViewers();
5654 }
5655
5656 //=============================================================================
5657 /*!
5658  *
5659  */
5660 //=============================================================================
5661 void SMESHGUI::UpdateScalarBar(float MinRange, float MaxRange)
5662 {
5663         vtkScalarBarActor *aScalarBar = GetScalarBar();
5664         if (aScalarBar == NULL)
5665         {
5666                 MESSAGE("myScalarBar is NULL");
5667                 return;
5668         }
5669         DisplayScalarBar(false);
5670
5671         aScalarBar->GetLookupTable()->SetRange(MinRange, MaxRange);
5672         vtkRenderer *aRenderer =
5673                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
5674                 getRightFrame()->getViewFrame())->getRenderer();
5675         vtkActorCollection *aActorList = aRenderer->GetActors();
5676         aActorList->InitTraversal();
5677         vtkActor *aActor = aActorList->GetNextActor();
5678         while (aActor != NULL)
5679         {
5680                 if (aActor->IsA("SMESH_Actor"))
5681                 {
5682                         SMESH_Actor *aMeshActor = SMESH_Actor::SafeDownCast(aActor);
5683                         vtkDataSetMapper *aMeshMapper =
5684                                 (vtkDataSetMapper *) (aMeshActor->getMapper());
5685                         if ((aMeshMapper != NULL))
5686                         {
5687                                 aMeshMapper->SetScalarRange(MinRange, MaxRange);
5688                                 aMeshMapper->ScalarVisibilityOn();
5689                         }
5690                 }
5691                 aActor = aActorList->GetNextActor();
5692         }
5693         DisplayScalarBar(true);
5694 }
5695
5696 //=============================================================================
5697 /*!
5698  *
5699  */
5700 //=============================================================================
5701 void SMESHGUI::SetDisplaySettings()
5702 {
5703         EmitSignalDeactivateDialog();
5704         SMESHGUI_Preferences_ColorDlg *aDlg =
5705                 new SMESHGUI_Preferences_ColorDlg(QAD_Application::getDesktop(), "");
5706
5707         QString SCr = QAD_CONFIG->getSetting("SMESH:SettingsFillColorRed");
5708         QString SCg = QAD_CONFIG->getSetting("SMESH:SettingsFillColorGreen");
5709         QString SCb = QAD_CONFIG->getSetting("SMESH:SettingsFillColorBlue");
5710         QColor color = QColor(SCr.toInt(), SCg.toInt(), SCb.toInt());
5711         aDlg->SetColor(1, color);
5712
5713         SCr = QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorRed");
5714         SCg = QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorGreen");
5715         SCb = QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorBlue");
5716         color = QColor(SCr.toInt(), SCg.toInt(), SCb.toInt());
5717         aDlg->SetColor(2, color);
5718
5719         SCr = QAD_CONFIG->getSetting("SMESH:SettingsNodeColorRed");
5720         SCg = QAD_CONFIG->getSetting("SMESH:SettingsNodeColorGreen");
5721         SCb = QAD_CONFIG->getSetting("SMESH:SettingsNodeColorBlue");
5722         color = QColor(SCr.toInt(), SCg.toInt(), SCb.toInt());
5723         aDlg->SetColor(3, color);
5724
5725         QString SBr = QAD_CONFIG->getSetting("SMESH:SettingsBackFaceColorRed");
5726         QString SBg = QAD_CONFIG->getSetting("SMESH:SettingsBackFaceColorGreen");
5727         QString SBb = QAD_CONFIG->getSetting("SMESH:SettingsBackFaceColorBlue");
5728         color = QColor(SBr.toInt(), SBg.toInt(), SBb.toInt());
5729         aDlg->SetColor(4, color);
5730
5731         QString intValue = QAD_CONFIG->getSetting("SMESH:SettingsWidth");
5732         aDlg->SetIntValue(1, intValue.toInt());
5733         intValue = QAD_CONFIG->getSetting("SMESH:SettingsNodesSize");
5734         aDlg->SetIntValue(2, intValue.toInt());
5735         intValue = QAD_CONFIG->getSetting("SMESH:SettingsShrinkCoeff");
5736         aDlg->SetIntValue(3, intValue.toInt());
5737
5738         if (aDlg->exec())
5739         {
5740                 QColor colorFill = aDlg->GetColor(1);
5741                 QAD_CONFIG->addSetting("SMESH:SettingsFillColorRed", colorFill.red());
5742                 QAD_CONFIG->addSetting("SMESH:SettingsFillColorGreen",
5743                         colorFill.green());
5744                 QAD_CONFIG->addSetting("SMESH:SettingsFillColorBlue", colorFill.blue());
5745
5746                 QColor colorOutline = aDlg->GetColor(2);
5747                 QAD_CONFIG->addSetting("SMESH:SettingsOutlineColorRed",
5748                         colorOutline.red());
5749                 QAD_CONFIG->addSetting("SMESH:SettingsOutlineColorGreen",
5750                         colorOutline.green());
5751                 QAD_CONFIG->addSetting("SMESH:SettingsOutlineColorBlue",
5752                         colorOutline.blue());
5753
5754                 QColor colorNode = aDlg->GetColor(3);
5755                 QAD_CONFIG->addSetting("SMESH:SettingsNodeColorRed", colorNode.red());
5756                 QAD_CONFIG->addSetting("SMESH:SettingsNodeColorGreen",
5757                         colorNode.green());
5758                 QAD_CONFIG->addSetting("SMESH:SettingsNodeColorBlue", colorNode.blue());
5759
5760                 QColor colorBackFace = aDlg->GetColor(4);
5761                 QAD_CONFIG->addSetting("SMESH:SettingsBackFaceColorRed",
5762                         colorBackFace.red());
5763                 QAD_CONFIG->addSetting("SMESH:SettingsBackFaceColorGreen",
5764                         colorBackFace.green());
5765                 QAD_CONFIG->addSetting("SMESH:SettingsBackFaceColorBlue",
5766                         colorBackFace.blue());
5767
5768                 int width = aDlg->GetIntValue(1);
5769                 QAD_CONFIG->addSetting("SMESH:SettingsWidth", width);
5770
5771                 int nodes_size = aDlg->GetIntValue(2);
5772                 QAD_CONFIG->addSetting("SMESH:SettingsNodesSize", nodes_size);
5773
5774                 int shrink_coeff = aDlg->GetIntValue(3);
5775                 QAD_CONFIG->addSetting("SMESH:SettingsShrinkCoeff", shrink_coeff);
5776         }
5777
5778         delete aDlg;
5779 }
5780
5781 //=======================================================================
5782 // function : Parameter()
5783 // purpose  : return a parameter (double) from a dialog box
5784 //
5785 //  aValue     : is a double used as a default value displayed
5786 //  aLabel     : is the title for aValue1
5787 //  aTitle     : is the main title
5788 //  bottom     : maximum value to be entered
5789 //  top        : minimum value to be entered
5790 //  decimals   : number of decimals
5791 //=======================================================================
5792 double SMESHGUI::Parameter(Standard_Boolean & res,
5793         const double aValue,
5794         const char *aLabel,
5795         const char *aTitle,
5796         const double bottom, const double top, const int decimals)
5797 {
5798         SMESHGUI_aParameterDlg *Dialog =
5799                 new SMESHGUI_aParameterDlg(QAD_Application::getDesktop(),
5800                 aTitle,
5801                 aLabel,
5802                 bottom, top, decimals,
5803                 TRUE);
5804         Dialog->setValue(aValue);
5805         double X = 0.0;
5806         res = (Dialog->exec() == QDialog::Accepted);
5807         if (res)
5808                 X = Dialog->getDblValue();
5809         return X;
5810 }
5811
5812 //=======================================================================
5813 // function : Parameter()
5814 // purpose  : return a parameter (int) from a dialog box
5815 //
5816 //  aValue     : is a int used as a default value displayed
5817 //  aLabel     : is the title for aValue1
5818 //  aTitle     : is the main title
5819 //  bottom     : maximum value to be entered
5820 //  top        : minimum value to be entered
5821 //=======================================================================
5822 int SMESHGUI::Parameter(Standard_Boolean & res,
5823         const int aValue,
5824         const char *aLabel, const char *aTitle, const int bottom, const int top)
5825 {
5826         SMESHGUI_aParameterDlg *Dialog =
5827                 new SMESHGUI_aParameterDlg(QAD_Application::getDesktop(),
5828                 aTitle,
5829                 aLabel,
5830                 bottom, top,
5831                 TRUE);
5832         Dialog->setValue(aValue);
5833         int X = 0;
5834         res = (Dialog->exec() == QDialog::Accepted);
5835         if (res)
5836                 X = Dialog->getIntValue();
5837         return X;
5838 }
5839
5840 //=============================================================================
5841 /*!
5842  *
5843  */
5844 //=============================================================================
5845 void SMESHGUI::DisplayEdges(SMESH_Actor * ac, bool visibility)
5846 {
5847         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
5848                 return;
5849         if (ac->DataSource == NULL || ac->GetMapper() == NULL)
5850                 return;
5851
5852         vtkGeometryFilter *gf = vtkGeometryFilter::New();
5853         gf->SetInput(ac->DataSource);
5854         vtkFeatureEdges *edges = vtkFeatureEdges::New();
5855         edges->SetInput(gf->GetOutput());
5856         edges->BoundaryEdgesOn();
5857         edges->ManifoldEdgesOn();
5858
5859         vtkPolyDataMapper *edgeMapper = vtkPolyDataMapper::New();
5860         edgeMapper->SetInput(edges->GetOutput());
5861         edgeMapper->ScalarVisibilityOff();
5862
5863         vtkRenderer *theRenderer =
5864                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
5865                 getRightFrame()->getViewFrame())->getRenderer();
5866         vtkActorCollection *actorList = theRenderer->GetActors();
5867
5868         int test = actorList->IsItemPresent(ac->EdgeDevice);
5869         if (test == 0)
5870         {
5871                 vtkProperty *prop = vtkProperty::New();
5872                 prop->SetColor(QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorRed").
5873                         toFloat() / 255.,
5874                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorGreen").
5875                         toFloat() / 255.,
5876                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorBlue").toFloat() /
5877                         255.);
5878                 prop->SetPointSize(QAD_CONFIG->getSetting("SMESH:SettingsNodesSize").
5879                         toInt());
5880                 prop->SetLineWidth(QAD_CONFIG->getSetting("SMESH:SettingsWidth").
5881                         toInt());
5882                 ac->EdgeDevice->SetProperty(prop);
5883                 ac->SetEdgeColor(QAD_CONFIG->
5884                         getSetting("SMESH:SettingsOutlineColorRed").toFloat() / 255.,
5885                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorGreen").
5886                         toFloat() / 255.,
5887                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorBlue").toFloat() /
5888                         255.);
5889                 ac->EdgeDevice->SetMapper(edgeMapper);
5890
5891                 theRenderer->AddActor(ac->EdgeDevice);
5892         }
5893         else
5894         {
5895                 ac->EdgeDevice->SetMapper(edgeMapper);
5896                 edgeMapper->Update();
5897         }
5898
5899         vtkShrinkFilter *shrink = vtkShrinkFilter::New();
5900         shrink->SetInput(ac->DataSource);
5901         shrink->SetShrinkFactor(ac->GetShrinkFactor());
5902         vtkGeometryFilter *Shrinkgf = vtkGeometryFilter::New();
5903         Shrinkgf->SetInput(shrink->GetOutput());
5904         vtkFeatureEdges *ShrinkEdges = vtkFeatureEdges::New();
5905         ShrinkEdges->SetInput(Shrinkgf->GetOutput());
5906         ShrinkEdges->BoundaryEdgesOn();
5907         ShrinkEdges->ManifoldEdgesOn();
5908
5909         vtkPolyDataMapper *ShrinkEdgeMapper = vtkPolyDataMapper::New();
5910         ShrinkEdgeMapper->SetInput(ShrinkEdges->GetOutput());
5911         ShrinkEdgeMapper->ScalarVisibilityOff();
5912
5913         test = actorList->IsItemPresent(ac->EdgeShrinkDevice);
5914         if (test == 0)
5915         {
5916                 vtkProperty *prop = vtkProperty::New();
5917                 prop->SetColor(QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorRed").
5918                         toFloat() / 255.,
5919                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorGreen").
5920                         toFloat() / 255.,
5921                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorBlue").toFloat() /
5922                         255.);
5923                 prop->SetPointSize(QAD_CONFIG->getSetting("SMESH:SettingsNodesSize").
5924                         toInt());
5925                 prop->SetLineWidth(QAD_CONFIG->getSetting("SMESH:SettingsWidth").
5926                         toInt());
5927                 ac->EdgeShrinkDevice->SetProperty(prop);
5928                 ac->SetEdgeColor(QAD_CONFIG->
5929                         getSetting("SMESH:SettingsOutlineColorRed").toFloat() / 255.,
5930                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorGreen").
5931                         toFloat() / 255.,
5932                         QAD_CONFIG->getSetting("SMESH:SettingsOutlineColorBlue").toFloat() /
5933                         255.);
5934                 ac->EdgeShrinkDevice->SetMapper(ShrinkEdgeMapper);
5935
5936                 theRenderer->AddActor(ac->EdgeShrinkDevice);
5937         }
5938         else
5939         {
5940                 ac->EdgeShrinkDevice->SetMapper(ShrinkEdgeMapper);
5941                 ShrinkEdgeMapper->Update();
5942         }
5943
5944         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
5945         renWin->Render();
5946 }
5947
5948 //=============================================================================
5949 /*!
5950  *
5951  */
5952 //=============================================================================
5953 void SMESHGUI::InitActor(SMESH::SMESH_Mesh_ptr aMesh)
5954 {
5955         SALOMEDS::SObject_var aSO_M = myStudyAPI.FindMesh(aMesh);
5956         SALOMEDS::GenericAttribute_var anAttr;
5957         SALOMEDS::AttributeName_var aName;
5958         if (!aSO_M->_is_nil())
5959         {
5960                 if (aSO_M->FindAttribute(anAttr, "AttributeName"))
5961                 {
5962                         aName = SALOMEDS::AttributeName::_narrow(anAttr);
5963                         Standard_Boolean result;
5964                         SMESH_Actor *MeshActor =
5965                                 smeshGUI->FindActorByEntry(aSO_M->GetID(), result, true);
5966                         if (!result)
5967                         {
5968                                 SMESH_Actor *amesh = SMESH_Actor::New();
5969                                 Handle(SALOME_InteractiveObject) IO =
5970                                         new SALOME_InteractiveObject(aSO_M->GetID(), "MESH",
5971                                         aName->Value());
5972                                 amesh->setIO(IO);
5973                                 amesh->setName(aName->Value());
5974                                 DisplayActor(amesh, false);
5975                         }
5976                 }
5977         }
5978 }
5979
5980 //=============================================================================
5981 /*!
5982  *
5983  */
5984 //=============================================================================
5985 void SMESHGUI::Update()
5986 {
5987         if (myActiveStudy->getActiveStudyFrame()->getTypeView() == VIEW_VTK)
5988         {                                                       //VTK
5989                 vtkRenderer *theRenderer =
5990                         ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
5991                         getRightFrame()->getViewFrame())->getRenderer();
5992
5993                 SALOME_Selection *Sel =
5994                         SALOME_Selection::Selection(myActiveStudy->getSelection());
5995                 int nbSel = Sel->IObjectCount();
5996                 if (nbSel == 0)
5997                 {
5998                         vtkActorCollection *actorList = theRenderer->GetActors();
5999                         actorList->InitTraversal();
6000                         vtkActor *ac = actorList->GetNextActor();
6001                         while (!(ac == NULL))
6002                         {
6003                                 if (ac->IsA("SMESH_Actor"))
6004                                 {
6005                                         SMESH_Actor *anActor = SMESH_Actor::SafeDownCast(ac);
6006                                         if (anActor->hasIO())
6007                                         {
6008                                                 Handle(SALOME_InteractiveObject) IO = anActor->getIO();
6009                                                 Update(IO);
6010                                         }
6011                                 }
6012                                 ac = actorList->GetNextActor();
6013                         }
6014                 }
6015                 else
6016                 {
6017                         SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
6018                         for (; It.More(); It.Next())
6019                         {
6020                                 Handle(SALOME_InteractiveObject) IO = It.Value();
6021                                 Update(IO);
6022                         }
6023                 }
6024                 vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6025                 renWin->Render();
6026         }
6027         QApplication::restoreOverrideCursor();
6028 }
6029
6030 //=============================================================================
6031 /*!
6032  *
6033  */
6034 //=============================================================================
6035 void SMESHGUI::Update(const Handle(SALOME_InteractiveObject) & IO)
6036 {
6037         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6038                 return;
6039
6040         if (IO->hasEntry())
6041         {
6042                 Standard_Boolean res;
6043                 SMESH::SMESH_Mesh_var aMesh = ConvertIOinMesh(IO, res);
6044                 if (res)
6045                 {
6046                         SMESH_Actor *ac = FindActorByEntry(IO->getEntry(), res, false);
6047                         if (res)
6048                         {
6049                                 // Check whether the actor belongs to the active view
6050                                 VTKViewer_RenderWindowInteractor *rwInter =
6051                                         ((VTKViewer_ViewFrame *) myActiveStudy->
6052                                         getActiveStudyFrame()->getRightFrame()->getViewFrame())->
6053                                         getRWInteractor();
6054
6055                                 // The actor belongs to inactive view -> create a copy and display it in the active view
6056                                 if (!rwInter->isInViewer(IO))
6057                                 {
6058                                         SMESH_Actor *acCopy = SMESH_Actor::New();
6059                                         acCopy->ShallowCopy(ac);
6060
6061                                         smeshGUI->DisplayActor(acCopy, false);
6062                                 }
6063                                 ac = ReadScript(aMesh);
6064                                 if (ac != NULL)
6065                                 {
6066 #ifdef TRACE
6067                                         Dump(ac);
6068 #endif
6069                                         DisplayActor(ac);
6070                                         DisplayEdges(ac);
6071                                         smeshGUI->ChangeRepresentation(ac, ac->getDisplayMode());
6072                                 }
6073                         }
6074                 }
6075         }
6076 }
6077
6078 //=============================================================================
6079 /*!
6080  *
6081  */
6082 //=============================================================================
6083 vtkActor *SMESHGUI::SimulationMoveNode(SMESH_Actor * Mactor, int idnode)
6084 {
6085         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6086                 return NULL;
6087
6088         mySimulationActors = vtkActorCollection::New();
6089         vtkRenderer *theRenderer =
6090                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6091                 getRightFrame()->getViewFrame())->getRenderer();
6092
6093         vtkUnstructuredGrid *ugrid =
6094                 vtkUnstructuredGrid::SafeDownCast(Mactor->DataSource);
6095         vtkIdList *IdCells = vtkIdList::New();
6096         ugrid->GetPointCells(idnode, IdCells);
6097
6098         vtkPoints *Pts = vtkPoints::New();
6099         Pts = ugrid->GetPoints();
6100
6101         vtkUnstructuredGrid *ugridSimulation = vtkUnstructuredGrid::New();
6102         ugridSimulation->SetPoints(Pts);
6103         vtkIdList *IdPts = vtkIdList::New();
6104         for (int j = 0; j < IdCells->GetNumberOfIds(); j++)
6105         {
6106                 ugrid->GetCellPoints(IdCells->GetId(j), IdPts);
6107                 ugridSimulation->InsertNextCell(ugrid->GetCellType(IdCells->GetId(j)),
6108                         IdPts);
6109         }
6110
6111         vtkProperty *prop = vtkProperty::New();
6112         prop->SetColor(1., 0., 0.);
6113         prop->SetRepresentationToWireframe();
6114
6115         int Edgewidth = (int)Mactor->EdgeDevice->GetProperty()->GetLineWidth();
6116         if (Edgewidth == 0)
6117                 Edgewidth = 1;
6118         prop->SetLineWidth(Edgewidth + 1);
6119
6120         vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
6121         Mapper->SetInput(ugridSimulation);
6122         vtkActor *ac = vtkActor::New();
6123         ac->SetMapper(Mapper);
6124         ac->SetProperty(prop);
6125
6126         ac->GetMapper()->SetResolveCoincidentTopologyToShiftZBuffer();
6127         ac->GetMapper()->SetResolveCoincidentTopologyZShift(0.02);
6128
6129         mySimulationActors->AddItem(ac);
6130         theRenderer->AddActor(ac);
6131
6132         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6133         renWin->Render();
6134
6135         return ac;
6136 }
6137
6138 //=============================================================================
6139 /*!
6140  *
6141  */
6142 //=============================================================================
6143 void SMESHGUI::DisplaySimulationNode(SMESH::SMESH_Mesh_ptr aMesh, float x,
6144         float y, float z)
6145 {
6146         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6147                 return;
6148
6149         EraseSimulationActors();
6150         mySimulationActors = vtkActorCollection::New();
6151         vtkRenderer *theRenderer =
6152                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6153                 getRightFrame()->getViewFrame())->getRenderer();
6154         Standard_Boolean result;
6155         SMESH_Actor *ac = FindActor(aMesh, result, true);
6156
6157         if (result)
6158         {
6159                 vtkUnstructuredGrid *ugrid =
6160                         vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6161                 vtkUnstructuredGrid *newugrid = vtkUnstructuredGrid::New();
6162
6163                 vtkPoints *Pts = ugrid->GetPoints();
6164                 vtkPoints *newPts = vtkPoints::New();
6165                 int nbPts = Pts->GetNumberOfPoints();
6166                 for (int i = 0; i < nbPts; i++)
6167                 {
6168                         newPts->InsertPoint(i, Pts->GetPoint(i));
6169                 }
6170
6171                 newugrid->SetPoints(newPts);
6172                 newugrid->GetPoints()->InsertNextPoint(x, y, z);
6173
6174                 vtkMaskPoints *verts = vtkMaskPoints::New();
6175                 verts->SetInput(newugrid);
6176                 verts->SetGenerateVertices(1);
6177                 verts->SetOnRatio(1);
6178
6179                 vtkPolyDataMapper *vertMapper = vtkPolyDataMapper::New();
6180                 vertMapper->SetInput(verts->GetOutput());
6181                 vertMapper->ScalarVisibilityOff();
6182
6183                 vtkActor *node = vtkActor::New();
6184                 node->SetMapper(vertMapper);
6185
6186                 QString SCr = QAD_CONFIG->getSetting("SMESH:SettingsNodeColorRed");
6187                 QString SCg = QAD_CONFIG->getSetting("SMESH:SettingsNodeColorGreen");
6188                 QString SCb = QAD_CONFIG->getSetting("SMESH:SettingsNodeColorBlue");
6189                 QColor nodecolor(SCr.toInt(), SCg.toInt(), SCb.toInt());
6190                 if (!nodecolor.isValid())
6191 //       nodecolor = QColor(0.,1.,0.);
6192                         nodecolor = QColor(0, 1, 0);
6193
6194                 node->GetProperty()->SetColor(float (nodecolor.red()) / 255.,
6195                         float (nodecolor.green()) / 255., float (nodecolor.blue()) / 255.);
6196
6197                 int intValue =
6198                         QAD_CONFIG->getSetting("SMESH:SettingsNodesSize").toInt();
6199                 if (intValue < 1)
6200                         intValue == 1;
6201
6202                 node->GetProperty()->SetPointSize(intValue);
6203
6204                 node->VisibilityOn();
6205
6206                 mySimulationActors->AddItem(node);
6207                 theRenderer->AddActor(node);
6208         }
6209
6210         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6211         renWin->Render();
6212 }
6213
6214 //=============================================================================
6215 /*!
6216  *
6217  */
6218 //=============================================================================
6219 void SMESHGUI::DisplaySimulationMoveNode(vtkActor * ac, int idnode, float x,
6220         float y, float z)
6221 {
6222         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6223                 return;
6224
6225         vtkRenderer *theRenderer =
6226                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6227                 getRightFrame()->getViewFrame())->getRenderer();
6228         float *pt = ac->GetMapper()->GetInput()->GetPoint(idnode);
6229         pt[0] = x;
6230         pt[1] = y;
6231         pt[2] = z;
6232
6233         ac->GetMapper()->ImmediateModeRenderingOn();
6234         ac->GetProperty()->SetRepresentationToWireframe();
6235
6236         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6237
6238         renWin->Render();
6239 }
6240
6241 //=============================================================================
6242 /*!
6243  *
6244  */
6245 //=============================================================================
6246 void SMESHGUI::MoveNode(SMESH::SMESH_Mesh_ptr aMesh, int idnode, float x,
6247         float y, float z)
6248 {
6249         Standard_Boolean result;
6250
6251         SMESH_Actor *MeshActor = FindActor(aMesh, result, true);
6252         if (result)
6253         {
6254         }
6255 }
6256
6257 //=============================================================================
6258 /*!
6259  *
6260  */
6261 //=============================================================================
6262 void SMESHGUI::ScalarVisibilityOff()
6263 {
6264         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6265                 return;
6266
6267         vtkRenderer *theRenderer =
6268                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6269                 getRightFrame()->getViewFrame())->getRenderer();
6270         vtkActorCollection *actorList = theRenderer->GetActors();
6271
6272         actorList->InitTraversal();
6273         vtkActor *ac = actorList->GetNextActor();
6274         while (!(ac == NULL))
6275         {
6276                 if (ac->IsA("SMESH_Actor"))
6277                 {
6278                         SMESH_Actor *anActor = SMESH_Actor::SafeDownCast(ac);
6279                         if (anActor->GetVisibility() == 1)
6280                         {
6281                                 vtkDataSetMapper *meshMapper =
6282                                         (vtkDataSetMapper *) (anActor->getMapper());
6283                                 meshMapper->ScalarVisibilityOff();
6284                                 meshMapper->SetInput(anActor->DataSource);
6285                                 ChangeRepresentation(anActor, anActor->getDisplayMode());
6286                         }
6287                 }
6288                 ac = actorList->GetNextActor();
6289         }
6290
6291         theRenderer->Render();
6292 }
6293
6294 //=============================================================================
6295 /*!
6296  *
6297  */
6298 //=============================================================================
6299 void SMESHGUI::DisplaySimulationEdge(SMESH::SMESH_Mesh_ptr aMesh,
6300         const TColStd_MapOfInteger & MapIndex)
6301 {
6302         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6303                 return;
6304
6305         EraseSimulationActors();
6306         mySimulationActors = vtkActorCollection::New();
6307         vtkRenderer *theRenderer =
6308                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6309                 getRightFrame()->getViewFrame())->getRenderer();
6310         Standard_Boolean result;
6311         SMESH_Actor *ac = FindActor(aMesh, result, true);
6312         if (result)
6313         {
6314                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6315                 int idNodes[2];
6316                 int pts[2];
6317                 int i = 0;
6318                 vtkIdList *Ids = vtkIdList::New();
6319                 for (; ite.More(); ite.Next())
6320                 {
6321                         idNodes[i] = ite.Key();
6322                         i++;
6323                 }
6324
6325                 Ids->InsertId(0, idNodes[0]);
6326                 pts[0] = idNodes[0];
6327                 Ids->InsertId(1, idNodes[1]);
6328                 pts[1] = idNodes[1];
6329
6330                 vtkUnstructuredGrid *ugrid =
6331                         vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6332                 vtkUnstructuredGrid *newugrid = vtkUnstructuredGrid::New();
6333                 newugrid->SetPoints(ugrid->GetPoints());
6334                 newugrid->InsertNextCell(VTK_LINE, 2, pts);
6335
6336                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
6337                 Mapper->SetInput(newugrid);
6338                 Mapper->Update();
6339
6340                 vtkActor *edge = vtkActor::New();
6341                 edge->SetMapper(Mapper);
6342                 edge->SetProperty(ac->GetProperty());
6343                 edge->SetBackfaceProperty(ac->GetBackfaceProperty());
6344                 edge->VisibilityOn();
6345                 mySimulationActors->AddItem(edge);
6346                 theRenderer->AddActor(edge);
6347         }
6348
6349         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6350         renWin->Render();
6351 }
6352
6353 //=============================================================================
6354 /*!
6355  *
6356  */
6357 //=============================================================================
6358 void SMESHGUI::DisplaySimulationTriangle(SMESH::SMESH_Mesh_ptr aMesh,
6359         const TColStd_MapOfInteger & MapIndex, bool reverse)
6360 {
6361         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6362                 return;
6363
6364         EraseSimulationActors();
6365         mySimulationActors = vtkActorCollection::New();
6366         vtkRenderer *theRenderer =
6367                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6368                 getRightFrame()->getViewFrame())->getRenderer();
6369         Standard_Boolean result;
6370         SMESH_Actor *ac = FindActor(aMesh, result, true);
6371         if (result)
6372         {
6373                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6374                 int idNodes[3];
6375                 int pts[3];
6376                 int i = 0;
6377                 vtkIdList *Ids = vtkIdList::New();
6378                 for (; ite.More(); ite.Next())
6379                 {
6380                         idNodes[i] = ite.Key();
6381                         i++;
6382                 }
6383
6384                 if (reverse)
6385                 {
6386                         Ids->InsertId(0, idNodes[2]);
6387                         pts[0] = idNodes[2];
6388                         Ids->InsertId(1, idNodes[1]);
6389                         pts[1] = idNodes[1];
6390                         Ids->InsertId(2, idNodes[0]);
6391                         pts[2] = idNodes[0];
6392                 }
6393                 else
6394                 {
6395                         Ids->InsertId(0, idNodes[0]);
6396                         pts[0] = idNodes[0];
6397                         Ids->InsertId(1, idNodes[1]);
6398                         pts[1] = idNodes[1];
6399                         Ids->InsertId(2, idNodes[2]);
6400                         pts[2] = idNodes[2];
6401                 }
6402                 vtkUnstructuredGrid *ugrid =
6403                         vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6404                 vtkUnstructuredGrid *newugrid = vtkUnstructuredGrid::New();
6405                 newugrid->SetPoints(ugrid->GetPoints());
6406                 newugrid->InsertNextCell(VTK_TRIANGLE, 3, pts);
6407
6408                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
6409                 Mapper->SetInput(newugrid);
6410                 Mapper->Update();
6411
6412                 vtkActor *tri = vtkActor::New();
6413                 tri->SetMapper(Mapper);
6414                 tri->SetProperty(ac->GetProperty());
6415                 tri->SetBackfaceProperty(ac->GetBackfaceProperty());
6416                 tri->VisibilityOn();
6417                 mySimulationActors->AddItem(tri);
6418                 theRenderer->AddActor(tri);
6419         }
6420
6421         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6422         renWin->Render();
6423 }
6424
6425 //=============================================================================
6426 /*!
6427  *
6428  */
6429 //=============================================================================
6430 void SMESHGUI::DisplaySimulationQuadrangle(SMESH::SMESH_Mesh_ptr aMesh,
6431         const TColStd_MapOfInteger & MapIndex, bool reverse)
6432 {
6433         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6434                 return;
6435
6436         EraseSimulationActors();
6437         mySimulationActors = vtkActorCollection::New();
6438         vtkRenderer *theRenderer =
6439                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6440                 getRightFrame()->getViewFrame())->getRenderer();
6441         Standard_Boolean result;
6442         SMESH_Actor *ac = FindActor(aMesh, result, true);
6443
6444         vtkUnstructuredGrid *ugrid =
6445                 vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6446
6447         if (result)
6448         {
6449                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6450                 int i = 0;
6451                 int idNodes[4];
6452                 vtkIdList *Ids = vtkIdList::New();
6453                 for (; ite.More(); ite.Next())
6454                 {
6455                         idNodes[i] = ite.Key();
6456                         i++;
6457                 }
6458
6459                 float *p0 = ugrid->GetPoint(idNodes[0]);
6460                 float *p1 = ugrid->GetPoint(idNodes[1]);
6461                 float *p2 = ugrid->GetPoint(idNodes[2]);
6462                 float *p3 = ugrid->GetPoint(idNodes[3]);
6463
6464                 gp_Pnt P0(p0[0], p0[1], p0[2]);
6465
6466                 gp_Vec V1(P0, gp_Pnt(p1[0], p1[1], p1[2]));
6467                 gp_Vec V2(P0, gp_Pnt(p2[0], p2[1], p2[2]));
6468                 gp_Vec V3(P0, gp_Pnt(p3[0], p3[1], p3[2]));
6469
6470                 gp_Vec Cross1 = V1 ^ V2;
6471                 gp_Vec Cross2 = V2 ^ V3;
6472
6473                 int tmp;
6474                 if (Cross1.Dot(Cross2) < 0)
6475                 {
6476                         V1 = gp_Vec(P0, gp_Pnt(p2[0], p2[1], p2[2]));
6477                         V2 = gp_Vec(P0, gp_Pnt(p1[0], p1[1], p1[2]));
6478                         Cross1 = V1 ^ V2;
6479                         Cross2 = V2 ^ V3;
6480
6481                         if (Cross1.Dot(Cross2) < 0)
6482                         {
6483                                 tmp = idNodes[2];
6484                                 idNodes[2] = idNodes[3];
6485                                 idNodes[3] = tmp;
6486                         }
6487                         else
6488                         {
6489                                 tmp = idNodes[1];
6490                                 idNodes[1] = idNodes[2];
6491                                 idNodes[2] = tmp;
6492                         }
6493                 }
6494
6495                 if (reverse)
6496                 {
6497                         Ids->InsertId(0, idNodes[3]);
6498                         Ids->InsertId(1, idNodes[2]);
6499                         Ids->InsertId(2, idNodes[1]);
6500                         Ids->InsertId(3, idNodes[0]);
6501                 }
6502                 else
6503                 {
6504                         Ids->InsertId(0, idNodes[0]);
6505                         Ids->InsertId(1, idNodes[1]);
6506                         Ids->InsertId(2, idNodes[2]);
6507                         Ids->InsertId(3, idNodes[3]);
6508                 }
6509
6510                 //    vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( ac->DataSource );
6511                 vtkUnstructuredGrid *newugrid = vtkUnstructuredGrid::New();
6512                 newugrid->SetPoints(ugrid->GetPoints());
6513                 newugrid->InsertNextCell(VTK_QUAD, Ids);
6514
6515                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
6516                 Mapper->SetInput(newugrid);
6517                 Mapper->Update();
6518
6519                 vtkActor *quad = vtkActor::New();
6520                 quad->SetMapper(Mapper);
6521                 quad->SetProperty(ac->GetProperty());
6522                 quad->SetBackfaceProperty(ac->GetBackfaceProperty());
6523                 quad->VisibilityOn();
6524                 mySimulationActors->AddItem(quad);
6525                 theRenderer->AddActor(quad);
6526         }
6527         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6528         renWin->Render();
6529 }
6530
6531 //=============================================================================
6532 /*!
6533  *
6534  */
6535 //=============================================================================
6536 void SMESHGUI::DisplaySimulationTetra(SMESH::SMESH_Mesh_ptr aMesh,
6537         const TColStd_MapOfInteger & MapIndex)
6538 {
6539         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6540                 return;
6541
6542         EraseSimulationActors();
6543         mySimulationActors = vtkActorCollection::New();
6544         vtkRenderer *theRenderer =
6545                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6546                 getRightFrame()->getViewFrame())->getRenderer();
6547         Standard_Boolean result;
6548         SMESH_Actor *ac = FindActor(aMesh, result, true);
6549         if (result)
6550         {
6551                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6552                 int i = 0;
6553                 int idNodes[4];
6554                 vtkIdList *Ids = vtkIdList::New();
6555                 for (; ite.More(); ite.Next())
6556                 {
6557                         idNodes[i] = ite.Key();
6558                         i++;
6559                 }
6560
6561                 Ids->InsertId(0, idNodes[0]);
6562                 Ids->InsertId(1, idNodes[1]);
6563                 Ids->InsertId(2, idNodes[2]);
6564                 Ids->InsertId(3, idNodes[3]);
6565
6566                 vtkUnstructuredGrid *ugrid =
6567                         vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6568                 vtkUnstructuredGrid *newugrid = vtkUnstructuredGrid::New();
6569                 newugrid->SetPoints(ugrid->GetPoints());
6570                 newugrid->InsertNextCell(VTK_TETRA, Ids);
6571
6572                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
6573                 Mapper->SetInput(newugrid);
6574                 Mapper->Update();
6575
6576                 vtkActor *tetra = vtkActor::New();
6577                 tetra->SetMapper(Mapper);
6578                 tetra->SetProperty(ac->GetProperty());
6579                 tetra->SetBackfaceProperty(ac->GetBackfaceProperty());
6580                 tetra->VisibilityOn();
6581                 mySimulationActors->AddItem(tetra);
6582                 theRenderer->AddActor(tetra);
6583         }
6584         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6585         renWin->Render();
6586 }
6587
6588 //=============================================================================
6589 /*!
6590  *
6591  */
6592 //=============================================================================
6593 void SMESHGUI::DisplaySimulationHexa(SMESH::SMESH_Mesh_ptr aMesh,
6594         const TColStd_MapOfInteger & MapIndex)
6595 {
6596         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6597                 return;
6598
6599         EraseSimulationActors();
6600         mySimulationActors = vtkActorCollection::New();
6601         vtkRenderer *theRenderer =
6602                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6603                 getRightFrame()->getViewFrame())->getRenderer();
6604         Standard_Boolean result;
6605         SMESH_Actor *ac = FindActor(aMesh, result, true);
6606         if (result)
6607         {
6608                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6609                 int i = 0;
6610                 int idNodes[8];
6611                 vtkIdList *Ids = vtkIdList::New();
6612                 for (; ite.More(); ite.Next())
6613                 {
6614                         idNodes[i] = ite.Key();
6615                         i++;
6616                 }
6617
6618                 Ids->InsertId(0, idNodes[0]);
6619                 Ids->InsertId(1, idNodes[1]);
6620                 Ids->InsertId(2, idNodes[2]);
6621                 Ids->InsertId(3, idNodes[3]);
6622                 Ids->InsertId(4, idNodes[4]);
6623                 Ids->InsertId(5, idNodes[5]);
6624                 Ids->InsertId(6, idNodes[6]);
6625                 Ids->InsertId(7, idNodes[7]);
6626
6627                 vtkUnstructuredGrid *ugrid =
6628                         vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6629                 vtkUnstructuredGrid *newugrid = vtkUnstructuredGrid::New();
6630                 newugrid->SetPoints(ugrid->GetPoints());
6631                 newugrid->InsertNextCell(VTK_HEXAHEDRON, Ids);
6632
6633                 vtkDataSetMapper *Mapper = vtkDataSetMapper::New();
6634                 Mapper->SetInput(newugrid);
6635                 Mapper->Update();
6636
6637                 vtkActor *hexa = vtkActor::New();
6638                 hexa->SetMapper(Mapper);
6639                 hexa->SetProperty(ac->GetProperty());
6640                 hexa->SetBackfaceProperty(ac->GetBackfaceProperty());
6641                 hexa->VisibilityOn();
6642                 mySimulationActors->AddItem(hexa);
6643                 theRenderer->AddActor(hexa);
6644         }
6645         vtkRenderWindow *renWin = theRenderer->GetRenderWindow();
6646         renWin->Render();
6647 }
6648
6649 //=============================================================================
6650 /*!
6651  *
6652  */
6653 //=============================================================================
6654 void SMESHGUI::AddFace(SMESH::SMESH_Mesh_ptr aMesh,
6655         const TColStd_MapOfInteger & MapIndex, bool reverse)
6656 {
6657         QApplication::setOverrideCursor(Qt::waitCursor);
6658         Standard_Boolean result;
6659         SMESH_Actor *ac = FindActor(aMesh, result, true);
6660         if (result)
6661         {
6662                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6663                 SMESH::long_array_var anArrayOfIdeces = new SMESH::long_array;
6664                 anArrayOfIdeces->length(MapIndex.Extent());
6665
6666                 int i = 0;
6667                 for (; ite.More(); ite.Next())
6668                 {
6669                         anArrayOfIdeces[i] = ac->GetIdSMESHDSNode(ite.Key());
6670                         i++;
6671                 }
6672
6673                 int tmp;
6674                 if (MapIndex.Extent() == 4)
6675                 {
6676                         int idNodes[4];
6677                         int i = 0;
6678                         TColStd_MapIteratorOfMapOfInteger ite1(MapIndex);
6679                         for (; ite1.More(); ite1.Next())
6680                         {
6681                                 idNodes[i] = ite1.Key();
6682                                 i++;
6683                         }
6684
6685                         vtkUnstructuredGrid *ugrid =
6686                                 vtkUnstructuredGrid::SafeDownCast(ac->DataSource);
6687                         float *p0 = ugrid->GetPoint(idNodes[0]);
6688                         float *p1 = ugrid->GetPoint(idNodes[1]);
6689                         float *p2 = ugrid->GetPoint(idNodes[2]);
6690                         float *p3 = ugrid->GetPoint(idNodes[3]);
6691
6692                         gp_Pnt P0(p0[0], p0[1], p0[2]);
6693
6694                         gp_Vec V1(P0, gp_Pnt(p1[0], p1[1], p1[2]));
6695                         gp_Vec V2(P0, gp_Pnt(p2[0], p2[1], p2[2]));
6696                         gp_Vec V3(P0, gp_Pnt(p3[0], p3[1], p3[2]));
6697
6698                         gp_Vec Cross1 = V1 ^ V2;
6699                         gp_Vec Cross2 = V2 ^ V3;
6700
6701                         if (Cross1.Dot(Cross2) < 0)
6702                         {
6703
6704                                 V1 = gp_Vec(P0, gp_Pnt(p2[0], p2[1], p2[2]));
6705                                 V2 = gp_Vec(P0, gp_Pnt(p1[0], p1[1], p1[2]));
6706                                 Cross1 = V1 ^ V2;
6707                                 Cross2 = V2 ^ V3;
6708
6709                                 if (Cross1.Dot(Cross2) < 0)
6710                                 {
6711                                         tmp = anArrayOfIdeces[2];
6712                                         anArrayOfIdeces[2] = anArrayOfIdeces[3];
6713                                         anArrayOfIdeces[3] = tmp;
6714                                 }
6715                                 else
6716                                 {
6717                                         tmp = anArrayOfIdeces[1];
6718                                         anArrayOfIdeces[1] = anArrayOfIdeces[2];
6719                                         anArrayOfIdeces[2] = tmp;
6720                                 }
6721                         }
6722                 }
6723
6724                 //    int tmp;
6725                 if (reverse)
6726                 {
6727                         for (i = 0; i < (MapIndex.Extent() / 2); i++)
6728                         {
6729                                 tmp = anArrayOfIdeces[i];
6730                                 anArrayOfIdeces[i] = anArrayOfIdeces[MapIndex.Extent() - i - 1];
6731                                 anArrayOfIdeces[MapIndex.Extent() - i - 1] = tmp;
6732                         }
6733                 }
6734                 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
6735                 aMeshEditor->AddFace(anArrayOfIdeces);
6736         }
6737         if (myAutomaticUpdate)
6738         {
6739                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
6740                 if (Mesh != NULL)
6741                 {
6742                         smeshGUI->DisplayActor(Mesh);
6743                         smeshGUI->DisplayEdges(Mesh);
6744                         smeshGUI->ChangeRepresentation(Mesh, Mesh->getDisplayMode());
6745                         AddActorInSelection(Mesh);
6746                 }
6747         }
6748         QApplication::restoreOverrideCursor();
6749 }
6750
6751 //=============================================================================
6752 /*!
6753  *
6754  */
6755 //=============================================================================
6756 void SMESHGUI::AddVolume(SMESH::SMESH_Mesh_ptr aMesh,
6757         const TColStd_MapOfInteger & MapIndex)
6758 {
6759         QApplication::setOverrideCursor(Qt::waitCursor);
6760         Standard_Boolean result;
6761         SMESH_Actor *ac = FindActor(aMesh, result, true);
6762         if (result)
6763         {
6764                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6765                 SMESH::long_array_var anArrayOfIdeces = new SMESH::long_array;
6766                 anArrayOfIdeces->length(MapIndex.Extent());
6767
6768                 int i = 0;
6769                 for (; ite.More(); ite.Next())
6770                 {
6771                         anArrayOfIdeces[i] = ac->GetIdSMESHDSNode(ite.Key());
6772                         i++;
6773                 }
6774
6775                 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
6776                 aMeshEditor->AddVolume(anArrayOfIdeces);
6777         }
6778         if (myAutomaticUpdate)
6779         {
6780                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
6781                 if (Mesh != NULL)
6782                 {
6783                         smeshGUI->DisplayActor(Mesh);
6784                         smeshGUI->DisplayEdges(Mesh);
6785                         smeshGUI->ChangeRepresentation(Mesh, Mesh->getDisplayMode());
6786                         AddActorInSelection(Mesh);
6787                 }
6788         }
6789         QApplication::restoreOverrideCursor();
6790 }
6791
6792 //=============================================================================
6793 /*!
6794  *
6795  */
6796 //=============================================================================
6797 void SMESHGUI::AddEdge(SMESH::SMESH_Mesh_ptr aMesh,
6798         const TColStd_MapOfInteger & MapIndex)
6799 {
6800         QApplication::setOverrideCursor(Qt::waitCursor);
6801         Standard_Boolean result;
6802         SMESH_Actor *ac = FindActor(aMesh, result, true);
6803         if (result)
6804         {
6805                 TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
6806                 SMESH::long_array_var anArrayOfIdeces = new SMESH::long_array;
6807                 anArrayOfIdeces->length(MapIndex.Extent());
6808
6809                 int i = 0;
6810                 for (; ite.More(); ite.Next())
6811                 {
6812                         anArrayOfIdeces[i] = ac->GetIdSMESHDSNode(ite.Key());
6813                         i++;
6814                 }
6815
6816                 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
6817                 aMeshEditor->AddEdge(anArrayOfIdeces);
6818         }
6819         if (myAutomaticUpdate)
6820         {
6821                 SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
6822                 if (Mesh != NULL)
6823                 {
6824                         smeshGUI->DisplayActor(Mesh);
6825                         smeshGUI->DisplayEdges(Mesh);
6826                         smeshGUI->ChangeRepresentation(Mesh, Mesh->getDisplayMode());
6827                         AddActorInSelection(Mesh);
6828                 }
6829         }
6830         QApplication::restoreOverrideCursor();
6831 }
6832
6833 //=============================================================================
6834 /*!
6835  *
6836  */
6837 //=============================================================================
6838 void SMESHGUI::AddNode(SMESH::SMESH_Mesh_ptr aMesh, float x, float y, float z)
6839 {
6840         QApplication::setOverrideCursor(Qt::waitCursor);
6841         Standard_Boolean result;
6842         SMESH_Actor *ac = FindActor(aMesh, result, true);
6843         if (result)
6844         {
6845                 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
6846                 aMeshEditor->AddNode(x, y, z);
6847
6848                 if (myAutomaticUpdate)
6849                 {
6850                         SMESH_Actor *Mesh = smeshGUI->ReadScript(aMesh);
6851                         if (Mesh != NULL)
6852                         {
6853                                 smeshGUI->DisplayActor(Mesh);
6854                                 smeshGUI->DisplayEdges(Mesh);
6855                                 smeshGUI->ChangeRepresentation(Mesh, Mesh->getDisplayMode());
6856                                 AddActorInSelection(Mesh);
6857                         }
6858                 }
6859         }
6860         QApplication::restoreOverrideCursor();
6861 }
6862
6863 //=============================================================================
6864 /*!
6865  *
6866  */
6867 //=============================================================================
6868 void SMESHGUI::DisplayEdgesConnectivityLegendBox(vtkActor * ac)
6869 {
6870         if (myActiveStudy->getActiveStudyFrame()->getTypeView() != VIEW_VTK)
6871                 return;
6872
6873         EraseSimulationActors();
6874         mySimulationActors2D = vtkActor2DCollection::New();
6875
6876         vtkRenderer *theRenderer =
6877                 ((VTKViewer_ViewFrame *) myActiveStudy->getActiveStudyFrame()->
6878                 getRightFrame()->getViewFrame())->getRenderer();
6879
6880         vtkGlyphSource2D *gs2 = vtkGlyphSource2D::New();
6881         gs2->SetGlyphTypeToTriangle();
6882         gs2->FilledOff();
6883
6884         vtkLegendBoxActor *legend = vtkLegendBoxActor::New();
6885         legend->GetPositionCoordinate()->SetValue(0.025, 0.025, 0.);
6886         legend->GetPosition2Coordinate()->SetValue(0.3, 0.3, 0.);       //relative to Position
6887
6888         legend->SetNumberOfEntries(4);
6889         legend->SetEntryString(0, tr("SMESH_BOUNDARYEDGES"));
6890         legend->SetEntrySymbol(0, gs2->GetOutput());
6891         legend->SetEntryColor(0, ac->GetMapper()->GetLookupTable()->GetColor(0.));
6892         legend->SetEntryString(1, tr("SMESH_MANIFOLDEDGES"));
6893         legend->SetEntrySymbol(1, gs2->GetOutput());
6894         legend->SetEntryColor(1,
6895                 ac->GetMapper()->GetLookupTable()->GetColor(0.666667));
6896         legend->SetEntryString(2, tr("SMESH_NONMANIFOLDEDGES"));
6897         legend->SetEntrySymbol(2, gs2->GetOutput());
6898         legend->SetEntryColor(2,
6899                 ac->GetMapper()->GetLookupTable()->GetColor(0.222222));
6900         legend->SetEntryString(3, tr("SMESH_FEATUREEDGES"));
6901         legend->SetEntrySymbol(3, gs2->GetOutput());
6902         legend->SetEntryColor(3,
6903                 ac->GetMapper()->GetLookupTable()->GetColor(0.444444));
6904         legend->SetPadding(5);
6905         //  legend->GetProperty()->SetColor();
6906
6907         mySimulationActors2D->AddItem(legend);
6908         theRenderer->AddActor2D(legend);
6909
6910         // Update the view
6911         myActiveStudy->getActiveStudyFrame()->getRightFrame()->getViewFrame()->
6912                 Repaint();
6913 }
6914
6915 //===============================================================================
6916 // function : OnEditDelete()
6917 // purpose  :
6918 //===============================================================================
6919 void SMESHGUI::OnEditDelete()
6920 {
6921         if (QAD_MessageBox::warn2
6922                 (QAD_Application::getDesktop(),
6923                         tr("SMESH_WRN_WARNING"),
6924                         tr("SMESH_REALLY_DELETE"),
6925                         tr("SMESH_BUT_YES"), tr("SMESH_BUT_NO"), 1, 0, 0) != 1)
6926                 return;
6927
6928         int nbSf = myActiveStudy->getStudyFramesCount();
6929
6930         Standard_Boolean found;
6931         SALOMEDS::Study_var aStudy = myActiveStudy->getStudyDocument();
6932         SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
6933         SALOMEDS::GenericAttribute_var anAttr;
6934         SALOMEDS::AttributeIOR_var anIOR;
6935
6936         SALOME_Selection *Sel =
6937                 SALOME_Selection::Selection(myActiveStudy->getSelection());
6938         SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
6939         for (; It.More(); It.Next())
6940         {
6941                 Handle(SALOME_InteractiveObject) IObject = It.Value();
6942                 if (IObject->hasEntry())
6943                 {
6944                         SALOMEDS::SObject_var SO =
6945                                 myStudy->FindObjectID(IObject->getEntry());
6946
6947                         /* Erase child graphical objects */
6948                         SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(SO);
6949                         for (; it->More(); it->Next())
6950                         {
6951                                 SALOMEDS::SObject_var CSO = it->Value();
6952                                 if (CSO->FindAttribute(anAttr, "AttributeIOR"))
6953                                 {
6954                                         anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
6955
6956                                         for (int i = 0; i < nbSf; i++)
6957                                         {
6958                                                 QAD_StudyFrame *sf = myActiveStudy->getStudyFrame(i);
6959                                                 if (sf->getTypeView() == VIEW_VTK)
6960                                                 {
6961                                                         vtkRenderer *Renderer =
6962                                                                 ((VTKViewer_ViewFrame *) smeshGUI->
6963                                                                 myActiveStudy->getActiveStudyFrame()->
6964                                                                 getRightFrame()->getViewFrame())->getRenderer();
6965                                                         SMESH_Actor *ac =
6966                                                                 smeshGUI->FindActorByEntry(CSO->GetID(), found,
6967                                                                 false);
6968                                                         if (found)
6969                                                         {
6970                                                                 Renderer->RemoveActor(ac->EdgeDevice);
6971                                                                 Renderer->RemoveActor(ac->EdgeShrinkDevice);
6972                                                                 Renderer->RemoveActor(ac);
6973                                                         }
6974                                                 }
6975                                         }
6976                                 }
6977                         }
6978
6979                         /* Erase main graphical object */
6980                         for (int i = 0; i < nbSf; i++)
6981                         {
6982                                 QAD_StudyFrame *sf = myActiveStudy->getStudyFrame(i);
6983                                 if (sf->getTypeView() == VIEW_VTK)
6984                                 {
6985                                         vtkRenderer *Renderer =
6986                                                 ((VTKViewer_ViewFrame *) smeshGUI->myActiveStudy->
6987                                                 getActiveStudyFrame()->getRightFrame()->
6988                                                 getViewFrame())->getRenderer();
6989                                         VTKViewer_RenderWindowInteractor *myRenderInter =
6990                                                 ((VTKViewer_ViewFrame *) sf->getRightFrame()->
6991                                                 getViewFrame())->getRWInteractor();
6992                                         SMESH_Actor *ac =
6993                                                 smeshGUI->FindActorByEntry(IObject->getEntry(), found,
6994                                                 false);
6995                                         if (found)
6996                                         {
6997                                                 Renderer->RemoveActor(ac->EdgeDevice);
6998                                                 Renderer->RemoveActor(ac->EdgeShrinkDevice);
6999                                         }
7000                                         myRenderInter->Remove(IObject);
7001                                 }
7002                         }
7003
7004                         /* Erase objects in Study */
7005                         SALOMEDS::SObject_var obj =
7006                                 myStudy->FindObjectID(IObject->getEntry());
7007                         if (!obj->_is_nil())
7008                         {
7009                                 QAD_Operation *op =
7010                                         new SALOMEGUI_ImportOperation(myActiveStudy);
7011                                 op->start();
7012                                 aStudyBuilder->RemoveObject(obj);
7013                                 op->finish();
7014                         }
7015
7016                 }                                               /* IObject->hasEntry() */
7017         }                                                       /* more/next           */
7018
7019         /* Clear any previous selection */
7020         Sel->ClearIObjects();
7021         myActiveStudy->updateObjBrowser();
7022 }