-// Copyright (C) 2009-2013 CEA/DEN, EDF R&D
+// Copyright (C) 2009-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <cassert>
-
+#include <QDir>
#include <QInputDialog>
#include <QIcon>
#include <QStackedWidget>
+#include <QMenu>
+#include <QSplitter>
#include <QtxTreeView.h>
#include <SUIT_MessageBox.h>
#include <SALOME_ListIO.hxx>
-#include <SALOME_ListIteratorOfListIO.hxx>
#include <SALOME_LifeCycleCORBA.hxx>
#include "HEXABLOCKGUI_DocumentModel.hxx"
#include "HEXABLOCKGUI_DocumentSelectionModel.hxx"
-#include "HEXABLOCKGUI_DocumentDelegate.hxx"
+//#include "HEXABLOCKGUI_DocumentDelegate.hxx"
#include "HEXABLOCKGUI_DocumentPanel.hxx"
#include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
#include "HEXABLOCKGUI_OccGraphicView.hxx"
#include "HEXABLOCKGUI_GraphicViewsHandler.hxx"
-#include <HEXABLOCK_version.h>
+#include "HEXABLOCK_version.h"
#include "MyBasicGUI_PointDlg.hxx"
#include <Visual3d_ViewManager.hxx>
-#include <Graphic3d_Structure.hxx>
-#include <Graphic3d_Group.hxx>
-#include <V3d_PerspectiveView.hxx>
+//#include <V3d_PerspectiveView.hxx>
#include <V3d_AmbientLight.hxx>
-#include <Graphic3d_GraphicDevice.hxx>
-#include <Graphic3d_Array1OfVertex.hxx>
#include <V3d_DirectionalLight.hxx>
#include <Xw_Window.hxx>
#include <V3d_TypeOfShadingModel.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
+#include <utilities.h>
#define DW_MINIMUM_WIDTH 50
#define DWINPUT_MINIMUM_HEIGHT 50
HEXABLOCKGUI::HEXABLOCKGUI() :
SalomeApp_Module( "HEXABLOCK" ),
+// LightApp_Module( "HEXABLOCK" ),
_menuId(190),
_dwPattern(0),
_dwAssociation(0),
_dwObjectBrowser(0),
_dwInputPanel(0),
_patternDataTreeView(0),
- _patternBuilderTreeView(0),
+// _patternBuilderTreeView(0),
_patternGeomTreeView(0),
_groupsTreeView(0),
_meshTreeView(0),
- _treeViewDelegate(0),
+// _treeViewDelegate(0),
_isSaved( false ),
moduleActivatedOnce(false),
+ menusEnabled(true),
_vertexDiag(0),
_edgeDiag(0),
_quadDiag(0),
_makeHemiSphereDiag(0),
_modelInfoDiag(NULL),
_addShapeDiag(NULL),
+ _vertexInfoDialog(NULL),
+ _edgeInfoDialog(NULL),
+ _quadInfoDialog(NULL),
+ _hexaInfoDialog(NULL),
+ _vectorInfoDialog(NULL),
+ _groupInfoDialog(NULL),
+ _lawInfoDialog(NULL),
+ _propagationInfoDialog(NULL),
currentDialog(NULL),
lastOccPrs(NULL),
lastVtkDocGView(NULL)
void HEXABLOCKGUI::initialize( CAM_Application* app )
{
+ MESSAGE("HEXABLOCKGUI::initialize");
DEBTRACE("HEXABLOCKGUI::initialize");
SalomeApp_Module::initialize( app );
currentDocGView->getViewWindow()->installEventFilter(this);
}
else
- initialMenus();
+ {
+ newDocument();
+// initialMenus();
+ }
return bOk;
}
SOCC_Prs* prs = getOccPrs(currentDocGView);
if (prs == NULL)
{
- prs = new SOCC_Prs();
+ prs = new SOCC_Prs(0);
isNewPrs = true;
}
docModel->setName( name );
aName->SetValue( name.toLatin1().data() );
getApp()->updateObjectBrowser();
- _dwPattern->setWindowTitle( name );
+// _dwPattern->setWindowTitle( name );
result = true;
}
}
DEBTRACE("HEXABLOCKGUI::windows");
theMap.clear();
theMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
+#ifndef DISABLE_PYCONSOLE
theMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
+#endif
}
QString HEXABLOCKGUI::engineIOR() const
{
docGView->setViewWindow(graphicViewsHandler->createVtkWindow());
docGView->getViewWindow()->installEventFilter(this);
+ showAllMenus();
+ if (!menusEnabled)
+ setAllMenusEnabled(true);
}
else
docGView->setViewWindow(currentDocGView->getViewWindow());
SVTK_ViewWindow* window = dynamic_cast<SVTK_ViewWindow*>(svw);
if (window != NULL)
{
-
//VTK clean close
if (currentDocGView != NULL && currentDocGView->getViewWindow() == window)
{ //HexaBlock Vtk Window has been closed
if (currentDialog != NULL) currentDialog->close();
- if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
+// if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
if (currentDocGView != NULL)
currentDocGView->setViewWindow(NULL);
- initialMenus();
+// initialMenus();
+ setAllMenusEnabled(false);
+ enableDocumentMenus(true);
+
return;
}
if (_edgeAssocDiag != NULL) _edgeAssocDiag->clear();
if (_quadAssocDiag != NULL) _quadAssocDiag->clear();
if (currentDialog != NULL) currentDialog->close();
- if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
+// if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
currentOccGView->getViewWindow()->removeEventFilter(this);
-
currentOccGView->setViewWindow(NULL);
}
}
{
//close opened dialog
if (currentDialog != NULL) currentDialog->close();
- if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
+// if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
initialMenus();
}
QTreeView* theTree = NULL;
if ( sender() == currentGraphicView->getPatternDataSelectionModel() ){
theTree = _patternDataTreeView;
- } else if ( sender() == currentGraphicView->getPatternBuilderSelectionModel() ){
+ }
+ /*else if ( sender() == currentGraphicView->getPatternBuilderSelectionModel() ){
theTree = _patternBuilderTreeView;
- } else if ( sender() == currentGraphicView->getPatternGeomSelectionModel() ) {
+ }*/
+ else if ( sender() == currentGraphicView->getPatternGeomSelectionModel() ) {
theTree = _patternGeomTreeView;
}
else if ( sender() == currentGraphicView->getGroupsSelectionModel() ){
void HEXABLOCKGUI::createAndFillDockWidget()
{
+
QMainWindow *aParent = application()->desktop();
// Create dock widget (3 dock)
_dwInputPanel = new QDockWidget(aParent);
_dwInputPanel->setVisible(false);
_dwInputPanel->setWindowTitle("Input Panel");
- _dwInputPanel->setMinimumWidth(DWINPUT_MINIMUM_WIDTH); // --- force a minimum until display
+ _dwInputPanel->setObjectName("hexablockInputPanelDock");
+// _dwInputPanel->setMinimumWidth(DWINPUT_MINIMUM_WIDTH); // --- force a minimum until display
- _treeViewDelegate = new DocumentDelegate(_dwInputPanel);
+// _treeViewDelegate = new DocumentDelegate(_dwInputPanel);
//2) ************* document data ( Pattern, Association, Mesh ) in treeview representation
// Pattern
_dwPattern->setVisible(false);
_dwPattern->setWindowTitle("Model");
_dwPattern->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
+ _dwPattern->setObjectName("hexablockModelDock");
QFrame* patternFrame = new QFrame(_dwPattern);
patternFrame->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
patternLayout->setSizeConstraint(QLayout::SetMaximumSize);
QSplitter *splitter = new QSplitter(Qt::Vertical,patternFrame);
_patternDataTreeView = new QTreeView(patternFrame);//_dwPattern);
- _patternBuilderTreeView = new QTreeView(patternFrame);
+// _patternBuilderTreeView = new QTreeView(patternFrame); // ---> TO REMOVE
_patternGeomTreeView = new QTreeView(patternFrame);
splitter->addWidget(_patternDataTreeView);
- splitter->addWidget(_patternBuilderTreeView);
+// splitter->addWidget(_patternBuilderTreeView); // ---> TO REMOVE
splitter->addWidget(_patternGeomTreeView);
patternLayout->addWidget(splitter);
- _patternDataTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers/*QAbstractItemView::DoubleClicked*/);
+ _patternDataTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers/*QAbstractItemView::DoubleClicked*/);
_patternDataTreeView->setSelectionMode(QAbstractItemView::SingleSelection/*QAbstractItemView::MultiSelection*/);
- _patternDataTreeView->setItemDelegate(_treeViewDelegate);
+// _patternDataTreeView->setItemDelegate(_treeViewDelegate);
- _patternBuilderTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
- _patternBuilderTreeView->setItemDelegate(_treeViewDelegate);
+// _patternBuilderTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
+// _patternBuilderTreeView->setItemDelegate(_treeViewDelegate);
_patternGeomTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
_patternGeomTreeView->setSelectionMode(QAbstractItemView::SingleSelection/*QAbstractItemView::MultiSelection*/);
_dwGroups->setVisible(false);
_dwGroups->setWindowTitle("Groups");
_dwGroups->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
+ _dwGroups->setObjectName("hexablockGroupsDock");
_groupsTreeView = new QTreeView(_dwGroups);
- _groupsTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
- _groupsTreeView->setItemDelegate(_treeViewDelegate);
+ _groupsTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
+// _groupsTreeView->setItemDelegate(_treeViewDelegate);
_dwGroups->setWidget(_groupsTreeView);
_groupsTreeView->show();
_dwMesh->setVisible(false);
_dwMesh->setWindowTitle("Mesh");
_dwMesh->setMinimumWidth(DW_MINIMUM_WIDTH); // --- force a minimum until display
+ _dwMesh->setObjectName("hexablockMeshDock");
_meshTreeView = new QTreeView(_dwMesh);
- _meshTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
+ _meshTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
_meshTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
- _meshTreeView->setItemDelegate(_treeViewDelegate);
+// _meshTreeView->setItemDelegate(_treeViewDelegate);
_dwMesh->setWidget(_meshTreeView);
_meshTreeView->show();
- QDockWidget *_dwObjectBrowser = 0;
+// QDockWidget *_dwObjectBrowser = 0;
QWidget* wid = getApp()->objectBrowser()->treeView();
QWidget *w = wid->parentWidget();
while ( w && !_dwObjectBrowser ) {
// dock widget position
aParent->addDockWidget( Qt::LeftDockWidgetArea, _dwObjectBrowser );
- aParent->addDockWidget( Qt::LeftDockWidgetArea, _dwInputPanel );
+ aParent->addDockWidget( Qt::RightDockWidgetArea, _dwInputPanel );
+
+// aParent->tabifyDockWidget( _dwPattern, _dwObjectBrowser );
+// aParent->tabifyDockWidget( _dwGroups, _dwPattern );
+// aParent->tabifyDockWidget( _dwMesh, _dwGroups );
aParent->tabifyDockWidget( _dwObjectBrowser, _dwPattern );
aParent->tabifyDockWidget( _dwPattern, _dwGroups );
aParent->tabifyDockWidget( _dwGroups, _dwMesh );
-
#if QT_VERSION >= 0x040500
aParent->setTabPosition(Qt::AllDockWidgetAreas, Resource::tabPanelsUp? QTabWidget::North: QTabWidget::South);
#endif
-
// popup menu on data tree view
_patternDataTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(_patternDataTreeView,
{
int aToolId;
- aToolId = createTool ( tr( "HexaBlock Toolbar" ) );
+ aToolId = createTool ( tr( "HexaBlock Toolbar" ), QString( "HexaBlockMain" ) );
createTool( _newAct, aToolId );
createTool( _importAct, aToolId );
createTool( _saveAct, aToolId );
//createTool( separator(), aToolId );
// Pattern Data
- aToolId = createTool ( tr( "Construction" ) );
+ aToolId = createTool ( tr( "Construction" ), QString( "HexaBlockConstruction" ) );
createTool( _addVertex, aToolId );
createTool( _addEdge, aToolId );
createTool( _addQuad, aToolId );
createTool( _makePipes, aToolId );
// Pattern Data Edition
- aToolId = createTool ( tr( "Operation" ) );
+ aToolId = createTool ( tr( "Operation" ), QString( "HexaBlockOperation" ) );
createTool( _removeHexa, aToolId );
createTool( _prismQuad, aToolId );
createTool( _joinQuad, aToolId );
createTool( _quadRevolution, aToolId );
// Association
- aToolId = createTool ( tr( "Association" ) );
+ aToolId = createTool ( tr( "Association" ), QString( "HexaBlockAssociation" ) );
createTool( _assocVertex, aToolId );
createTool( _assocEdge, aToolId );
createTool( _assocQuad, aToolId );
createTool( _addShapeAct, aToolId );
// Group
- aToolId = createTool ( tr( "Group" ) );
+ aToolId = createTool ( tr( "Group" ), QString( "HexaBlockGroup" ) );
createTool( _addGroup, aToolId );
createTool( _removeGroup, aToolId ); //CS_TODO
// Law
- aToolId = createTool ( tr( "Mesh" ) );
+ aToolId = createTool ( tr( "Mesh" ), QString( "HexaBlockMesh" ) );
createTool( _addLaw, aToolId );
createTool( _removeLaw, aToolId );
createTool( _setPropagation, aToolId );
showMeshMenus( true );
}
+void HEXABLOCKGUI::setAllMenusEnabled(bool enable)
+{
+ enableDocumentMenus( enable );
+ enablePatternMenus( enable );
+ enableAssociationMenus( enable );
+ enableGroupsMenus( enable );
+ enableMeshMenus( enable );
+
+ menusEnabled = enable;
+}
void HEXABLOCKGUI::showDocumentMenus(bool show)
{
setToolShown(_saveAct, show);
}
+void HEXABLOCKGUI::enableDocumentMenus(bool enable)
+{
+ _newAct->setEnabled(enable);
+// setToolShown(_newAct, enable);
+
+ _importAct->setEnabled(enable);
+// setToolShown(_importAct, enable);
+
+ _showModelInfoAct->setEnabled(enable);
+// setToolShown(_showModelInfoAct, enable);
+
+ _saveAct->setEnabled(enable);
+// setToolShown(_saveAct, enable);
+}
+
+
void HEXABLOCKGUI::showPatternMenus(bool show)
{
DEBTRACE("HEXABLOCKGUI::showPatternMenus " << show);
setMenuShown( _showModelInfoAct, show );
}
+void HEXABLOCKGUI::enablePatternMenus(bool enable)
+{
+ if ( enable && !getCurrentModel() ) return;
+
+ _addVertex->setEnabled(enable);
+// setToolShown(_addVertex, enable);
+
+ _addEdge->setEnabled(enable);
+// setToolShown(_addEdge, enable);
+
+ _addQuad->setEnabled(enable);
+// setToolShown(_addQuad, enable);
+
+ _addHexa->setEnabled(enable);
+// setToolShown(_addHexa, enable);
+
+// setMenuShown(_sep1, enable );
+// setToolShown(_sep1, enable);
+
+ _addVector->setEnabled(enable);
+// setToolShown( _addVector, enable);
+
+// setMenuShown(_sep2, enable );
+// setToolShown(_sep2, enable);
+
+ _makeGrid->setEnabled(enable);
+// setToolShown( _makeGrid, enable);
+
+ _makePipe->setEnabled(enable);
+// setToolShown( _makePipe, enable);
+
+// setMenuShown(_sep3, enable );
+// setToolShown(_sep3, enable);
+
+ _makeCylinder->setEnabled(enable);
+// setToolShown( _makeCylinder, enable);
+
+ _makeCylinders->setEnabled(enable);
+// setToolShown( _makeCylinders, enable);
+
+ _makePipes->setEnabled(enable);
+// setToolShown( _makePipes, enable);
+
+ _makeHemiSphere->setEnabled(enable);
+// setToolShown( _makeHemiSphere, enable);
+
+ // Pattern Data Edition
+ _removeHexa->setEnabled(enable);
+// setToolShown( _removeHexa, enable);
+
+ _prismQuad->setEnabled(enable);
+// setToolShown( _prismQuad, enable);
+
+ _joinQuad->setEnabled(enable);
+// setToolShown( _joinQuad, enable);
+
+ _merge->setEnabled(enable);
+// setToolShown( _merge, enable);
+
+ _disconnect->setEnabled(enable);
+// setToolShown( _disconnect, enable);
+
+ _cutEdge->setEnabled(enable);
+// setToolShown( _cutEdge, enable);
+
+ _makeTransformation->setEnabled(enable);
+// setToolShown( _makeTransformation, enable);
+
+ _makeSymmetry->setEnabled(enable);
+// setToolShown( _makeSymmetry, enable);
+
+ _performTransformation->setEnabled(enable);
+// setToolShown( _performTransformation, enable);
+
+ _performSymmetry->setEnabled(enable);
+// setToolShown( _performSymmetry, enable);
+
+ _replaceHexa->setEnabled(enable);
+// setToolShown( _replaceHexa, enable);
+
+ _quadRevolution->setEnabled(enable);
+// setToolShown( _quadRevolution, enable);
+
+// setMenuShown( _sep4, enable );
+ _showModelInfoAct->setEnabled(enable);
+}
+
void HEXABLOCKGUI::showAssociationMenus(bool show)
{
// Association Edition
setMenuShown( _assocVertex, show );
setToolShown( _assocVertex, show );
+
setMenuShown( _assocEdge, show );
setToolShown( _assocEdge, show );
+
setMenuShown( _assocQuad, show );
setToolShown( _assocQuad, show );
+
setMenuShown( _addShapeAct, show );
setToolShown( _addShapeAct, show );
+}
+
+void HEXABLOCKGUI::enableAssociationMenus(bool enable)
+{
+ if ( enable && !getCurrentModel() )
+ return;
+
+ // Association Edition
+ _assocVertex->setEnabled(enable);
+ // setToolShown( _assocVertex, enable );
+
+ _assocEdge->setEnabled(enable);
+ // setToolShown( _assocEdge, enable );
+ _assocQuad->setEnabled(enable);
+ // setToolShown( _assocQuad, enable );
+
+ _addShapeAct->setEnabled(enable);
+ // setToolShown( _addShapeAct, enable );
}
void HEXABLOCKGUI::showGroupsMenus(bool show)
setToolShown( _removeGroup , show);
}
+void HEXABLOCKGUI::enableGroupsMenus(bool enable)
+{
+ if ( enable && !getCurrentModel() )
+ return;
+
+ _addGroup->setEnabled(enable);
+// setToolShown( _addGroup, enable);
+
+ _removeGroup->setEnabled(enable);
+// setToolShown( _removeGroup , enable);
+}
+
void HEXABLOCKGUI::showMeshMenus(bool show)
{
DEBTRACE("HEXABLOCKGUI::showMeshMenus" << show);
setToolShown( _computeMesh, show);
}
-void HEXABLOCKGUI::showActor()
+void HEXABLOCKGUI::enableMeshMenus(bool enable)
{
- VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
- if (currentVtkGView == NULL || currentVtkGView->getViewWindow() == NULL ||
- currentVtkGView->isEmpty() || currentVtkGView->getDocumentActor() == NULL)
+ if ( enable && !getCurrentModel() )
return;
- currentVtkGView->getViewWindow()->setFocus();
- currentVtkGView->getViewWindow()->Display(currentVtkGView->getDocumentActor()->getIO());
- currentVtkGView->update();
- currentVtkGView->getViewWindow()->onFitAll();
+ _addLaw->setEnabled(enable);
+// setToolShown( _addLaw, enable);
- //update the visibility state now
- SalomeApp_Study* aStudy = HEXABLOCKGUI::activeStudy();
- SUIT_ViewManager* vman = currentVtkGView->getViewWindow()->getViewManager();
- if (aStudy == NULL || vman == NULL) return;
+ _removeLaw->setEnabled(enable);
+// setToolShown( _removeLaw, enable);
- Handle(SALOME_InteractiveObject) anIO = currentVtkGView->getDocumentActor()->getIO();
- aStudy->setObjectProperty(vman->getId(), anIO->getEntry(), "Visibility", 1 );
- displayer()->setVisibilityState(anIO->getEntry(), Qtx::ShownState);
+ _setPropagation->setEnabled(enable);
+// setToolShown( _setPropagation, enable);
+
+ _computeMesh->setEnabled(enable);
+// setToolShown( _computeMesh, enable);
}
-//SOCC_Prs* currentPrs = NULL;
-void HEXABLOCKGUI::showOnlyActor()
+void HEXABLOCKGUI::showVtkActor()
{
VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
if (currentVtkGView == NULL || currentVtkGView->isEmpty() ||
currentVtkGView->getDocumentActor() == NULL)
return;
+
SVTK_ViewWindow* vtkView = currentVtkGView->getViewWindow();
if (vtkView == NULL)
return;
//show only the current actor -----------------
vtkView->setFocus();
-// vtkView->DisplayOnly(currentVtkGView->getDocumentActor()->getIO());
- Document_Actor *lastDocActor, *currentDocActor = currentVtkGView->getDocumentActor();
+ // vtkView->DisplayOnly(currentVtkGView->getDocumentActor()->getIO());
+ Document_Actor *lastDocActor;
if (lastVtkDocGView != NULL)
{
lastDocActor = lastVtkDocGView->getDocumentActor();
displayer()->setVisibilityState(anIO->getEntry(), Qtx::ShownState);
}
vtkView->onFitAll();
+}
-// //showOnly in occ viewer -------------
-
+void HEXABLOCKGUI::showOccActor()
+{
if (currentOccGView == NULL)
- return;
+ return;
OCCViewer_ViewWindow* occView = currentOccGView->getViewWindow();
if (occView == NULL)
return;
if (vf == NULL)
return;
-// vf->EraseAll();
if (lastOccPrs != NULL)
vf->Erase(lastOccPrs);
currentOccGView->globalSelection();
occView->onFitAll();
}
-void HEXABLOCKGUI::hideActor()
+void HEXABLOCKGUI::hideVtkActor()
{
- // * vtk --
VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
if (currentVtkGView == NULL || currentVtkGView->isEmpty() ||
- currentVtkGView->getViewWindow() == NULL ||
- currentVtkGView->getDocumentActor() == NULL) return;
+ currentVtkGView->getViewWindow() == NULL ||
+ currentVtkGView->getDocumentActor() == NULL) return;
currentVtkGView->getViewWindow()->Erase(currentVtkGView->getDocumentActor()->getIO());
currentVtkGView->getViewWindow()->onResetView();
Handle(SALOME_InteractiveObject) anIO = currentVtkGView->getDocumentActor()->getIO();
aStudy->setObjectProperty(vman->getId(), anIO->getEntry(), "Visibility", 0 );
displayer()->setVisibilityState(anIO->getEntry(), Qtx::HiddenState);
+}
- // * occ --
+void HEXABLOCKGUI::hideOccActor()
+{
OCCViewer_ViewWindow* occView = currentOccGView == NULL ? NULL : currentOccGView->getViewWindow();
- DocumentModel* docModel = currentVtkGView->getDocumentModel();
+ VtkDocumentGraphicView* currentVtkGView = getCurrentVtkGraphicView();
+ DocumentModel* docModel = (currentVtkGView == NULL ? NULL : currentVtkGView->getDocumentModel());
if (occView == NULL || docModel == NULL)
return;
SALOME_View* vf = dynamic_cast<SALOME_View*>(occView->getViewManager()->getViewModel());
if (vf == NULL)
return;
-// vf->EraseAll();
SOCC_Prs* currentOccPrs = getOccPrs(currentDocGView);
if (currentOccPrs != NULL)
vf->Erase(currentOccPrs);
occView->onResetView();
}
+void HEXABLOCKGUI::showOnlyActor()
+{
+ showVtkActor();
+ showOccActor();
+}
+
+void HEXABLOCKGUI::hideActor()
+{
+ hideVtkActor();
+ hideOccActor();
+}
+
void HEXABLOCKGUI::showDockWidgets(bool isVisible)
{
dgview->getPatternDataSelectionModel(), SLOT( salomeSelectionChanged() ), Qt::UniqueConnection );
connect( dgview->getPatternDataSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
- connect( dgview->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
- this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
+// connect( dgview->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
+// this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
connect( dgview->getPatternGeomSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
connect( dgview->getGroupsSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
dgview->getPatternDataSelectionModel(), SLOT( salomeSelectionChanged() ) );
disconnect( dgview->getPatternDataSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
- disconnect( dgview->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
- this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
+// disconnect( dgview->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
+// this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
disconnect( dgview->getPatternGeomSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
disconnect( dgview->getGroupsSelectionModel(), SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
//close opened dialog
if (currentDialog != NULL) currentDialog->close();
- if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
+// if (_treeViewDelegate != NULL) _treeViewDelegate->closeDialog();
initialMenus();
if (currentDocGView != dgview) clearDialogs();
_patternDataTreeView->setModel(dgview->getPatternDataModel());
- _patternBuilderTreeView->setModel(dgview->getPatternBuilderModel());
+// _patternBuilderTreeView->setModel(dgview->getPatternBuilderModel());
_patternGeomTreeView->setModel(dgview->getPatternGeomModel());
_groupsTreeView->setModel(dgview->getGroupsModel());
_meshTreeView->setModel(dgview->getMeshModel());
_patternDataTreeView->setSelectionModel(dgview->getPatternDataSelectionModel());
- _patternDataTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
+ _patternDataTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
- _patternBuilderTreeView->setSelectionModel(dgview->getPatternBuilderSelectionModel());
- _patternBuilderTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
+// _patternBuilderTreeView->setSelectionModel(dgview->getPatternBuilderSelectionModel());
+// _patternBuilderTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
_patternGeomTreeView->setSelectionModel(dgview->getPatternGeomSelectionModel());
_patternGeomTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
_groupsTreeView->setSelectionModel(dgview->getGroupsSelectionModel());
- _groupsTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
+ _groupsTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
_meshTreeView->setSelectionModel(dgview->getMeshSelectionModel());
- _meshTreeView->setEditTriggers(QAbstractItemView::AllEditTriggers);
+ _meshTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
// = * init occ view * =
currentDocGView = dgview;
showOnlyActor();
currentDocGView->getDocumentModel()->refresh();
- _dwPattern->setWindowTitle(currentDocGView->getDocumentModel()->getName());
+// _dwPattern->setWindowTitle(currentDocGView->getDocumentModel()->getName());
showAllMenus();
+ if (!menusEnabled)
+ setAllMenusEnabled(true);
}
DocumentModel* HEXABLOCKGUI::getCurrentModel()
currentModelDialogs.insert(diag);
//close the current dialog box info
- if (_treeViewDelegate != NULL)
- _treeViewDelegate->closeDialog();
+// if (_treeViewDelegate != NULL)
+// _treeViewDelegate->closeDialog();
- if (_dwInputPanel->widget())
- _dwInputPanel->widget()->close();
+// if (_dwInputPanel->widget())
+// _dwInputPanel->widget()->close();
//Temporary for debugging EdgeAssoc Faked InfoDialog
if (diag == _edgeAssocDiag)
currentDialog = diag;
diag->setFocus();
+
+ if (currentDocGView != NULL)
+ currentDocGView->getPatternDataSelectionModel()->setInfoMode(false);
+}
+
+void HEXABLOCKGUI::showVertexInfoDialog(HEXA_NS::Vertex* vertex)
+{
+ if (vertex == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_vertexInfoDialog == NULL)
+ _vertexInfoDialog = new VertexDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _vertexInfoDialog->setValue(vertex);
+ _vertexInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _vertexInfoDialog;
+}
+
+void HEXABLOCKGUI::showEdgeInfoDialog(HEXA_NS::Edge* edge)
+{
+ if (edge == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_edgeInfoDialog == NULL)
+ _edgeInfoDialog = new EdgeDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _edgeInfoDialog->setValue(edge);
+ _edgeInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _edgeInfoDialog;
+}
+
+void HEXABLOCKGUI::showQuadInfoDialog(HEXA_NS::Quad* quad)
+{
+ if (quad == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_quadInfoDialog == NULL)
+ _quadInfoDialog = new QuadDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _quadInfoDialog->setValue(quad);
+ _quadInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _quadInfoDialog;
+}
+
+void HEXABLOCKGUI::showHexaInfoDialog(HEXA_NS::Hexa* hexa)
+{
+ if (hexa == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_hexaInfoDialog == NULL)
+ _hexaInfoDialog = new HexaDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _hexaInfoDialog->setValue(hexa);
+ _hexaInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _hexaInfoDialog;
+}
+
+void HEXABLOCKGUI::showVectorInfoDialog(HEXA_NS::Vector* vector)
+{
+ if (vector == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_vectorInfoDialog == NULL)
+ _vectorInfoDialog = new VectorDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _vectorInfoDialog->setValue(vector);
+ _vectorInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _vectorInfoDialog;
+}
+
+void HEXABLOCKGUI::showGroupInfoDialog(HEXA_NS::Group* group)
+{
+ if (group == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_groupInfoDialog == NULL)
+ _groupInfoDialog = new GroupDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _groupInfoDialog->setValue(group);
+ _groupInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _groupInfoDialog;
+}
+
+void HEXABLOCKGUI::showLawInfoDialog(HEXA_NS::Law* law)
+{
+ if (law == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_lawInfoDialog == NULL)
+ _lawInfoDialog = new LawDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _lawInfoDialog->setValue(law);
+ _lawInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _lawInfoDialog;
+}
+
+void HEXABLOCKGUI::showPropagationInfoDialog(HEXA_NS::Propagation* propagation)
+{
+ if (propagation == NULL || _dwInputPanel == NULL)
+ return;
+
+ if (_propagationInfoDialog == NULL)
+ _propagationInfoDialog = new PropagationDialog(_dwInputPanel, HexaBaseDialog::INFO_MODE);
+
+ _propagationInfoDialog->setValue(propagation);
+ _propagationInfoDialog->resetSizeAndShow(_dwInputPanel);
+ currentDialog = _propagationInfoDialog;
}
void HEXABLOCKGUI::addVertex()
_vectorDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_VECTOR).c_str());
}
-void HEXABLOCKGUI::addCylinder()
-{
- if ( !_cylinderDiag ){
- _cylinderDiag = new CylinderDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
- }
- _showDialogBox( _cylinderDiag );
-
- //set default name
- HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
- if (_cylinderDiag != NULL && doc != NULL)
- _cylinderDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_CYLINDER).c_str());
-}
+//void HEXABLOCKGUI::addCylinder()
+//{
+// if ( !_cylinderDiag ){
+// _cylinderDiag = new CylinderDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
+// }
+// _showDialogBox( _cylinderDiag );
+//
+// //set default name
+// HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
+// if (_cylinderDiag != NULL && doc != NULL)
+// _cylinderDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_CYLINDER).c_str());
+//}
-void HEXABLOCKGUI::addPipe()
-{
- if ( !_pipeDiag){
- _pipeDiag = new PipeDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
- }
- _showDialogBox( _pipeDiag );
-
- //set default name
- HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
- if (_pipeDiag != NULL && doc != NULL)
- _pipeDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_CYLINDER).c_str());
-}
+//void HEXABLOCKGUI::addPipe()
+//{
+// if ( !_pipeDiag){
+// _pipeDiag = new PipeDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
+// }
+// _showDialogBox( _pipeDiag );
+//
+// //set default name
+// HEXA_NS::Document* doc = getCurrentModel() ? getCurrentModel()->getHexaDocument() : NULL;
+// if (_pipeDiag != NULL && doc != NULL)
+// _pipeDiag->name_le->setText(doc->getNextName(HEXA_NS::EL_CYLINDER).c_str());
+//}
void HEXABLOCKGUI::makeGrid()
void HEXABLOCKGUI::setPropagation()
{
- if ( !_propagationDiag ){
+ if ( !_propagationDiag )
_propagationDiag = new PropagationDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
- }
+
_showDialogBox( _propagationDiag );
}
// --------------------------------------------
void HEXABLOCKGUI::computeMesh()
{
- if ( !_computeMeshDiag ){
+ if ( !_computeMeshDiag )
_computeMeshDiag = new ComputeMeshDialog(_dwInputPanel, HexaBaseDialog::NEW_MODE);
- }
- _computeMeshDiag->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+
_showDialogBox( _computeMeshDiag );
}
extern "C"
{
- HEXABLOCKGUI_EXPORT CAM_Module* createModule()
+ HEXABLOCK_EXPORT CAM_Module* createModule()
{
return new HEXABLOCKGUI();
}
- HEXABLOCKGUI_EXPORT char* getModuleVersion()
+ HEXABLOCK_EXPORT char* getModuleVersion()
{
return (char*)HEXABLOCK_VERSION_STR;
}
