src/HEXABLOCKGUI/HEXABLOCKGUI.cxx

   1 // Copyright (C) 2009-2016  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 //#define _DEVDEBUG_
  21
  22 #include <cassert>
  23
  24 #include <QDir>
  25 #include <QInputDialog>
  26 #include <QIcon>
  27 #include <QStackedWidget>
  28 #include <QMenu>
  29 #include <QSplitter>
  30
  31 #include <QtxTreeView.h>
  32 #include <SUIT_MessageBox.h>
  33 #include <SUIT_Session.h>
  34 #include <SUIT_ResourceMgr.h>
  35 #include <SUIT_Desktop.h>
  36 #include <SUIT_ViewManager.h>
  37 #include <SUIT_ViewWindow.h>
  38 #include <SUIT_DataObject.h>
  39 #include <SUIT_DataBrowser.h>
  40 #include <SUIT_FileDlg.h>
  41
  42 #include <SVTK_ViewManager.h>
  43 #include <SVTK_ViewModel.h>
  44 #include <SVTK_ViewWindow.h>
  45
  46 #include <VTKViewer_ViewModel.h>
  47 #include <vtkActor.h>
  48 #include <vtkActorCollection.h>
  49 #include <VTKViewer_Algorithm.h>
  50 #include <vtkRenderer.h>
  51
  52
  53
  54 #include <SOCC_ViewModel.h>
  55 #include <SOCC_ViewWindow.h>
  56 #include <OCCViewer_ViewWindow.h>
  57 #include <SALOME_Prs.h>
  58 #include <SOCC_Prs.h>
  59 #include <SOCC.h>
  60
  61 // SALOME KERNEL includes
  62 #include <SALOMEDS_Study.hxx>
  63 #include <SALOMEDSClient_StudyBuilder.hxx>
  64 #include <SALOMEDSClient_SComponent.hxx>
  65 #include <SALOMEDSClient_ClientFactory.hxx>
  66 #include <SALOMEDSClient_IParameters.hxx>
  67
  68
  69
  70 #include <SalomeApp_Study.h>
  71 #include <SalomeApp_Module.h>
  72 #include <SalomeApp_Application.h>
  73 #include <SalomeApp_DataModel.h>
  74
  75
  76 #include <SALOME_ListIO.hxx>
  77
  78
  79 #include <SALOME_LifeCycleCORBA.hxx>
  80
  81 #include <LightApp_VTKSelector.h>
  82
  83 #include <OCCViewer_ViewManager.h>
  84
  85 #include <QtxPopupMgr.h>
  86
  87 #include "Resource.hxx"
  88
  89 #include "HEXABLOCKGUI.hxx"
  90 #include "HEXABLOCKGUI_Export.hxx"
  91 #include "HEXABLOCKGUI_Trace.hxx"
  92 #include "HEXABLOCKGUI_Resource.hxx"
  93
  94 #include "HEXABLOCKGUI_DocumentModel.hxx"
  95 #include "HEXABLOCKGUI_DocumentSelectionModel.hxx"
  96 //#include "HEXABLOCKGUI_DocumentDelegate.hxx"
  97 #include "HEXABLOCKGUI_DocumentPanel.hxx"
  98 #include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
  99 #include "HEXABLOCKGUI_OccGraphicView.hxx"
 100 #include "HEXABLOCKGUI_GraphicViewsHandler.hxx"
 101
 102 #include "HEXABLOCK_version.h"
 103
 104 #include "MyBasicGUI_PointDlg.hxx"
 105
 106 // #include "HEXABLOCK.hxx"                del Hexa6
 107 // #include "HexDocument_impl.hxx"         del Hexa6
 108 #include "Hex.hxx"
 109
 110 //#include <V3d_PerspectiveView.hxx>
 111 #include <V3d_AmbientLight.hxx>
 112 #include <V3d_DirectionalLight.hxx>
 113 #include <Xw_Window.hxx>
 114 #include <V3d_TypeOfShadingModel.hxx>
 115 #include <TCollection_ExtendedString.hxx>
 116
 117 #include <BRepAlgoAPI_Fuse.hxx>
 118
 119 #include <AIS_ListIteratorOfListOfInteractive.hxx>
 120
 121 #include <utilities.h>
 122
 123 #define DW_MINIMUM_WIDTH       50
 124 #define DWINPUT_MINIMUM_HEIGHT 50
 125 #define DWINPUT_MINIMUM_WIDTH  50//255
 126
 127 using namespace std;
 128 using namespace HEXABLOCK::GUI;
 129
 130 int  HEXABLOCKGUI::_oldStudyId = -1;
 131
 132 // HEXABLOCK_ORB::HEXABLOCK_Gen_var HEXABLOCKGUI::_hexaEngine  = HEXABLOCK_ORB::HEXABLOCK_Gen::_nil();
 133 //
 134 VtkDocumentGraphicView* HEXABLOCKGUI::currentDocGView = NULL;
 135 OccGraphicView*         HEXABLOCKGUI::currentOccGView = NULL;
 136 bool                    HEXABLOCKGUI::assocInProgress = false;
 137 SalomeApp_Application*  HEXABLOCKGUI::myApplication = NULL;
 138
 139 HEXABLOCKGUI::HEXABLOCKGUI() :
 140           SalomeApp_Module( "HEXABLOCK" ),
 141 //          LightApp_Module( "HEXABLOCK" ),
 142           _menuId(190),
 143           _dwPattern(0),
 144           _dwAssociation(0),
 145           _dwGroups(0),
 146           _dwMesh(0),
 147           _dwObjectBrowser(0),
 148           _dwInputPanel(0),
 149           _patternDataTreeView(0),
 150 //          _patternBuilderTreeView(0),
 151           _patternGeomTreeView(0),
 152           _groupsTreeView(0),
 153           _meshTreeView(0),
 154 //          _treeViewDelegate(0),
 155           _isSaved( false ),
 156           moduleActivatedOnce(false),
 157           menusEnabled(true),
 158           _vertexDiag(0),
 159           _edgeDiag(0),
 160           _quadDiag(0),
 161           _hexaDiag(0),
 162           _vectorDiag(0),
 163           _cylinderDiag(0),
 164           _pipeDiag(0),
 165           _makeGridDiag(0),
 166           _makeCylinderDiag(0),
 167           _makePipeDiag(0),
 168           _makeCylindersDiag(0),
 169           _makePipesDiag(0),
 170           _removeHexaDiag(0),
 171           _prismQuadDiag(0),
 172           _joinQuadDiag(0),
 173           _mergeDiag(0),
 174           _disconnectDiag(0),
 175           _cutEdgeDiag(0),
 176           _makeTransformationDiag(0),
 177           _makeSymmetryDiag(0),
 178           _performTransformationDiag(0),
 179           _performSymmetryDiag(0),
 180           _vertexAssocDiag(0),
 181           _edgeAssocDiag(0),
 182           _quadAssocDiag(0),
 183           _groupDiag(0),
 184           _lawDiag(0),
 185           _propagationDiag(0),
 186           _computeMeshDiag(0),
 187           _replaceHexaDiag(0),
 188           _quadRevolutionDiag(0),
 189           _makeHemiSphereDiag(0),
 190           _modelInfoDiag(NULL),
 191           _addShapeDiag(NULL),
 192           _vertexInfoDialog(NULL),
 193           _edgeInfoDialog(NULL),
 194           _quadInfoDialog(NULL),
 195           _hexaInfoDialog(NULL),
 196           _vectorInfoDialog(NULL),
 197           _groupInfoDialog(NULL),
 198           _lawInfoDialog(NULL),
 199           _propagationInfoDialog(NULL),
 200           currentDialog(NULL),
 201           lastOccPrs(NULL),
 202           lastVtkDocGView(NULL)
 203 {
 204     DEBTRACE("HEXABLOCKGUI::HEXABLOCKGUI");
 205
 206     graphicViewsHandler = new GraphicViewsHandler();
 207     loadDocLastPath = new QDir();
 208     saveDocLastPath = new QDir();
 209     hexa_root       = HEXA_NS::Hex::getInstance ();
 210 }
 211
 212 HEXABLOCKGUI::~HEXABLOCKGUI()
 213 {
 214 }
 215
 216
 217 SalomeApp_Study* HEXABLOCKGUI::activeStudy()
 218 {
 219     SUIT_Application* app = SUIT_Session::session()->activeApplication();
 220     if( app )
 221         return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
 222     else
 223         return NULL;
 224 }
 225
 226
 227 // Gets an reference to the module's engine
 228 /****************************************************
 229 HEXABLOCK_ORB::HEXABLOCK_Gen_ptr HEXABLOCKGUI::InitHEXABLOCKGen( SalomeApp_Application* app )
 230 {
 231     Engines::EngineComponent_var comp = app->lcc()->FindOrLoad_Component( "FactoryServer", "HEXABLOCK" );
 232     HEXABLOCK_ORB::HEXABLOCK_Gen_ptr clr = HEXABLOCK_ORB::HEXABLOCK_Gen::_narrow(comp);
 233     ASSERT(!CORBA::is_nil(clr));
 234     return clr;
 235 }
 236  **************************************************** */
 237
 238 void HEXABLOCKGUI::initialize( CAM_Application* app )
 239 {
 240         MESSAGE("HEXABLOCKGUI::initialize");
 241     DEBTRACE("HEXABLOCKGUI::initialize");
 242     SalomeApp_Module::initialize( app );
 243
 244     // _hexaEngine = InitHEXABLOCKGen( dynamic_cast<SalomeApp_Application*>( app ) );
 245
 246     DEBTRACE(app << "  " << application() << " " << application()->desktop() << " " << aParent);
 247
 248     SUIT_ResourceMgr* aResourceMgr = app->resourceMgr();
 249     setResource(aResourceMgr);
 250
 251     createAndFillDockWidget();
 252     createActions();
 253     createMenus();
 254     createTools();
 255     studyActivated();
 256 }
 257
 258 void HEXABLOCKGUI::viewManagers( QStringList& list ) const
 259 {
 260     DEBTRACE("HEXABLOCKGUI::viewManagers");
 261     //   list.append( QxScene_Viewer::Type() );
 262     //   list.append( OCCViewer_Viewer::Type() );
 263     //   list.append( SVTK_Viewer::Type() );
 264 }
 265
 266
 267 bool HEXABLOCKGUI::activateModule( SUIT_Study* theStudy )
 268 {
 269     DEBTRACE("HEXABLOCKGUI::activateModule");
 270
 271     /*HexaBlock can be launched in only one application*/
 272     if (myApplication == NULL)
 273         //remember the first application
 274         myApplication = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
 275
 276     //application verification: if it's not the one known by HexaBlock,
 277     //leave without activating
 278     SalomeApp_Application* currentApplication =  dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
 279     if (myApplication != currentApplication) return false;
 280
 281     bool bOk = SalomeApp_Module::activateModule( theStudy );
 282     if ( !bOk ) return false;
 283
 284     showDockWidgets(true);
 285
 286     connect( getApp()->desktop(), SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
 287             this, SLOT(onWindowActivated( SUIT_ViewWindow* )), Qt::UniqueConnection );
 288     connect( getApp()->objectBrowser()->treeView(),SIGNAL( clicked(const QModelIndex&) ),
 289             this, SLOT( onObjectBrowserClick(const QModelIndex&) ), Qt::UniqueConnection );
 290
 291     LightApp_SelectionMgr* sm = getApp()->selectionMgr();
 292
 293     SUIT_ViewManager* vm;
 294     ViewManagerList OCCViewManagers, VTKViewManagers;
 295
 296     application()->viewManagers( OCCViewer_Viewer::Type(), OCCViewManagers );
 297     QListIterator<SUIT_ViewManager*> itOCC( OCCViewManagers );
 298     while ( itOCC.hasNext() && (vm = itOCC.next()) )
 299         myOCCSelectors.append( new HEXABLOCKGUI_OCCSelector( ((OCCViewer_ViewManager*)vm)->getOCCViewer(), sm ) );
 300
 301     application()->viewManagers( SVTK_Viewer::Type(), VTKViewManagers );
 302     QListIterator<SUIT_ViewManager*> itVTK( VTKViewManagers );
 303     while ( itVTK.hasNext() && (vm = itVTK.next()) )
 304         myVTKSelectors.append( new LightApp_VTKSelector( dynamic_cast<SVTK_Viewer*>( vm->getViewModel() ), sm ) );
 305
 306     //NPAL 19674
 307     SALOME_ListIO selected;
 308     sm->selectedObjects( selected );
 309     sm->clearSelected();
 310
 311     // disable OCC selectors
 312     getApp()->selectionMgr()->setEnabled( false, OCCViewer_Viewer::Type() );
 313     QListIterator<HEXABLOCKGUI_OCCSelector*> itOCCSel( myOCCSelectors );
 314     while ( itOCCSel.hasNext() )
 315         if ( HEXABLOCKGUI_OCCSelector* sr = itOCCSel.next() )
 316             sr->setEnabled(true);
 317
 318     // disable VTK selectors
 319     getApp()->selectionMgr()->setEnabled( false, SVTK_Viewer::Type() );
 320     QListIterator<LightApp_VTKSelector*> itVTKSel( myVTKSelectors );
 321     while ( itVTKSel.hasNext() )
 322         if ( LightApp_VTKSelector* sr = itVTKSel.next() )
 323             sr->setEnabled(true);
 324
 325     sm->setSelectedObjects( selected, true );   //NPAL 19674
 326
 327     //connect close signal to vtk view manager
 328     vm = getApp()->getViewManager(SVTK_Viewer::Type(), false);
 329     if (vm != NULL)
 330     {
 331         connect( vm, SIGNAL( tryCloseView( SUIT_ViewWindow * ) ),
 332                 this, SLOT( onWindowClosed(SUIT_ViewWindow *) ), Qt::UniqueConnection );
 333     }
 334
 335     //connect close signal to occ view manager
 336     vm = getApp()->getViewManager(OCCViewer_Viewer::Type(), false);
 337     if (vm != NULL)
 338     {
 339         connect( vm, SIGNAL( tryCloseView( SUIT_ViewWindow * ) ),
 340                 this, SLOT( onWindowClosed(SUIT_ViewWindow *) ), Qt::UniqueConnection );
 341     }
 342
 343     /* ************************************   TODO Hexa6
 344     _hexaEngine->SetCurrentStudy(SALOMEDS::Study::_nil());
 345     if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( theStudy ))
 346         if ( _PTR(Study) aStudy = s->studyDS()) {
 347             _hexaEngine->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
 348             updateObjBrowser(); // objects can be removed
 349         }
 350      ************************************ */
 351
 352     if (currentOccGView != NULL && currentOccGView->getViewWindow() != NULL)
 353             currentOccGView->getViewWindow()->installEventFilter(this);
 354
 355     if (currentDocGView != NULL)
 356     {
 357         switchModel(currentDocGView);
 358         showAllMenus();
 359
 360         if (currentDocGView->getViewWindow() != NULL)
 361             currentDocGView->getViewWindow()->installEventFilter(this);
 362     }
 363     else
 364     {
 365         newDocument();
 366 //        initialMenus();
 367     }
 368
 369     return bOk;
 370 }
 371
 372
 373 bool HEXABLOCKGUI::deactivateModule( SUIT_Study* theStudy )
 374 {
 375     disconnect( getApp()->desktop(), SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
 376             this, SLOT(onWindowActivated( SUIT_ViewWindow* )) );
 377     disconnect( getApp()->objectBrowser()->treeView(),SIGNAL( clicked(const QModelIndex&) ),
 378             this, SLOT( onObjectBrowserClick(const QModelIndex&) ) );
 379
 380     SVTK_ViewWindow* vtkView = (currentDocGView != NULL) ? currentDocGView->getViewWindow() : NULL;
 381     if ( vtkView != NULL)
 382     {
 383         //default selectionMode in VTKView
 384         vtkView->SetSelectionMode( ActorSelection );
 385         vtkView->removeEventFilter(this);
 386 //        vtkView->close();
 387     }
 388
 389     OCCViewer_ViewWindow* occView = (currentOccGView != NULL) ? currentOccGView->getViewWindow() : NULL;
 390     if (occView != NULL)
 391     {
 392         //defaut selectionMode in OccView
 393         selectionMgr()->clearSelected();
 394         currentOccGView->globalSelection();
 395         occView->removeEventFilter(this);
 396 //        occView->close();
 397     }
 398
 399     qDeleteAll(myOCCSelectors);
 400     myOCCSelectors.clear();
 401     getApp()->selectionMgr()->setEnabled( true, OCCViewer_Viewer::Type() );
 402
 403     qDeleteAll(myVTKSelectors);
 404     myVTKSelectors.clear();
 405     getApp()->selectionMgr()->setEnabled( true, SVTK_Viewer::Type() );
 406
 407     bool bOk = SalomeApp_Module::deactivateModule( theStudy );
 408
 409     //switch off current document graphic view
 410     switchOffGraphicView(currentDocGView);
 411
 412     //...and hide menus
 413     setMenuShown( false );
 414     setToolShown( false );
 415     showDockWidgets( false );
 416     if (_dwInputPanel)
 417         _dwInputPanel->close();
 418
 419     hideActor();
 420
 421     return bOk;
 422 }
 423
 424 SALOMEDS::Study_var HEXABLOCKGUI::ClientStudyToStudy (_PTR(Study) theStudy)
 425 {
 426   SALOME_NamingService *aNamingService = SalomeApp_Application::namingService();
 427   CORBA::Object_var aSMObject = aNamingService->Resolve("/myStudyManager");
 428   SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow(aSMObject);
 429   int aStudyID = theStudy->StudyId();
 430   SALOMEDS::Study_var aDSStudy = aStudyManager->GetStudyByID(aStudyID);
 431   return aDSStudy._retn();
 432 }
 433
 434 void HEXABLOCKGUI::addInStudy(QMap<QString, TopoDS_Shape>& topo_shapes,
 435                               QMap<QString, QString>& docShapesEntry,
 436                               QMap<QString, QString>& docShapesName)
 437 {
 438     if (topo_shapes.size() == 0 || currentOccGView == NULL || currentDocGView == NULL)
 439         return; //there's nothing to publish in this case
 440
 441     SalomeApp_Study* appStudy = HEXABLOCKGUI::activeStudy();
 442     if(!appStudy) return;
 443     _PTR(Study) aStudy = appStudy->studyDS();
 444     SALOMEDS::Study_var aDSStudy = ClientStudyToStudy( aStudy );
 445     SALOMEDS::StudyBuilder_var     aBuilder (aDSStudy->NewBuilder());
 446     QString entry = currentDocGView->getDocumentModel()->documentEntry();
 447     SALOMEDS::SObject_var aFatherSO = aDSStudy->FindObjectID( qPrintable(entry) );
 448     if (aFatherSO->_is_nil())
 449         return;
 450
 451     // * get a presentation
 452     bool isNewPrs = false;
 453     SOCC_Prs* prs = getOccPrs(currentDocGView);
 454     if (prs == NULL)
 455     {
 456         prs = new SOCC_Prs(0);
 457         isNewPrs = true;
 458     }
 459
 460     // * init the presentation with the given shapes
 461     QMap<QString, TopoDS_Shape>::const_iterator i = topo_shapes.constBegin();
 462     while (i != topo_shapes.constEnd())
 463     {
 464         QString shapeName  = i.key();
 465         TopoDS_Shape shapeValue = i.value();
 466         Handle(AIS_Shape) ais_shape = new AIS_Shape(shapeValue);
 467         SALOMEDS::SObject_var aSO = aBuilder->NewObject(aFatherSO);
 468         QString objStudyEntry = aSO->GetID(); //the entry of the published object
 469         Handle( SALOME_InteractiveObject ) io = new SALOME_InteractiveObject(objStudyEntry.toStdString().c_str(),
 470                                                                     "HEXABLOCK", shapeName.toStdString().c_str());
 471         ais_shape->SetOwner(io);
 472         prs->AddObject(ais_shape);
 473         aSO->SetAttrString("AttributeName", shapeName.toStdString().c_str());
 474         docShapesEntry[shapeName] = objStudyEntry;
 475         docShapesName[objStudyEntry] = shapeName;
 476         currentOccGView->addShape(objStudyEntry, ais_shape);
 477         i++; //handle next shape
 478     }
 479     // * set the preview
 480     if (isNewPrs)
 481         prs->AddObject(currentOccGView->getPreviewShape());
 482
 483     occPrs[currentDocGView] = prs;
 484     getApp()->updateObjectBrowser();
 485     showOnlyActor();
 486 }
 487
 488
 489 bool HEXABLOCKGUI::renameAllowed( const QString& entry) const
 490 {
 491     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 492     SalomeApp_Study* appStudy = app ? dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) : 0;
 493     SalomeApp_DataObject* obj = appStudy ? dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry)) : 0;
 494
 495     return (app && appStudy && obj && !appStudy->isComponent(entry) && !obj->isReference());
 496 }
 497
 498
 499 bool HEXABLOCKGUI::renameObject( const QString& entry, const QString& name)
 500 {
 501     bool result = false;
 502
 503     // Pas de renommage des shapes pour le moment, juste les documents
 504     VtkDocumentGraphicView* dgview = getDocGViewByEntry(entry);
 505     if (dgview == NULL || dgview->getDocumentModel() == NULL)
 506         return result;
 507
 508     SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication());
 509     SalomeApp_Study* appStudy = app ? dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) : 0;
 510
 511     if(!appStudy)
 512         return result;
 513
 514     _PTR(Study) aStudy = appStudy->studyDS();
 515
 516     if(!aStudy)
 517         return result;;
 518
 519     _PTR(SObject) obj ( aStudy->FindObjectID(qPrintable(entry)) );
 520     _PTR(GenericAttribute) anAttr;
 521     if ( obj ){
 522         if ( obj->FindAttribute(anAttr, "AttributeName") ){
 523             _PTR(AttributeName) aName (anAttr);
 524             DocumentModel* docModel = dgview->getDocumentModel();
 525             docModel->setName( name );
 526             aName->SetValue( name.toLatin1().data() );
 527             getApp()->updateObjectBrowser();
 528 //            _dwPattern->setWindowTitle( name );
 529             result = true;
 530         }
 531     }
 532     return result;
 533 }
 534
 535 // --- Default windows
 536 void HEXABLOCKGUI::windows( QMap<int, int>& theMap ) const
 537 {
 538     DEBTRACE("HEXABLOCKGUI::windows");
 539     theMap.clear();
 540     theMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
 541 #ifndef DISABLE_PYCONSOLE
 542     theMap.insert( SalomeApp_Application::WT_PyConsole,     Qt::BottomDockWidgetArea );
 543 #endif
 544 }
 545
 546 QString  HEXABLOCKGUI::engineIOR() const
 547 {
 548     DEBTRACE("HEXABLOCKGUI::engineIOR");
 549
 550     /* ************************************   TODO Hexa6
 551     CORBA::ORB_var anORB = getApp()->orb();
 552     CORBA::String_var anIOR = anORB->object_to_string(_hexaEngine);
 553     return QString( anIOR.in() );
 554        ************************************ */
 555     return "";
 556 }
 557
 558 VtkDocumentGraphicView* HEXABLOCKGUI::getOrCreateDocument(SalomeApp_DataObject* studyObject)
 559 {
 560     if (docs.count(studyObject->entry()) == 0)
 561     {
 562         //Object's document not acquired yet
 563         VtkDocumentGraphicView* dgview;
 564         HEXA_NS::Hex* directory = HEXA_NS::Hex::getInstance();
 565         if (directory == NULL)
 566             return NULL;    //No working director found
 567
 568         //------------------ Load the document -----------------
 569         HEXA_NS::Document* document = directory->findDocument(studyObject->name().toStdString());
 570         if (document == NULL)
 571             return NULL;    //No document found
 572
 573         DocumentModel* docModel = new DocumentModel(document, studyObject->entry(), this );
 574         if (!docModel) {
 575             MESSAGE("Doc model creation failed!");
 576             return NULL;
 577         }
 578         dgview = graphicViewsHandler->createDocumentGraphicView( docModel, NULL, application()->desktop() );
 579         if (dgview == NULL) return NULL;
 580
 581         //update the data tree
 582         docs[studyObject->entry()] = dgview;
 583     }
 584
 585     return docs[studyObject->entry()];
 586 }
 587
 588 void HEXABLOCKGUI::onObjectBrowserClick(const QModelIndex& index)
 589 {
 590     // ** we want to switch automatically to the right view windows
 591
 592     //first, find selected item
 593     QString itemEntry;
 594     DataObjectList dol = getApp()->objectBrowser()->getSelected();
 595     if (dol.isEmpty()) return;
 596     SalomeApp_DataObject* item = dynamic_cast<SalomeApp_DataObject*>(dol[0]);
 597     if (!item || item->parent()->name().compare(tr("HEXABLOCK")) != 0 ||
 598             item->entry().isEmpty())
 599         return;
 600
 601     // find the document corresponding to it
 602     VtkDocumentGraphicView* docGView = NULL;
 603     if (docs.contains(item->entry()))
 604         docGView = docs[item->entry()];
 605     else
 606         docGView = getOrCreateDocument(item);
 607
 608     //Init OCC if necessary
 609     if (currentOccGView == NULL)
 610     {
 611         currentOccGView = new OccGraphicView(graphicViewsHandler->createOccWindow(), application()->desktop());
 612         currentOccGView->getViewWindow()->installEventFilter(this);
 613     }
 614     else if (currentOccGView->getViewWindow() == NULL)
 615     {
 616         currentOccGView->setViewWindow(graphicViewsHandler->createOccWindow());
 617         currentOccGView->getViewWindow()->installEventFilter(this);
 618     }
 619
 620     //Init the vtk view if necessary
 621     if (docGView->getViewWindow() == NULL)
 622     {
 623         if (currentDocGView == NULL || currentDocGView->getViewWindow() == NULL)
 624         {
 625             docGView->setViewWindow(graphicViewsHandler->createVtkWindow());
 626             docGView->getViewWindow()->installEventFilter(this);
 627             showAllMenus();
 628             if (!menusEnabled)
 629                 setAllMenusEnabled(true);
 630         }
 631         else
 632             docGView->setViewWindow(currentDocGView->getViewWindow());
 633
 634         if (docGView->getDocumentActor() == NULL)
 635             docGView->update();
 636     }
 637
 638     if (docGView == NULL || docGView == currentDocGView)
 639     {
 640         showOnlyActor();
 641         return;
 642     }
 643
 644     //update the current document
 645     switchModel(docGView);
 646 }
 647
 648
 649 void HEXABLOCKGUI::onWindowActivated( SUIT_ViewWindow* svw)
 650 {
 651     DEBTRACE("HEXABLOCKGUI::onWindowActivated");
 652 }
 653
 654 void HEXABLOCKGUI::onWindowClosed( SUIT_ViewWindow* svw)
 655 {
 656     DEBTRACE("HEXABLOCKGUI::onWindowClosed");
 657
 658     //Decharger le model correspondant (VTK)
 659     SVTK_ViewWindow* window = dynamic_cast<SVTK_ViewWindow*>(svw);
 660     if (window != NULL)
 661     {
 662         //VTK clean close
 663         if (currentDocGView != NULL && currentDocGView->getViewWindow() == window)
 664         { //HexaBlock Vtk Window has been closed
 665
 666             if (currentDialog != NULL) currentDialog->close();
 667 //            if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
 668             if (currentDocGView != NULL)
 669                 currentDocGView->setViewWindow(NULL);
 670
 671 //            initialMenus();
 672             setAllMenusEnabled(false);
 673             enableDocumentMenus(true);
 674
 675             return;
 676         }
 677
 678         //SAVE DOCUMENT
 679         /*VtkDocumentGraphicView* dgview = graphicViewsHandler->getDocumentGraphicView(window);
 680         if (dgview == NULL) return; //The window has no document to close
 681
 682         //Save the document? (Ask only if the document is not empty
 683         int answerCode = SUIT_MessageBox::question(
 684                             0,
 685                             tr("Close"),
 686                             tr("Save the document ?"),
 687                             SUIT_MessageBox::Yes | SUIT_MessageBox::Cancel,
 688                             SUIT_MessageBox::Cancel);
 689         if ( answerCode == SUIT_MessageBox::Cancel) return; //abort closing
 690         else if (answerCode == SUIT_MessageBox::Yes)
 691             saveDocument(); //Save the document
 692         */
 693 //        switchOffGraphicView(window); //disconnect all connected signals
 694 //        currentVtkView = NULL;
 695 //        graphicViewsHandler->closeDocumentGraphicView(window);
 696
 697         //create a new one (empty document)
 698 //        newDocument();
 699 //        currentVtkView->setWindowTitle(tr("HEXABLOCK") + " : " + currentVtkView->windowTitle());
 700     }
 701
 702     //OCC clean close
 703     if (currentOccGView != NULL && svw == currentOccGView->getViewWindow())
 704     {
 705         if (_vertexAssocDiag != NULL) _vertexAssocDiag->clear();
 706         if (_edgeAssocDiag != NULL) _edgeAssocDiag->clear();
 707         if (_quadAssocDiag != NULL) _quadAssocDiag->clear();
 708         if (currentDialog != NULL) currentDialog->close();
 709 //        if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
 710
 711         currentOccGView->getViewWindow()->removeEventFilter(this);
 712         currentOccGView->setViewWindow(NULL);
 713     }
 714 }
 715
 716 void HEXABLOCKGUI::onViewManagerAdded( SUIT_ViewManager*  vm)
 717 {
 718     DEBTRACE("HEXABLOCKGUI::onViewManagerAdded");
 719
 720     connect( vm, SIGNAL( tryCloseView( SUIT_ViewWindow * ) ),
 721             this, SLOT( onWindowClosed(SUIT_ViewWindow *) ), Qt::UniqueConnection );
 722
 723     if ( vm && vm->getType() == OCCViewer_Viewer::Type() )
 724       {
 725         LightApp_SelectionMgr* sm = getApp()->selectionMgr();
 726         myOCCSelectors.append( new HEXABLOCKGUI_OCCSelector( ((OCCViewer_ViewManager*)vm)->getOCCViewer(), sm ) );
 727         // disable OCC selectors
 728         getApp()->selectionMgr()->setEnabled( false, OCCViewer_Viewer::Type() );
 729         QListIterator<HEXABLOCKGUI_OCCSelector*> itOCCSel( myOCCSelectors );
 730         while ( itOCCSel.hasNext() )
 731           if ( HEXABLOCKGUI_OCCSelector* sr = itOCCSel.next() )
 732             sr->setEnabled(true);
 733       }
 734       else if ( vm->getType() == SVTK_Viewer::Type() )
 735       {
 736         LightApp_SelectionMgr* sm = getApp()->selectionMgr();
 737         myVTKSelectors.append( new LightApp_VTKSelector( dynamic_cast<SVTK_Viewer*>( vm->getViewModel() ), sm ) );
 738
 739         // disable VTK selectors
 740         getApp()->selectionMgr()->setEnabled( false, SVTK_Viewer::Type() );
 741         QListIterator<LightApp_VTKSelector*> itVTKSel( myVTKSelectors );
 742         while ( itVTKSel.hasNext() )
 743           if ( LightApp_VTKSelector* sr = itVTKSel.next() )
 744             sr->setEnabled(true);
 745       }
 746 }
 747
 748 void HEXABLOCKGUI::onViewManagerRemoved( SUIT_ViewManager* vm)
 749 {
 750     DEBTRACE("HEXABLOCKGUI::::onViewManagerRemoved");
 751
 752     SUIT_ViewModel* viewer = vm->getViewModel();
 753     if (vm != NULL && vm->getType() == SVTK_Viewer::Type())
 754     {
 755         //VTK View Manager removed
 756         if (getApp()->activeModule()->moduleName().compare("HEXABLOCK") == 0)
 757         {
 758             //Process only if it's our view manager
 759             SUIT_ViewManager* myVm = NULL;
 760             if (currentDocGView != NULL && currentDocGView->getViewWindow() != NULL)
 761                 myVm = currentDocGView->getViewWindow()->getViewManager();
 762
 763             if (myVm == vm)
 764             {
 765                 //close opened dialog
 766                 if (currentDialog != NULL) currentDialog->close();
 767 //                if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
 768
 769                 initialMenus();
 770             }
 771         }
 772
 773         //remove its selector
 774         QListIterator<LightApp_VTKSelector*> itVTKSel( myVTKSelectors );
 775         while ( itVTKSel.hasNext() )
 776             if ( LightApp_VTKSelector* sr = itVTKSel.next() )
 777                 if ( sr->viewer() == viewer )
 778                 {
 779                     delete myVTKSelectors.takeAt( myVTKSelectors.indexOf( sr ) );
 780                     break;
 781                 }
 782         return;
 783     }
 784
 785     //OCC
 786     if ( vm && vm->getType() == OCCViewer_Viewer::Type() )
 787     {
 788         //OCC View removed: remove its selector
 789         QListIterator<HEXABLOCKGUI_OCCSelector*> itOCCSel( myOCCSelectors );
 790         while ( itOCCSel.hasNext() )
 791             if ( HEXABLOCKGUI_OCCSelector* sr = itOCCSel.next() )
 792                 if ( sr->viewer() == viewer )
 793                 {
 794                     delete myOCCSelectors.takeAt( myOCCSelectors.indexOf( sr ) );
 795                     break;
 796                 }
 797     }
 798 }
 799
 800 void HEXABLOCKGUI::onSelectionChanged( const QItemSelection & selected, const QItemSelection & deselected  )
 801 {
 802     QModelIndexList l = selected.indexes();
 803     if ( l.count() == 0 ) return;
 804     if ( !l[0].isValid() ) return;
 805     VtkDocumentGraphicView* currentGraphicView = getCurrentVtkGraphicView();
 806     if ( currentGraphicView == NULL) return;
 807
 808     QTreeView* theTree = NULL;
 809     if ( sender() == currentGraphicView->getPatternDataSelectionModel() ){
 810         theTree = _patternDataTreeView;
 811     }
 812     /*else if ( sender() == currentGraphicView->getPatternBuilderSelectionModel() ){
 813         theTree = _patternBuilderTreeView;
 814     }*/
 815     else if ( sender() == currentGraphicView->getPatternGeomSelectionModel() ) {
 816         theTree =  _patternGeomTreeView;
 817     }
 818     else if ( sender() == currentGraphicView->getGroupsSelectionModel() ){
 819         theTree = _groupsTreeView;
 820     } else if ( sender() == currentGraphicView->getMeshSelectionModel() ){
 821         theTree = _meshTreeView;
 822     }
 823     if ( theTree ){
 824         theTree->scrollTo ( l[0] );
 825     }
 826 }
 827
 828 bool HEXABLOCKGUI::createSComponent() //addComponent
 829 {
 830     DEBTRACE("HEXABLOCKGUI::createSComponent");
 831     // --- Find or create (if not done yet) "HEXABLOCK" SComponent in the study
 832
 833     _PTR(Study)            aStudy = (( SalomeApp_Study* )(getApp()->activeStudy()))->studyDS();
 834     _PTR(StudyBuilder)     aBuilder (aStudy->NewBuilder());
 835     _PTR(GenericAttribute) anAttr;
 836     _PTR(AttributeName)    aName;
 837     _PTR(AttributeGraphic) aGraphic;
 838
 839     _PTR(SComponent) aComponent = aStudy->FindComponent("HEXABLOCK");
 840     if ( !aComponent ){ //Create hexablock component if there's not one yet
 841         aComponent = aBuilder->NewComponent("HEXABLOCK");
 842         anAttr = aBuilder->FindOrCreateAttribute(aComponent, "AttributeName");
 843         aName = _PTR(AttributeName) (anAttr);
 844         aName->SetValue(getApp()->moduleTitle("HEXABLOCK").toStdString());
 845
 846         anAttr = aBuilder->FindOrCreateAttribute(aComponent, "AttributePixMap");
 847         _PTR(AttributePixMap) aPixmap(anAttr);
 848         aPixmap->SetPixMap(tr("ICO_MODULE_HEXABLOCK_SMALL").toStdString());
 849
 850         aBuilder->DefineComponentInstance(aComponent, engineIOR().toStdString());
 851         DEBTRACE("HEXABLOCKGUI::createSComponent engineIOR=>"<<engineIOR().toStdString());
 852         return true;
 853     }
 854     return false;
 855 }
 856
 857 void HEXABLOCKGUI::setResource(SUIT_ResourceMgr* r)
 858 {
 859     DEBTRACE("HEXABLOCKGUI::setResource");
 860     _myresource = new HEXABLOCKGUI_Resource(r);
 861     _myresource->preferencesChanged();
 862 }
 863
 864 void HEXABLOCKGUI::createPreferences()
 865 {
 866     DEBTRACE("HEXABLOCKGUI::createPreferences");
 867     _myresource->createPreferences(this);
 868 }
 869
 870 void HEXABLOCKGUI::preferencesChanged( const QString& sect, const QString& name )
 871 {
 872     DEBTRACE("HEXABLOCKGUI::preferencesChanged");
 873     _myresource->preferencesChanged(sect, name);
 874 //    if(name=="userCatalog")
 875 //        _genericGui->getCatalogWidget()->addCatalogFromFile(Resource::userCatalog.toStdString());
 876 }
 877
 878 void HEXABLOCKGUI::studyActivated() //CS_TODO
 879 {
 880     int newStudyId = getApp()->activeStudy()->id();
 881     DEBTRACE("HEXABLOCKGUI::studyActivated " << _oldStudyId << " " << newStudyId);
 882 //    if (_oldStudyId != -1)
 883 //    {
 884 //        _studyContextMap[_oldStudyId] = QtGuiContext::getQtCurrent();
 885 //        if (_studyContextMap.count(newStudyId))
 886 //        {
 887 //            DEBTRACE("switch to valid context " << QtGuiContext::getQtCurrent() << " " << _studyContextMap[newStudyId]);
 888 //            QtGuiContext::setQtCurrent(_studyContextMap[newStudyId]);
 889 //        }
 890 //        else
 891 //        {
 892 //            DEBTRACE("no switch to null context");
 893 //        }
 894 //    }
 895     _oldStudyId = newStudyId;
 896 }
 897
 898 void HEXABLOCKGUI::treeContextMenu(const QPoint& aPosition)
 899 {
 900     QModelIndex currentIndex = _patternDataTreeView->currentIndex();
 901     QVariant currentAssocVariant;
 902     QString currentAssocEntry;
 903
 904     currentAssocVariant = currentIndex.data( HEXA_ASSOC_ENTRY_ROLE );
 905     currentAssocEntry    = currentIndex.data( HEXA_ASSOC_ENTRY_ROLE ).toString();
 906     if ( currentAssocVariant.isValid() && !currentAssocEntry.isEmpty() ){
 907         QMenu menu( _patternDataTreeView );
 908         //Remove association
 909         QAction *clearAct = menu.addAction( "Remove association(s)" );
 910         connect( clearAct, SIGNAL(triggered()), this, SLOT(clearAssociations()), Qt::UniqueConnection );
 911         menu.exec( _patternDataTreeView->mapToGlobal( aPosition) );
 912     }
 913     else {
 914
 915         VtkDocumentGraphicView* currentVtkGraphicView = getCurrentVtkGraphicView();
 916         if (currentVtkGraphicView == NULL) return;
 917         QStandardItem *item = currentVtkGraphicView->getPatternDataModel()->itemFromIndex(currentIndex);
 918
 919         //We don't do anything for single items
 920         if ( item->type() == VERTEXITEM || item->type() == EDGEITEM ||
 921                 item->type() == QUADITEM || item->type() == HEXAITEM)
 922             return;
 923
 924         //No associations for HEXA
 925         QVariant treeVariant = currentIndex.data( HEXA_TREE_ROLE );
 926         if ( !treeVariant.isValid() ) return;
 927         int eltType = treeVariant.toInt();
 928         if (eltType == HEXA_DIR_TREE) return;
 929         QMenu menu( _patternDataTreeView );
 930
 931         //Show association(s)
 932         QAction *showAssocAct = menu.addAction( "Show associations" );
 933         connect( showAssocAct, SIGNAL(triggered()), this, SLOT(showAssociations()), Qt::UniqueConnection );
 934
 935         //Clear all associations
 936         QAction *clearAllAssocAct = menu.addAction( "Remove all associations" );
 937         connect( clearAllAssocAct, SIGNAL(triggered()), this, SLOT(clearAllAssociations()), Qt::UniqueConnection );
 938
 939         menu.exec( _patternDataTreeView->mapToGlobal( aPosition) );
 940     }
 941 }
 942
 943
 944 void HEXABLOCKGUI::createAndFillDockWidget()
 945 {
 946
 947     QMainWindow *aParent = application()->desktop();
 948
 949     // Create dock widget (3 dock)
 950
 951     //1) *********** user input panel ( contain user's edit dialog box )
 952     _dwInputPanel = new QDockWidget(aParent);
 953     _dwInputPanel->setVisible(false);
 954     _dwInputPanel->setWindowTitle("Input Panel");
 955     _dwInputPanel->setObjectName("hexablockInputPanelDock");
 956 //    _dwInputPanel->setMinimumWidth(DWINPUT_MINIMUM_WIDTH); // --- force a minimum until display
 957
 958 //    _treeViewDelegate = new DocumentDelegate(_dwInputPanel);
 959
 960     //2) ************* document data ( Pattern, Association, Mesh ) in treeview representation
 961     //      Pattern
 962     _dwPattern = new QDockWidget(aParent);
 963     _dwPattern->setVisible(false);
 964     _dwPattern->setWindowTitle("Model");
 965     _dwPattern->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
 966     _dwPattern->setObjectName("hexablockModelDock");
 967
 968     QFrame*      patternFrame  = new QFrame(_dwPattern);
 969     patternFrame->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
 970     QVBoxLayout* patternLayout = new QVBoxLayout(patternFrame);
 971     patternLayout->setSizeConstraint(QLayout::SetMaximumSize);
 972     QSplitter *splitter = new QSplitter(Qt::Vertical,patternFrame);
 973     _patternDataTreeView    = new QTreeView(patternFrame);//_dwPattern);
 974 //    _patternBuilderTreeView = new QTreeView(patternFrame);                  // ---> TO REMOVE
 975     _patternGeomTreeView    = new QTreeView(patternFrame);
 976     splitter->addWidget(_patternDataTreeView);
 977 //    splitter->addWidget(_patternBuilderTreeView);                           // ---> TO REMOVE
 978     splitter->addWidget(_patternGeomTreeView);
 979     patternLayout->addWidget(splitter);
 980
 981     _patternDataTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers/*QAbstractItemView::DoubleClicked*/);
 982     _patternDataTreeView->setSelectionMode(QAbstractItemView::SingleSelection/*QAbstractItemView::MultiSelection*/);
 983 //    _patternDataTreeView->setItemDelegate(_treeViewDelegate);
 984
 985
 986 //    _patternBuilderTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
 987 //    _patternBuilderTreeView->setItemDelegate(_treeViewDelegate);
 988
 989     _patternGeomTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
 990     _patternGeomTreeView->setSelectionMode(QAbstractItemView::SingleSelection/*QAbstractItemView::MultiSelection*/);
 991
 992     _dwPattern->setWidget(patternFrame);
 993     patternFrame->show();
 994
 995     //      Groups
 996     _dwGroups = new QDockWidget(aParent);
 997
 998     _dwGroups->setVisible(false);
 999     _dwGroups->setWindowTitle("Groups");
1000     _dwGroups->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
1001     _dwGroups->setObjectName("hexablockGroupsDock");
1002     _groupsTreeView = new QTreeView(_dwGroups);
1003     _groupsTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
1004 //    _groupsTreeView->setItemDelegate(_treeViewDelegate);
1005     _dwGroups->setWidget(_groupsTreeView);
1006     _groupsTreeView->show();
1007
1008     //      Mesh
1009     _dwMesh = new QDockWidget(aParent);
1010     _dwMesh->setVisible(false);
1011     _dwMesh->setWindowTitle("Mesh");
1012     _dwMesh->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
1013     _dwMesh->setObjectName("hexablockMeshDock");
1014     _meshTreeView = new QTreeView(_dwMesh);
1015     _meshTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
1016     _meshTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
1017 //    _meshTreeView->setItemDelegate(_treeViewDelegate);
1018     _dwMesh->setWidget(_meshTreeView);
1019     _meshTreeView->show();
1020
1021 //    QDockWidget *_dwObjectBrowser = 0;
1022     QWidget* wid = getApp()->objectBrowser()->treeView();
1023     QWidget *w   = wid->parentWidget();
1024     while ( w && !_dwObjectBrowser ) {
1025         _dwObjectBrowser = ::qobject_cast<QDockWidget*>( w );
1026         w = w->parentWidget();
1027     }
1028     _dwObjectBrowser->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
1029     _dwObjectBrowser->setWindowTitle("Study");
1030
1031     // dock widget position
1032     aParent->addDockWidget( Qt::LeftDockWidgetArea, _dwObjectBrowser );
1033     aParent->addDockWidget( Qt::RightDockWidgetArea, _dwInputPanel );
1034
1035 //    aParent->tabifyDockWidget( _dwPattern, _dwObjectBrowser );
1036 //    aParent->tabifyDockWidget( _dwGroups, _dwPattern );
1037 //    aParent->tabifyDockWidget( _dwMesh, _dwGroups );
1038
1039     aParent->tabifyDockWidget( _dwObjectBrowser, _dwPattern );
1040     aParent->tabifyDockWidget( _dwPattern, _dwGroups );
1041     aParent->tabifyDockWidget( _dwGroups, _dwMesh );
1042
1043 #if QT_VERSION >= 0x040500
1044     aParent->setTabPosition(Qt::AllDockWidgetAreas, Resource::tabPanelsUp? QTabWidget::North: QTabWidget::South);
1045 #endif
1046
1047     // popup menu on data tree view
1048     _patternDataTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
1049     connect(_patternDataTreeView,
1050             SIGNAL(customContextMenuRequested(const QPoint &)),
1051             this,
1052             SLOT(treeContextMenu(const QPoint &)),
1053             Qt::UniqueConnection );
1054 }
1055
1056 void HEXABLOCKGUI::createActions()
1057 {
1058     QMainWindow *aParent = application()->desktop();
1059     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1060
1061     // Document
1062     _newAct = createAction(_menuId++,
1063             tr("Create a new document"),
1064             resMgr->loadPixmap("HEXABLOCK", tr("ICON_NEW_DOCUMENT")),
1065             tr("New Document"),
1066             tr("Create a new document"),
1067             0, aParent, false, this, SLOT(newDocument()));
1068     _newAct->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_N ); // --- QKeySequence::New ambiguous in SALOME
1069
1070     _importAct = createAction(_menuId++,
1071             tr("Load a document"),
1072             resMgr->loadPixmap("HEXABLOCK", tr("ICON_LOAD_DOCUMENT")),
1073             tr("Load Document"),
1074             tr("Load a document"),
1075             0, aParent, false, this, SLOT(loadDocument()));
1076     _importAct->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_O); // --- QKeySequence::Open ambiguous in SALOME
1077
1078     _saveAct = createAction(_menuId++,
1079             tr("Save the document"),
1080             resMgr->loadPixmap("HEXABLOCK", tr("ICON_SAVE_DOCUMENT")),
1081             tr("Save Document"),
1082             tr("Save the document"),
1083             0, aParent, false, this, SLOT(saveDocument()));
1084
1085     // Pattern Data creation
1086     _addVertex = createAction(_menuId++,
1087             tr("Create a vertex"),
1088             resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_VERTEX")),
1089             tr("Add Vertex"),
1090             tr("Create a new vertex"),
1091             0, aParent, false, this, SLOT(addVertex()));
1092
1093     _addEdge = createAction(_menuId++,
1094             tr("Create an edge"),
1095             resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_EDGE")),
1096             tr("Add Edge"),
1097             tr("Create a new edge"),
1098             0, aParent, false, this, SLOT(addEdge()));
1099
1100     _addQuad = createAction(_menuId++,
1101             tr("Create a quadrangle"),
1102             resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_QUAD")),
1103             tr("Add Quadrangle"),
1104             tr("Create a new quadrangle"),
1105             0, aParent, false, this, SLOT(addQuad()));
1106
1107     _addHexa = createAction(_menuId++,
1108             tr("Create an hexahedron"),
1109             resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_HEXA")),
1110             tr("Add Hexahedron"),
1111             tr("Create a new hexahedron"),
1112             0, aParent, false, this, SLOT(addHexa()));
1113
1114     // Builder Data creation
1115     _addVector = createAction(_menuId++,
1116             tr("Create a vector"),
1117             resMgr->loadPixmap( "HEXABLOCK", tr("ICON_ADD_VECTOR")),
1118             tr("Add Vector"),
1119             tr("Create a new vector"),
1120             0, aParent, false, this, SLOT(addVector()));
1121
1122 //    _addCylinder = createAction(_menuId++,
1123 //            tr("Create a cylinder"),
1124 //            resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_CYLINDER")),
1125 //            tr("Add Cylinder"),
1126 //            tr("Create a new cylinder"),
1127 //            0, aParent, false, this,  SLOT(addCylinder()));
1128
1129 //    _addPipe = createAction(_menuId++,
1130 //            tr("Create a pipe"),
1131 //            resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_PIPE")),
1132 //            tr("Add Pipe"),
1133 //            tr("Create a new pipe"),
1134 //            0, aParent, false, this, SLOT(addPipe()));
1135
1136     _makeGrid = createAction(_menuId++,
1137             tr("Make a grid"),
1138             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_GRID")),
1139             tr("Make Grid"),
1140             tr("Make a grid"),
1141             0, aParent, false, this,  SLOT(makeGrid()));
1142
1143     _makeCylinder = createAction(_menuId++,
1144             tr("Make a cylinder"),
1145             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_CYLINDER")),
1146             tr("Make Cylinder"),
1147             tr("Make a cylinder"),
1148             0, aParent, false, this, SLOT(makeCylinder()));
1149
1150     _makePipe = createAction(_menuId++,
1151             tr("Make a pipe"),
1152             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_PIPE")),
1153             tr("Make Pipe"),
1154             tr("Make a pipe"),
1155             0, aParent, false, this, SLOT(makePipe()));
1156
1157     _makeCylinders = createAction(_menuId++,
1158             tr("Make cylinders"),
1159             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_CYLINDERS")),
1160             tr("Make Cylinders"),
1161             tr("Make cylinders"),
1162             0, aParent, false, this, SLOT(makeCylinders()));
1163
1164     _makePipes = createAction(_menuId++,
1165             tr("Make pipes"),
1166             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_PIPES")),
1167             tr("Make Pipes"),
1168             tr("Make pipes"),
1169             0, aParent, false, this, SLOT(makePipes()));
1170
1171     _makeHemiSphere = createAction(_menuId++,
1172             tr("Make an hemisphere"),
1173             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_HEMISPHERE")),
1174             tr("Make Hemisphere"),
1175             tr("Make an hemisphere"),
1176             0, aParent, false, this, SLOT(makeHemiSphere()));
1177
1178     // Pattern Data edition
1179     _removeHexa = createAction(_menuId++,
1180             tr("Remove hexahedra"),
1181             resMgr->loadPixmap("HEXABLOCK", tr("ICON_REMOVE_HEXA")),
1182             tr("Remove Hexahedra"),
1183             tr("Remove hexahedra"),
1184             0, aParent, false, this, SLOT(removeHexa()));
1185
1186     _prismQuad = createAction(_menuId++,
1187             tr("Prism quadrangles"),
1188             resMgr->loadPixmap( "HEXABLOCK", tr("ICON_PRISM_QUAD")),
1189             tr("Prism Quadrangles"),
1190             tr("Prism quadrangles"),
1191             0, aParent, false, this, SLOT(prismQuad()));
1192
1193     _joinQuad = createAction(_menuId++,
1194             tr("Join quadrangles"),
1195             resMgr->loadPixmap("HEXABLOCK", tr("ICON_JOIN_QUAD")),
1196             tr("Join Quadrangles"),
1197             tr("Join quadrangles with hexahedra"),
1198             0, aParent, false, this, SLOT(joinQuad()));
1199
1200     _merge = createAction(_menuId++,
1201             tr("Merge"),
1202             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MERGE")),
1203             tr("Merge"),
1204             tr("Merge"),
1205             0, aParent, false, this, SLOT(merge()));
1206
1207     _disconnect = createAction(_menuId++,
1208             tr("Disconnect"),
1209             resMgr->loadPixmap("HEXABLOCK", tr("ICON_DISCONNECT")),
1210             tr("Disconnect"),
1211             tr("Disconnect edges, vertexes or quadrangles"),
1212             0, aParent, false, this, SLOT(disconnectElts()));
1213
1214     _cutEdge = createAction(_menuId++,
1215             tr("Cut edge"),
1216             resMgr->loadPixmap("HEXABLOCK", tr("ICON_CUT_EDGE")),
1217             tr("Cut Edge"),
1218             tr("Cut edge"),
1219             0, aParent, false, this, SLOT(cutEdge()));
1220
1221     _makeTransformation = createAction(_menuId++,
1222             tr("Make transformation"),
1223             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_TRANSFORMATION")),
1224             tr("Make Transformation"),
1225             tr("Make transformation"),
1226             0, aParent, false, this, SLOT(makeTransformation()));
1227
1228     _makeSymmetry = createAction(_menuId++,
1229             tr("Make symmetry"),
1230             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MAKE_SYMMETRY")),
1231             tr("Make Symmetry"),
1232             tr("Make symmetry"),
1233             0, aParent, false, this, SLOT(makeSymmetry()));
1234
1235     _performTransformation = createAction(_menuId++,
1236             tr("Perform transformation"),
1237             resMgr->loadPixmap("HEXABLOCK", tr("ICON_PERFORM_TRANSFORMATION")),
1238             tr("Perform Transformation"),
1239             tr("Perform transformation"),
1240             0, aParent, false, this, SLOT(performTransformation()));
1241
1242     _performSymmetry = createAction(_menuId++,
1243             tr("Perform symmetry"),
1244             resMgr->loadPixmap("HEXABLOCK", tr("ICON_PERFORM_SYMMETRY")),
1245             tr("Perform Symmetry"),
1246             tr("Perform symmetry"),
1247             0, aParent, false, this, SLOT(performSymmetry()));
1248
1249     _replaceHexa = createAction(_menuId++,
1250             tr("Replace hexahedron"),
1251             resMgr->loadPixmap("HEXABLOCK", tr("ICON_REPLACE_HEXA")),
1252             tr("Replace Hexahedron"),
1253             tr("Replace hexahedron"),
1254             0, aParent, false, this, SLOT(replaceHexa()));
1255
1256     _quadRevolution = createAction(_menuId++,
1257             tr("Quad revolution"),
1258             resMgr->loadPixmap("HEXABLOCK", tr("ICON_QUAD_REVOLUTION")),
1259             tr("Quad Revolution"),
1260             tr("Quad revolution"),
1261             0, aParent, false, this, SLOT(quadRevolution()));
1262
1263     // Association
1264     _assocVertex = createAction(_menuId++,
1265             tr("Make vertex association"),
1266             resMgr->loadPixmap("HEXABLOCK", tr("ICON_VERTEX_ASSOCIATION")),
1267             tr("Make Vertex association"),
1268             tr("Make vertex association"),
1269             0, aParent, false, this, SLOT(assocVertex()));
1270
1271     _assocEdge = createAction(_menuId++,
1272             tr("Make edge association"),
1273             resMgr->loadPixmap("HEXABLOCK", tr("ICON_EDGE_ASSOCIATION")),
1274             tr("Make Edge Association"),
1275             tr("Make edge association"),
1276             0, aParent, false, this, SLOT(assocEdge()));
1277
1278     _assocQuad = createAction(_menuId++,
1279             tr("Make quad association"),
1280             resMgr->loadPixmap("HEXABLOCK", tr("ICON_QUAD_ASSOCIATION")),
1281             tr("Make Quad Association"),
1282             tr("Make quad association"),
1283             0, aParent, false, this, SLOT(assocQuad()));
1284
1285     // Group
1286     _addGroup = createAction(_menuId++,
1287             tr("Add a group"),
1288             resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_GROUP")),
1289             tr("Add Group"),
1290             tr("Add a group"),
1291             0, aParent, false, this, SLOT(addGroup()));
1292
1293     _removeGroup = createAction(_menuId++,
1294             tr("Remove a group"),
1295             resMgr->loadPixmap("HEXABLOCK", tr("ICON_REMOVE_GROUP")),
1296             tr("Remove Group"),
1297             tr("Remove a group"),
1298             0, aParent, false, this, SLOT(removeGroup()));
1299
1300     // Mesh
1301     _addLaw = createAction(_menuId++,
1302             tr("Add a law"),
1303             resMgr->loadPixmap("HEXABLOCK", tr("ICON_ADD_LAW")),
1304             tr("Add Law"),
1305             tr("Add a law"),
1306             0, aParent, false, this, SLOT(addLaw()));
1307
1308     _removeLaw = createAction(_menuId++,
1309             tr("Remove a law"),
1310             resMgr->loadPixmap("HEXABLOCK", tr("ICON_REMOVE_LAW")),
1311             tr("Remove Law"),
1312             tr("Remove a law"),
1313             0, aParent, false, this, SLOT(removeLaw()));
1314
1315     _setPropagation = createAction(_menuId++,
1316             tr("Set propagation"),
1317             resMgr->loadPixmap("HEXABLOCK", tr("ICON_SET_PROPAGATION")),
1318             tr("Set Propagation"),
1319             tr("Set propagation"),
1320             0, aParent, false, this, SLOT(setPropagation()));
1321
1322     _computeMesh = createAction(_menuId++,
1323             tr("Compute mesh"),
1324             resMgr->loadPixmap("HEXABLOCK", tr("ICON_COMPUTE_MESH")),
1325             tr("Compute Mesh"),
1326             tr("Compute mesh"),
1327             0, aParent, false, this, SLOT(computeMesh()));
1328
1329     _showModelInfoAct = createAction(_menuId++,
1330             tr("Show Model Info"),
1331             resMgr->loadPixmap("HEXABLOCK", tr("ICON_MODEL_INFO")),
1332             tr("MODEL_INFO"),
1333             tr("MODEL_INFO"),
1334             0, aParent, false, this, SLOT(showModelInfo()));
1335
1336     _addShapeAct = createAction(_menuId++,
1337             tr("Add Shape"),
1338             resMgr->loadPixmap("HEXABLOCK", tr("ICON_GEOM_ASSOCIATION")),
1339             tr("ADD_SHAPE"),
1340             tr("ADD_SHAPE"),
1341             0, aParent, false, this, SLOT(addShape()));
1342
1343 //   _newAct->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_N ); // --- QKeySequence::New ambiguous in SALOME
1344 //   QAction* createAction(const int id,
1345 //                         const QString& toolTip,
1346 //                         const QIcon& icon,
1347 //                         const QString& menu,
1348 //                         const QString& status,
1349 //                         const int shortCut,
1350 //                         QObject* parent =0,
1351 //                         bool checkable = false,
1352 //                         QObject* receiver =0,
1353 //                         const char* member =0);
1354
1355     _sep1 =  separator();
1356     _sep2 =  separator();
1357     _sep3 =  separator();
1358     _sep4 =  separator();
1359 }
1360
1361
1362 void HEXABLOCKGUI::createMenus()
1363 {
1364     int aMenuId, subMenuId,aMenuIdMain;
1365
1366     aMenuIdMain = createMenu( tr("MEN_FILE"), -1, -1);
1367
1368     aMenuId = createMenu( tr("HEXABLOCK"), aMenuIdMain, -1, 10 );
1369     createMenu( actionId(_newAct), aMenuId );
1370     createMenu( actionId(_importAct), aMenuId );
1371     createMenu( _saveAct, aMenuId );
1372
1373
1374     int aMenuDocId = createMenu( tr( "Document" ), -1, -1, 30 );
1375     createMenu( _newAct, aMenuDocId );//, 10
1376     createMenu( _importAct, aMenuDocId );
1377     createMenu( _saveAct, aMenuDocId );
1378
1379     aMenuId = createMenu( tr("Model"), -1, -1, 30 );
1380     subMenuId = createMenu( tr( "Construction" ), aMenuId, -1 );
1381     createMenu( _addVertex, subMenuId );
1382     createMenu( _addEdge,   subMenuId );
1383     createMenu( _addQuad,   subMenuId );
1384     createMenu( _addHexa,   subMenuId );
1385     createMenu( _sep1, subMenuId);
1386
1387     // Pattern Builder
1388     createMenu( _addVector, subMenuId );
1389 //    createMenu( _addCylinder, subMenuId );
1390 //    createMenu( _addPipe, subMenuId );
1391
1392     createMenu( _sep2, subMenuId);
1393
1394     createMenu( _makeGrid,  subMenuId ); //Cartesian, Cylindrical, Spherical
1395     createMenu( _makeHemiSphere,subMenuId );
1396
1397     createMenu( _sep3, subMenuId);
1398
1399     createMenu( _makeCylinder, subMenuId );
1400     createMenu( _makePipe,     subMenuId );
1401     createMenu( _makeCylinders,subMenuId );
1402     createMenu( _makePipes,    subMenuId );
1403
1404     // Pattern Data Edition
1405     subMenuId = createMenu( tr( "Operation" ), aMenuId, -1 );
1406     createMenu( _removeHexa, subMenuId );
1407     createMenu( _prismQuad,  subMenuId );
1408     createMenu( _joinQuad,   subMenuId );
1409     createMenu( _merge,      subMenuId );
1410     createMenu( _disconnect, subMenuId );
1411     createMenu( _cutEdge,    subMenuId );
1412     createMenu( _makeTransformation, subMenuId );
1413     createMenu( _makeSymmetry,       subMenuId );
1414     createMenu( _performTransformation,   subMenuId );
1415     createMenu( _performSymmetry,         subMenuId );
1416     createMenu( _replaceHexa,    subMenuId );
1417     createMenu( _quadRevolution, subMenuId );
1418     createMenu( _sep4, aMenuId );
1419     createMenu( _showModelInfoAct, aMenuId );
1420
1421     // Association
1422     aMenuId = createMenu( tr("Association"), -1, -1, 30 );
1423     createMenu( _addShapeAct, aMenuId );
1424     createMenu( _assocVertex, aMenuId );
1425     createMenu( _assocEdge,   aMenuId );
1426     createMenu( _assocQuad,   aMenuId );
1427
1428     // Group
1429     aMenuId = createMenu( tr("Groups"), -1, -1, 30 );
1430     createMenu( _addGroup,    aMenuId );
1431     createMenu( _removeGroup, aMenuId ); //CS_TODO
1432
1433     // Law
1434     aMenuId = createMenu( tr("Mesh "), -1, -1, 30 );
1435     createMenu( _addLaw,    aMenuId );
1436     createMenu( _removeLaw, aMenuId );
1437     createMenu( _setPropagation, aMenuId );
1438     createMenu( _computeMesh, aMenuId );
1439
1440     //show model infomation menu
1441     QString aRule = "$component={'HEXABLOCK'}";
1442     popupMgr()->insert( _showModelInfoAct, -1, -1 );
1443     popupMgr()->setRule( _showModelInfoAct, aRule);
1444
1445     //associate shape to a document menu
1446     popupMgr()->insert( _addShapeAct, -1, -1 );
1447     popupMgr()->setRule( _addShapeAct, aRule );
1448
1449     //-------------------------------------------------
1450     // Display / Erase
1451     //-------------------------------------------------
1452     //  QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
1453     //  QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
1454     //  QString isNotEmpty("numberOfNodes <> 0");
1455     //  QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
1456     //  QString aType = QString( "%1type in {%2}" ).arg( lc );
1457     ////  aType = aType.arg( mesh_part );
1458     //
1459     //  aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
1460     //  QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
1461     //  QString aSelCount = QString( "%1 > 0" ).arg( dc );
1462
1463 //    popupMgr()->insert( separator(), -1, -1 );
1464 //    QString aRule = "$component={'HEXABLOCK'}";/* and  ( type='(" + aClient + " and " +
1465 //                aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";*/
1466 //    //  MESSAGE("aClient = " << aClient.toStdString());
1467 //    //  MESSAGE("aType = " << aType.toStdString());
1468 //    //  MESSAGE("aSelCount = " << aSelCount.toStdString());
1469 //    //  MESSAGE("anActiveVTK = " << anActiveVTK.toStdString());
1470 //    //  MESSAGE("isNotEmpty = " << isNotEmpty.toStdString());
1471 //    //  MESSAGE("aRule = " << aRule.toStdString());
1472 //    popupMgr()->insert( _showAct, -1, -1 ); // DISPLAY
1473 //    popupMgr()->setRule( _showAct, aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
1474 //
1475 //    popupMgr()->insert( _hideAct, -1, -1 ); // ERASE
1476 //    popupMgr()->setRule( _hideAct, aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
1477 //
1478 //    popupMgr()->insert( _showOnlyAct, -1, -1 ); // DISPLAY_ONLY
1479 //    popupMgr()->setRule(_showOnlyAct, aRule.arg( "" ), QtxPopupMgr::VisibleRule );
1480 //
1481 //    popupMgr()->insert( separator(), -1, -1 );
1482 }
1483
1484
1485 void HEXABLOCKGUI::createTools()
1486 {
1487     int aToolId;
1488
1489     aToolId = createTool ( tr( "HexaBlock Toolbar" ), QString( "HexaBlockMain" ) );
1490     createTool( _newAct, aToolId );
1491     createTool( _importAct, aToolId );
1492     createTool( _saveAct, aToolId );
1493     createTool( _showModelInfoAct, aToolId );
1494     //   createTool( _testAct, aToolId );
1495     //createTool( separator(), aToolId );
1496
1497     // Pattern Data
1498     aToolId = createTool ( tr( "Construction" ), QString( "HexaBlockConstruction" ) );
1499     createTool( _addVertex, aToolId );
1500     createTool( _addEdge, aToolId );
1501     createTool( _addQuad, aToolId );
1502     createTool( _addHexa, aToolId );
1503
1504     createTool( _sep1, aToolId );
1505
1506     // Pattern Builder
1507     createTool( _addVector, aToolId );
1508 //    createTool( _addCylinder, aToolId );
1509 //    createTool( _addPipe, aToolId );
1510
1511     createTool( _sep2, aToolId );
1512
1513     createTool( _makeGrid,  aToolId );
1514     createTool( _makeHemiSphere,   aToolId );
1515
1516     createTool( _sep3, aToolId );
1517
1518     createTool( _makeCylinder, aToolId );
1519     createTool( _makePipe,     aToolId );
1520     createTool( _makeCylinders,aToolId );
1521     createTool( _makePipes,    aToolId );
1522
1523     // Pattern Data Edition
1524     aToolId = createTool ( tr( "Operation" ), QString( "HexaBlockOperation" ) );
1525     createTool( _removeHexa, aToolId );
1526     createTool( _prismQuad,  aToolId );
1527     createTool( _joinQuad,   aToolId );
1528     createTool( _merge,      aToolId );
1529     createTool( _disconnect, aToolId );
1530     createTool( _cutEdge,    aToolId );
1531     createTool( _makeTransformation, aToolId );
1532     createTool( _makeSymmetry,       aToolId );
1533     createTool( _performTransformation,   aToolId );
1534     createTool( _performSymmetry,         aToolId );
1535     createTool( _replaceHexa,    aToolId );
1536     createTool( _quadRevolution, aToolId );
1537
1538     // Association
1539     aToolId = createTool ( tr( "Association" ), QString( "HexaBlockAssociation" ) );
1540     createTool( _assocVertex, aToolId );
1541     createTool( _assocEdge, aToolId );
1542     createTool( _assocQuad, aToolId );
1543     createTool( _addShapeAct, aToolId );
1544
1545     // Group
1546     aToolId = createTool ( tr( "Group" ), QString( "HexaBlockGroup" ) );
1547     createTool( _addGroup,    aToolId );
1548     createTool( _removeGroup, aToolId ); //CS_TODO
1549
1550     // Law
1551     aToolId = createTool ( tr( "Mesh" ), QString( "HexaBlockMesh" ) );
1552     createTool( _addLaw,    aToolId );
1553     createTool( _removeLaw, aToolId );
1554     createTool( _setPropagation, aToolId );
1555     createTool( _computeMesh, aToolId );
1556
1557 }
1558
1559 void HEXABLOCKGUI::initialMenus()
1560 {
1561     showDocumentMenus( true );
1562     showPatternMenus( false );
1563     showAssociationMenus( false );
1564     showGroupsMenus( false );
1565     showMeshMenus( false );
1566 }
1567
1568 void HEXABLOCKGUI::showAllMenus()
1569 {
1570     showDocumentMenus( true );
1571     showPatternMenus( true );
1572     showAssociationMenus( true );
1573     showGroupsMenus( true );
1574     showMeshMenus( true );
1575 }
1576
1577 void HEXABLOCKGUI::setAllMenusEnabled(bool enable)
1578 {
1579     enableDocumentMenus( enable );
1580     enablePatternMenus( enable );
1581     enableAssociationMenus( enable );
1582     enableGroupsMenus( enable );
1583     enableMeshMenus( enable );
1584
1585     menusEnabled = enable;
1586 }
1587
1588 void HEXABLOCKGUI::showDocumentMenus(bool show)
1589 {
1590     DEBTRACE("HEXABLOCKGUI::showDocumentMenus " << show);
1591     show = true; //
1592     setMenuShown(_newAct, show);
1593     setToolShown(_newAct, show);
1594     setMenuShown(_importAct, show);
1595     setToolShown(_importAct, show);
1596     setMenuShown(_showModelInfoAct, show);
1597     setToolShown(_showModelInfoAct, show);
1598     setMenuShown(_saveAct, show);
1599     setToolShown(_saveAct, show);
1600 }
1601
1602 void HEXABLOCKGUI::enableDocumentMenus(bool enable)
1603 {
1604     _newAct->setEnabled(enable);
1605 //    setToolShown(_newAct, enable);
1606
1607     _importAct->setEnabled(enable);
1608 //    setToolShown(_importAct, enable);
1609
1610     _showModelInfoAct->setEnabled(enable);
1611 //    setToolShown(_showModelInfoAct, enable);
1612
1613     _saveAct->setEnabled(enable);
1614 //    setToolShown(_saveAct, enable);
1615 }
1616
1617
1618 void HEXABLOCKGUI::showPatternMenus(bool show)
1619 {
1620     DEBTRACE("HEXABLOCKGUI::showPatternMenus " << show);
1621     DEBTRACE("getCurrentModel()  " << getCurrentModel()  );
1622     if ( show && !getCurrentModel() ) return;
1623
1624     setMenuShown(_addVertex, show );
1625     setToolShown(_addVertex, show);
1626     setMenuShown(_addEdge,  show );
1627     setToolShown(_addEdge, show);
1628     setMenuShown(_addQuad,  show );
1629     setToolShown(_addQuad, show);
1630     setMenuShown(_addHexa,  show );
1631     setToolShown(_addHexa, show);
1632
1633     setMenuShown(_sep1, show );
1634     setToolShown(_sep1, show);
1635
1636     setMenuShown( _addVector,  show );
1637     setToolShown( _addVector, show);
1638 //    setMenuShown( _addCylinder,  show );
1639 //    setToolShown( _addCylinder, show);
1640 //    setMenuShown( _addPipe,  show );
1641 //    setToolShown( _addPipe, show);
1642
1643     setMenuShown(_sep2, show );
1644     setToolShown(_sep2, show);
1645
1646     setMenuShown( _makeGrid,  show );
1647     setToolShown( _makeGrid, show);
1648     setMenuShown( _makePipe,  show );
1649     setToolShown( _makePipe, show);
1650
1651     setMenuShown(_sep3, show );
1652     setToolShown(_sep3, show);
1653
1654     setMenuShown( _makeCylinder,  show );
1655     setToolShown( _makeCylinder, show);
1656     setMenuShown( _makeCylinders,  show );
1657     setToolShown( _makeCylinders, show);
1658     setMenuShown( _makePipes,  show );
1659     setToolShown( _makePipes, show);
1660     setMenuShown( _makeHemiSphere,  show );
1661     setToolShown( _makeHemiSphere, show);
1662
1663     // Pattern Data Edition
1664     setMenuShown( _removeHexa,  show );
1665     setToolShown( _removeHexa, show);
1666     setMenuShown( _prismQuad,  show );
1667     setToolShown( _prismQuad, show);
1668     setMenuShown( _joinQuad,  show );
1669     setToolShown( _joinQuad, show);
1670     setMenuShown( _merge,  show );
1671     setToolShown( _merge, show);
1672     setMenuShown( _disconnect,  show );
1673     setToolShown( _disconnect, show);
1674     setMenuShown( _cutEdge,  show );
1675     setToolShown( _cutEdge, show);
1676     setMenuShown( _makeTransformation,  show );
1677     setToolShown( _makeTransformation, show);
1678     setMenuShown( _makeSymmetry,  show );
1679     setToolShown( _makeSymmetry, show);
1680     setMenuShown( _performTransformation,  show );
1681     setToolShown( _performTransformation, show);
1682     setMenuShown( _performSymmetry,  show );
1683     setToolShown( _performSymmetry, show);
1684     setMenuShown( _replaceHexa,  show );
1685     setToolShown( _replaceHexa, show);
1686     setMenuShown( _quadRevolution,  show );
1687     setToolShown( _quadRevolution, show);
1688
1689     setMenuShown( _sep4, show );
1690     setMenuShown( _showModelInfoAct, show );
1691 }
1692
1693 void HEXABLOCKGUI::enablePatternMenus(bool enable)
1694 {
1695     if ( enable && !getCurrentModel() ) return;
1696
1697     _addVertex->setEnabled(enable);
1698 //    setToolShown(_addVertex, enable);
1699
1700     _addEdge->setEnabled(enable);
1701 //    setToolShown(_addEdge, enable);
1702
1703     _addQuad->setEnabled(enable);
1704 //    setToolShown(_addQuad, enable);
1705
1706     _addHexa->setEnabled(enable);
1707 //    setToolShown(_addHexa, enable);
1708
1709 //    setMenuShown(_sep1, enable );
1710 //    setToolShown(_sep1, enable);
1711
1712     _addVector->setEnabled(enable);
1713 //    setToolShown( _addVector, enable);
1714
1715 //    setMenuShown(_sep2, enable );
1716 //    setToolShown(_sep2, enable);
1717
1718     _makeGrid->setEnabled(enable);
1719 //    setToolShown( _makeGrid, enable);
1720
1721     _makePipe->setEnabled(enable);
1722 //    setToolShown( _makePipe, enable);
1723
1724 //    setMenuShown(_sep3, enable );
1725 //    setToolShown(_sep3, enable);
1726
1727     _makeCylinder->setEnabled(enable);
1728 //    setToolShown( _makeCylinder, enable);
1729
1730     _makeCylinders->setEnabled(enable);
1731 //    setToolShown( _makeCylinders, enable);
1732
1733     _makePipes->setEnabled(enable);
1734 //    setToolShown( _makePipes, enable);
1735
1736     _makeHemiSphere->setEnabled(enable);
1737 //    setToolShown( _makeHemiSphere, enable);
1738
1739     // Pattern Data Edition
1740     _removeHexa->setEnabled(enable);
1741 //    setToolShown( _removeHexa, enable);
1742
1743     _prismQuad->setEnabled(enable);
1744 //    setToolShown( _prismQuad, enable);
1745
1746     _joinQuad->setEnabled(enable);
1747 //    setToolShown( _joinQuad, enable);
1748
1749     _merge->setEnabled(enable);
1750 //    setToolShown( _merge, enable);
1751
1752     _disconnect->setEnabled(enable);
1753 //    setToolShown( _disconnect, enable);
1754
1755     _cutEdge->setEnabled(enable);
1756 //    setToolShown( _cutEdge, enable);
1757
1758     _makeTransformation->setEnabled(enable);
1759 //    setToolShown( _makeTransformation, enable);
1760
1761     _makeSymmetry->setEnabled(enable);
1762 //    setToolShown( _makeSymmetry, enable);
1763
1764     _performTransformation->setEnabled(enable);
1765 //    setToolShown( _performTransformation, enable);
1766
1767     _performSymmetry->setEnabled(enable);
1768 //    setToolShown( _performSymmetry, enable);
1769
1770     _replaceHexa->setEnabled(enable);
1771 //    setToolShown( _replaceHexa, enable);
1772
1773     _quadRevolution->setEnabled(enable);
1774 //    setToolShown( _quadRevolution, enable);
1775
1776 //    setMenuShown( _sep4, enable );
1777     _showModelInfoAct->setEnabled(enable);
1778 }
1779
1780
1781 void HEXABLOCKGUI::showAssociationMenus(bool show)
1782 {
1783     DEBTRACE("HEXABLOCKGUI::showAssociationMenus" << show);
1784     if ( show && !getCurrentModel() ) return;
1785
1786     // Association Edition
1787     setMenuShown( _assocVertex,  show );
1788     setToolShown( _assocVertex, show );
1789
1790     setMenuShown( _assocEdge,  show );
1791     setToolShown( _assocEdge, show );
1792
1793     setMenuShown( _assocQuad,  show );
1794     setToolShown( _assocQuad, show );
1795
1796     setMenuShown( _addShapeAct, show );
1797     setToolShown( _addShapeAct, show );
1798 }
1799
1800 void HEXABLOCKGUI::enableAssociationMenus(bool enable)
1801 {
1802     if ( enable && !getCurrentModel() )
1803         return;
1804
1805     // Association Edition
1806      _assocVertex->setEnabled(enable);
1807  //    setToolShown( _assocVertex, enable );
1808
1809      _assocEdge->setEnabled(enable);
1810  //    setToolShown( _assocEdge, enable );
1811
1812      _assocQuad->setEnabled(enable);
1813  //    setToolShown( _assocQuad, enable );
1814
1815      _addShapeAct->setEnabled(enable);
1816  //    setToolShown( _addShapeAct, enable );
1817 }
1818
1819 void HEXABLOCKGUI::showGroupsMenus(bool show)
1820 {
1821     DEBTRACE("HEXABLOCKGUI::showGroupsMenus" << show);
1822     if ( show && !getCurrentModel() ) return;
1823     setMenuShown( _addGroup,  show );
1824     setToolShown( _addGroup, show);
1825     setMenuShown( _removeGroup ,  show );
1826     setToolShown( _removeGroup , show);
1827 }
1828
1829 void HEXABLOCKGUI::enableGroupsMenus(bool enable)
1830 {
1831     if ( enable && !getCurrentModel() )
1832         return;
1833
1834     _addGroup->setEnabled(enable);
1835 //    setToolShown( _addGroup, enable);
1836
1837     _removeGroup->setEnabled(enable);
1838 //    setToolShown( _removeGroup , enable);
1839 }
1840
1841 void HEXABLOCKGUI::showMeshMenus(bool show)
1842 {
1843     DEBTRACE("HEXABLOCKGUI::showMeshMenus" << show);
1844     if ( show && !getCurrentModel() ) return;
1845     setMenuShown( _addLaw,  show );
1846     setToolShown( _addLaw, show);
1847     setMenuShown( _removeLaw,  show );
1848     setToolShown( _removeLaw, show);;
1849     setMenuShown( _setPropagation,  show );
1850     setToolShown( _setPropagation, show);
1851     setMenuShown( _computeMesh, show);
1852     setToolShown( _computeMesh, show);
1853 }
1854
1855 void HEXABLOCKGUI::enableMeshMenus(bool enable)
1856 {
1857     if ( enable && !getCurrentModel() )
1858         return;
1859
1860     _addLaw->setEnabled(enable);
1861 //    setToolShown( _addLaw, enable);
1862
1863     _removeLaw->setEnabled(enable);
1864 //    setToolShown( _removeLaw, enable);
1865
1866     _setPropagation->setEnabled(enable);
1867 //    setToolShown( _setPropagation, enable);
1868
1869     _computeMesh->setEnabled(enable);
1870 //    setToolShown( _computeMesh, enable);
1871 }
1872
1873 void HEXABLOCKGUI::showVtkActor()
1874 {
1875     VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
1876     if (currentVtkGView == NULL || currentVtkGView->isEmpty() ||
1877             currentVtkGView->getDocumentActor() == NULL)
1878         return;
1879
1880     SVTK_ViewWindow* vtkView = currentVtkGView->getViewWindow();
1881     if (vtkView == NULL)
1882         return;
1883
1884     SUIT_ViewManager* vman = vtkView->getViewManager();
1885     SalomeApp_Study* aStudy = HEXABLOCKGUI::activeStudy();
1886
1887     //show only the current actor -----------------
1888     vtkView->setFocus();
1889     //    vtkView->DisplayOnly(currentVtkGView->getDocumentActor()->getIO());
1890     Document_Actor *lastDocActor;
1891     if (lastVtkDocGView != NULL)
1892     {
1893         lastDocActor = lastVtkDocGView->getDocumentActor();
1894         Handle(SALOME_InteractiveObject) lastActorIO = lastDocActor->getIO();
1895         if (!lastActorIO.IsNull() && lastActorIO->hasEntry())
1896         {
1897             vtkView->Erase(lastActorIO);
1898             aStudy->setObjectProperty(vman->getId(), lastActorIO->getEntry(),  "Visibility", 0 );
1899             displayer()->setVisibilityState(lastActorIO->getEntry(), Qtx::HiddenState);
1900         }
1901     }
1902     currentVtkGView->update();
1903     Handle(SALOME_InteractiveObject) anIO = currentVtkGView->getDocumentActor()->getIO();
1904     if (!anIO.IsNull() && anIO->hasEntry())
1905     {
1906         vtkView->Display(anIO);
1907         aStudy->setObjectProperty(vman->getId(), anIO->getEntry(),  "Visibility", 1 );
1908         displayer()->setVisibilityState(anIO->getEntry(), Qtx::ShownState);
1909     }
1910     vtkView->onFitAll();
1911 }
1912
1913 void HEXABLOCKGUI::showOccActor()
1914 {
1915     if (currentOccGView == NULL)
1916         return;
1917     OCCViewer_ViewWindow* occView = currentOccGView->getViewWindow();
1918     if (occView == NULL)
1919         return;
1920     SALOME_View* vf = dynamic_cast<SALOME_View*>(occView->getViewManager()->getViewModel());
1921     if (vf == NULL)
1922         return;
1923
1924     if (lastOccPrs != NULL)
1925         vf->Erase(lastOccPrs);
1926     currentOccGView->globalSelection();
1927     SOCC_Prs* prs = getOccPrs(currentDocGView);
1928     currentOccGView->setPrs(prs);
1929     vf->Display(prs);
1930     vf->Repaint();
1931     occView->onFitAll();
1932 }
1933
1934 void HEXABLOCKGUI::hideVtkActor()
1935 {
1936     VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
1937     if (currentVtkGView == NULL || currentVtkGView->isEmpty() ||
1938         currentVtkGView->getViewWindow() == NULL ||
1939         currentVtkGView->getDocumentActor() == NULL) return;
1940
1941     currentVtkGView->getViewWindow()->Erase(currentVtkGView->getDocumentActor()->getIO());
1942     currentVtkGView->getViewWindow()->onResetView();
1943
1944     //update the visibility state now
1945     SalomeApp_Study* aStudy = HEXABLOCKGUI::activeStudy();
1946     SUIT_ViewManager* vman = currentVtkGView->getViewWindow()->getViewManager();
1947     if (aStudy == NULL || vman == NULL) return;
1948
1949     Handle(SALOME_InteractiveObject) anIO = currentVtkGView->getDocumentActor()->getIO();
1950     aStudy->setObjectProperty(vman->getId(), anIO->getEntry(),  "Visibility", 0 );
1951     displayer()->setVisibilityState(anIO->getEntry(), Qtx::HiddenState);
1952 }
1953
1954 void HEXABLOCKGUI::hideOccActor()
1955 {
1956     OCCViewer_ViewWindow* occView = currentOccGView == NULL ? NULL : currentOccGView->getViewWindow();
1957     VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
1958     DocumentModel* docModel = (currentVtkGView == NULL ? NULL : currentVtkGView->getDocumentModel());
1959     if (occView == NULL || docModel == NULL)
1960         return;
1961     SALOME_View* vf = dynamic_cast<SALOME_View*>(occView->getViewManager()->getViewModel());
1962     if (vf == NULL)
1963         return;
1964
1965     SOCC_Prs* currentOccPrs = getOccPrs(currentDocGView);
1966     if (currentOccPrs != NULL)
1967         vf->Erase(currentOccPrs);
1968     vf->Repaint();
1969     occView->onResetView();
1970 }
1971
1972 void HEXABLOCKGUI::showOnlyActor()
1973 {
1974     showVtkActor();
1975     showOccActor();
1976 }
1977
1978 void HEXABLOCKGUI::hideActor()
1979 {
1980     hideVtkActor();
1981     hideOccActor();
1982 }
1983
1984
1985 void HEXABLOCKGUI::showDockWidgets(bool isVisible)
1986 {
1987     DEBTRACE("HEXABLOCKGUI::showDockWidgets " << isVisible);
1988
1989     if (_dwObjectBrowser) _dwObjectBrowser->setVisible(isVisible);
1990     if (_dwObjectBrowser) _dwObjectBrowser->toggleViewAction()->setVisible(isVisible);
1991
1992     if (_dwPattern) _dwPattern->setVisible(isVisible);
1993     if (_dwPattern) _dwPattern->toggleViewAction()->setVisible(isVisible);
1994
1995     if (_dwMesh) _dwMesh->setVisible(isVisible);
1996     if (_dwMesh) _dwMesh->toggleViewAction()->setVisible(isVisible);
1997
1998     if (_dwGroups) _dwGroups->setVisible(isVisible);
1999     if (_dwGroups) _dwGroups->toggleViewAction()->setVisible(isVisible);
2000 }
2001
2002
2003 //clear all used dialogs by the current model
2004 void HEXABLOCKGUI::clearDialogs()
2005 {
2006     std::set<HexaBaseDialog*>::const_iterator debut (currentModelDialogs.begin()),
2007                                               fin   (currentModelDialogs.end());
2008     for(;debut!=fin;++debut) (*debut)->clear();
2009
2010     currentModelDialogs.clear(); //empty the used dialogs list
2011 }
2012
2013 HexaBaseDialog* HEXABLOCKGUI::getDlgBox(VtkDocumentGraphicView* dgview)
2014 {
2015     if (!gViewDlgBox.contains(dgview)) return NULL;
2016     return gViewDlgBox[dgview];
2017 }
2018
2019 void HEXABLOCKGUI::switchOnGraphicView(VtkDocumentGraphicView* dgview)
2020 {
2021    if (dgview == NULL) return;
2022
2023    switchOffGraphicView(dgview, false); //to avoid double connect
2024
2025    //connect signals
2026    connect( selectionMgr(), SIGNAL( currentSelectionChanged() ),
2027          dgview->getPatternDataSelectionModel(), SLOT( salomeSelectionChanged() ), Qt::UniqueConnection );
2028    connect( dgview->getPatternDataSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2029          this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
2030 //   connect( dgview->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2031 //         this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
2032    connect( dgview->getPatternGeomSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2033             this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
2034    connect( dgview->getGroupsSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2035          this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
2036    connect( dgview->getMeshSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2037          this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
2038
2039    showAllMenus();
2040 }
2041
2042 void HEXABLOCKGUI::switchOffGraphicView(VtkDocumentGraphicView* dgview, bool saveCurrentDlg)
2043 {
2044    if (dgview == NULL) return;
2045
2046    //disconnect signals
2047    disconnect( selectionMgr(), SIGNAL( currentSelectionChanged() ),
2048          dgview->getPatternDataSelectionModel(), SLOT( salomeSelectionChanged() ) );
2049    disconnect( dgview->getPatternDataSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2050          this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
2051 //   disconnect( dgview->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2052 //         this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
2053    disconnect( dgview->getPatternGeomSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2054             this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
2055    disconnect( dgview->getGroupsSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2056          this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
2057    disconnect( dgview->getMeshSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
2058          this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
2059
2060    if (saveCurrentDlg)
2061        gViewDlgBox[dgview] = currentDialog;
2062
2063    //close opened dialog
2064    if (currentDialog != NULL) currentDialog->close();
2065 //   if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
2066
2067    initialMenus();
2068
2069 }
2070
2071 void HEXABLOCKGUI::switchModel(VtkDocumentGraphicView* dgview)
2072 {
2073     DEBTRACE("HEXABLOCKGUI::switchModel " << dgview);
2074
2075     if (dgview == NULL)
2076     {
2077         MESSAGE("HEXABLOCKGUI::switchModel : no need to switch!");
2078         return;
2079     }
2080
2081     //switch off the current document graphic view (disconnect signals...)
2082     if (currentDocGView != NULL)
2083     {
2084         //Hide current actor
2085         hideActor();
2086         switchOffGraphicView(currentDocGView);
2087     }
2088
2089     //clear the dialogs used by the current model so they can be used by the new model
2090     if (currentDocGView != dgview) clearDialogs();
2091
2092     _patternDataTreeView->setModel(dgview->getPatternDataModel());
2093 //    _patternBuilderTreeView->setModel(dgview->getPatternBuilderModel());
2094     _patternGeomTreeView->setModel(dgview->getPatternGeomModel());
2095     _groupsTreeView->setModel(dgview->getGroupsModel());
2096     _meshTreeView->setModel(dgview->getMeshModel());
2097
2098     _patternDataTreeView->setSelectionModel(dgview->getPatternDataSelectionModel());
2099     _patternDataTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
2100
2101 //    _patternBuilderTreeView->setSelectionModel(dgview->getPatternBuilderSelectionModel());
2102 //    _patternBuilderTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
2103
2104     _patternGeomTreeView->setSelectionModel(dgview->getPatternGeomSelectionModel());
2105     _patternGeomTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
2106
2107     _groupsTreeView->setSelectionModel(dgview->getGroupsSelectionModel());
2108     _groupsTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
2109
2110     _meshTreeView->setSelectionModel(dgview->getMeshSelectionModel());
2111     _meshTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
2112
2113
2114     // = * init occ view * =
2115     if (currentOccGView != NULL && currentOccGView->getViewWindow() == NULL)
2116     {
2117         currentOccGView->setViewWindow(graphicViewsHandler->createOccWindow());
2118         currentOccGView->getViewWindow()->installEventFilter(this);
2119     }
2120     // ==
2121
2122
2123     // = * init vtk view * =
2124     if (currentDocGView != NULL)
2125     {
2126         if (currentDocGView->getViewWindow() != NULL)
2127             dgview->setViewWindow(currentDocGView->getViewWindow());
2128         else
2129         {
2130             dgview->setViewWindow(graphicViewsHandler->createVtkWindow());
2131             dgview->getViewWindow()->installEventFilter(this);
2132         }
2133     }
2134
2135     // ==
2136
2137     switchOnGraphicView(dgview);
2138
2139     if (currentDocGView != NULL)
2140     {
2141         lastVtkDocGView = currentDocGView;
2142         lastOccPrs = getOccPrs(currentDocGView);
2143     }
2144     else
2145     {
2146         lastVtkDocGView = dgview;
2147         lastOccPrs = getOccPrs(dgview);
2148     }
2149
2150     currentDocGView = dgview;
2151     showOnlyActor();
2152     currentDocGView->getDocumentModel()->refresh();
2153 //    _dwPattern->setWindowTitle(currentDocGView->getDocumentModel()->getName());
2154     showAllMenus();
2155     if (!menusEnabled)
2156         setAllMenusEnabled(true);
2157 }
2158
2159 DocumentModel* HEXABLOCKGUI::getCurrentModel()
2160 {
2161     if (currentDocGView == NULL) return NULL;
2162     return currentDocGView->getDocumentModel();
2163 }
2164
2165
2166 HEXABLOCKGUI::ViewType HEXABLOCKGUI::getActiveViewType()
2167 {
2168     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2169     if (anApp == NULL) return UNKNOWN;
2170     SUIT_ViewManager* activeVm = anApp->activeViewManager();
2171     if (activeVm == NULL) return UNKNOWN;
2172
2173    QString vmType = activeVm->getType();
2174    if ( (vmType == SVTK_Viewer::Type()) || (vmType == VTKViewer_Viewer::Type()) )
2175        return VTK;
2176    else if ( vmType == OCCViewer_Viewer::Type() )
2177        return OCC;
2178
2179    return UNKNOWN;
2180 }
2181
2182 HEXABLOCKGUI* HEXABLOCKGUI::getInstance()
2183 {
2184     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2185     if (anApp == NULL)
2186         return NULL;
2187
2188     return  dynamic_cast<HEXABLOCKGUI*>(anApp->activeModule());
2189 }
2190
2191 pair <QString, HEXA_NS::Document*> HEXABLOCKGUI::newHexaDocument()
2192 {
2193     // Create Document from HEXABLOCK ENGINE
2194     // WARNING : IN HEXABLOCK component,  GUI and ENGINE share the same process
2195     // HEXABLOCK_ORB::Document_ptr docIn = _hexaEngine->addDocument("default"); // Perime  Hexa6
2196
2197     // looking doc impl ( c++ )
2198     // ^Hexa6 Document_impl* dServant = DownCast<Document_impl*>( docIn );
2199     // ^Hexa6 ASSERT( dServant );
2200     // ^Hexa6 if ( dServant)
2201         // ^Hexa6 doc = dServant->GetImpl();
2202
2203     HEXA_NS::Document* doc = hexa_root->addDocument ("default");
2204     QString docEntry = addDocInStudy (doc);
2205
2206     // looking for docEntry
2207     /* ****************************************************************
2208     if ( !CORBA::is_nil(docIn) ){
2209         CORBA::String_var anIOR = SalomeApp_Application::orb()->object_to_string( docIn );
2210         QString docIOR = anIOR.in();
2211         SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( SUIT_Session::session()->activeApplication()->activeStudy() );
2212         if ( !docIOR.isEmpty() ) {
2213             _PTR(SObject) SO( study->studyDS()->FindObjectIOR( docIOR.toLatin1().constData() ) );
2214             if ( SO )
2215                 docEntry = SO->GetID().c_str();
2216         }
2217     }
2218        **************************************************************** */
2219     DEBTRACE("HEXABLOCKGUI::newHexaDocument docEntry "<<docEntry.toStdString());
2220
2221     return make_pair (docEntry, doc);
2222 }
2223
2224
2225 void HEXABLOCKGUI::newDocument()
2226 {
2227     DEBTRACE("HEXABLOCKGUI::newDocument");
2228
2229     createSComponent();
2230     QMainWindow *aParent = application()->desktop();
2231     QWidget *central = aParent->centralWidget();
2232     if (central)
2233         central->setFocus();
2234     else
2235         DEBTRACE("No Central Widget");
2236
2237     //Init OCC
2238     if (currentOccGView == NULL)
2239     {
2240         currentOccGView = new OccGraphicView(graphicViewsHandler->createOccWindow(),
2241                 application()->desktop());
2242         currentOccGView->getViewWindow()->installEventFilter(this);
2243     }
2244     else if (currentOccGView->getViewWindow() == NULL)
2245     {
2246         currentOccGView->setViewWindow(graphicViewsHandler->createOccWindow());
2247         currentOccGView->getViewWindow()->installEventFilter(this);
2248     }
2249
2250     //NEW DOCUMENT
2251     // Create Document from HEXABLOCK ENGINE
2252     pair <QString, HEXA_NS::Document*> docEntry_Doc ( newHexaDocument() );
2253
2254     VtkDocumentGraphicView* newGraphicView = NULL;
2255     //One document at a time
2256     if (currentDocGView != NULL)
2257     {
2258         if (currentDocGView->getViewWindow() == NULL)
2259         {
2260             currentDocGView->setViewWindow(graphicViewsHandler->createVtkWindow());
2261             currentDocGView->getViewWindow()->installEventFilter(this);
2262         }
2263
2264           // Create a new document with the current window
2265           newGraphicView = graphicViewsHandler->createDocumentGraphicView(
2266                                         new DocumentModel( docEntry_Doc.second,
2267                                         docEntry_Doc.first, this ),
2268                                         currentDocGView->getViewWindow(),
2269                                         application()->desktop() );
2270     }
2271     else
2272     {
2273           // Create the new Document Graphic View with a new window
2274           newGraphicView = graphicViewsHandler->createDocumentGraphicView(
2275                                         new DocumentModel( docEntry_Doc.second,
2276                                         docEntry_Doc.first, this ),
2277                                         graphicViewsHandler->createVtkWindow(),
2278                                         application()->desktop() );
2279           newGraphicView->getViewWindow()->installEventFilter(this);
2280     }
2281
2282     if (newGraphicView == NULL)
2283         //We couldn't create a new document graphic view
2284         //we'd better show a dialog box info to inform the user
2285         return;
2286
2287     docs[docEntry_Doc.first] = newGraphicView;
2288     switchModel(newGraphicView); //select the corresponding document in the browser instead
2289
2290     getApp()->updateObjectBrowser();
2291     showAllMenus();
2292 }
2293
2294
2295 //Loads the model from the xmlFile in the current graphic view
2296 void HEXABLOCKGUI::loadDocument( const QString &inFile )
2297 {
2298     DEBTRACE("HEXABLOCKGUI::loadDocument");
2299
2300     createSComponent();
2301     QMainWindow *aParent = application()->desktop();
2302     QString selectedFile;
2303
2304     if ( inFile.isNull() ){
2305         QFileDialog dialog( aParent, tr("Open HexaBlock Document") ,
2306                 QString::null, tr( "XML-Files (*.xml);;All Files (*)" ) );
2307         dialog.setHistory( getQuickDirList() );
2308
2309         //use the last path as default
2310         if (!(loadDocLastPath->absolutePath()).isEmpty())
2311             dialog.setDirectory(*loadDocLastPath);
2312
2313         if (dialog.exec()){
2314             QStringList selectedFiles = dialog.selectedFiles();
2315             if (!selectedFiles.isEmpty())
2316                 selectedFile = selectedFiles.first();
2317
2318             //remember the selected path
2319             *loadDocLastPath = dialog.directory();
2320         }
2321     } else
2322         selectedFile = inFile;
2323
2324     if (selectedFile.isEmpty())
2325         return;
2326
2327     //we create a new document if necessary
2328     if (currentDocGView == NULL)
2329         //Need a new document
2330         newDocument();
2331     else if (currentDocGView->getViewWindow() == NULL) //there's a document without a view
2332     {
2333         currentDocGView->setViewWindow(graphicViewsHandler->createVtkWindow());
2334         currentDocGView->getViewWindow()->installEventFilter(this);
2335     }
2336
2337     if (!currentDocGView->isEmpty())
2338         //we can only have one document for a graphic view
2339         newDocument();
2340
2341     //we load the selected file in the current graphic view
2342     currentDocGView->loadDocument(selectedFile);
2343     DocumentModel* currentModel = getCurrentModel();
2344     renameObject( currentModel->documentEntry(), currentModel->getName() );
2345
2346     showOnlyActor();
2347 }
2348
2349 void HEXABLOCKGUI::saveDocument()
2350 {
2351     QMainWindow *aParent = application()->desktop();
2352
2353     QString aDocName = "document", aFilename;
2354     QStringList filter;
2355     filter.append( QObject::tr( "XML_FILES_FILTER" ) + " (*.xml)" );
2356     filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
2357
2358     //use the last selected directory as default path for file selection
2359     aFilename =  saveDocLastPath->absolutePath();
2360     if (!aFilename.isEmpty())
2361         aFilename += QString("/") + aDocName;
2362
2363     //show the dialog for file selection
2364     aFilename = SUIT_FileDlg::getFileName( aParent,
2365             aFilename,
2366             filter,
2367             tr( "Save HexaBlock Document" ),
2368             false );
2369
2370     //save the document in the selected file
2371     if ( !aFilename.isEmpty() ) {
2372         getCurrentVtkGraphicView()->saveDocument( aFilename );
2373
2374         //Remember the path for next save
2375         QFileInfo fileInfo(aFilename);
2376         *saveDocLastPath = fileInfo.dir();
2377     }
2378     //CS_TODO save doc
2379 }
2380
2381
2382 void HEXABLOCKGUI::slot_modelChanged(const QModelIndex &topLeft, const QModelIndex  &bottomRight)
2383 {
2384     _patternDataTreeView->openPersistentEditor( topLeft );
2385 }
2386
2387 void HEXABLOCKGUI::_showDialogBox( HexaBaseDialog* diag )
2388 {
2389     if (diag == NULL || _dwInputPanel == NULL ||
2390             getCurrentVtkGraphicView() == NULL) return;
2391
2392     //mark this dialog as used by the current model
2393     currentModelDialogs.insert(diag);
2394
2395     //close the current dialog box info
2396 //    if (_treeViewDelegate != NULL)
2397 //        _treeViewDelegate->closeDialog();
2398
2399 //    if (_dwInputPanel->widget())
2400 //        _dwInputPanel->widget()->close();
2401
2402     //Temporary for debugging EdgeAssoc Faked InfoDialog
2403     if (diag == _edgeAssocDiag)
2404         diag->debugEdgeAssoc = true;
2405     else
2406         diag->debugEdgeAssoc = false;
2407
2408     if (diag == _vertexAssocDiag || diag ==  _edgeAssocDiag ||
2409                 diag ==  _quadAssocDiag || diag == _addShapeDiag)
2410         assocInProgress = true;
2411     else
2412         assocInProgress = false;
2413
2414     //show the dialog box in the dockwidget
2415     diag->resetSizeAndShow(_dwInputPanel);
2416
2417     //clear the current selections
2418     selectionMgr()->clearSelected();
2419
2420     currentDialog = diag;
2421     diag->setFocus();
2422
2423     if (currentDocGView != NULL)
2424         currentDocGView->getPatternDataSelectionModel()->setInfoMode(false);
2425 }
2426
2427 void HEXABLOCKGUI::showVertexInfoDialog(HEXA_NS::Vertex* vertex)
2428 {
2429     if (vertex == NULL || _dwInputPanel == NULL)
2430         return;
2431
2432     if (_vertexInfoDialog == NULL)
2433         _vertexInfoDialog = new VertexDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2434
2435     _vertexInfoDialog->setValue(vertex);
2436     _vertexInfoDialog->resetSizeAndShow(_dwInputPanel);
2437     currentDialog = _vertexInfoDialog;
2438 }
2439
2440 void HEXABLOCKGUI::showEdgeInfoDialog(HEXA_NS::Edge* edge)
2441 {
2442     if (edge == NULL || _dwInputPanel == NULL)
2443         return;
2444
2445     if (_edgeInfoDialog == NULL)
2446         _edgeInfoDialog = new EdgeDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2447
2448     _edgeInfoDialog->setValue(edge);
2449     _edgeInfoDialog->resetSizeAndShow(_dwInputPanel);
2450     currentDialog = _edgeInfoDialog;
2451 }
2452
2453 void HEXABLOCKGUI::showQuadInfoDialog(HEXA_NS::Quad* quad)
2454 {
2455     if (quad == NULL || _dwInputPanel == NULL)
2456         return;
2457
2458     if (_quadInfoDialog == NULL)
2459         _quadInfoDialog = new QuadDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2460
2461     _quadInfoDialog->setValue(quad);
2462     _quadInfoDialog->resetSizeAndShow(_dwInputPanel);
2463     currentDialog = _quadInfoDialog;
2464 }
2465
2466 void HEXABLOCKGUI::showHexaInfoDialog(HEXA_NS::Hexa* hexa)
2467 {
2468     if (hexa == NULL || _dwInputPanel == NULL)
2469         return;
2470
2471     if (_hexaInfoDialog == NULL)
2472         _hexaInfoDialog = new HexaDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2473
2474     _hexaInfoDialog->setValue(hexa);
2475     _hexaInfoDialog->resetSizeAndShow(_dwInputPanel);
2476     currentDialog = _hexaInfoDialog;
2477 }
2478
2479 void HEXABLOCKGUI::showVectorInfoDialog(HEXA_NS::Vector* vector)
2480 {
2481     if (vector == NULL || _dwInputPanel == NULL)
2482         return;
2483
2484     if (_vectorInfoDialog == NULL)
2485         _vectorInfoDialog = new VectorDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2486
2487     _vectorInfoDialog->setValue(vector);
2488     _vectorInfoDialog->resetSizeAndShow(_dwInputPanel);
2489     currentDialog = _vectorInfoDialog;
2490 }
2491
2492 void HEXABLOCKGUI::showGroupInfoDialog(HEXA_NS::Group* group)
2493 {
2494     if (group == NULL || _dwInputPanel == NULL)
2495         return;
2496
2497     if (_groupInfoDialog == NULL)
2498         _groupInfoDialog = new GroupDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2499
2500     _groupInfoDialog->setValue(group);
2501     _groupInfoDialog->resetSizeAndShow(_dwInputPanel);
2502     currentDialog = _groupInfoDialog;
2503 }
2504
2505 void HEXABLOCKGUI::showLawInfoDialog(HEXA_NS::Law* law)
2506 {
2507     if (law == NULL || _dwInputPanel == NULL)
2508         return;
2509
2510     if (_lawInfoDialog == NULL)
2511         _lawInfoDialog = new LawDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2512
2513     _lawInfoDialog->setValue(law);
2514     _lawInfoDialog->resetSizeAndShow(_dwInputPanel);
2515     currentDialog = _lawInfoDialog;
2516 }
2517
2518 void HEXABLOCKGUI::showPropagationInfoDialog(HEXA_NS::Propagation* propagation)
2519 {
2520     if (propagation == NULL || _dwInputPanel == NULL)
2521         return;
2522
2523     if (_propagationInfoDialog == NULL)
2524         _propagationInfoDialog = new PropagationDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
2525
2526     _propagationInfoDialog->setValue(propagation);
2527     _propagationInfoDialog->resetSizeAndShow(_dwInputPanel);
2528     currentDialog = _propagationInfoDialog;
2529 }
2530
2531 void HEXABLOCKGUI::addVertex()
2532 {
2533     if ( !_vertexDiag ){
2534         _vertexDiag = new VertexDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2535     }
2536     _showDialogBox( _vertexDiag );
2537
2538     //set default name
2539     HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2540     if (_vertexDiag != NULL && doc != NULL)
2541         _vertexDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_VERTEX).c_str());
2542 }
2543
2544 void HEXABLOCKGUI::addEdge()
2545 {
2546     if ( !_edgeDiag ){
2547         _edgeDiag = new EdgeDialog( _dwInputPanel, HexaBaseDialog::NEW_MODE);
2548     }
2549     _showDialogBox( _edgeDiag );
2550
2551     //set default name
2552     HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2553     if (_edgeDiag != NULL && doc != NULL)
2554         _edgeDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_EDGE).c_str());
2555 }
2556
2557 void HEXABLOCKGUI::addQuad()
2558 {
2559     if ( !_quadDiag ){
2560         _quadDiag = new QuadDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2561
2562     }
2563     _showDialogBox( _quadDiag );
2564
2565     //set default name
2566     HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2567     if (_quadDiag != NULL && doc != NULL)
2568         _quadDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_QUAD).c_str());
2569 }
2570
2571 void HEXABLOCKGUI::addHexa()
2572 {
2573     if ( !_hexaDiag ){
2574         _hexaDiag = new HexaDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2575     }
2576     _showDialogBox( _hexaDiag );
2577
2578     //set default name
2579     HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2580     if (_hexaDiag != NULL && doc != NULL)
2581         _hexaDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_HEXA).c_str());
2582 }
2583
2584 void HEXABLOCKGUI::addVector()
2585 {
2586     if ( !_vectorDiag ){
2587         _vectorDiag = new VectorDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2588     }
2589     _showDialogBox( _vectorDiag );
2590
2591     //set default name
2592     HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2593     if (_vectorDiag != NULL && doc != NULL)
2594         _vectorDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_VECTOR).c_str());
2595 }
2596
2597 //void HEXABLOCKGUI::addCylinder()
2598 //{
2599 //    if ( !_cylinderDiag ){
2600 //        _cylinderDiag = new CylinderDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2601 //    }
2602 //    _showDialogBox( _cylinderDiag );
2603 //
2604 //    //set default name
2605 //    HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2606 //    if (_cylinderDiag != NULL && doc != NULL)
2607 //        _cylinderDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_CYLINDER).c_str());
2608 //}
2609
2610
2611 //void HEXABLOCKGUI::addPipe()
2612 //{
2613 //    if ( !_pipeDiag){
2614 //        _pipeDiag = new PipeDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2615 //    }
2616 //    _showDialogBox( _pipeDiag );
2617 //
2618 //    //set default name
2619 //    HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
2620 //    if (_pipeDiag != NULL && doc != NULL)
2621 //        _pipeDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_CYLINDER).c_str());
2622 //}
2623
2624
2625 void HEXABLOCKGUI::makeGrid()
2626 {
2627     if ( !_makeGridDiag ){
2628         _makeGridDiag = new MakeGridDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2629     }
2630     _showDialogBox( _makeGridDiag );
2631 }
2632
2633
2634 void HEXABLOCKGUI::makeCylinder()
2635 {
2636     if ( !_makeCylinderDiag ){
2637         _makeCylinderDiag = new MakeCylinderDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2638     }
2639     _showDialogBox( _makeCylinderDiag );
2640 }
2641
2642 void HEXABLOCKGUI::makePipe()
2643 {
2644     if ( !_makePipeDiag ){
2645         _makePipeDiag = new MakePipeDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2646     }
2647     _showDialogBox( _makePipeDiag );
2648 }
2649
2650 void HEXABLOCKGUI::makeCylinders()
2651 {
2652     if ( !_makeCylindersDiag ){
2653         _makeCylindersDiag = new MakeCylindersDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2654     }
2655     _showDialogBox( _makeCylindersDiag );
2656 }
2657
2658 void HEXABLOCKGUI::makePipes()
2659 {
2660     if ( !_makePipesDiag ){
2661         _makePipesDiag = new MakePipesDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2662     }
2663     _showDialogBox( _makePipesDiag );
2664 }
2665
2666
2667 void HEXABLOCKGUI::makeHemiSphere()  // NEW HEXA3
2668 {
2669     if ( !_makeHemiSphereDiag ){
2670         _makeHemiSphereDiag = new MakeHemiSphereDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2671     }
2672     _showDialogBox( _makeHemiSphereDiag );
2673 }
2674
2675
2676 void HEXABLOCKGUI::removeHexa()
2677 {
2678     if ( !_removeHexaDiag ){
2679         _removeHexaDiag = new RemoveHexaDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2680     }
2681     _showDialogBox( _removeHexaDiag );
2682 }
2683
2684
2685 void HEXABLOCKGUI::prismQuad()
2686 {
2687     if ( !_prismQuadDiag ){
2688         _prismQuadDiag = new PrismQuadDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2689     }
2690     _showDialogBox( _prismQuadDiag );
2691 }
2692
2693
2694 void HEXABLOCKGUI::joinQuad()
2695 {
2696     if ( !_joinQuadDiag ){
2697         _joinQuadDiag = new JoinQuadDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2698     }
2699     _showDialogBox( _joinQuadDiag );
2700 }
2701
2702 void HEXABLOCKGUI::merge()
2703 {
2704     if ( !_mergeDiag ){
2705         _mergeDiag = new MergeDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2706     }
2707     _showDialogBox( _mergeDiag );
2708 }
2709
2710 void HEXABLOCKGUI::disconnectElts()
2711 {
2712     if ( !_disconnectDiag ){
2713         _disconnectDiag = new DisconnectDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2714     }
2715     _showDialogBox( _disconnectDiag );
2716 }
2717
2718 void HEXABLOCKGUI::cutEdge()
2719 {
2720     if ( !_cutEdgeDiag ){
2721         _cutEdgeDiag = new CutEdgeDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2722     }
2723     _showDialogBox( _cutEdgeDiag );
2724 }
2725
2726 void HEXABLOCKGUI::makeTransformation()
2727 {
2728     if ( !_makeTransformationDiag ){
2729         _makeTransformationDiag = new MakeTransformationDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2730     }
2731     _showDialogBox( _makeTransformationDiag );
2732 }
2733
2734
2735 void HEXABLOCKGUI::makeSymmetry()
2736 {
2737     if ( !_makeSymmetryDiag ){
2738         _makeSymmetryDiag = new MakeSymmetryDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2739     }
2740     _showDialogBox( _makeSymmetryDiag );
2741 }
2742
2743
2744 void HEXABLOCKGUI::performTransformation()
2745 {
2746     if ( !_performTransformationDiag ){
2747         _performTransformationDiag = new PerformTransformationDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2748     }
2749     _showDialogBox( _performTransformationDiag );
2750 }
2751
2752
2753 void HEXABLOCKGUI::performSymmetry()
2754 {
2755     if ( !_performSymmetryDiag ){
2756         _performSymmetryDiag = new PerformSymmetryDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2757     }
2758     _showDialogBox( _performSymmetryDiag );
2759 }
2760
2761
2762 void HEXABLOCKGUI::replaceHexa()    // NEW HEXA3
2763 {
2764     if ( !_replaceHexaDiag ){
2765         _replaceHexaDiag = new ReplaceHexaDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2766     }
2767     _showDialogBox( _replaceHexaDiag );
2768 }
2769
2770
2771 void HEXABLOCKGUI::quadRevolution() // NEW HEXA3
2772 {
2773     if ( !_quadRevolutionDiag ){
2774         _quadRevolutionDiag = new QuadRevolutionDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2775     }
2776     _showDialogBox( _quadRevolutionDiag );
2777 }
2778
2779
2780 void HEXABLOCKGUI::assocVertex()
2781 {
2782         if (!_dwInputPanel) return;
2783         QWidget* d = dynamic_cast<SUIT_Desktop*>(_dwInputPanel->parent());
2784         if ( !_vertexAssocDiag  )
2785                 _vertexAssocDiag  = new VertexAssocDialog( d /*_dwInputPanel*/);
2786         _showDialogBox( _vertexAssocDiag );
2787 }
2788
2789
2790 void HEXABLOCKGUI::assocEdge()
2791 {
2792     if ( !_edgeAssocDiag )
2793         _edgeAssocDiag = new EdgeAssocDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2794     _showDialogBox( _edgeAssocDiag );
2795 }
2796
2797 void HEXABLOCKGUI::assocQuad()
2798 {
2799     if ( !_quadAssocDiag )
2800         _quadAssocDiag = new QuadAssocDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2801     _showDialogBox( _quadAssocDiag );
2802 }
2803
2804
2805 void HEXABLOCKGUI::addGroup()
2806 {
2807     if ( !_groupDiag ){
2808         _groupDiag = new GroupDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2809     }
2810     _showDialogBox( _groupDiag );
2811     if (_groupDiag != NULL && getCurrentModel() != NULL)
2812     {
2813         HEXA_NS::Document* doc = getCurrentModel()->getHexaDocument();
2814         if (doc == NULL) return;
2815         char defaultName[16];
2816         sprintf (defaultName, "g%04d", doc->countGroup());
2817         _groupDiag->name_le->setText(defaultName);
2818     }
2819 }
2820
2821 void HEXABLOCKGUI::removeGroup()
2822 {
2823     VtkDocumentGraphicView* currentDGView = getCurrentVtkGraphicView();
2824     if (currentDGView == NULL) return;
2825
2826     QItemSelectionModel *groupsSelectionModel = _groupsTreeView->selectionModel();
2827     QModelIndexList l = groupsSelectionModel->selectedIndexes();
2828     int nbGroupsRemoved = 0;
2829
2830     if ( l.isEmpty() ){
2831         SUIT_MessageBox::information( 0, tr( "CANNOT REMOVE GROUP" ),
2832                 tr( "No group selected!" ) );
2833         return;
2834     }
2835
2836     foreach( QModelIndex selected, l ){
2837         if ( selected.data(HEXA_TREE_ROLE) == GROUP_TREE ){
2838             selected = currentDGView->getGroupsModel()->mapToSource( selected );
2839             Q_ASSERT(selected.isValid());
2840
2841             //Confirm the deletion of the group
2842             if (SUIT_MessageBox::question(
2843                     0,
2844                     tr("Remove Group"),
2845                     tr("Remove group : %1 ?").arg(selected.data().toString()),
2846                     SUIT_MessageBox::Ok | SUIT_MessageBox::Cancel,
2847                     SUIT_MessageBox::Cancel
2848             ) == SUIT_MessageBox::Cancel) return;
2849
2850             bool removed = getCurrentModel()->removeGroup( selected );
2851             if ( !removed ) {
2852                 SUIT_MessageBox::critical( 0, tr( "ERR_ERROR" ),
2853                         tr( "CANNOT REMOVE %1" ).arg(selected.data().toString()) );
2854                 return;
2855             }
2856             nbGroupsRemoved++;
2857         }
2858     }
2859     if (!nbGroupsRemoved)
2860         SUIT_MessageBox::information( 0, tr( "CANNOT REMOVE GROUP" ),
2861                 tr( "No group selected!" ) );
2862 }
2863
2864 void HEXABLOCKGUI::addLaw()
2865 {
2866     if ( !_lawDiag ){
2867         _lawDiag = new LawDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2868     }
2869     _showDialogBox( _lawDiag );
2870     if (_lawDiag != NULL && getCurrentModel() != NULL)
2871     {
2872         HEXA_NS::Document* doc = getCurrentModel()->getHexaDocument();
2873         if (doc == NULL) return;
2874         char defaultName[16];
2875         sprintf (defaultName, "l%04d", doc->countLaw());
2876         _lawDiag->name_le->setText(defaultName);
2877     }
2878 }
2879
2880 void HEXABLOCKGUI::removeLaw()
2881 {
2882     VtkDocumentGraphicView* currentDGView = getCurrentVtkGraphicView();
2883     if (currentDGView == NULL) return;
2884
2885     QModelIndexList l = currentDGView->getMeshSelectionModel()->selectedIndexes();
2886     int nbLawsRemoved = 0;
2887
2888     if ( l.isEmpty() ){
2889         SUIT_MessageBox::information( 0, tr( "CANNOT REMOVE LAW" ),
2890                 tr( "No law selected!" ) );
2891         return;
2892     }
2893
2894     foreach( QModelIndex selected, l ){
2895         if ( selected.data(HEXA_TREE_ROLE) == LAW_TREE ){
2896             selected = currentDGView->getMeshModel()->mapToSource( selected );
2897             Q_ASSERT(selected.isValid());
2898
2899             //Confirm the deletion of the law
2900             if (SUIT_MessageBox::question(
2901                     0,
2902                     tr("Remove Law"),
2903                     tr("Remove law : %1 ?\nAll propagations having this law will have the default law.").arg(selected.data().toString()),
2904                     SUIT_MessageBox::Ok | SUIT_MessageBox::Cancel,
2905                     SUIT_MessageBox::Cancel
2906             ) == SUIT_MessageBox::Cancel) return;
2907
2908             bool removed = getCurrentModel()->removeLaw(selected);
2909             if ( !removed ) {
2910                 SUIT_MessageBox::critical( 0, tr( "ERR_ERROR" ),
2911                         tr( "CANNOT REMOVE %1" ).arg(selected.data().toString()) );
2912                 return;
2913             }
2914             nbLawsRemoved++;
2915         }
2916     }
2917     if (!nbLawsRemoved)
2918         SUIT_MessageBox::information( 0, tr( "CANNOT REMOVE LAW" ),
2919                                          tr( "No law selected!" ) );
2920
2921 }
2922
2923
2924 void HEXABLOCKGUI::setPropagation()
2925 {
2926     if ( !_propagationDiag )
2927         _propagationDiag = new PropagationDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2928
2929     _showDialogBox( _propagationDiag );
2930 }
2931
2932 // Dialog box to compute a mesh from a document
2933 // --------------------------------------------
2934 void HEXABLOCKGUI::computeMesh()
2935 {
2936     if ( !_computeMeshDiag )
2937         _computeMeshDiag = new ComputeMeshDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
2938
2939     _showDialogBox( _computeMeshDiag );
2940 }
2941
2942 void HEXABLOCKGUI::clearAssociations()
2943 {
2944     VtkDocumentGraphicView* currentDGView = getCurrentVtkGraphicView();
2945     if (currentDGView == NULL) return;
2946
2947     //   QMessageBox::warning( 0, "windowTitle()", "clearAssociations" );
2948     QModelIndex iDataModel = _patternDataTreeView->currentIndex();
2949     QModelIndex iModel     = currentDGView->getPatternDataModel()->mapToSource(iDataModel);
2950
2951     getCurrentModel()->clearEltAssociations(iModel);
2952
2953     //  SUIT_MessageBox::information( 0, tr( "HEXA_INFO" ), tr( "ASSOCIATION CLEARED" ) );
2954 }
2955
2956 void HEXABLOCKGUI::showModelInfo()
2957 {
2958     //create the info dialog if not yet
2959     if (_modelInfoDiag == NULL)
2960         _modelInfoDiag = new ModelInfoDialog(_dwInputPanel);
2961
2962     //show the model informations dialog
2963     _showDialogBox( _modelInfoDiag );
2964 }
2965
2966 void HEXABLOCKGUI::addShape()
2967 {
2968     //create the info dialog if not yet
2969     if (_addShapeDiag == NULL)
2970         _addShapeDiag = new AddShapeDialog(_dwInputPanel);
2971
2972     //show the model informations dialog
2973     _showDialogBox( _addShapeDiag );
2974 }
2975
2976 void HEXABLOCKGUI::clearAllAssociations()
2977 {
2978     VtkDocumentGraphicView* currentDGView = getCurrentVtkGraphicView();
2979     if (currentDGView == NULL) return;
2980
2981     QModelIndex currentIndex = currentDGView->getPatternDataModel()->mapToSource(_patternDataTreeView->currentIndex());
2982     if (!currentIndex.isValid()) return;
2983     QVariant currentAssocVariant;
2984     QString currentAssocEntry;
2985
2986     //Confirm the deletion of the associations
2987     QVariant treeVariant = currentIndex.data( HEXA_TREE_ROLE );
2988     if ( !treeVariant.isValid() ) return;
2989     int eltType = treeVariant.toInt();
2990     QString typeStr = "";
2991     HEXA_NS::EnumElt hexaType;
2992     if (eltType == VERTEX_DIR_TREE)
2993     {
2994         typeStr = tr("TREE_ITEM_VERTEX").toUpper();
2995         hexaType = HEXA_NS::EL_VERTEX;
2996     }
2997     else if (eltType == EDGE_DIR_TREE)
2998     {
2999         typeStr = tr("TREE_ITEM_EDGE").toUpper();
3000         hexaType = HEXA_NS::EL_EDGE;
3001     }
3002     else if (eltType == QUAD_DIR_TREE)
3003     {
3004         typeStr = tr("TREE_ITEM_QUAD").toUpper();
3005         hexaType = HEXA_NS::EL_QUAD;
3006     }
3007
3008     if (SUIT_MessageBox::question(
3009             0,
3010             tr("CLEAR_ASSOCIATIONS"),
3011             tr("CLEAR_ALL_ASSOCIATIONS_ON") + " " + typeStr + "?",
3012             SUIT_MessageBox::Ok | SUIT_MessageBox::Cancel,
3013             SUIT_MessageBox::Cancel
3014     ) == SUIT_MessageBox::Cancel) return;
3015
3016
3017     DocumentModel* docModel = getCurrentModel();
3018     if (docModel == NULL) return;
3019     docModel->clearAssociation(hexaType);
3020 }
3021
3022 void HEXABLOCKGUI::showAssociations()
3023 {
3024     VtkDocumentGraphicView* currentDGView = getCurrentVtkGraphicView();
3025     if (currentDGView == NULL) return;
3026
3027     QModelIndexList elts;
3028     int currentChildIndex = 0;
3029     QVariant currentAssocVariant;
3030     QString currentAssocEntry;
3031     QModelIndex currentIndex = _patternDataTreeView->currentIndex();
3032     QModelIndex currentChild = currentIndex.child(currentChildIndex++, 0);
3033
3034     while( currentChild.isValid() ) {
3035
3036         currentAssocVariant = currentChild.data( HEXA_ASSOC_ENTRY_ROLE );
3037         currentAssocEntry = currentChild.data( HEXA_ASSOC_ENTRY_ROLE ).toString();
3038         if ( currentAssocVariant.isValid() && !currentAssocEntry.isEmpty() )
3039             elts << currentChild;
3040
3041         currentChild = currentChild.sibling(currentChildIndex++, 0);
3042     }
3043     currentDocGView->highlight(elts);
3044     currentOccGView->highlight(elts, false);
3045 }
3046
3047
3048 LightApp_SelectionMgr* HEXABLOCKGUI::selectionMgr()
3049 {
3050     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
3051     if( anApp )
3052         return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
3053     else
3054         return NULL;
3055 }
3056
3057 bool HEXABLOCKGUI::eventFilter(QObject *obj, QEvent *event)
3058 {
3059     if ( event->type() == QEvent::Enter )
3060     {   // *** ENTER EVENT
3061
3062         if (currentDialog == NULL || !currentDialog->isVisible())
3063             return QObject::eventFilter(obj, event);
3064
3065         //  ** The window acquire the focus when the cursor enter
3066
3067             //OCC - window enter
3068         OCCViewer_ViewWindow* occWindow = dynamic_cast<OCCViewer_ViewWindow*>(obj);
3069         if ( occWindow != NULL)
3070             currentDialog->onWindowActivated(occWindow->getViewManager());
3071         else
3072             //VTK - window enter
3073         {
3074             SVTK_ViewWindow* vtkWindow = dynamic_cast<SVTK_ViewWindow*>(obj);
3075             if ( vtkWindow != NULL)
3076                 currentDialog->onWindowActivated(vtkWindow->getViewManager());
3077         }
3078     }
3079
3080     //standard event processing
3081     return QObject::eventFilter(obj, event);
3082 }
3083
3084 QStringList HEXABLOCKGUI::getQuickDirList()
3085 {
3086     QStringList dirList;
3087     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
3088     if ( resMgr )
3089         dirList = resMgr->stringValue( "FileDlg", "QuickDirList" ).split( ';', QString::SkipEmptyParts );
3090
3091     return dirList;
3092 }
3093
3094
3095 // --- Export the module
3096
3097 extern "C"
3098 {
3099     HEXABLOCK_EXPORT CAM_Module* createModule()
3100     {
3101         return new HEXABLOCKGUI();
3102     }
3103
3104     HEXABLOCK_EXPORT char* getModuleVersion()
3105     {
3106         return (char*)HEXABLOCK_VERSION_STR;
3107     }
3108 }
3109
3110
3111
3112 // ******************** TESTS ***************************************************
3113
3114 void HEXABLOCKGUI::testDocument()
3115 {
3116     //CS_TEST
3117     // ----------
3118     //   QStandardItem *parentItem = getCurrentModel()->invisibleRootItem();
3119     //   QStandardItem *myItem =  new QStandardItem("MyItem");
3120     //   parentItem->appendRow(myItem);
3121     // //   ----------
3122     //   QModelIndex v0 = getCurrentModel()->addVertex(0., 0., 0.);
3123     //   QModelIndex v1 = getCurrentModel()->addVertex(5., 0., 0.);
3124     //   QModelIndex v2 = getCurrentModel()->addVertex(5., 5., 0.);
3125     //   QModelIndex v3 = getCurrentModel()->addVertex(0., 5., 0.);
3126     //   QModelIndex v4 = getCurrentModel()->addVertex(0., 0., 5.);
3127     //   QModelIndex v5 = getCurrentModel()->addVertex(5., 0., 5.);
3128     //   QModelIndex v6 = getCurrentModel()->addVertex(5., 5., 5.);
3129     //   QModelIndex v7 = getCurrentModel()->addVertex(0., 5., 5.);
3130     // //
3131     // //
3132     //   QModelIndex q0 = getCurrentModel()->addQuadVertices( v0, v1, v2, v3 );
3133     //   QModelIndex q1 = getCurrentModel()->addQuadVertices( v4, v5, v6, v7 );
3134     //   QModelIndex q2 = getCurrentModel()->addQuadVertices( v0, v3, v7, v4 );
3135     //   QModelIndex q3 = getCurrentModel()->addQuadVertices( v1, v2, v6, v5 );
3136     //   QModelIndex q4 = getCurrentModel()->addQuadVertices( v0, v1, v5, v4 );
3137     //   QModelIndex q5 = getCurrentModel()->addQuadVertices( v3, v2, v6, v7 );
3138     //
3139     //   QModelIndex h0 = getCurrentModel()->addHexaQuad( q0, q1, q2, q3, q4, q5 );
3140     //   QModelIndex vx = getCurrentModel()->addVector(1., 0., 0.);
3141     //   QModelIndex vy = getCurrentModel()->addVector(0., 1., 0.);
3142     //   QModelIndex vz = getCurrentModel()->addVector(0., 0., 1.);
3143     //
3144
3145
3146
3147     // //   QModelIndex orig1 = getCurrentModel()->addVertex (0, 0,0);
3148     // //   QModelIndex orig2 = getCurrentModel()->addVertex (50,0,0);
3149     // //   QModelIndex vz    = getCurrentModel()->addVector (0,0,1);
3150     // //   QModelIndex vx    = getCurrentModel()->addVector (1,0,0);
3151     // //
3152     // //   int nr  = 4;
3153     // //   int nri = 3;
3154     // //   int nre = nr;
3155     // //   int na = 9;
3156     // //   int nl = 5;
3157     // //
3158     // //   QModelIndex  cyl  = getCurrentModel()->addCylinder   (orig1, vz, nr, nl);
3159     // //   QModelIndex  pipe = getCurrentModel()->addPipe       (orig2, vz, nri, nre, nl);
3160     // //
3161     // //   getCurrentModel()->makeCylinder (cyl,  vx, nr, na, nl);
3162     // //   getCurrentModel()->makePipe(pipe, vx, nr, na, nl);
3163
3164
3165
3166     //   newMesh( "toto", 3, "FactoryServer");
3167     // newMesh
3168 }
3169
3170 void HEXABLOCKGUI::test_make_cart_grid()
3171 {
3172     QModelIndex orig1 = getCurrentModel()->addVertex( 0, 0, 0);
3173     QModelIndex orig2 = getCurrentModel()->addVertex( 10, 0, 0);
3174     QModelIndex orig3 = getCurrentModel()->addVertex( 0, 10, 0);
3175     QModelIndex orig4 = getCurrentModel()->addVertex( 10, 10, 0);
3176     QModelIndex orig5 = getCurrentModel()->addVertex( 0, 20, 0);
3177     QModelIndex orig6 = getCurrentModel()->addVertex( 10, 20, 0);
3178
3179     QModelIndex vz = getCurrentModel()->addVector(0, 0, 1);
3180     QModelIndex vx = getCurrentModel()->addVector(1, 0, 0);
3181
3182     //int dr = 1;
3183     //int dl = 1;
3184     //int nr = 2;
3185     //int nl = 3;
3186
3187     // QModelIndex c1 = getCurrentModel()->makeCylindrical(orig1, vx, vz, dr, 360, dl, nr, 4, nl, true);
3188     // QModelIndex c2 = getCurrentModel()->makeCylindrical(orig2, vx, vz, dr, 360, dl, nr, 8, nl, true);
3189     // QModelIndex c3 = getCurrentModel()->makeCylindrical(orig3, vx, vz, dr, 270, dl, nr, 8, nl, true);
3190     // QModelIndex c4 = getCurrentModel()->makeCylindrical(orig4, vx, vz, dr, 270, dl, nr, 7, nl, true);
3191     // QModelIndex c5 = getCurrentModel()->makeCylindrical(orig5, vx, vz, dr, 360, dl, nr, 5, nl, true);
3192     // QModelIndex c6 = getCurrentModel()->makeCylindrical(orig6, vx, vz, dr, 360, dl, nr, 6, nl, true);
3193
3194 }
3195
3196
3197 void HEXABLOCKGUI::test_make_elmts_transform()
3198 {
3199
3200 //    int size_x = 1;
3201 //    int size_y = 1;
3202 //    int size_z = 2;
3203 //
3204 //    QModelIndex orig = getCurrentModel()->addVertex(0, 0, 0);
3205 //    QModelIndex dirVr = getCurrentModel()->addVector(1, 1, 1);
3206
3207     //obsolete
3208 //    QModelIndex grid = getCurrentModel()->makeCartesian(orig, dirVr, size_x, size_y, size_z);//, 0, 0, 0);
3209     // orig.setScalar(2);
3210
3211     // file_name = os.path.join(os.environ['TMP'], 'transfo0.vtk')
3212     // getCurrentModel()->saveVtk(file_name)
3213
3214 //    QModelIndex devant = getCurrentModel()->addVector(5, 0, 0);
3215 //    QModelIndex grid2  = getCurrentModel()->makeTranslation(grid, devant);
3216
3217     // file_name = os.path.join(os.environ['TMP'], 'transfo_translation.vtk')
3218     // getCurrentModel()->saveVtk(file_name)
3219
3220 //    QModelIndex grid4 = getCurrentModel()->makeRotation(grid2, orig, dirVr, 45);
3221
3222
3223     // file_name = os.path.join(os.environ['TMP'], 'transfo_rotation.vtk');
3224     // getCurrentModel()->saveVtk(file_name);
3225
3226
3227     // print "...test make elements by transforming elements OK"
3228 }
3229 // =============================================================== addDocInSudy
3230 QString HEXABLOCKGUI::addDocInStudy (HEXA_NS::Document* document)
3231 {
3232     QString docEntry;
3233
3234     if (document == NULL)
3235         return docEntry;
3236
3237     QString docName  = document->getName ();
3238
3239     SalomeApp_Study* app_study = HEXABLOCKGUI::activeStudy();
3240     if (app_study == NULL)
3241         return docEntry;
3242
3243     _PTR(Study)         study    = app_study->studyDS();
3244     SALOMEDS::Study_var ds_study = ClientStudyToStudy (study);
3245     SALOMEDS::StudyBuilder_var aBuilder (ds_study->NewBuilder());
3246     QString entry = app_study->centry("HEXABLOCK");
3247     SALOMEDS::SObject_var aFatherSO = ds_study->FindObjectID( qPrintable(entry) );
3248     if (aFatherSO->_is_nil())
3249         return docEntry;
3250
3251     SALOMEDS::SObject_var aSO = aBuilder->NewObject(aFatherSO);
3252     if (aSO->_is_nil())
3253         return docEntry;
3254     aSO->SetAttrString("AttributeName", docName.toStdString().c_str());
3255     docEntry = aSO->GetID(); //the entry of the published object
3256
3257     return docEntry;
3258 }
3259
3260 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8
3261
3262 void HEXABLOCKGUI::test()
3263 {
3264     DEBTRACE("HEXABLOCKGUI::test");
3265     VtkDocumentGraphicView* currentDGView = getCurrentVtkGraphicView();
3266     if (currentDGView == NULL) return;
3267     currentDGView->update();
3268
3269 }
3270
3271 void HEXABLOCKGUI::test_association()
3272 {
3273     DEBTRACE("HEXABLOCKGUI::test_association");
3274     newDocument();
3275
3276     QModelIndex v0, v1, v2, v3, e0, e1, q0;
3277
3278     DocumentModel::GeomObj v0Assoc, v1Assoc, v2Assoc, v3Assoc;
3279     DocumentModel::GeomObj e0AssocA, e1AssocA, e1AssocB, e1AssocC;
3280     DocumentModel::GeomObj q0AssocA, q0AssocB;
3281
3282     DocumentModel::GeomObj v0Assoc_test, v1Assoc_test, v2Assoc_test, v3Assoc_test;
3283     QList<DocumentModel::GeomObj> e1Assocs_test;
3284     DocumentModel::GeomObj q0Assoc_test;
3285
3286     v0 = getCurrentModel()->addVertex(0, 0, 0);
3287     v1 = getCurrentModel()->addVertex(1, 0, 0);
3288     v2 = getCurrentModel()->addVertex(1, 1, 0);
3289     v3 = getCurrentModel()->addVertex(0, 1, 0);
3290     e0  = getCurrentModel()->addEdgeVertices(v0, v1);
3291     e1  = getCurrentModel()->addEdgeVertices(v1, v2);
3292     q0 = getCurrentModel()->addQuadVertices( v0, v1, v2, v3 );
3293
3294
3295     // >>> face3.GetEntry()'0:1:4'
3296     // >>> e1.GetEntry()'0:1:8'
3297     // >>> e2.GetEntry()'0:1:9'
3298     // >>> e3.GetEntry()'0:1:10'
3299     // >>> e4.GetEntry()'0:1:11'
3300     // >>> v1.GetEntry()'0:1:12'
3301     // >>> v2.GetEntry()'0:1:13'
3302     // >>> v3.GetEntry()'0:1:14'
3303     // >>> v4.GetEntry()'0:1:15'
3304
3305
3306     //   v0Assoc.name  = "geomV0";
3307     //   v0Assoc.entry = "0:1:1:1:3:6";//"0:1:12";
3308     //   v0Assoc.brep  = "brepV0";
3309     //   v1Assoc.name  = "geomV1";
3310     //   v1Assoc.entry = "0:1:1:1:3:7";//"0:1:13";
3311     //   v1Assoc.brep  = "brepV1";
3312     //   v2Assoc.name  = "geomV2";
3313     //   v2Assoc.entry = "0:1:1:1:3:8";//"0:1:14";
3314     //   v2Assoc.brep  = "brepV2";
3315     //   v3Assoc.name  = "geomV3";
3316     //   v3Assoc.entry = "0:1:1:1:3:9";//"0:1:15";
3317     //   v3Assoc.brep  = "brepV3";
3318     //
3319     //
3320     //
3321     //   e0AssocA.name   = "geomE0a";
3322     //   e0AssocA.entry  = "0:1:1:1:3:5";//"0:1:8";
3323     //   e0AssocA.brep  = "brepE0a";
3324     //   e0AssocA.start  = 0.10;
3325     //   e0AssocA.end    = 0.95;
3326     //
3327     //
3328     //
3329     //   e1AssocA.name   = "geomE1a";
3330     //   e1AssocA.entry  = "0:1:1:1:3:2";//"0:1:8";
3331     //   e1AssocA.brep  = "brepE1a";
3332     //   e1AssocA.start  = 0.12;
3333     //   e1AssocA.end    = 0.89;
3334     //   e1AssocB.name   = "geomE1b";
3335     //   e1AssocB.entry  = "0:1:1:1:3:3";//"0:1:9";
3336     //   e1AssocB.brep  = "brepE1b";
3337     //   e1AssocB.start  = 0.20;
3338     //   e1AssocB.end    = 0.80;
3339     //   e1AssocC.name   = "geomE1c";
3340     //   e1AssocC.entry  = "0:1:1:1:3:4";//"0:1:10";
3341     //   e1AssocC.brep  = "brepE1c";
3342     //   e1AssocC.start  = 0.16;
3343     //   e1AssocC.end    = 0.96;
3344     //
3345     //   q0AssocA.name   = "geomQuad";
3346     //   q0AssocA.entry  = "0:1:1:1:3";
3347     //   q0AssocA.brep   = "brepq0";
3348     //
3349     //   q0AssocB.name   = "geomQuad";
3350     //   q0AssocB.entry  = "0:1:1:1:4";
3351     //   q0AssocB.brep   = "brepq0";
3352     //
3353     //   getCurrentModel()->addAssociation( v0, v0Assoc );
3354     //   getCurrentModel()->addAssociation( v1, v1Assoc );
3355     //   getCurrentModel()->addAssociation( v2, v2Assoc );
3356     //   getCurrentModel()->addAssociation( v3, v3Assoc );
3357     //
3358     //
3359     //   getCurrentModel()->addAssociation( e0, e0AssocA );
3360     //
3361     //   getCurrentModel()->addAssociation( e1, e1AssocA );
3362     //   getCurrentModel()->addAssociation( e1, e1AssocB );
3363     //   getCurrentModel()->addAssociation( e1, e1AssocC );
3364     //
3365     //   getCurrentModel()->addAssociation( q0, q0AssocA );
3366     //   getCurrentModel()->addAssociation( q0, q0AssocB );
3367
3368
3369
3370
3371
3372     //   v0Assoc_test = getCurrentModel()->getAssociations( v0 )[0];
3373     //   v1Assoc_test = getCurrentModel()->getAssociations( v1 )[0];
3374     //   v2Assoc_test = getCurrentModel()->getAssociations( v2 )[0];
3375     //   v3Assoc_test = getCurrentModel()->getAssociations( v3 )[0];
3376     //   ASSERT( v0Assoc.name == v0Assoc_test.name );
3377     //   ASSERT( v1Assoc.name == v1Assoc_test.name );
3378     //   ASSERT( v2Assoc.name == v2Assoc_test.name );
3379     //   ASSERT( v3Assoc.name == v3Assoc_test.name );
3380     //   ASSERT( v0Assoc.entry == v0Assoc_test.entry );
3381     //   ASSERT( v1Assoc.entry == v1Assoc_test.entry );
3382     //   ASSERT( v2Assoc.entry == v2Assoc_test.entry );
3383     //   ASSERT( v3Assoc.entry == v3Assoc_test.entry );
3384     //
3385     //
3386     //   e1Assocs_test = getCurrentModel()->getAssociations( e1 );
3387     //   ASSERT( e1Assocs_test[0].name == e1AssocA.name );
3388     //   ASSERT( e1Assocs_test[1].name == e1AssocB.name );
3389     //   ASSERT( e1Assocs_test[2].name == e1AssocC.name );
3390     //   ASSERT( e1Assocs_test[0].entry == e1AssocA.entry );
3391     //   ASSERT( e1Assocs_test[1].entry == e1AssocB.entry );
3392     //   ASSERT( e1Assocs_test[2].entry == e1AssocC.entry );
3393     //   ASSERT( e1Assocs_test[0].start == e1AssocA.start );
3394     //   ASSERT( e1Assocs_test[1].start == e1AssocB.start );
3395     //   ASSERT( e1Assocs_test[2].start == e1AssocC.start );
3396     //   ASSERT( e1Assocs_test[0].end == e1AssocA.end );
3397     //   ASSERT( e1Assocs_test[1].end == e1AssocB.end );
3398     //   ASSERT( e1Assocs_test[2].end == e1AssocC.end );
3399     //
3400     //   q0Assoc_test = getCurrentModel()->getAssociations( q0 )[0];
3401     //   ASSERT( q0Assoc_test.name  == q0Assoc.name );
3402     //   ASSERT( q0Assoc_test.entry == q0Assoc.entry );
3403
3404
3405     DEBTRACE("HEXABLOCKGUI::test_association fin");
3406 }