X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCalc%2Fgui%2FPresentationController.cxx;h=93c5eef0c191c752a5adb6654b1f59368f789503;hb=70087ddf60110c529327c7016daf1cd96e86df19;hp=ea2aa57521de4aa9050cbecae37f1b45c3a813d1;hpb=c55144bfb0c9d1d77af03ad9d0c34e18781a0532;p=modules%2Fmed.git diff --git a/src/MEDCalc/gui/PresentationController.cxx b/src/MEDCalc/gui/PresentationController.cxx index ea2aa5752..93c5eef0c 100644 --- a/src/MEDCalc/gui/PresentationController.cxx +++ b/src/MEDCalc/gui/PresentationController.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2016 CEA/DEN, EDF R&D +// Copyright (C) 2016-2021 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 @@ -18,21 +18,55 @@ // #include "PresentationController.hxx" -#include "DatasourceConstants.hxx" +#include #include "MEDModule.hxx" #include "Basics_Utils.hxx" #include "QtxActionGroup.h" +#include "QtxActionToolMgr.h" #include "MEDFactoryClient.hxx" +#include "MEDPresentationManager_i.hxx" +#include "XmedConsoleDriver.hxx" + +#include "MEDPresentationMeshView.hxx" +#include "MEDPresentationScalarMap.hxx" +#include "MEDPresentationContour.hxx" +#include "MEDPresentationSlices.hxx" +#include "MEDPresentationPointSprite.hxx" +#include "MEDPresentationVectorField.hxx" +#include "MEDPresentationPlot3D.hxx" +#include "MEDPresentationStreamLines.hxx" +#include "MEDPresentationCutSegment.hxx" +#include "MEDPresentationDeflectionShape.hxx" + +#include "MEDWidgetHelperMeshView.hxx" +#include "MEDWidgetHelperScalarMap.hxx" +#include "MEDWidgetHelperContour.hxx" +#include "MEDWidgetHelperSlices.hxx" +#include "MEDWidgetHelperPointSprite.hxx" +#include "MEDWidgetHelperPlot3D.hxx" +#include "MEDWidgetHelperStreamLines.hxx" +#include "MEDWidgetHelperCutSegment.hxx" +#include "MEDWidgetHelperVectorField.hxx" +#include "MEDWidgetHelperDeflectionShape.hxx" #include #include #include +#include +#include + #include #include #include +#include +#include #include +#include +#include + +#include "MEDFactoryClient.hxx" static const int OPTIONS_VIEW_MODE_ID = 943; static const int OPTIONS_VIEW_MODE_REPLACE_ID = 944; @@ -40,31 +74,76 @@ static const int OPTIONS_VIEW_MODE_OVERLAP_ID = 945; static const int OPTIONS_VIEW_MODE_NEW_LAYOUT_ID = 946; static const int OPTIONS_VIEW_MODE_SPLIT_VIEW_ID = 947; -PresentationController::PresentationController(MEDModule* salomeModule) +//! The only instance of the MEDPresentationManager +MEDCALC::MEDPresentationManager_ptr PresentationController::_presManager; + +PresentationController::PresentationController(MEDModule* salomeModule) : + _salomeModule(salomeModule), + _consoleDriver(0), + _studyEditor(salomeModule->getStudyEditor()), + _presHelperMap(), + _currentWidgetHelper(0) { STDLOG("Creating a PresentationController"); - _salomeModule = salomeModule; - _studyEditor = _salomeModule->getStudyEditor(); + + _widgetPresentationParameters = new WidgetPresentationParameters(); + + QMainWindow* parent = salomeModule->getApp()->desktop(); + _dockWidget = new QDockWidget(parent); + _dockWidget->setVisible(false); + _dockWidget->setWindowTitle(tr("TITLE_PRESENTATION_PARAMETERS")); + _dockWidget->setObjectName(tr("TITLE_PRESENTATION_PARAMETERS")); + _dockWidget->setFeatures(QDockWidget::AllDockWidgetFeatures); + _dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); + _dockWidget->setWidget(_widgetPresentationParameters); + parent->addDockWidget(Qt::LeftDockWidgetArea, _dockWidget); + //_dockWidget->show(); + + // Retrieve MEDFactory to get MEDPresentationManager (sometimes GUI needs to talk to the engine directly) + if ( ! _presManager ) { + _presManager = MEDFactoryClient::getFactory()->getPresentationManager(); + } + + // Connect to the click in the object browser + connect(salomeModule, SIGNAL( presentationSelected(int , const QString&, const QString&) ), + this, SLOT(onPresentationSelected(int , const QString&, const QString&) ) ); } PresentationController::~PresentationController() { - STDLOG("Deleting the PresentationController"); + STDLOG("Deleting the resentationController"); + // Clean allocated widget helpers: + for ( std::map::iterator it = _presHelperMap.begin(); it != _presHelperMap.end(); ++it) + delete((*it).second); +} + +std::string +PresentationController::_getIconName(const std::string& name) +{ + SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); + if (!mgr) + return name; + + // Read value from preferences and suffix name to select icon theme + int theme = mgr->integerValue("MEDCalc", "icons"); + if (theme == 0) { + return name + "_MODERN"; + } else if (theme == 1) { + return name + "_CLASSIC"; + } + return name + "_DEFAULT"; } void PresentationController::createActions() { STDLOG("Creating PresentationController actions"); - int toolbarId = _salomeModule->createTool("View Mode", "PresentationToolbar"); - - int presentationMenuId = _salomeModule->createMenu(tr("MENU_PRESENTATIONS"), -1, 1); // View Mode + int viewModeToolbarId = _salomeModule->createTool("View Mode", "ViewModeToolbar"); QtxActionGroup* ag = _salomeModule->createActionGroup(OPTIONS_VIEW_MODE_ID, true); ag->setText("View mode"); ag->setUsesDropDown(true); - QString label = tr("LAB_VIEW_MODE_REPLACE"); QString tooltip = tr("TIP_VIEW_MODE_REPLACE"); QAction* a = _salomeModule->createAction(OPTIONS_VIEW_MODE_REPLACE_ID,label,QIcon(),label,tooltip,0); @@ -90,175 +169,846 @@ PresentationController::createActions() a->setCheckable(true); ag->add(a); - _salomeModule->createTool(OPTIONS_VIEW_MODE_ID, toolbarId); + _salomeModule->createTool(OPTIONS_VIEW_MODE_ID, viewModeToolbarId); // Presentations + int presentationToolbarId = _salomeModule->createTool("Presentations", "PresentationToolbar"); + int presentationMenuId = _salomeModule->createMenu(tr("MENU_PRESENTATIONS"), -1, -1, 10); + + label = tr("LAB_PRESENTATION_MESH_VIEW"); + tooltip = tr("TIP_PRESENTATION_MESH_VIEW"); + QString icon = tr(_getIconName("ICO_PRESENTATION_MESH_VIEW").c_str()); + int actionId; + actionId = _salomeModule->createStandardAction(label,this, SLOT(onVisualizeMeshView()),icon,tooltip); + _salomeModule->createTool(actionId, presentationToolbarId); + _salomeModule->action(actionId)->setIconVisibleInMenu(true); + _salomeModule->createMenu(actionId, presentationMenuId); + label = tr("LAB_PRESENTATION_SCALAR_MAP"); tooltip = tr("TIP_PRESENTATION_SCALAR_MAP"); - QString icon = tr("ICO_PRESENTATION_SCALAR_MAP"); - int actionId; - actionId = _salomeModule->createStandardAction(label,this, SLOT(OnVisualizeScalarMap()),icon,tooltip); - _salomeModule->createTool(actionId, toolbarId); + icon = tr(_getIconName("ICO_PRESENTATION_SCALAR_MAP").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeScalarMap()), + icon, tooltip, FIELDSOp::OpScalarMap); + _salomeModule->createTool(actionId, presentationToolbarId); _salomeModule->action(actionId)->setIconVisibleInMenu(true); _salomeModule->createMenu(actionId, presentationMenuId); label = tr("LAB_PRESENTATION_CONTOUR"); tooltip = tr("TIP_PRESENTATION_CONTOUR"); - icon = tr("ICO_PRESENTATION_CONTOUR"); - actionId = _salomeModule->createStandardAction(label,this, SLOT(OnVisualizeContour()),icon,tooltip); - _salomeModule->createTool(actionId, toolbarId); + icon = tr(_getIconName("ICO_PRESENTATION_CONTOUR").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeContour()), + icon, tooltip, FIELDSOp::OpContour); + _salomeModule->createTool(actionId, presentationToolbarId); _salomeModule->action(actionId)->setIconVisibleInMenu(true); _salomeModule->createMenu(actionId, presentationMenuId); label = tr("LAB_PRESENTATION_VECTOR_FIELD"); tooltip = tr("TIP_PRESENTATION_VECTOR_FIELD"); - icon = tr("ICO_PRESENTATION_VECTOR_FIELD"); - actionId = _salomeModule->createStandardAction(label,this, SLOT(OnVisualizeVectorField()),icon,tooltip); - _salomeModule->createTool(actionId, toolbarId); + icon = tr(_getIconName("ICO_PRESENTATION_VECTOR_FIELD").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeVectorField()), + icon, tooltip, FIELDSOp::OpVectorFields); + _salomeModule->createTool(actionId, presentationToolbarId); _salomeModule->action(actionId)->setIconVisibleInMenu(true); _salomeModule->createMenu(actionId, presentationMenuId); label = tr("LAB_PRESENTATION_SLICES"); tooltip = tr("TIP_PRESENTATION_SLICES"); - icon = tr("ICO_PRESENTATION_SLICES"); - actionId = _salomeModule->createStandardAction(label,this, SLOT(OnVisualizeSlices()),icon,tooltip); - _salomeModule->createTool(actionId, toolbarId); + icon = tr(_getIconName("ICO_PRESENTATION_SLICES").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeSlices()), + icon, tooltip, FIELDSOp::OpSlices); + _salomeModule->createTool(actionId, presentationToolbarId); _salomeModule->action(actionId)->setIconVisibleInMenu(true); _salomeModule->createMenu(actionId, presentationMenuId); label = tr("LAB_PRESENTATION_DEFLECTION_SHAPE"); tooltip = tr("TIP_PRESENTATION_DEFLECTION_SHAPE"); - icon = tr("ICO_PRESENTATION_DEFLECTION_SHAPE"); - actionId = _salomeModule->createStandardAction(label,this, SLOT(OnVisualizeDeflectionShape()),icon,tooltip); - _salomeModule->createTool(actionId, toolbarId); + icon = tr(_getIconName("ICO_PRESENTATION_DEFLECTION_SHAPE").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeDeflectionShape()), + icon, tooltip, FIELDSOp::OpDeflectionShape); + _salomeModule->createTool(actionId, presentationToolbarId); _salomeModule->action(actionId)->setIconVisibleInMenu(true); _salomeModule->createMenu(actionId, presentationMenuId); label = tr("LAB_PRESENTATION_POINT_SPRITE"); tooltip = tr("TIP_PRESENTATION_POINT_SPRITE"); - icon = tr("ICO_PRESENTATION_POINT_SPRITE"); - actionId = _salomeModule->createStandardAction(label,this, SLOT(OnVisualizePointSprite()),icon,tooltip); - _salomeModule->createTool(actionId, toolbarId); + icon = tr(_getIconName("ICO_PRESENTATION_POINT_SPRITE").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizePointSprite()), + icon, tooltip, FIELDSOp::OpPointSprite); + _salomeModule->createTool(actionId, presentationToolbarId); _salomeModule->action(actionId)->setIconVisibleInMenu(true); _salomeModule->createMenu(actionId, presentationMenuId); + + // sphinx doc: begin of plot3d gui items + label = tr("LAB_PRESENTATION_PLOT3D"); + tooltip = tr("TIP_PRESENTATION_PLOT3D"); + icon = tr(_getIconName("ICO_PRESENTATION_PLOT3D").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizePlot3D()), + icon, tooltip, FIELDSOp::OpPlot3D); + _salomeModule->createTool(actionId, presentationToolbarId); + _salomeModule->action(actionId)->setIconVisibleInMenu(true); + _salomeModule->createMenu(actionId, presentationMenuId); + // sphinx doc: end of plot3d gui items + + label = tr("LAB_PRESENTATION_STREAM_LINES"); + tooltip = tr("TIP_PRESENTATION_STREAM_LINES"); + icon = tr(_getIconName("ICO_PRESENTATION_STREAM_LINES").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeStreamLines()), + icon, tooltip, FIELDSOp::OpStreamLines); + _salomeModule->createTool(actionId, presentationToolbarId); + _salomeModule->action(actionId)->setIconVisibleInMenu(true); + _salomeModule->createMenu(actionId, presentationMenuId); + + label = tr("LAB_PRESENTATION_CUT_SEGMENT"); + tooltip = tr("TIP_PRESENTATION_CUT_SEGMENT"); + icon = tr(_getIconName("ICO_PRESENTATION_CUT_SEGMENT").c_str()); + actionId = _salomeModule->createStandardAction(label, this, SLOT(onVisualizeCutSegment()), + icon, tooltip, FIELDSOp::OpCutSegment); + _salomeModule->createTool(actionId, presentationToolbarId); + _salomeModule->action(actionId)->setIconVisibleInMenu(true); + _salomeModule->createMenu(actionId, presentationMenuId); + + + // Separator + _salomeModule->createMenu(_salomeModule->separator(), presentationMenuId); + + label = tr("LAB_DELETE_PRESENTATION"); + tooltip = tr("TIP_DELETE_PRESENTATION"); + icon = tr("ICO_DELETE_PRESENTATION"); + actionId = _salomeModule->createStandardAction(label,this, SLOT(onDeletePresentation()),icon,tooltip); + // _salomeModule->createTool(actionId, presentationToolbarId); + // _salomeModule->action(actionId)->setIconVisibleInMenu(true); + _salomeModule->createMenu(actionId, presentationMenuId); + + // Low level PARAVIS dump + label = tr("LAB_PARAVIS_DUMP"); + tooltip = tr("TIP_PARAVIS_DUMP"); + actionId = _salomeModule->createStandardAction(label,this,SLOT(onParavisDump()),""); + _salomeModule->createMenu(actionId, presentationMenuId); + + // + // Actions for popup menu only + // + } -MEDCALC::MEDPresentationViewMode -PresentationController::getSelectedViewMode() +MEDCALC::ViewModeType +PresentationController::getSelectedViewMode() const { if (_salomeModule->action(OPTIONS_VIEW_MODE_REPLACE_ID)->isChecked()) { - return MEDCALC::VIEW_MODE_REPLACE; + return MEDCALC::VIEW_MODE_REPLACE; } else if (_salomeModule->action(OPTIONS_VIEW_MODE_OVERLAP_ID)->isChecked()) { - return MEDCALC::VIEW_MODE_OVERLAP; + return MEDCALC::VIEW_MODE_OVERLAP; } else if (_salomeModule->action(OPTIONS_VIEW_MODE_NEW_LAYOUT_ID)->isChecked()) { - return MEDCALC::VIEW_MODE_NEW_LAYOUT; + return MEDCALC::VIEW_MODE_NEW_LAYOUT; } else if (_salomeModule->action(OPTIONS_VIEW_MODE_SPLIT_VIEW_ID)->isChecked()) { - return MEDCALC::VIEW_MODE_SPLIT_VIEW; + return MEDCALC::VIEW_MODE_SPLIT_VIEW; } + // Should not happen + STDLOG("Strange!! No matching view mode found - returning VIEW_MODE_REPLACE."); + return MEDCALC::VIEW_MODE_REPLACE; +} + +MEDCALC::ColorMapType +PresentationController::getSelectedColorMap() const +{ + return _widgetPresentationParameters->getColorMap(); +} + +MEDCALC::ScalarBarRangeType +PresentationController::getSelectedScalarBarRange() const +{ + return _widgetPresentationParameters->getScalarBarRange(); } void PresentationController::visualize(PresentationEvent::EventType eventType) { - // We need a _studyEditor updated on the active study - _studyEditor->updateActiveStudy(); - // Get the selected objects in the study (SObject) SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects(); // For each object, emit a signal to the workspace to request a // visualisation using the tui command (so that the user can see how // to make a view of an object from the tui console). - for (int i=0; isize(); i++) { - SALOMEDS::SObject_var soField = listOfSObject->at(i); - int fieldId = _studyEditor->getParameterInt(soField,OBJECT_ID); - // If fieldId equals -1, then it means that it is not a field - // managed by the MED module, and we stop this function process. - if ( fieldId < 0 ) - continue; - - MEDCALC::FieldHandler* fieldHandler = MEDFactoryClient::getDataManager()->getFieldHandler(fieldId); - if (! fieldHandler) { - QMessageBox::warning(_salomeModule->getApp()->desktop(), - tr("Operation not allowed"), - tr("No field is defined")); - return; - } - - PresentationEvent* event = new PresentationEvent(); - event->eventtype = eventType; - XmedDataObject* dataObject = new XmedDataObject(); - dataObject->setFieldHandler(*fieldHandler); - event->objectdata = dataObject; - emit presentationSignal(event); + for (int i=0; i<(int)listOfSObject->size(); i++) { + SALOMEDS::SObject_var soObj = listOfSObject->at(i); + std::string name(_studyEditor->getName(soObj)); + if (soObj->_is_nil() || name == "MEDCalc") + return; + int fieldId = _salomeModule->getIntParamFromStudyEditor(soObj, FIELD_ID); + int meshId = _salomeModule->getIntParamFromStudyEditor(soObj, MESH_ID); + MEDCALC::FieldHandler* fieldHandler = 0; + MEDCALC::MeshHandler* meshHandler = 0; + + // is it a mesh? + if (meshId >= 0) + { + if (eventType != PresentationEvent::EVENT_VIEW_OBJECT_MESH_VIEW) + continue; + meshHandler = MEDFactoryClient::getDataManager()->getMeshHandler(meshId); + } + else + { + if (fieldId < 0) // is it a field series? + { + int fieldSeriesId = _salomeModule->getIntParamFromStudyEditor(soObj, FIELD_SERIES_ID); + // If fieldId and fieldSeriesId equals -1, then it means that it is not a field + // managed by the MED module, and we stop this function process. + if ( fieldSeriesId < 0) + continue; + + // get the current timestamp + double timestamp = _salomeModule->getCurrentAnimationTimestamp(); + // get the field id a the current timestamp + fieldId = MEDFactoryClient::getDataManager()->getFieldIdAtTimestamp(fieldSeriesId, timestamp); + } + fieldHandler = MEDFactoryClient::getDataManager()->getFieldHandler(fieldId); + } + + if ((!fieldHandler) && (!meshHandler)) { + QMessageBox::warning(_salomeModule->getApp()->desktop(), + tr("Operation not allowed"), + tr("No field (or mesh) is defined")); + return; + } + + PresentationEvent* event = new PresentationEvent(); + event->eventtype = eventType; + event->fieldHandler = fieldHandler; + event->meshHandler = meshHandler; + emit presentationSignal(event); // --> processPresentationEvent() } } void -PresentationController::OnVisualizeScalarMap() +PresentationController::onVisualizeMeshView() +{ + this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_MESH_VIEW); +} + +void +PresentationController::onVisualizeScalarMap() { this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_SCALAR_MAP); } void -PresentationController::OnVisualizeContour() +PresentationController::onVisualizeContour() { this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_CONTOUR); } void -PresentationController::OnVisualizeVectorField() +PresentationController::onVisualizeVectorField() { this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_VECTOR_FIELD); } void -PresentationController::OnVisualizeSlices() +PresentationController::onVisualizeSlices() { this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_SLICES); } void -PresentationController::OnVisualizeDeflectionShape() +PresentationController::onVisualizeDeflectionShape() { this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_DEFLECTION_SHAPE); } void -PresentationController::OnVisualizePointSprite() +PresentationController::onVisualizePointSprite() { this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_POINT_SPRITE); } +// sphinx doc: begin of onVisualizePlot3D +void +PresentationController::onVisualizePlot3D() +{ + this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_PLOT3D); +} +// sphinx doc: end of onVisualizePlot3D + +void +PresentationController::onVisualizeStreamLines() +{ + this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_STREAM_LINES); +} + +void +PresentationController::onVisualizeCutSegment() +{ + // Cut segment presentation "creates" new view, so switch off visibility state update + // because pqActiveObjects::viewChanged is emmited + _salomeModule->visibilityStateUpdateOff(); + this->visualize(PresentationEvent::EVENT_VIEW_OBJECT_CUT_SEGMENT); + _salomeModule->visibilityStateUpdateOn(); + _salomeModule->updateVisibilityState(); +} + +void +PresentationController::onDeletePresentation() +{ + // Get the selected objects in the study (SObject) + SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects(); + + // For each object, emit a signal to the workspace to request pres deletion + for (int i=0; i<(int)listOfSObject->size(); i++) { + SALOMEDS::SObject_var soPres = listOfSObject->at(i); + std::string name(_studyEditor->getName(soPres)); + if (soPres->_is_nil() || name == "MEDCalc") + return; + int presId = _salomeModule->getIntParamFromStudyEditor(soPres,PRESENTATION_ID); + // If fieldId equals -1, then it means that it is not a field + // managed by the MED module, and we stop this function process. + if ( presId < 0 ) + continue; + + PresentationEvent* event = new PresentationEvent(); + event->eventtype = PresentationEvent::EVENT_DELETE_PRESENTATION; + event->presentationId = presId; + emit presentationSignal(event); // --> processPresentationEvent() + } +} + +QString +PresentationController::getViewModePython() const +{ + MEDCALC::ViewModeType viewMode = getSelectedViewMode(); + switch(viewMode) { + case MEDCALC::VIEW_MODE_REPLACE: return "MEDCALC.VIEW_MODE_REPLACE"; + case MEDCALC::VIEW_MODE_OVERLAP: return "MEDCALC.VIEW_MODE_OVERLAP"; + case MEDCALC::VIEW_MODE_NEW_LAYOUT: return "MEDCALC.VIEW_MODE_NEW_LAYOUT"; + case MEDCALC::VIEW_MODE_SPLIT_VIEW: return "MEDCALC.VIEW_MODE_SPLIT_VIEW"; + } + return QString(); +} + +QString +PresentationController::getColorMapPython() const +{ + MEDCALC::ColorMapType colorMap = getSelectedColorMap(); + switch(colorMap) { + case MEDCALC::COLOR_MAP_BLUE_TO_RED_RAINBOW: return "MEDCALC.COLOR_MAP_BLUE_TO_RED_RAINBOW"; + case MEDCALC::COLOR_MAP_COOL_TO_WARM: return "MEDCALC.COLOR_MAP_COOL_TO_WARM"; + } + return QString(); +} + +QString +PresentationController::getScalarBarRangePython() const +{ + MEDCALC::ScalarBarRangeType scalarBarRange = getSelectedScalarBarRange(); + switch(scalarBarRange) { + case MEDCALC::SCALAR_BAR_ALL_TIMESTEPS: return "MEDCALC.SCALAR_BAR_ALL_TIMESTEPS"; + case MEDCALC::SCALAR_BAR_CURRENT_TIMESTEP: return "MEDCALC.SCALAR_BAR_CURRENT_TIMESTEP"; + case MEDCALC::SCALAR_BAR_CUSTOM_RANGE: return "MEDCALC.SCALAR_BAR_CUSTOM_RANGE"; + } + return QString(); +} + +QString +PresentationController::getMeshModePython(const int mode) const +{ + MEDCALC::MeshModeType mod = static_cast(mode); + switch(mod) { + case MEDCALC::MESH_MODE_WIREFRAME: return "MEDCALC.MESH_MODE_WIREFRAME"; + case MEDCALC::MESH_MODE_SURFACE: return "MEDCALC.MESH_MODE_SURFACE"; + case MEDCALC::MESH_MODE_SURFACE_EDGES: return "MEDCALC.MESH_MODE_SURFACE_EDGES"; + } + return QString(); +} + +QString +PresentationController::getSliceOrientationPython(const int orientation) const +{ + MEDCALC::SliceOrientationType orient = static_cast(orientation); + switch(orient) { + case MEDCALC::SLICE_NORMAL_TO_X: return "MEDCALC.SLICE_NORMAL_TO_X"; + case MEDCALC::SLICE_NORMAL_TO_Y: return "MEDCALC.SLICE_NORMAL_TO_Y"; + case MEDCALC::SLICE_NORMAL_TO_Z: return "MEDCALC.SLICE_NORMAL_TO_Z"; + case MEDCALC::SLICE_NORMAL_TO_XY: return "MEDCALC.SLICE_NORMAL_TO_XY"; + case MEDCALC::SLICE_NORMAL_TO_XZ: return "MEDCALC.SLICE_NORMAL_TO_XZ"; + case MEDCALC::SLICE_NORMAL_TO_YZ: return "MEDCALC.SLICE_NORMAL_TO_YZ"; + case MEDCALC::SLICE_NORMAL_TO_XYZ: return "MEDCALC.SLICE_NORMAL_TO_XYZ"; + } + return QString(); +} + +QString +PresentationController::getIntegrDirTypePython(const int intDir) const +{ + MEDCALC::IntegrationDirType type = static_cast(intDir); + switch(type) { + case MEDCALC::INTEGRATION_DIR_BOTH: return "MEDCALC.INTEGRATION_DIR_BOTH"; + case MEDCALC::INTEGRATION_DIR_FORWARD: return "MEDCALC.INTEGRATION_DIR_FORWARD"; + case MEDCALC::INTEGRATION_DIR_BACKWARD: return "MEDCALC.INTEGRATION_DIR_BACKWARD"; + } + return QString(); +} + + +std::string +PresentationController::getPresTypeFromWidgetHelper(int presId) const +{ + std::map::const_iterator it =_presHelperMap.find(presId); + if (it != _presHelperMap.end()) + return (*it).second->getPythonTag(); + return "UNKNOWN"; +} + void -PresentationController::updateTreeViewWithNewPresentation(long fieldId, long presentationId) +PresentationController::emitPresentationSignal(const PresentationEvent* event) +{ + emit presentationSignal(event); +} + +void +PresentationController::processPresentationEvent(const PresentationEvent* event) { + // --> Send commands to SALOME Python console + QString viewMode = getViewModePython(); + QString colorMap = getColorMapPython(); + QString scalarBarRange = getScalarBarRangePython(); + MEDCALC::FieldHandler* fieldHandler = event->fieldHandler; + QStringList commands; + + // [ABN] using event mechanism for all this is awkward? TODO: direct implementation in each + // dedicated widget helper class? + + if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_MESH_VIEW ) { + // Do we request mesh view from a field or from a mesh only? + int meshId = event->meshHandler ? event->meshHandler->id : event->fieldHandler->meshid; + commands += QString("presentation_id = medcalc.MakeMeshView(%1, viewMode=%2)").arg(meshId).arg(viewMode); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_SCALAR_MAP ) { + commands += QString("presentation_id = medcalc.MakeScalarMap(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_CONTOUR ) { + commands += QString("presentation_id = medcalc.MakeContour(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_SLICES ) { + commands += QString("presentation_id = medcalc.MakeSlices(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_VECTOR_FIELD ) { + commands += QString("presentation_id = medcalc.MakeVectorField(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_POINT_SPRITE ) { + commands += QString("presentation_id = medcalc.MakePointSprite(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + // sphinx doc: begin of plot3d prs creation + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_PLOT3D ) { + commands += QString("presentation_id = medcalc.MakePlot3D(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + // sphinx doc: end of plot3d prs creation + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_STREAM_LINES ) { + commands += QString("presentation_id = medcalc.MakeStreamLines(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_CUT_SEGMENT ) { + commands += QString("presentation_id = medcalc.MakeCutSegment(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + else if ( event->eventtype == PresentationEvent::EVENT_VIEW_OBJECT_DEFLECTION_SHAPE ) { + commands += QString("presentation_id = medcalc.MakeDeflectionShape(accessField(%1), viewMode=%2, scalarBarRange=%3, colorMap=%4)") + .arg(fieldHandler->id).arg(viewMode).arg(scalarBarRange).arg(colorMap); + commands += QString("presentation_id"); + } + + + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_COMPONENT ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.Get%1Parameters(%2)").arg(QString::fromStdString(typ)).arg(event->presentationId); + commands += QString("params.displayedComponent = '%1'").arg(QString::fromStdString(event->aString)); + commands += QString("medcalc.Update%1(%2, params)").arg(QString::fromStdString(typ)).arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_COLORMAP ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.Get%1Parameters(%2)").arg(QString::fromStdString(typ)).arg(event->presentationId); + commands += QString("params.colorMap = %1").arg(getColorMapPython()); + commands += QString("medcalc.Update%1(%2, params)").arg(QString::fromStdString(typ)).arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_TIME_RANGE ) { + bool customRangeFlag = + (bool)_presManager->getPresentationIntProperty(event->presentationId, MEDPresentation::PROP_HIDE_DATA_OUTSIDE_CUSTOM_RANGE.c_str()); + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.Get%1Parameters(%2)").arg(QString::fromStdString(typ)).arg(event->presentationId); + commands += QString("params.scalarBarRange = %1").arg(getScalarBarRangePython()); + if (getSelectedScalarBarRange() == MEDCALC::SCALAR_BAR_CUSTOM_RANGE) { + commands += QString("params.scalarBarRangeArray = [%1, %2]").arg(event->aDouble1).arg(event->aDouble2); + } + else { + if (customRangeFlag) // switch off hideDataOutsideCustomRange + { + commands += QString("params.hideDataOutsideCustomRange = False"); + } + } + commands += QString("medcalc.Update%1(%2, params)").arg(QString::fromStdString(typ)).arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_NB_CONTOUR ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetContourParameters(%2)").arg(event->presentationId); + commands += QString("params.nbContours = %1").arg(event->anInteger); + commands += QString("medcalc.UpdateContour(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_MESH_MODE ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetMeshViewParameters(%2)").arg(event->presentationId); + commands += QString("params.mode = %1").arg(getMeshModePython(event->anInteger)); + commands += QString("medcalc.UpdateMeshView(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_NB_SLICES ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetSlicesParameters(%2)").arg(event->presentationId); + commands += QString("params.nbSlices = %1").arg(event->anInteger); + commands += QString("medcalc.UpdateSlices(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_SLICE_ORIENTATION ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetSlicesParameters(%2)").arg(event->presentationId); + commands += QString("params.orientation = %1").arg(getSliceOrientationPython(event->anInteger)); + commands += QString("medcalc.UpdateSlices(%1, params)").arg(event->presentationId); + } + // sphinx doc: begin of plot3d prs update + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_PLANE_POS ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetPlot3DParameters(%2)").arg(event->presentationId); + commands += QString("params.planePos = %1").arg(event->aDouble3); + commands += QString("medcalc.UpdatePlot3D(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_NORMAL ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetPlot3DParameters(%2)").arg(event->presentationId); + commands += QString("params.planeNormal = [%1, %2, %3]").arg(event->aDoubleN[0]).arg(event->aDoubleN[1]).arg(event->aDoubleN[2]); + commands += QString("medcalc.UpdatePlot3D(%1, params)").arg(event->presentationId); + } + // sphinx doc: end of plot3d prs update + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_CUT_POINT1 ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetCutSegmentParameters(%2)").arg(event->presentationId); + commands += QString("params.point1 = [%1, %2, %3]").arg(event->aDoubleP1[0]).arg(event->aDoubleP1[1]).arg(event->aDoubleP1[2]); + commands += QString("medcalc.UpdateCutSegment(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_CUT_POINT2 ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetCutSegmentParameters(%2)").arg(event->presentationId); + commands += QString("params.point2 = [%1, %2, %3]").arg(event->aDoubleP2[0]).arg(event->aDoubleP2[1]).arg(event->aDoubleP2[2]); + commands += QString("medcalc.UpdateCutSegment(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_INTEGR_DIR ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetStreamLinesParameters(%2)").arg(event->presentationId); + commands += QString("params.integrDir = %1").arg(getIntegrDirTypePython(event->anInteger)); + commands += QString("medcalc.UpdateStreamLines(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_CONTOUR_COMPONENT) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetContourParameters(%2)").arg(event->presentationId); + commands += QString("params.contourComponent = '%1'").arg(event->aString.c_str()); + commands += QString("medcalc.UpdateContour(%1, params)").arg(event->presentationId); + } + else if ( event->eventtype == PresentationEvent::EVENT_CHANGE_SCALE_FACTOR ) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetVectorFieldParameters(%2)").arg(event->presentationId); + commands += QString("params.scaleFactor = %1").arg(event->aDouble3); + commands += QString("medcalc.UpdateVectorField(%1, params)").arg(event->presentationId); + } + + else if (event->eventtype == PresentationEvent::EVENT_CHANGE_CUSTOM_SCALE_FACTOR) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.GetVectorFieldParameters(%2)").arg(event->presentationId); + commands += QString("params.customScaleFactor = %1").arg(event->anInteger); + if(event->anInteger) { + commands += QString("params.scaleFactor = %1").arg(event->aDouble3); + } + commands += QString("medcalc.UpdateVectorField(%1, params)").arg(event->presentationId); + } + + else if ( event->eventtype == PresentationEvent::EVENT_DELETE_PRESENTATION ) { + commands += QString("medcalc.RemovePresentation(%1)").arg(event->presentationId); + + } + else if (event->eventtype == PresentationEvent::EVENT_DISPLAY_PRESENTATION || + event->eventtype == PresentationEvent::EVENT_ERASE_PRESENTATION) { + commands += QString("params = medcalc.Get%1Parameters(%2)").arg(QString::fromStdString(getPresTypeFromWidgetHelper(event->presentationId))) + .arg(event->presentationId); + QString visility = event->eventtype == PresentationEvent::EVENT_DISPLAY_PRESENTATION ? QString("True") : QString("False"); + commands += QString("params.visibility = %1").arg(visility); + commands += QString("medcalc.Update%1(%2, params)").arg(QString::fromStdString(getPresTypeFromWidgetHelper(event->presentationId))) + .arg(event->presentationId); + } + else if (event->eventtype == PresentationEvent::EVENT_SCALAR_BAR_VISIBILITY_CHANGED || + event->eventtype == PresentationEvent::EVENT_HIDE_DATA_OUTSIDE_CUSTOM_RANGE_CHANGED) { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + QString param; + switch (event->eventtype) { + case PresentationEvent::EVENT_SCALAR_BAR_VISIBILITY_CHANGED: + param = QString("scalarBarVisibility"); + break; + case PresentationEvent::EVENT_HIDE_DATA_OUTSIDE_CUSTOM_RANGE_CHANGED: + param = QString("hideDataOutsideCustomRange"); + break; + default: break; + } + commands += QString("params = medcalc.Get%1Parameters(%2)").arg(QString::fromStdString(typ)).arg(event->presentationId); + commands += QString("params.%1 = %2").arg(param).arg( event->anInteger ? QString("True") : QString("False")); + if (event->eventtype == PresentationEvent::EVENT_HIDE_DATA_OUTSIDE_CUSTOM_RANGE_CHANGED && event->anInteger) { + commands += QString("params.scalarBarRangeArray = [%1, %2]").arg(event->aDouble1).arg(event->aDouble2); + } + commands += QString("medcalc.Update%1(%2, params)").arg(QString::fromStdString(typ)).arg(event->presentationId); + } + else if (event->eventtype == PresentationEvent::EVENT_CUSTOM_RANGE_CHANGED) + { + std::string typ = getPresTypeFromWidgetHelper(event->presentationId); + commands += QString("params = medcalc.Get%1Parameters(%2)").arg(QString::fromStdString(typ)).arg(event->presentationId); + commands += QString("params.scalarBarRangeArray = [%1, %2]").arg(event->aDouble1).arg(event->aDouble2); + commands += QString("medcalc.Update%1(%2, params)").arg(QString::fromStdString(typ)).arg(event->presentationId); + } + else { + STDLOG("The event "<eventtype<<" is not implemented yet"); + } + _consoleDriver->exec(commands); +} + +MEDWidgetHelper * +PresentationController::findOrCreateWidgetHelper(MEDCALC::MEDPresentationManager_ptr /*presManager*/, // todo: unused + int presId, const std::string& type, const std::string& name ) +{ + std::map::const_iterator it =_presHelperMap.find(presId); + if (it != _presHelperMap.end()) + return (*it).second; + MEDWidgetHelper * wh = 0; + if (type == MEDPresentationMeshView::TYPE_NAME) + wh = new MEDWidgetHelperMeshView(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationScalarMap::TYPE_NAME) + wh = new MEDWidgetHelperScalarMap(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationContour::TYPE_NAME) + wh = new MEDWidgetHelperContour(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationSlices::TYPE_NAME) + wh = new MEDWidgetHelperSlices(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationVectorField::TYPE_NAME) + wh = new MEDWidgetHelperVectorField(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationPointSprite::TYPE_NAME) + wh = new MEDWidgetHelperPointSprite(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationPlot3D::TYPE_NAME) + wh = new MEDWidgetHelperPlot3D(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationStreamLines::TYPE_NAME) + wh = new MEDWidgetHelperStreamLines(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationCutSegment::TYPE_NAME) + wh = new MEDWidgetHelperCutSegment(this, _presManager, presId, name, _widgetPresentationParameters); + else if (type == MEDPresentationDeflectionShape::TYPE_NAME) + wh = new MEDWidgetHelperDeflectionShape(this, _presManager, presId, name, _widgetPresentationParameters); + else + { + STDLOG("findOrCreateWidgetHelper(): NOT IMPLEMENTED !!!"); + return wh; + } + _presHelperMap[presId] = wh; + return wh; +} + +void +PresentationController::onPresentationSelected(int presId, const QString& presType, const QString& presName) +{ + if (presId == -1) + { + if (_widgetPresentationParameters->isShown()) + { + _widgetPresentationParameters->toggleWidget(false); + if(_currentWidgetHelper) + _currentWidgetHelper->releaseWidget(); + } + } + else + { + if(_currentWidgetHelper) + _currentWidgetHelper->releaseWidget(); + // Activate corresponding ParaView render view + _presManager->activateView(presId); + // Update widgets parameters + _currentWidgetHelper = findOrCreateWidgetHelper(_presManager, presId, presType.toStdString(), presName.toStdString()); + _currentWidgetHelper->updateWidget(true); + } +} + +void +PresentationController::onParavisDump() +{ + // Get the selected objects in the study (SObject) + SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects(); + + // For the first object only, request the dump + for (int i=0; i<(int)listOfSObject->size(); i++) { + SALOMEDS::SObject_var soPres = listOfSObject->at(i); + std::string name(_studyEditor->getName(soPres)); + if (soPres->_is_nil() || name == "MEDCalc") + return; + int presId = _salomeModule->getIntParamFromStudyEditor(soPres,PRESENTATION_ID); + // If fieldId equals -1, then it means that it is not a field + // managed by the MED module, and we stop this function process. + if ( presId < 0 ) + continue; + + std::string dump(_presManager->getParavisDump(presId)); + std::cerr << "#====== ParaVis dump (presentation " << presId << ") =====" << std::endl; + std::cerr << dump; + std::cerr << "#====== End of ParaVis dump =============== " << std::endl; + + break; // stop at the first one + } +} + +void +PresentationController::updateTreeViewWithNewPresentation(long dataId, long presentationId) { if (presentationId < 0) { - std::cerr << "Unknown presentation\n"; - return; + std::cerr << "Unknown presentation\n"; + return; } - std::string name = MEDFactoryClient::getPresentationManager()->getPresentationProperty(presentationId, "name"); - std::string icon = std::string("ICO_") + name; + std::string name(_presManager->getPresentationStringProperty(presentationId, MEDPresentation::PROP_NAME.c_str())); + std::string type = name; + std::string icon = std::string("ICO_") + type; + icon = _getIconName(icon); + std::string ico = tr(icon.c_str()).toStdString(); + + // Append presentation ID to the displayed name in the OB: + std::ostringstream oss; name = tr(name.c_str()).toStdString(); - std::string label = tr(icon.c_str()).toStdString(); + oss << name << " (" << presentationId << ")"; + + // Mesh views are always registered at the mesh level: + if (type == MEDPresentationMeshView::TYPE_NAME) + { + _salomeModule->engine()->registerPresentationMesh(dataId, oss.str().c_str(), type.c_str(),ico.c_str(), presentationId); + } + else + _salomeModule->engine()->registerPresentationField(dataId, oss.str().c_str(), type.c_str(),ico.c_str(), presentationId); - SalomeApp_Study* study = dynamic_cast(_salomeModule->application()->activeStudy()); - _PTR(Study) studyDS = study->studyDS(); + // update Object browser + _salomeModule->getApp()->updateObjectBrowser(true); + + // auto-select new presentation + std::string entry = _salomeModule->engine()->getStudyPresentationEntry(presentationId); + SALOME_ListIO selectedObjects; + LightApp_Study* lightStudy = dynamic_cast( _salomeModule->application()->activeStudy() ); + QString component = lightStudy->componentDataType( entry.c_str() ); + selectedObjects.Append( new SALOME_InteractiveObject( (const char*)entry.c_str(), + (const char*)component.toLatin1(), + ""/*refobj->Name().c_str()*/ ) ); + //QStringList selectedObjects; + //selectedObjects << QString(entry.c_str()); + LightApp_SelectionMgr* aSelectionMgr = _salomeModule->getApp()->selectionMgr(); + aSelectionMgr->setSelectedObjects(selectedObjects, false); + + // emit onPresentationSelected + int presId = -1; + _salomeModule->itemClickGeneric(name, type, presId); + onPresentationSelected(presId, QString::fromStdString(type), QString::fromStdString(name)); + updateVisibilityState(presId); +} + +void +PresentationController::updateTreeViewForPresentationRemoval(long presentationId) +{ + if (presentationId < 0) { + std::cerr << "Unknown presentation\n"; + return; + } - _salomeModule->engine()->registerPresentation(_CAST(Study, studyDS)->GetStudy(), fieldId, name.c_str(), label.c_str()); + _salomeModule->engine()->unregisterPresentation(presentationId); // update Object browser _salomeModule->getApp()->updateObjectBrowser(true); } +void +PresentationController::_dealWithReplaceMode() +{ + // Deal with replace mode: presentations with invalid IDs have to be removed: + + MEDCALC::PresentationsList * lstManager = _presManager->getAllPresentations(); + MED_ORB::PresentationsList * lstModule = _salomeModule->engine()->getStudyPresentations(); + // The IDs not in the intersection needs deletion: + CORBA::Long * last = lstManager->get_buffer() + lstManager->length(); + for (unsigned i = 0; i < lstModule->length(); i++) { + CORBA::Long * ptr = std::find(lstManager->get_buffer(), last, (*lstModule)[i]); + if (ptr == last) { + STDLOG("Removing pres " << (*lstModule)[i] << " from OB."); + // Presentation in module but not in manager anymore: to be deleted from OB: + updateTreeViewForPresentationRemoval((*lstModule)[i]); + } + } +} + void PresentationController::processWorkspaceEvent(const MEDCALC::MedEvent* event) { if ( event->type == MEDCALC::EVENT_ADD_PRESENTATION ) { - this->updateTreeViewWithNewPresentation(event->dataId, event->presentationId); + if (event->dataId == -1) { + // A file has been loaded, and we want to create a default presentation (MeshView) for it + QString viewMode = getViewModePython(); + QStringList commands; + commands += QString("presentation_id = medcalc.MakeMeshView(medcalc.GetFirstMeshFromDataSource(source_id), viewMode=%1)").arg(viewMode); + commands += QString("presentation_id"); + _consoleDriver->exec(commands); + } + else { + updateTreeViewWithNewPresentation(event->dataId, event->presentationId); + _dealWithReplaceMode(); + // Update parameter widget if shown: some parameters should be updated after presentation has been added + if (_currentWidgetHelper) + _currentWidgetHelper->updateWidget(false); + } + } + else if ( event->type == MEDCALC::EVENT_REMOVE_PRESENTATION ) { + updateTreeViewForPresentationRemoval(event->presentationId); + // Hide parameter widget if necessary: + onPresentationSelected(-1, "", ""); + } + else if ( event->type == MEDCALC::EVENT_MODIFY_PRESENTATION ) { + // Update parameter widget if shown: + if(_currentWidgetHelper) + _currentWidgetHelper->updateWidget(false); + } + else if (event->type == MEDCALC::EVENT_VISIBILITY_CHANGED) { + updateVisibilityState(event->presentationId); + } +} + +void +PresentationController::showDockWidgets(bool isVisible) +{ + _dockWidget->setVisible(isVisible); +} + +void PresentationController::updateVisibilityState(long presId) +{ + char* str = _salomeModule->engine()->getStudyPresentationEntry(presId); + if (str) { + QStringList entries; + entries.append(str); + _salomeModule->updateVisibilityState(false, entries); } } + +std::string PresentationController::presentationName2Type(const std::string& name) { + return std::regex_replace(name, std::regex("MEDPresentation"), std::string("")); +} \ No newline at end of file