#include "VisuGUI_Tools.h"
+#include "VisuGUI.h"
+#include "VisuGUI_ViewTools.h"
+
#include "VISU_Gen_i.hh"
#include "VISU_Prs3d_i.hh"
#include "VISU_Result_i.hh"
#include "VISU_ViewManager_i.hh"
#include "VISU_Actor.h"
+#include "VISU_ScalarMapAct.h"
#include "SalomeApp_Module.h"
#include "SalomeApp_Study.h"
#include "SalomeApp_Application.h"
-#include "SalomeApp_SelectionMgr.h"
+
+#include "LightApp_DataObject.h"
+#include "LightApp_SelectionMgr.h"
+
+#include "OB_Browser.h"
#include "SALOME_ListIO.hxx"
#include "SALOME_ListIteratorOfListIO.hxx"
#include "SVTK_ViewWindow.h"
-#include "SVTK_ViewModel.h"
#include "SVTK_Functor.h"
#include "VTKViewer_Algorithm.h"
return theModule->application()->desktop();
}
- SalomeApp_SelectionMgr*
+ LightApp_SelectionMgr*
GetSelectionMgr(const SalomeApp_Module* theModule)
{
return theModule->getApp()->selectionMgr();
}
bool
- CheckLock( _PTR(Study) theStudy )
+ CheckLock( _PTR(Study) theStudy,
+ QWidget* theWidget )
+ {
+ if(IsStudyLocked(theStudy)){
+ SUIT_MessageBox::warn1(theWidget,
+ QObject::tr("WRN_VISU_WARNING"),
+ QObject::tr("WRN_STUDY_LOCKED"),
+ QObject::tr("BUT_OK"));
+ return true;
+ }
+ return false;
+ }
+
+ LightApp_DataObject*
+ FindDataObject(SUIT_DataObject* theDataObject,
+ const QString& theEntry,
+ int theLevel)
+ {
+ int aLevel = theDataObject->level() + 2;
+ QString aSourceEntry = theEntry.section(':',0,aLevel);
+ DataObjectList aList;
+ theDataObject->children(aList);
+ DataObjectListIterator aDataObjectIter(aList);
+ while(SUIT_DataObject* aDataObject = aDataObjectIter.current()){
+ if(LightApp_DataObject* aChildDataObject = dynamic_cast<LightApp_DataObject*>(aDataObject)){
+ QString anEntry = aChildDataObject->entry();
+ QString aCurrentEntry = anEntry.section(':',0,aLevel);
+ if(aSourceEntry == aCurrentEntry){
+ if(theLevel == aLevel){
+ return aChildDataObject;
+ }else{
+ return FindDataObject(aChildDataObject,theEntry,theLevel);
+ }
+ }
+ }
+ ++aDataObjectIter;
+ }
+ return NULL;
+ }
+
+ LightApp_DataObject*
+ FindDataObject(CAM_Module* theModule,
+ _PTR(SObject) theSObject)
+ {
+ CAM_DataModel* aDataModel = theModule->dataModel();
+ CAM_DataObject* aRootDataObject = aDataModel->root();
+ if(_PTR(SComponent) aComponent = theSObject)
+ return dynamic_cast<LightApp_DataObject*>(aRootDataObject);
+
+ int aLevel = theSObject->Depth();
+ std::string anEntry = theSObject->GetID();
+ return FindDataObject(aRootDataObject,anEntry.c_str(),aLevel);
+ }
+
+ void
+ UpdateObjBrowser(SalomeApp_Module* theModule,
+ bool theIsUpdateDataModel,
+ _PTR(SObject) theSObject)
+ {
+ LightApp_DataObject* aDataObject = NULL;
+ if(theSObject)
+ aDataObject = FindDataObject(theModule,theSObject);
+
+ theModule->updateObjBrowser(theIsUpdateDataModel,aDataObject);
+ theModule->getApp()->updateActions();
+ }
+
+ bool
+ IsSObjectTable( _PTR(SObject) theSObject )
{
- if(IsStudyLocked(theStudy))
- throw std::runtime_error(QObject::tr("WRN_STUDY_LOCKED").latin1());
+ if ( theSObject ) {
+ _PTR(GenericAttribute) anAttr;
+ if (theSObject->FindAttribute( anAttr, "AttributeTableOfInteger" ))
+ return true;
+ if (theSObject->FindAttribute( anAttr, "AttributeTableOfReal" ))
+ return true;
+ }
return false;
}
return aStr;
}
- //************************************************************
+ //------------------------------------------------------------
// Selection
CORBA::Object_var
GetSelectedObj(const SalomeApp_Study* theStudy,
Handle(SALOME_InteractiveObject)* theIO,
VISU::Storable::TRestoringMap* theMap)
{
- SalomeApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
+ LightApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
SALOME_ListIO aListIO;
aSelectionMgr->selectedObjects(aListIO);
SALOME_ListIteratorOfListIO anIter(aListIO);
return CORBA::Object::_nil();
}
+ VISU::Prs3d_i*
+ GetPrsToModify(const SalomeApp_Module* theModule,
+ Handle(SALOME_InteractiveObject)* theIO,
+ VISU::Storable::TRestoringMap* theMap)
+ {
+ if (CheckLock(GetCStudy(GetAppStudy(theModule)),GetDesktop(theModule)))
+ return NULL;
+
+ CORBA::Object_var anObject = GetSelectedObj(theModule, theIO);
+ if (CORBA::is_nil(anObject))
+ return NULL;
+
+ PortableServer::ServantBase_var aServant = VISU::GetServant(anObject);
+ if (!aServant.in())
+ return NULL;
+
+ return dynamic_cast<VISU::Prs3d_i*>(aServant.in());
+ }
+
void
- Add(SalomeApp_SelectionMgr* theSelectionMgr,
+ Add(LightApp_SelectionMgr* theSelectionMgr,
const Handle(SALOME_InteractiveObject)& theIO)
{
SALOME_ListIO aListIO;
}
void
- Remove(SalomeApp_SelectionMgr* theSelectionMgr,
+ Remove(LightApp_SelectionMgr* theSelectionMgr,
const Handle(SALOME_InteractiveObject)& theIO)
{
if (theIO.IsNull()) return;
bool
IsRemovableSelected (const SalomeApp_Module* theModule)
{
- SalomeApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
+ LightApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
SALOME_ListIO aListIO;
aSelectionMgr->selectedObjects(aListIO);
for (; anIter.More(); anIter.Next()) {
Handle(SALOME_InteractiveObject) anIO = anIter.Value();
if (anIO->hasEntry()) {
+
+ // asv : if selected object is a Save Point object selected in object browser - return false
+ if ( QString( anIO->getEntry() ).startsWith( QObject::tr( "SAVE_POINT_DEF_NAME" ) ) )
+ return false;
+
_PTR(SObject) aSObject = aStudy->FindObjectID(anIO->getEntry());
VISU::Storable::TRestoringMap pMap;
if (aSObject) {
return true;
}
- //************************************************************
- // Display/Erase
-
- void
- ErasePrs (const SalomeApp_Module* theModule,
- CORBA::Object_ptr theObject, bool theUpdate)
- {
- if (!CORBA::is_nil(theObject)) {
- VISU::Base_var aBase = VISU::Base::_narrow(theObject);
- if (CORBA::is_nil(aBase)) return;
- VISU::VISUType aType = aBase->GetType();
- switch (aType) {
- case VISU::TCURVE:
- {
- if (VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aBase).in()))
- PlotCurve(theModule, aCurve, VISU::eErase );
- break;
- }
- case VISU::TCONTAINER:
- {
- if (VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(VISU::GetServant(aBase).in()))
- PlotContainer(theModule, aContainer, VISU::eErase );
- break;
- }
- case VISU::TTABLE:
- {
- if (VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(VISU::GetServant(aBase).in()))
- PlotTable(theModule, aTable, VISU::eErase );
- break;
- }
- default:
- {
- if (VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(aBase).in())) {
- ErasePrs3d(theModule, aPrsObject);
- if (theUpdate) {
- if (SVTK_ViewWindow* vw = GetViewWindow(theModule))
- vw->Repaint();
- }
- }
- }
- } // switch (aType)
- }
- }
-
void
- DeleteSObject (SalomeApp_Module* theModule,
- _PTR(Study) theStudy,
- _PTR(SObject) theSObject)
+ DeleteSObject(VisuGUI* theModule,
+ _PTR(Study) theStudy,
+ _PTR(SObject) theSObject)
{
_PTR(ChildIterator) aChildIter = theStudy->NewChildIterator(theSObject);
for (aChildIter->InitEx(true); aChildIter->More(); aChildIter->Next()) {
_PTR(SObject) aChildSObject = aChildIter->Value();
CORBA::Object_var aChildObj = VISU::ClientSObjectToObject(aChildSObject);
- ErasePrs(theModule, aChildObj);
+ ErasePrs(theModule, aChildObj, /*repaint_view_window = */false);
}
CORBA::Object_var anObj = VISU::ClientSObjectToObject(theSObject);
if (!CORBA::is_nil(anObj)) {
+ ErasePrs(theModule, anObj, /*repaint_view_window = */true);
+
VISU::RemovableObject_var aRemovableObject = VISU::RemovableObject::_narrow(anObj);
if (!CORBA::is_nil(aRemovableObject)) {
aRemovableObject->RemoveFromStudy();
}
} else {
// Remove aSObject together with all its sub-objects
+
VISU::RemoveFromStudy(theSObject,
false, // remove not only IOR attribute, but Object With Children
false); // not Destroy() sub-objects
}
void
- DeletePrs3d(SalomeApp_Module* theModule,
+ DeletePrs3d(VisuGUI* theModule,
VISU::Prs3d_i* thePrs,
const Handle(SALOME_InteractiveObject)& theIO)
{
if (!thePrs)
return;
- if (CheckLock(GetCStudy(GetAppStudy(theModule))))
+ if (CheckLock(GetCStudy(GetAppStudy(theModule)),GetDesktop(theModule)))
return;
- SALOMEDS::SObject_var aSObject = thePrs->GetSObject();
- CORBA::String_var anEntry = aSObject->GetID();
- SalomeApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule);
- Remove(aSelectionMgr,theIO);
- TViewWindows aViewWindows = GetViews(theModule);
- for(int i = 0, iEnd = aViewWindows.size(); i < iEnd; i++){
- SVTK_ViewWindow* aView = aViewWindows[i];
- if(VISU_Actor* anActor = FindActor(aView,anEntry.in())){
- aView->RemoveActor(anActor);
- anActor->Delete();
- }
- }
- thePrs->RemoveFromStudy();
- //theModule->updateObjBrowser(); //update Object browser
- }
- void
- ErasePrs3d(const SalomeApp_Module* theModule,
- VISU::Prs3d_i* thePrs)
- {
- if ( SVTK_ViewWindow* vw = GetViewWindow( theModule ) ){
- VISU_Actor* anVISUActor = FindActor( vw, thePrs );
- if (anVISUActor) {
- anVISUActor->VisibilityOff();
- }
- }
+ SVTK_ViewWindow* vw = GetActiveViewWindow<SVTK_ViewWindow>(theModule);
+ RemoveScalarBarPosition(theModule, vw, thePrs);
+
+ thePrs->RemoveFromStudy();
}
- //************************************************************
// Presentation management
void
ChangeRepresentation (const SalomeApp_Module* theModule,
VISU::PresentationType theType)
{
- SUIT_ViewWindow* aView = GetActiveView(theModule, VTKViewer_Viewer::Type());
- if (!aView) return;
- SVTK_ViewWindow* vw = (SVTK_ViewWindow*) aView;
+ SVTK_ViewWindow* vw = GetActiveViewWindow<SVTK_ViewWindow>(theModule);
+ if (!vw)
+ return;
Handle(SALOME_InteractiveObject) anIO;
CORBA::Object_var anObject = GetSelectedObj(theModule, &anIO);
if (CORBA::is_nil(anObject)) return;
+
+ VISU::Base_var aVisuObj = VISU::Base::_narrow(anObject);
+ if (CORBA::is_nil(aVisuObj)) return;
+
PortableServer::ServantBase_var aServant = VISU::GetServant(anObject);
if (!aServant.in()) return;
}
}
- //************************************************************
+ void
+ SetShading ( const SalomeApp_Module* theModule,
+ bool theOn )
+ {
+ SVTK_ViewWindow* vw = GetActiveViewWindow<SVTK_ViewWindow>(theModule);
+ if (!vw)
+ return;
+
+ Handle(SALOME_InteractiveObject) anIO;
+ CORBA::Object_var anObject = GetSelectedObj(theModule, &anIO);
+ if (CORBA::is_nil(anObject)) return;
+
+ VISU::Base_var aVisuObj = VISU::Base::_narrow(anObject);
+ if (CORBA::is_nil(aVisuObj)) return;
+
+ PortableServer::ServantBase_var aServant = VISU::GetServant(anObject);
+ if (!aServant.in()) return;
+
+ VISU::Prs3d_i* aPrs3d = dynamic_cast<VISU::Prs3d_i*>(aServant.in());
+ if (aPrs3d) {
+ if (VISU_Actor* anActor = GetActor(aPrs3d, vw)) {
+ if ( VISU_ScalarMapAct* aScalarMapActor = dynamic_cast<VISU_ScalarMapAct*>(anActor) )
+ aScalarMapActor->SetShading( theOn );
+ }
+ vw->Repaint();
+ }
+ }
+
// SObject type
bool
_PTR(SObject) theSource,
VISU::Result_var& theResult)
{
+ if(theSource->Depth() < 3) // Bug of SALOMEDS : can\t get father from root object
+ return NULL;
+
_PTR(SObject) aSObj = theSource->GetFather();
if (!aSObj)
return NULL;
return NULL;
theResult = VISU::Result::_narrow(anObject);
- VISU::Result_i* pResult = dynamic_cast<VISU::Result_i*>(VISU::GetServant(anObject).in());
- if (pResult == NULL)
- SUIT_MessageBox::warn1(GetDesktop(theModule),
- QObject::tr("WRN_VISU"),
- QObject::tr("WRN_NO_AVAILABLE_DATA"),
- QObject::tr("BUT_OK"));
- return pResult;
- }
-
- //************************************************************
- // Views
-
- SUIT_ViewWindow* GetActiveView(const SalomeApp_Module* theModule, QString theType)
- {
- if(SalomeApp_Application* anApp = theModule->getApp()){
- if(SUIT_ViewManager* aViewManager = anApp->activeViewManager()){
- if (!theType.isNull()) {
- if (aViewManager->getType() != theType)
- return 0;
- }
- return aViewManager->getActiveView();
- }
- }
- return 0;
+ return dynamic_cast<VISU::Result_i*>(VISU::GetServant(anObject).in());
}
- //************************************************************
// VTK View
- TViewWindows
- GetViews(const SalomeApp_Module* theModule)
- {
- TViewWindows aViewWindows;
- if(SalomeApp_Application* anApp = theModule->getApp()){
- ViewManagerList aViewManagerList;
- anApp->viewManagers(SVTK_Viewer::Type(),aViewManagerList);
- QPtrListIterator<SUIT_ViewManager> anIter(aViewManagerList);
- while(SUIT_ViewManager* aViewManager = anIter.current()){
- QPtrVector<SUIT_ViewWindow> aViews = aViewManager->getViews();
- for(int i = 0, iEnd = aViews.size(); i < iEnd; i++){
- if(SUIT_ViewWindow* aViewWindow = aViews.at(i))
- if(SVTK_ViewWindow* aView = dynamic_cast<SVTK_ViewWindow*>(aViewWindow))
- aViewWindows.push_back(aView);
- }
- ++anIter;
- }
- }
- return aViewWindows;
- }
-
- SVTK_ViewWindow*
- GetViewWindow(const SalomeApp_Module* theModule, const bool theCreate )
- {
- if(SalomeApp_Application* anApp = theModule->getApp()){
- if(SUIT_ViewManager* aViewManager = anApp->getViewManager( SVTK_Viewer::Type(), theCreate )){
- if(SUIT_ViewWindow* aViewWindow = aViewManager->getActiveView()){
- return dynamic_cast<SVTK_ViewWindow*>(aViewWindow);
- }
- }
- }
- return NULL;
- }
-
-
- SVTK_ViewWindow*
- GetViewWindow()
- {
- SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>
- (SUIT_Session::session()->activeApplication());
- if (anApp) {
- if (SUIT_ViewManager* aViewManager = anApp->activeViewManager()) {
- if (aViewManager->getType() == SVTK_Viewer::Type()) {
- if (SUIT_ViewWindow* aViewWindow = aViewManager->getActiveView()) {
- return dynamic_cast<SVTK_ViewWindow*>(aViewWindow);
- }
- }
- }
- }
- return NULL;
- }
-
VISU_Actor*
- PublishInView(const SalomeApp_Module* theModule,
- VISU::Prs3d_i* thePrs)
+ PublishMeshInView(const SalomeApp_Module* theModule,
+ VISU::Prs3d_i* thePrs,
+ SVTK_ViewWindow* theViewWindow)
{
VISU_Actor* aActor = NULL;
- if(!thePrs)
+ if (!thePrs || !theViewWindow)
return aActor;
- if(SVTK_ViewWindow* aView = GetViewWindow(theModule)){
- QApplication::setOverrideCursor( Qt::waitCursor );
- if(aActor = thePrs->CreateActor()){
- aView->AddActor(aActor);
- }
- QApplication::restoreOverrideCursor();
- }
- return aActor;
- }
- VISU_Actor*
- UpdateViewer(const SalomeApp_Module* theModule,
- VISU::Prs3d_i* thePrs,
- bool theDispOnly)
- {
- SVTK_ViewWindow* vw = GetViewWindow( theModule );
- if (!vw) return NULL;
-
- vtkRenderer *aRen = vw->getRenderer();
- vtkActorCollection *anActColl = aRen->GetActors();
-
- vtkActor *anActor;
- VISU_Actor* anVISUActor = NULL;
- VISU_Actor* aResActor = NULL;
- for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL; ){
- if(!SALOME_Actor::SafeDownCast(anActor))
- continue;
- if(anActor->IsA("VISU_Actor")){
- anVISUActor = VISU_Actor::SafeDownCast(anActor);
- VISU::Prs3d_i* aPrs = anVISUActor->GetPrs3d();
- if(aPrs == NULL) continue;
- if (thePrs == aPrs) {
- aResActor = anVISUActor->GetParent();
- thePrs->UpdateActor(aResActor);
- aResActor->VisibilityOn();
-
- } else if (theDispOnly) {
- anVISUActor->GetParent()->VisibilityOff();
- } else {
- }
- } else if (theDispOnly && anActor->GetVisibility()) {
- anActor->VisibilityOff();
- } else {
- }
+ QApplication::setOverrideCursor( Qt::waitCursor );
+ try {
+ if (aActor = thePrs->CreateActor())
+ theViewWindow->AddActor(aActor);
+ } catch(std::exception& exc) {
+ SUIT_MessageBox::warn1
+ (GetDesktop(theModule), QObject::tr("WRN_VISU"),
+ QObject::tr("ERR_CANT_CREATE_ACTOR") + ": " + QObject::tr(exc.what()),
+ QObject::tr("BUT_OK"));
}
- if (aResActor)
- return aResActor;
+ QApplication::restoreOverrideCursor();
- anVISUActor = PublishInView( theModule, thePrs );
- return anVISUActor;
+ return aActor;
}
void
FindActor(SVTK_ViewWindow* theViewWindow,
const char* theEntry)
{
- using namespace VTK;
+ using namespace SVTK;
if(vtkRenderer* aRenderer = theViewWindow->getRenderer()){
if(vtkActorCollection* aCollection = aRenderer->GetActors()){
if(VISU_Actor* anActor = Find<VISU_Actor>(aCollection,TIsSameEntry<VISU_Actor>(theEntry))){
- return anActor->GetParent();
+ return anActor;
}
}
}
CORBA::String_var anEntry = aSObject->GetID();
try {
- thePrs->Update();
+ thePrs->UpdateActors();
+ } catch (std::runtime_error& exc) {
+ INFOS(exc.what());
+ QApplication::restoreOverrideCursor();
+ SUIT_MessageBox::warn1
+ (GetDesktop(theModule), QObject::tr("WRN_VISU"),
+ QObject::tr("ERR_CANT_BUILD_PRESENTATION") + ": " + QObject::tr(exc.what()),
+ QObject::tr("BUT_OK"));
- TViewWindows aViewWindows = GetViews(theModule);
- for (int i = 0, iEnd = aViewWindows.size(); i < iEnd; i++) {
- SVTK_ViewWindow* aView = aViewWindows[i];
- if (VISU_Actor* anActor = FindActor(aView, anEntry.in())) {
- thePrs->UpdateActor(anActor);
- }
+ thePrs->RemoveActors();
+ return;
+ }
+ QApplication::restoreOverrideCursor();
+ }
+
+ static bool ComputeVisiblePropBounds(SVTK_ViewWindow* theViewWindow,
+ float allBounds[6],
+ const char* theActorClassName = "VISU_Actor")
+ {
+ vtkRenderer *aRen = theViewWindow->getRenderer();
+ vtkActorCollection *anActColl = aRen->GetActors();
+ vtkProp *prop;
+ float *bounds;
+ int somethingVisible = false;
+
+ allBounds[0] = allBounds[2] = allBounds[4] = VTK_LARGE_FLOAT;
+ allBounds[1] = allBounds[3] = allBounds[5] = -VTK_LARGE_FLOAT;
+ // loop through all props
+ for (anActColl->InitTraversal(); (prop = anActColl->GetNextProp()); ) {
+ // if it's invisible, or has no geometry, we can skip the rest
+ if (prop->GetVisibility() && prop->IsA(theActorClassName)) {
+ bounds = prop->GetBounds();
+ // make sure we haven't got bogus bounds
+ if (bounds != NULL &&
+ bounds[0] > -VTK_LARGE_FLOAT && bounds[1] < VTK_LARGE_FLOAT &&
+ bounds[2] > -VTK_LARGE_FLOAT && bounds[3] < VTK_LARGE_FLOAT &&
+ bounds[4] > -VTK_LARGE_FLOAT && bounds[5] < VTK_LARGE_FLOAT)
+ {
+ somethingVisible = true;
+ if (bounds[0] < allBounds[0]) allBounds[0] = bounds[0];
+ if (bounds[1] > allBounds[1]) allBounds[1] = bounds[1];
+ if (bounds[2] < allBounds[2]) allBounds[2] = bounds[2];
+ if (bounds[3] > allBounds[3]) allBounds[3] = bounds[3];
+ if (bounds[4] < allBounds[4]) allBounds[4] = bounds[4];
+ if (bounds[5] > allBounds[5]) allBounds[5] = bounds[5];
+ }//not bogus
}
- } catch (std::runtime_error& ex) {
- INFOS(ex.what());
- QApplication::restoreOverrideCursor();
- SUIT_MessageBox::warn1 (GetDesktop(theModule), QObject::tr("WRN_VISU"),
- QObject::tr("ERR_CANT_BUILD_PRESENTATION") + " " + QObject::tr(ex.what()),
- QObject::tr("BUT_OK"));
+ }
+ return somethingVisible;
+ }
- TViewWindows aViewWindows = GetViews(theModule);
- for (int i = 0, iEnd = aViewWindows.size(); i < iEnd; i++) {
- SVTK_ViewWindow* aView = aViewWindows[i];
- if (VISU_Actor* anActor = FindActor(aView, anEntry.in())) {
- aView->RemoveActor(anActor);
- anActor->Delete();
+ void SetFitAll(SVTK_ViewWindow* theViewWindow)
+ {
+ static float PRECISION = 0.000001;
+ static float DEVIATION = 600;
+ float XYZ_Bnd[6];
+ if (!ComputeVisiblePropBounds(theViewWindow, XYZ_Bnd)) return;
+
+ float absX = XYZ_Bnd[1] - XYZ_Bnd[0];
+ float absY = XYZ_Bnd[3] - XYZ_Bnd[2];
+ float absZ = XYZ_Bnd[5] - XYZ_Bnd[4];
+
+ enum CameraOrient {e3D, eFront, eLeft, eTop};
+ CameraOrient aCameraOrient = e3D;
+ if (absX <= PRECISION) aCameraOrient = eFront;
+ else {
+ if (absY <= PRECISION) aCameraOrient = eLeft;
+ else {
+ if (absZ <= PRECISION) aCameraOrient = eTop;
+ else {
+ // all the three dimensions exceeds precision
+ float dev_abs_XY = absX / absY;
+ float dev_abs_YZ = absY / absZ;
+ float dev_abs_XZ = absX / absZ;
+ if (dev_abs_XY >= DEVIATION || 1./dev_abs_YZ >= DEVIATION)
+ aCameraOrient = eLeft;
+ else {
+ if (1./dev_abs_XY >= DEVIATION || 1./dev_abs_XZ >= DEVIATION)
+ aCameraOrient = eFront;
+ else {
+ if (dev_abs_XZ >= DEVIATION || dev_abs_YZ >= DEVIATION)
+ aCameraOrient = eTop;
+ }
+ }
}
}
- return;
}
- QApplication::restoreOverrideCursor();
+
+ switch (aCameraOrient) {
+ case eFront: theViewWindow->onFrontView(); break;
+ case eLeft: theViewWindow->onLeftView(); break;
+ case eTop: theViewWindow->onTopView(); break;
+ case e3D: theViewWindow->onResetView(); break;
+ }
+ theViewWindow->getRenderer()->ResetCameraClippingRange();
+ theViewWindow->onFitAll();
}
//************************************************************
int theDisplaying)
{
if ( theDisplaying == VISU::eErase ) {
- if ( plotCurve )
+ if ( plotCurve && aPlot )
aPlot->eraseCurve( plotCurve, false );
}
else if ( theDisplaying == VISU::eDisplay || theDisplaying == VISU::eDisplayOnly ) {
plotCurve->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) );
}
plotCurve->setAutoAssign( theCurve->IsAuto() );
- aPlot->displayCurve( plotCurve, false );
+ if( aPlot )
+ aPlot->displayCurve( plotCurve, false );
}
else {
Plot2d_Curve* crv = theCurve->CreatePresentation();
if ( crv ) {
- aPlot->displayCurve( crv, false );
+ if( aPlot )
+ aPlot->displayCurve( crv, false );
theCurve->SetLine( (VISU::Curve::LineType)crv->getLine(), crv->getLineWidth() );
theCurve->SetMarker( (VISU::Curve::MarkerType)crv->getMarker());
SALOMEDS::Color newColor;
}
}
}
- //theModule->updateObjBrowser();
PlotContainer( theModule, pContainer, VISU::eDisplay );
+
+ QString anEntry = pContainer->GetEntry();
+ _PTR(Study) aStudy = theTableSO->GetStudy();
+ _PTR(SObject) aContainerSO = aStudy->FindObjectID(anEntry.latin1());
+ _PTR(SObject) aParentSO = aContainerSO->GetFather();
+ UpdateObjBrowser(theModule,true,aParentSO);
}
}
}
// Others
void CreateMesh (const SalomeApp_Module* theModule,
- const Handle(SALOME_InteractiveObject)& theIO)
+ const Handle(SALOME_InteractiveObject)& theIO,
+ SVTK_ViewWindow* theViewWindow)
{
_PTR(Study) aStudy = GetCStudy(GetAppStudy(theModule));
//if (CheckLock(aStudy))
timer.Show();
#endif
- QApplication::restoreOverrideCursor();
+ //QApplication::restoreOverrideCursor();
VISU::Mesh_i* pPresent = NULL;
if (!CORBA::is_nil(aMesh))
pPresent = dynamic_cast<VISU::Mesh_i*>(VISU::GetServant(aMesh).in());
return;
}
- if (SVTK_ViewWindow* aView = GetViewWindow(theModule)) {
+ if (theViewWindow) {
try {
#ifdef CHECKTIME
Utils_Timer timer;
timer.Start();
#endif
- PublishInView(theModule, pPresent);
- aView->onFitAll();
+ PublishMeshInView(theModule, pPresent, theViewWindow);
+ SetFitAll(theViewWindow);
#ifdef CHECKTIME
timer.Stop();
MESSAGE("VisuGUI::CreateMesh() - DISPLAY MESH");
timer.Show();
#endif
- theModule->application()->putInfo(QObject::tr("INF_DONE"));
} catch (std::runtime_error& exc) {
INFOS(exc.what());
- SUIT_MessageBox::warn1 (GetDesktop(theModule),
- QObject::tr("WRN_VISU"),
- QObject::tr("ERR_CANT_CREATE_ACTOR") + " " + QObject::tr(exc.what()),
- QObject::tr("BUT_OK"));
+ SUIT_MessageBox::warn1
+ (GetDesktop(theModule), QObject::tr("WRN_VISU"),
+ QObject::tr("ERR_CANT_CREATE_ACTOR") + ": " + QObject::tr(exc.what()),
+ QObject::tr("BUT_OK"));
}
}
+
+ theModule->application()->putInfo(QObject::tr("INF_DONE"));
+ // Make "Save" button active
+ theModule->getApp()->updateActions();
}
// ========================================================================================
case VISU::TVECTORS:
case VISU::TSTREAMLINES:
case VISU::TPLOT3D:
+ case VISU::TSCALARMAPONDEFORMEDSHAPE:
{
PortableServer::ServantBase_var aServant = VISU::GetServant(aCORBAObject);
if (aServant.in()) {
}
return aList;
}
+
+ int GetFreePositionOfDefaultScalarBar(VisuGUI* theModule, SVTK_ViewWindow* theViewWindow)
+ {
+ int minIndx = 1;
+ std::set<int> aIndexes;
+ TViewToPrs3d aMap = theModule->getScalarBarsMap();
+ TViewToPrs3d::const_iterator aViewToPrsIter = aMap.find(theViewWindow);
+ if (aViewToPrsIter != aMap.end()) {
+ TSetPrs3d::const_iterator aPrsIter = (aViewToPrsIter->second).begin();
+ for (; aPrsIter != (aViewToPrsIter->second).end(); aPrsIter++) {
+ aIndexes.insert((*aPrsIter).second);
+ }
+ }
+ std::set<int>::const_iterator aIter = aIndexes.begin();
+ for (int i = 1,length = aIndexes.size(); i <= length; i++) {
+ std::set<int>::const_iterator aIter = aIndexes.find(i);
+ if (aIter == aIndexes.end()) { minIndx = i; break; }
+ else minIndx = i + 1;
+ }
+ return minIndx;
+ }
+
+ void AddScalarBarPosition (VisuGUI* theModule, SVTK_ViewWindow* theViewWindow,
+ VISU::Prs3d_i* thePrs3d, int pos)
+ {
+ TViewToPrs3d& aMap = theModule->myScalarBarsMap;
+ TPrs3dToInd aPair; aPair.first = thePrs3d; aPair.second = pos;
+ aMap[theViewWindow].insert(aPair);
+ }
+
+ void RemoveScalarBarPosition(VisuGUI* theModule, SVTK_ViewWindow* theViewWindow,
+ VISU::Prs3d_i* thePrs3d)
+ {
+ TViewToPrs3d& aMap = theModule->myScalarBarsMap;
+ TSetPrs3d::iterator aIter = aMap[theViewWindow].begin();
+ for (; aIter != aMap[theViewWindow].end(); aIter++)
+ if ((*aIter).first == thePrs3d) {
+ aMap[theViewWindow].erase(*aIter);
+ return;
+ }
+ }
}
