src/HEXABLOCKGUI/HEXABLOCKGUI.cxx

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