X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FVISUGUI%2FVisuGUI_Tools.cxx;h=43991c9bcb8e6acfb098e1a0112ee8dcad7dc013;hb=911740bb49d7cdc4ce077b51f0c60674e99d8e11;hp=2b7f006998ff7474143f1193dd41a6d4f7d6ab8c;hpb=6cc55b3076170b189df8eda82770a5aba7e88987;p=modules%2Fvisu.git diff --git a/src/VISUGUI/VisuGUI_Tools.cxx b/src/VISUGUI/VisuGUI_Tools.cxx index 2b7f0069..43991c9b 100644 --- a/src/VISUGUI/VisuGUI_Tools.cxx +++ b/src/VISUGUI/VisuGUI_Tools.cxx @@ -1,681 +1,1399 @@ -// VISU VISUGUI : GUI of VISU component -// -// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// 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. +// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// 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. // -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + +// VISU VISUGUI : GUI of VISU component // File : VisuGUI_Tools.cxx // Author : Sergey Anikin // Module : VISU - #include "VisuGUI_Tools.h" +#include "VisuGUI_ViewTools.h" +#include "VisuGUI_Prs3dTools.h" +#include "VisuGUI_DialogRunner.h" + +#include "VisuGUI.h" + +#include "VISU_Tools.h" +#include "VISU_ColoredPrs3dHolder_i.hh" #include "VISU_Gen_i.hh" #include "VISU_Prs3d_i.hh" #include "VISU_Result_i.hh" #include "VISU_Table_i.hh" +//#include "VISU_Mesh_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 "SalomeApp_IntSpinBox.h" +#include "SalomeApp_DoubleSpinBox.h" + +#include "LightApp_DataObject.h" +#include "LightApp_SelectionMgr.h" + +//TODO +//#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" #include "SPlot2d_ViewModel.h" #include "Plot2d_ViewFrame.h" +#include "Plot2d_ViewManager.h" #include "SUIT_Session.h" #include "SUIT_MessageBox.h" +#include "SUIT_Desktop.h" +#include "SUIT_ViewWindow.h" +#include "SUIT_ResourceMgr.h" + +#include "CAM_DataModel.h" #include #include +#include +#include +#include +#include + +using namespace std; //============================================================================= namespace VISU { + //------------------------------------------------------------ SUIT_Desktop* GetDesktop(const CAM_Module* theModule) { - return theModule->application()->desktop(); + return theModule && theModule->application() ? theModule->application()->desktop() : 0; } - SalomeApp_SelectionMgr* + //------------------------------------------------------------ + LightApp_SelectionMgr* GetSelectionMgr(const SalomeApp_Module* theModule) { - return theModule->getApp()->selectionMgr(); + return theModule && theModule->getApp() ? theModule->getApp()->selectionMgr() : 0; } + //------------------------------------------------------------ SalomeApp_Study* GetAppStudy(const CAM_Module* theModule) { - return - dynamic_cast(theModule->application()->activeStudy()); + return theModule && theModule->application() ? + dynamic_cast(theModule->application()->activeStudy()) : 0; } + //------------------------------------------------------------ _PTR(Study) GetCStudy(const SalomeApp_Study* theStudy) { - return theStudy->studyDS(); + return theStudy ? theStudy->studyDS() : _PTR(Study)(); } - SALOMEDS::StudyManager_var - GetStudyManager() + //------------------------------------------------------------ + bool + IsStudyLocked( _PTR(Study) theStudy ) { - static SALOMEDS::StudyManager_var aStudyManager; - if(CORBA::is_nil(aStudyManager)){ - SALOME_NamingService *aNamingService = SalomeApp_Application::namingService(); - CORBA::Object_var anObject = aNamingService->Resolve("/myStudyManager"); - aStudyManager = SALOMEDS::StudyManager::_narrow(anObject); - } - return aStudyManager; + return theStudy ? theStudy->GetProperties()->IsLocked() : true; } + //------------------------------------------------------------ bool - IsStudyLocked( _PTR(Study) theStudy ) + CheckLock( _PTR(Study) theStudy, + QWidget* theWidget ) { - if( theStudy ) - return theStudy->GetProperties()->IsLocked(); - return true; + if(IsStudyLocked(theStudy)){ + SUIT_MessageBox::warning(theWidget, + QObject::tr("WRN_VISU_WARNING"), + QObject::tr("WRN_STUDY_LOCKED") ); + return true; + } + return false; + } + + //------------------------------------------------------------ + int + runAndWait( QDialog* dlg, const bool modal ) + { + VisuGUI_DialogRunner r( dlg ); + return r.run( modal ); + } + + //------------------------------------------------------------ + 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); + DataObjectList::Iterator aDataObjectIter = aList.begin(); + while( aDataObjectIter!= aList.end() ) { + if(LightApp_DataObject* aChildDataObject = dynamic_cast(*aDataObjectIter)){ + 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(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 - CheckLock( _PTR(Study) theStudy ) + 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; } + //------------------------------------------------------------ VISU_Gen_i* GetVisuGen(const CAM_Module* theModule) { - static VISU_Gen_i* aGen = NULL; + static VISU_Gen_i* aGen = 0; if(!aGen){ SALOME_LifeCycleCORBA aLCC(SalomeApp_Application::namingService()); - Engines::Component_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","VISU"); + Engines::EngineComponent_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","VISU"); VISU_Gen_var aVISU = VISU_Gen::_narrow(aComponent); - if(!CORBA::is_nil(aVISU)){ - aGen = VISU_Gen_i::GetVisuGenImpl(); - aGen->SetCurrentStudy(GetDSStudy(GetCStudy(GetAppStudy(theModule)))); - } + if(!CORBA::is_nil(aVISU)) + aGen = VISU_Gen_i::GetVisuGenImpl(); } - if(!aGen) - throw std::runtime_error(QObject::tr("ERR_CANT_FIND_VISU_COMPONENT").latin1()); + + if(aGen) + aGen->SetCurrentStudy(GetDSStudy(GetCStudy(GetAppStudy(theModule)))); + else + throw std::runtime_error(QObject::tr("ERR_CANT_FIND_VISU_COMPONENT").toLatin1().data()); return aGen; } +#ifdef WITH_MEDGEN + //------------------------------------------------------------ SALOME_MED::MED_Gen_var GetMEDEngine() { static SALOME_MED::MED_Gen_var aGen; if(CORBA::is_nil(aGen)){ SALOME_LifeCycleCORBA aLCC(SalomeApp_Application::namingService()); - Engines::Component_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","MED"); + Engines::EngineComponent_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","MED"); aGen = SALOME_MED::MED_Gen::_narrow(aComponent); } if(CORBA::is_nil(aGen)) - throw std::runtime_error(QObject::tr("ERR_CANT_FIND_MED_COMPONENT").latin1()); + throw std::runtime_error(QObject::tr("ERR_CANT_FIND_MED_COMPONENT").toLatin1().data()); return aGen; } +#endif // WITH_MEDGEN + + //---------------------------------------------------------------------------- + // Selection + TSelectionInfo + GetSelectedObjects(const SalomeApp_Module* theModule) + { + TSelectionInfo aSelectionInfo; + const SalomeApp_Study* aStudy = GetAppStudy(theModule); + LightApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule); + if ( aStudy && aSelectionMgr ) { + SALOME_ListIO aListIO; + aSelectionMgr->selectedObjects(aListIO); + SALOME_ListIteratorOfListIO anIter(aListIO); + while(anIter.More()) + { + Handle(SALOME_InteractiveObject) anIO = anIter.Value(); + if(anIO->hasEntry()) + { + TObjectInfo anObjectInfo = GetObjectByEntry(aStudy, anIO->getEntry()); + if(anObjectInfo.mySObject){ + TSelectionItem aSelectionItem; + aSelectionItem.myObjectInfo = anObjectInfo; + aSelectionItem.myIO = anIO; + aSelectionInfo.push_back(aSelectionItem); + } + } + anIter.Next(); // MULTIPR fixed + } + } + return aSelectionInfo; + } + + //---------------------------------------------------------------------------- + TObjectInfo + GetObjectByEntry(const SalomeApp_Study* theStudy, + const std::string& theEntry) + { + TObjectInfo anObjectInfo; + if(!theStudy || theEntry == "") + return anObjectInfo; + + _PTR(Study) aStudy = GetCStudy(theStudy); + if(_PTR(SObject) aSObject = aStudy->FindObjectID(theEntry)){ + anObjectInfo.mySObject = aSObject; + CORBA::Object_var anObject = ClientSObjectToObject(aSObject); + if(VISU::Base_i* aBase = GetServantInterface(anObject)) + anObjectInfo.myBase = aBase; + } + + return anObjectInfo; + } + + + //---------------------------------------------------------------------------- + VISU::Prs3d_i* + GetPrs3dToModify(const SalomeApp_Module* theModule, + Base_i* theBase) + { + if (CheckLock(GetCStudy(GetAppStudy(theModule)), GetDesktop(theModule))) + return NULL; + + return GetPrs3dFromBase(theBase); + } + + //---------------------------------------------------------------------------- + VISU::Prs3d_i* + GetPrs3dFromBase(Base_i* theBase) + { + if(theBase && theBase->GetType() == VISU::TCOLOREDPRS3DHOLDER){ + CORBA::Object_var anObject = theBase->_this(); + VISU::ColoredPrs3dHolder_var aHolder = VISU::ColoredPrs3dHolder::_narrow(anObject); + VISU::Prs3d_var aPrs3d = aHolder->GetDevice(); + return VISU::GetServantInterface(aPrs3d); + } + return dynamic_cast(theBase); + } + + + //---------------------------------------------------------------------------- + bool + GetPrs3dSelectionInfo(const SalomeApp_Module* theModule, + VISU::Prs3d_i*& thePrs3d, + SVTK_ViewWindow*& theViewWindow, + VISU_Actor*& thenActor) + { + VISU::TSelectionInfo aSelectionInfo = VISU::GetSelectedObjects(theModule); + if(aSelectionInfo.empty()) + return false; + + VISU::TSelectionItem aSelectionItem = aSelectionInfo.front(); + thePrs3d = GetPrs3dFromBase(aSelectionItem.myObjectInfo.myBase); + if(!thePrs3d) + return false; + + theViewWindow = GetActiveViewWindow(theModule); + if(!theViewWindow) + return false; + + thenActor = FindActor(theViewWindow, thePrs3d); + if(!thenActor) + return false; + + return true; + } + + + //---------------------------------------------------------------------------- + void + Add(LightApp_SelectionMgr* theSelectionMgr, + const Handle(SALOME_InteractiveObject)& theIO) + { + SALOME_ListIO aListIO; + theSelectionMgr->selectedObjects(aListIO); + aListIO.Append(theIO); + theSelectionMgr->setSelectedObjects(aListIO); + } - CORBA::Object_var - GetSelectedObj(const SalomeApp_Study* theStudy, - const QString& theEntry, - VISU::Storable::TRestoringMap* theMap) + //------------------------------------------------------------ + void + Remove(LightApp_SelectionMgr* theSelectionMgr, + const Handle(SALOME_InteractiveObject)& theIO) { - if ( !theStudy || theEntry.isEmpty() ) - return CORBA::Object::_nil(); + if (theIO.IsNull()) return; + SALOME_ListIO aListIO, aNewListIO; + theSelectionMgr->selectedObjects(aListIO); + SALOME_ListIteratorOfListIO anIter (aListIO); + for (; anIter.More(); anIter.Next()) { + Handle(SALOME_InteractiveObject) anIO = anIter.Value(); + if (!anIO->isSame(theIO)) { + aNewListIO.Append(theIO); + } + } + theSelectionMgr->setSelectedObjects(aNewListIO); + } - SALOMEDS::Study_var aStudy = GetDSStudy(GetCStudy( theStudy )); - SALOMEDS::SObject_var aSObject = aStudy->FindObjectID( theEntry.latin1() ); - if(!aSObject->_is_nil()){ - SALOMEDS::GenericAttribute_var anAttr; - if(theMap && aSObject->FindAttribute(anAttr,"AttributeComment")){ - SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr); - std::string aValue = aComment->Value(); - QString aString(aValue.c_str()); - VISU::Storable::StrToMap(aString,*theMap); + /*! + * \brief Check, if the object can be deleted + * + * \param theEntry - entry of the object to check + * \param theModule - is used to access Study and VISU_Gen + * \retval bool - returns TRUE if the object is removable + */ + bool + IsRemovable (const std::string theEntry, + const SalomeApp_Module* theModule) + { + // asv : if selected object is a Save Point object selected in object browser - return false + if ( QString( theEntry.c_str() ).startsWith( QObject::tr( "SAVE_POINT_DEF_NAME" ) ) ) + return false; + + _PTR(Study) aStudy = GetCStudy(GetAppStudy(theModule)); + + _PTR(SObject) aSObject = aStudy->FindObjectID(theEntry); + VISU::Storable::TRestoringMap pMap; + if (aSObject) { + CORBA::Object_var aCORBAObject = VISU::ClientSObjectToObject(aSObject); + if (!CORBA::is_nil(aCORBAObject)) { + VISU::RemovableObject_var aRemovableObj = VISU::RemovableObject::_narrow(aCORBAObject); + if (CORBA::is_nil(aRemovableObj)) { + // Not removable CORBA object + return false; + } + } else { + // Can be removed, if lays directly under VISU + // (first sub-level) or is a child of such an object + string aNAME, aVisuNAME = GetVisuGen(theModule)->ComponentDataType(); + _PTR(GenericAttribute) anAttr; + _PTR(AttributeString) aComment; + + _PTR(SObject) aRefSObject; + if (aSObject->ReferencedObject(aRefSObject)) { + // It can be a reference on curve, published under a container. IPAL 20317 + VISU::TObjectInfo aRefObjectInfo = GetObjectByEntry(GetAppStudy(theModule), aRefSObject->GetID()); + VISU::Base_i* aRefBase = aRefObjectInfo.myBase; + if( (aRefBase && aRefBase->GetType() == VISU::TCURVE) || (aRefBase && aRefBase->GetType() == VISU::TMESH) ) + return true; + } + + bool isUnderVISU = false; + _PTR(SObject) aFatherSObject = aSObject->GetFather(); + if (aFatherSObject->FindAttribute(anAttr, "AttributeName")) { + // mkr : 24.11.2006 : use AttributeName and module title for correct "Delete" + // popup item displaying in object browser popup + _PTR(AttributeName) aComment (anAttr); + aNAME = aComment->Value(); + QString aVisuTITLE = theModule->getApp()->moduleTitle(aVisuNAME.c_str()); + if (!aVisuTITLE.compare(aNAME.c_str())) { + isUnderVISU = true; + } + } + if (!isUnderVISU) { + // Not directly under VISU component, check father + aCORBAObject = VISU::ClientSObjectToObject(aFatherSObject); + if (!CORBA::is_nil(aCORBAObject)) { + // Father has IOR + return false; + } + + isUnderVISU = false; + aFatherSObject = aFatherSObject->GetFather(); + if (aFatherSObject->FindAttribute(anAttr, "AttributeString")) { + _PTR(AttributeString) aComment (anAttr); + aNAME = aComment->Value(); + if (aNAME == aVisuNAME) { + isUnderVISU = true; + } + } + if (!isUnderVISU) { + // Father is not directly under VISU component + return false; + } + } } - return VISU::SObjectToObject(aSObject); } - return CORBA::Object::_nil(); + return true; } - CORBA::Object_var - GetSelectedObj(const SalomeApp_Module* theModule, - Handle(SALOME_InteractiveObject)* theIO, - VISU::Storable::TRestoringMap* theMap) + /*! + * \brief Check, if "Delete" popup-menu can be put on current selection + * + * \param theModule - is used to access SelectionManager, Study and VISU_Gen + * \retval bool - returns TRUE if all currently selected objects are removable + */ + bool + IsRemovableSelected (const SalomeApp_Module* theModule) { - SalomeApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule); + LightApp_SelectionMgr* aSelectionMgr = GetSelectionMgr(theModule); SALOME_ListIO aListIO; aSelectionMgr->selectedObjects(aListIO); - SALOME_ListIteratorOfListIO anIter(aListIO); - if(anIter.More()){ + + if (aListIO.Extent() < 1) + return false; + + _PTR(Study) aStudy = GetCStudy(GetAppStudy(theModule)); + if (!aStudy) return false; + + SALOME_ListIteratorOfListIO anIter (aListIO); + for (; anIter.More(); anIter.Next()) { Handle(SALOME_InteractiveObject) anIO = anIter.Value(); - if(theIO) - *theIO = anIO; - if(anIO->hasEntry()) - return GetSelectedObj( GetAppStudy(theModule), anIO->getEntry(), theMap ); + if (anIO->hasEntry()) { + if (!IsRemovable(anIO->getEntry(), theModule)) + return false; + } } - return CORBA::Object::_nil(); + return true; } - VISU::Storable::TRestoringMap - getMapOfValue(SALOMEDS::SObject_var theSObject) + //------------------------------------------------------------ + void + DeleteSObject(VisuGUI* theModule, + _PTR(Study) theStudy, + _PTR(SObject) theSObject) { - VISU::Storable::TRestoringMap aMap; - if(!theSObject->_is_nil()){ - SALOMEDS::GenericAttribute_var anAttr; - if (theSObject->FindAttribute(anAttr, "AttributeComment")) { - SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr); - CORBA::String_var aValue = aComment->Value(); - QString aString(aValue.in()); - VISU::Storable::StrToMap(aString,aMap); + _PTR(ChildIterator) aChildIter = theStudy->NewChildIterator(theSObject); + for (aChildIter->InitEx(true); aChildIter->More(); aChildIter->Next()) { + _PTR(SObject) aSObject = aChildIter->Value(); + TObjectInfo anObjectInfo = GetObjectByEntry(GetAppStudy(theModule), aSObject->GetID()); + ErasePrs(theModule, anObjectInfo.myBase, /*repaint_view_window = */false); + } + + TObjectInfo anObjectInfo = GetObjectByEntry(GetAppStudy(theModule), theSObject->GetID()); + if(anObjectInfo.myBase){ + ErasePrs(theModule, anObjectInfo.myBase, /*repaint_view_window = */true); + + CORBA::Object_var anObject = ClientSObjectToObject(theSObject); + VISU::RemovableObject_var aRemovableObject = VISU::RemovableObject::_narrow(anObject); + 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 UnRegister() sub-objects } - return aMap; } - QString - getValue(SALOMEDS::SObject_var theSObject, - QString theKey) + //------------------------------------------------------------ + void + DeletePrs3d(VisuGUI* theModule, + VISU::Prs3d_i* thePrs) { - QString aStr(""); - VISU::Storable::TRestoringMap aMap = getMapOfValue(theSObject); - if(!aMap.empty()) - aStr = VISU::Storable::FindValue(aMap,theKey.latin1()); - return aStr; + if (!thePrs) + return; + + if (CheckLock(GetCStudy(GetAppStudy(theModule)),GetDesktop(theModule))) + return; + + if(SVTK_ViewWindow* aViewWindow = GetActiveViewWindow(theModule)) + RemoveScalarBarPosition(theModule, aViewWindow, thePrs); + + if(VISU::ColoredPrs3d_i* aColoredPrs3d = dynamic_cast(thePrs)){ + std::string anEntry = aColoredPrs3d->GetHolderEntry(); + if(anEntry != ""){ + VISU::TObjectInfo anObjectInfo = VISU::GetObjectByEntry(GetAppStudy(theModule), anEntry); + if(VISU::Base_i* aBase = anObjectInfo.myBase){ + if(aBase->GetType() == VISU::TCOLOREDPRS3DHOLDER){ + CORBA::Object_var anObject = aBase->_this(); + VISU::RemovableObject_var aRemovableObject = VISU::RemovableObject::_narrow(anObject); + aRemovableObject->RemoveFromStudy(); + return; + } + } + } + } + + thePrs->RemoveFromStudy(); } - VISU::Storable::TRestoringMap getMapOfValue (_PTR(SObject) theSObject) + //------------------------------------------------------------ + // Presentation management + void + ChangeRepresentation (const SalomeApp_Module* theModule, + VISU::PresentationType theType) { - VISU::Storable::TRestoringMap aMap; - if (theSObject) { - _PTR(GenericAttribute) anAttr; - if (theSObject->FindAttribute(anAttr, "AttributeComment")) { - _PTR(AttributeComment) aComment (anAttr); - std::string aValue = aComment->Value(); - QString aString (aValue.c_str()); - VISU::Storable::StrToMap(aString, aMap); + TSelectionInfo aSelectionInfo = GetSelectedObjects(theModule); + if(aSelectionInfo.empty()) + return; + + VISU::Prs3d_i* aPrs3d; + VISU::PointMap3d_i* aTable; + VISU_Actor* anActor; + VISU_ActorBase* anActorBase; + + TSelectionItem aSelectionItem = aSelectionInfo.front(); + aPrs3d = GetPrs3dFromBase(aSelectionItem.myObjectInfo.myBase); + if(!aPrs3d) { + aTable = dynamic_cast(aSelectionItem.myObjectInfo.myBase); + if(!aTable) + return; + } + + SVTK_ViewWindow* aViewWindow = GetActiveViewWindow(theModule); + if(!aViewWindow) + return; + + if (aPrs3d) { + anActor = FindActor(aViewWindow, aPrs3d); + if(!anActor) + return; + } else { + anActorBase = VISU::FindActorBase(aViewWindow, aTable); + if(!anActorBase) + return; + } + + switch (theType) { + case VISU::SHRINK: + if (aPrs3d) { + bool toShrink; + if (anActor->IsShrunk()) { + anActor->UnShrink(); + toShrink = false; + } + else { + anActor->SetShrink(); + toShrink = true; + } + if (VISU::Mesh_i* aMesh = dynamic_cast(aPrs3d)) { + aMesh->SetShrink(toShrink); + } + } else if (aTable) { + if (anActorBase->IsShrunk()) + anActorBase->UnShrink(); + else + anActorBase->SetShrink(); + } + break; + default: + if (aPrs3d) { + if (VISU::Mesh_i* aMesh = dynamic_cast(aPrs3d)) { + aMesh->SetPresentationType(theType); + RecreateActor(theModule, aMesh); + } else { + anActor->SetRepresentation(theType); + } + } + else if (aTable) { + anActorBase->SetRepresentation(theType); } } - return aMap; + aViewWindow->Repaint(); } - QString getValue (_PTR(SObject) theSObject, QString theKey) + + void ChangeQuadratic2DRepresentation (const SalomeApp_Module* theModule, + VISU::Quadratic2DPresentationType theType) { - QString aStr(""); - VISU::Storable::TRestoringMap aMap = getMapOfValue(theSObject); - if (!aMap.empty()) - aStr = VISU::Storable::FindValue(aMap, theKey.latin1()); - return aStr; + TSelectionInfo aSelectionInfo = GetSelectedObjects(theModule); + if(aSelectionInfo.empty()) + return; + + TSelectionItem aSelectionItem = aSelectionInfo.front(); + + VISU::Prs3d_i* aPrs3d = GetPrs3dFromBase(aSelectionItem.myObjectInfo.myBase); + + SVTK_ViewWindow* aViewWindow = GetActiveViewWindow(theModule); + + if(!aPrs3d || !aViewWindow) + return; + + VISU_Actor *anActor = FindActor(aViewWindow, aPrs3d); + if(!anActor) + return; + + if (VISU::Mesh_i* aMesh = dynamic_cast(aPrs3d)) { + aMesh->SetQuadratic2DPresentationType(theType); + RecreateActor(theModule, aMesh); + } else { + switch(theType){ + case VISU::LINES: + anActor->SetQuadratic2DRepresentation(VISU_Actor::eLines); + break; + case VISU::ARCS: + anActor->SetQuadratic2DRepresentation(VISU_Actor::eArcs); + break; + default: + break; + } + } } + //------------------------------------------------------------ + void + SetShading ( const SalomeApp_Module* theModule, + bool theOn ) + { + TSelectionInfo aSelectionInfo = GetSelectedObjects(theModule); + if(aSelectionInfo.empty()) + return; + TSelectionItem aSelectionItem = GetSelectedObjects(theModule).front(); + VISU::Prs3d_i* aPrs3d = GetPrs3dFromBase(aSelectionItem.myObjectInfo.myBase); + if(!aPrs3d) + return; + + SVTK_ViewWindow* aViewWindow = GetActiveViewWindow(theModule); + if(!aViewWindow) + return; + + VISU_Actor* anActor = FindActor(aViewWindow, aPrs3d); + if(!anActor) + return; + + if(VISU_ScalarMapAct* aScalarMapActor = dynamic_cast(anActor)){ + aScalarMapActor->SetShading(theOn); + aViewWindow->Repaint(); + } + } + + //------------------------------------------------------------ + // SObject type bool CheckTimeStamp(const SalomeApp_Module* theModule, - SALOMEDS::SObject_var& theSObject, - Handle(SALOME_InteractiveObject)* theIO) - { - Handle(SALOME_InteractiveObject) anIO; - CORBA::Object_var anObject = GetSelectedObj(theModule,&anIO); - if(theIO) - *theIO = anIO; - if(!anIO.IsNull() && anIO->hasEntry()){ - SALOMEDS::Study_var aStudy = GetDSStudy(GetCStudy(GetAppStudy(theModule))); - theSObject = aStudy->FindObjectID(anIO->getEntry()); - QString aValue = getValue(theSObject,"myType"); - if(aValue.toInt() == int(VISU::TTIMESTAMP)) - return true; - } - SUIT_MessageBox::warn1(GetDesktop(theModule), - QObject::tr("WRN_VISU"), - QObject::tr("WRN_NO_AVAILABLE_DATA"), - QObject::tr("BUT_OK") ); + _PTR(SObject)& theSObject, + Handle(SALOME_InteractiveObject)& theIO, + ColoredPrs3d_i::EPublishInStudyMode& thePublishInStudyMode) + { + TSelectionInfo aSelectionInfo = GetSelectedObjects(theModule); + if(!aSelectionInfo.empty()){ + TSelectionItem aSelectionItem = aSelectionInfo.front(); + theIO = aSelectionItem.myIO; + theSObject = aSelectionItem.myObjectInfo.mySObject; + VISU::VISUType aType = VISU::Storable::SObject2Type(theSObject); + if (VISU::TTIMESTAMP == aType){ + thePublishInStudyMode = ColoredPrs3d_i::EPublishUnderTimeStamp; + return true; + } + if (VISU::TFIELD == aType){ + thePublishInStudyMode = ColoredPrs3d_i::EPublishIndependently; + if(theSObject->FindSubObject(2,theSObject)) + return true; + } + } + SUIT_MessageBox::warning(GetDesktop(theModule), + QObject::tr("WRN_VISU"), + QObject::tr("WRN_NO_AVAILABLE_DATA") ); return false; } - + //------------------------------------------------------------ VISU::Result_i* CheckResult(const SalomeApp_Module* theModule, - SALOMEDS::SObject_var theSource, - VISU::Result_var& theResult) + _PTR(SObject) theSource, + VISU::Result_var& theResult) { - SALOMEDS::SObject_var aSObj; + if(theSource->Depth() < 3) // Bug of SALOMEDS : can\t get father from root object + return NULL; - aSObj = theSource->GetFather(); - if (CORBA::is_nil(aSObj)) + _PTR(SObject) aSObj = theSource->GetFather(); + if (!aSObj) return NULL; aSObj = aSObj->GetFather(); - if (CORBA::is_nil(aSObj)) + if (!aSObj) return NULL; aSObj = aSObj->GetFather(); - if (CORBA::is_nil(aSObj)) + if (!aSObj) return NULL; - CORBA::Object_var anObject = VISU::SObjectToObject(aSObj); + CORBA::Object_var anObject = VISU::ClientSObjectToObject(aSObj); if (CORBA::is_nil(anObject)) { aSObj = aSObj->GetFather(); - if (CORBA::is_nil(aSObj)) + if (!aSObj) return NULL; - anObject = VISU::SObjectToObject(aSObj); + anObject = VISU::ClientSObjectToObject(aSObj); } if (CORBA::is_nil(anObject)) return NULL; theResult = VISU::Result::_narrow(anObject); - VISU::Result_i* pResult = dynamic_cast(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; + return dynamic_cast(VISU::GetServant(anObject).in()); } - SVTK_ViewWindow* - GetViewWindow(const SalomeApp_Module* theModule) + //------------------------------------------------------------ + // VTK View + VISU_Actor* + PublishMeshInView(const SalomeApp_Module* theModule, + VISU::Prs3d_i* thePrs, + SVTK_ViewWindow* theViewWindow) { - if(SalomeApp_Application* anApp = theModule->getApp()){ - if(SUIT_ViewManager* aViewManager = anApp->getViewManager( SVTK_Viewer::Type(), true )){ - if(SUIT_ViewWindow* aViewWindow = aViewManager->getActiveView()){ - return dynamic_cast(aViewWindow); - } + VISU_Actor* anActor = NULL; + if (!thePrs || !theViewWindow) + return anActor; + + SalomeApp_Application *anApp = dynamic_cast(theModule->application()); + if(!anApp) + return anActor; + + SalomeApp_Study* aStudy = dynamic_cast(anApp->activeStudy()); + + if(!aStudy) + return anActor; + + + QApplication::setOverrideCursor( Qt::WaitCursor ); + try { + if ((anActor = thePrs->CreateActor())) { + theViewWindow->AddActor(anActor); + + if(anActor->hasIO() && anActor->getIO()->hasEntry()) + aStudy->setVisibilityState(anActor->getIO()->getEntry(), Qtx::ShownState); } + } catch(std::exception& exc) { + SUIT_MessageBox::warning + (GetDesktop(theModule), QObject::tr("WRN_VISU"), + QObject::tr("ERR_CANT_CREATE_ACTOR") + ": " + QObject::tr(exc.what()) ); } - return NULL; - } + QApplication::restoreOverrideCursor(); - SVTK_ViewWindow* - GetViewWindow() - { - SalomeApp_Application* anApp = dynamic_cast - (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(aViewWindow); - } - } - } - } - return NULL; + return anActor; } - TViewWindows - GetViews(const SalomeApp_Module* theModule) + //------------------------------------------------------------ + void + RepaintViewWindows (const SalomeApp_Module* theModule, + const Handle(SALOME_InteractiveObject)& theIObject) { TViewWindows aViewWindows; - if(SalomeApp_Application* anApp = theModule->getApp()){ + if (SalomeApp_Application* anApp = theModule->getApp()) { ViewManagerList aViewManagerList; anApp->viewManagers(SVTK_Viewer::Type(),aViewManagerList); - QPtrListIterator anIter(aViewManagerList); - while(SUIT_ViewManager* aViewManager = anIter.current()){ - QPtrVector 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(aViewWindow)) - aViewWindows.push_back(aView); - } - ++anIter; - } - } - return aViewWindows; - } - - VISU_Actor* - PublishInView(const SalomeApp_Module* theModule, - VISU::Prs3d_i* thePrs) - { - VISU_Actor* aActor = NULL; - if(!thePrs) - return aActor; - if(SVTK_ViewWindow* aView = GetViewWindow(theModule)){ - QApplication::setOverrideCursor( Qt::waitCursor ); - if(aActor = thePrs->CreateActor()){ - aView->AddActor(aActor); + QList::Iterator anIter = aViewManagerList.begin(); + while ( anIter != aViewManagerList.end() ) + { + QVector aViews = (*anIter)->getViews(); + for (int i = 0, iEnd = aViews.size(); i < iEnd; i++) { + if (SUIT_ViewWindow* aViewWindow = aViews.at(i)) { + if (SVTK_ViewWindow* vw = dynamic_cast(aViewWindow)) { + if (vw->isVisible(theIObject)) { + vw->getRenderer()->ResetCameraClippingRange(); + vw->Repaint(); + vw->highlight(theIObject, true, true); + } + } + } + } + anIter++; } - 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 { - } - } - if (aResActor) - return aResActor; - - anVISUActor = PublishInView( theModule, thePrs ); - return anVISUActor; } + //------------------------------------------------------------ VISU_Actor* - FindActor(SVTK_ViewWindow* theViewWindow, - const char* theEntry) - { - using namespace VTK; - if(vtkRenderer* aRenderer = theViewWindow->getRenderer()){ - if(vtkActorCollection* aCollection = aRenderer->GetActors()){ - if(VISU_Actor* anActor = Find(aCollection,TIsSameEntry(theEntry))){ - return anActor->GetParent(); - } - } - } - return NULL; - } - - VISU_Actor* - FindActor(SVTK_ViewWindow* theViewWindow, - VISU::Prs3d_i* thePrs) + FindActor(const SalomeApp_Study* theStudy, + SVTK_ViewWindow* theViewWindow, + const QString& theEntry) { - SALOMEDS::SObject_var aSObject = thePrs->GetSObject(); - CORBA::String_var anEntry = aSObject->GetID(); - return FindActor(theViewWindow,anEntry.in()); + TObjectInfo anObjectInfo = GetObjectByEntry(theStudy, theEntry.toLatin1().data()); + VISU::Prs3d_i* aPrs3d = GetPrs3dFromBase(anObjectInfo.myBase); + return FindActor(theViewWindow, aPrs3d); } - void - Add(SalomeApp_SelectionMgr* theSelectionMgr, - const Handle(SALOME_InteractiveObject)& theIO) + //------------------------------------------------------------ + VISU_ActorBase* + FindActorBase(const SalomeApp_Study* theStudy, + SVTK_ViewWindow* theViewWindow, + const QString& theEntry) { - SALOME_ListIO aListIO; - theSelectionMgr->selectedObjects(aListIO); - aListIO.Append(theIO); - theSelectionMgr->setSelectedObjects(aListIO); + TObjectInfo anObjectInfo = GetObjectByEntry(theStudy, theEntry.toLatin1().constData()); + VISU::PointMap3d_i* aTable = dynamic_cast(anObjectInfo.myBase); + return FindActorBase(theViewWindow, aTable); } + //------------------------------------------------------------ void - Remove(SalomeApp_SelectionMgr* theSelectionMgr, - const Handle(SALOME_InteractiveObject)& theIO) + RecreateActor (const SalomeApp_Module* theModule, + VISU::Prs3d_i* thePrs) { - if (theIO.IsNull()) return; - SALOME_ListIO aListIO, aNewListIO; - theSelectionMgr->selectedObjects(aListIO); - SALOME_ListIteratorOfListIO anIter (aListIO); - for (; anIter.More(); anIter.Next()) { - Handle(SALOME_InteractiveObject) anIO = anIter.Value(); - if (!anIO->isSame(theIO)) { - aNewListIO.Append(theIO); - } + QApplication::setOverrideCursor(Qt::WaitCursor); + + /* SALOMEDS::SObject_var aSObject = thePrs->GetSObject(); + CORBA::String_var anEntry = aSObject->GetID();*/ + + try { + thePrs->UpdateActors(); + } catch (std::runtime_error& exc) { + INFOS(exc.what()); + QApplication::restoreOverrideCursor(); + SUIT_MessageBox::warning + (GetDesktop(theModule), QObject::tr("WRN_VISU"), + QObject::tr("ERR_CANT_BUILD_PRESENTATION") + ": " + QObject::tr(exc.what()) ); + + thePrs->RemoveActors(); + return; } - theSelectionMgr->setSelectedObjects(aNewListIO); + QApplication::restoreOverrideCursor(); } - void - DeletePrs3d(SalomeApp_Module* theModule, - VISU::Prs3d_i* thePrs, - const Handle(SALOME_InteractiveObject)& theIO) + //------------------------------------------------------------ + bool + ComputeVisiblePropBounds(SVTK_ViewWindow* theViewWindow, + double allBounds[6], + const char* theActorClassName) { - if(!thePrs) - return; - if(CheckLock(GetCStudy(GetAppStudy(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(); + vtkRenderer *aRen = theViewWindow->getRenderer(); + VTK::ActorCollectionCopy aCopy(aRen->GetActors()); + vtkActorCollection *anActColl = aCopy.GetActors(); + vtkProp *prop; + double *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 } } - thePrs->RemoveFromStudy(); - theModule->updateObjBrowser(); //update Object browser + return somethingVisible; } - void - ErasePrs3d(SalomeApp_Module* theModule, - VISU::Prs3d_i* thePrs) + //------------------------------------------------------------ + void SetFitAll(SVTK_ViewWindow* theViewWindow) { - if ( SVTK_ViewWindow* vw = GetViewWindow( theModule ) ){ - VISU_Actor* anVISUActor = FindActor( vw, thePrs ); - if (anVISUActor) { - anVISUActor->VisibilityOff(); + static double PRECISION = 0.000001; + static double DEVIATION = 600; + double XYZ_Bnd[6]; + if (!ComputeVisiblePropBounds(theViewWindow, XYZ_Bnd)) return; + + double absX = XYZ_Bnd[1] - XYZ_Bnd[0]; + double absY = XYZ_Bnd[3] - XYZ_Bnd[2]; + double 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 + double dev_abs_XY = absX / absY; + double dev_abs_YZ = absY / absZ; + double 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; + } + } + } } } + + 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(); } + //************************************************************ + // Plot2d View + SPlot2d_Viewer* - GetPlot2dViewer(const SalomeApp_Module* theModule) + GetPlot2dViewer(const SalomeApp_Module* theModule, const bool theCreate) { if(SalomeApp_Application* anApp = theModule->getApp()){ - if(SUIT_ViewManager* aViewManager = anApp->getViewManager( Plot2d_Viewer::Type(), true )){ - return dynamic_cast(aViewManager->getViewModel()); + if(SUIT_ViewManager* aViewManager = anApp->getViewManager( Plot2d_Viewer::Type(), theCreate )){ + return dynamic_cast(aViewManager->getViewModel()); } } return NULL; } - // Internal function used by several public functions below + //------------------------------------------------------------ void - UpdateCurve(VISU::Curve_i* theCurve, - Plot2d_ViewFrame* aPlot, - SPlot2d_Curve* plotCurve, - int theDisplaying) - { - if ( theDisplaying == VISU::eErase ) { - if ( plotCurve ) - aPlot->eraseCurve( plotCurve, false ); - } - else if ( theDisplaying == VISU::eDisplay || theDisplaying == VISU::eDisplayOnly ) { - if ( plotCurve ) { - plotCurve->setHorTitle( theCurve->GetHorTitle().c_str() ); - //plotCurve->setVerTitle( ( theCurve->GetVerTitle().c_str() ) ); - plotCurve->setVerTitle( theCurve->GetName() ); - plotCurve->setHorUnits( theCurve->GetHorUnits().c_str() ); - plotCurve->setVerUnits( theCurve->GetVerUnits().c_str() ); - double* xList = 0; - double* yList = 0; - int nbPoints = theCurve->GetData( xList, yList ); - if ( nbPoints > 0 && xList && yList ) { - plotCurve->setData( xList, yList, nbPoints ); - } - if ( !theCurve->IsAuto() ) { - plotCurve->setLine( (Plot2d_Curve::LineType)theCurve->GetLine(), theCurve->GetLineWidth() ); - plotCurve->setMarker( (Plot2d_Curve::MarkerType)theCurve->GetMarker() ); - SALOMEDS::Color color = theCurve->GetColor(); - plotCurve->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) ); - } - plotCurve->setAutoAssign( theCurve->IsAuto() ); - aPlot->displayCurve( plotCurve, false ); - } - else { - Plot2d_Curve* crv = theCurve->CreatePresentation(); - if ( crv ) { - aPlot->displayCurve( crv, false ); - theCurve->SetLine( (VISU::Curve::LineType)crv->getLine(), crv->getLineWidth() ); - theCurve->SetMarker( (VISU::Curve::MarkerType)crv->getMarker()); - SALOMEDS::Color newColor; - newColor.R = crv->getColor().red()/255.; - newColor.G = crv->getColor().green()/255.; - newColor.B = crv->getColor().blue()/255.; - theCurve->SetColor( newColor ); - crv->setAutoAssign( theCurve->IsAuto() ); - } - } - } - } - - void - PlotTable(const SalomeApp_Module* theModule, - VISU::Table_i* table, - int theDisplaying) + PlotTable(const SalomeApp_Module* theModule, + VISU::Table_i* table, + int theDisplaying) { - SPlot2d_Viewer* aView = GetPlot2dViewer( theModule ); + SalomeApp_Study* aStudy = GetAppStudy( theModule ); + if( !aStudy ) + return; + + SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true ); // create if necessary if ( !aView ) return; Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame(); if ( !aPlot ) return; - if ( theDisplaying == VISU::eDisplayOnly ) - aPlot->EraseAll(); - QList clist; - aPlot->getCurves( clist ); - _PTR(Study) aStudy = GetCStudy( GetAppStudy( theModule ) ); - _PTR(SObject) TableSO = aStudy->FindObjectID( table->GetEntry() ); - if ( TableSO ) { - _PTR(ChildIterator) Iter = aStudy->NewChildIterator( TableSO ); - for ( ; Iter->More(); Iter->Next() ) { - CORBA::Object_var childObject = VISU::ClientSObjectToObject( Iter->Value() ); - if( !CORBA::is_nil( childObject ) ) { - CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject ); - if( !CORBA::is_nil( aCurve ) ) { - VISU::Curve_i* theCurve = dynamic_cast(VISU::GetServant(aCurve).in()); - SPlot2d_Curve* plotCurve = 0; - SPlot2d_Curve* tmpCurve; - for ( int i = 0; i < clist.count(); i++ ) { - tmpCurve = dynamic_cast( clist.at( i ) ); - if ( tmpCurve && tmpCurve->hasIO() && !strcmp( tmpCurve->getIO()->getEntry(), theCurve->GetEntry() ) ) { - plotCurve = tmpCurve; - break; - } - } - - UpdateCurve( theCurve, aPlot, plotCurve, theDisplaying ); - - if ( theDisplaying == VISU::eErase && plotCurve ) { - clist.remove( plotCurve ); - } - } - } - } - aPlot->Repaint(); - } + // implementation moved to VISU_I package (see VISU_Tools.h) + VISU::PlotTable( aStudy, aPlot, table, theDisplaying ); } + //------------------------------------------------------------ void - PlotCurve(const SalomeApp_Module* theModule, - VISU::Curve_i* theCurve, - int theDisplaying) + PlotCurve(const SalomeApp_Module* theModule, + VISU::Curve_i* theCurve, + int theDisplaying) { - SPlot2d_Viewer* aView = GetPlot2dViewer( theModule ); + SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true ); if ( !aView ) return; Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame(); if ( !aPlot ) return; -// if ( theDisplaying == VISU::eDisplayOnly ) -// aPlot->EraseAll(); - QList clist; - aPlot->getCurves( clist ); - SPlot2d_Curve* plotCurve = 0; - SPlot2d_Curve* tmpCurve; - for ( int i = 0; i < clist.count(); i++ ) { - tmpCurve = dynamic_cast( clist.at( i ) ); - if ( tmpCurve && tmpCurve->hasIO() && !strcmp( tmpCurve->getIO()->getEntry(), theCurve->GetEntry() ) ) { - plotCurve = tmpCurve; - } - else if ( theDisplaying == VISU::eDisplayOnly ) { - aPlot->eraseCurve( clist.at( i ) ); - } - } + // implementation moved to VISU_I package (see VISU_Tools.h) + VISU::PlotCurve( aPlot, theCurve, theDisplaying ); + } + + //------------------------------------------------------------ + void + PlotRemoveCurve(const SalomeApp_Module* theModule, + VISU::Curve_i* pCrv) + { + // implementation moved to VISU_I package (see VISU_Tools.h) + VISU::PlotRemoveCurve( theModule->getApp(), pCrv ); + } - UpdateCurve( theCurve, aPlot, plotCurve, theDisplaying ); + //------------------------------------------------------------ + void + PlotContainer(const SalomeApp_Module* theModule, + VISU::Container_i* container, + int theDisplaying) + { + SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true ); + if ( !aView ) + return; + Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame(); + if ( !aPlot ) + return; - aPlot->Repaint(); + // implementation moved to VISU_I package (see VISU_Tools.h) + VISU::PlotContainer( aPlot, container, theDisplaying ); } + //------------------------------------------------------------ void - PlotContainer(const SalomeApp_Module* theModule, - VISU::Container_i* container, - int theDisplaying) + CreatePlot(SalomeApp_Module* theModule, + _PTR(SObject) theTableSO) { - SPlot2d_Viewer* aView = GetPlot2dViewer( theModule ); + SPlot2d_Viewer* aView = GetPlot2dViewer( theModule, true ); if ( !aView ) return; Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame(); if ( !aPlot ) return; - if ( theDisplaying == VISU::eDisplayOnly ) - aPlot->EraseAll(); - QList clist; - aPlot->getCurves( clist ); - if ( container->GetNbCurves() > 0 ) { - int nbCurves = container->GetNbCurves(); - for ( int k = 1; k <= nbCurves; k++ ) { - VISU::Curve_i* theCurve = container->GetCurve( k ); - if ( theCurve && theCurve->IsValid() ) { - SPlot2d_Curve* plotCurve = dynamic_cast( aView->getCurveByIO( new SALOME_InteractiveObject( theCurve->GetEntry(), "", "" ) ) ); - - UpdateCurve( theCurve, aPlot, plotCurve, theDisplaying ); - - if ( plotCurve && theDisplaying == VISU::eErase ) { - clist.remove( plotCurve ); - } - } + VISU::VISU_Gen_i* aVisuGen = VISU::GetVisuGen( theModule ); + + // implementation moved to VISU_I package (see VISU_Tools.h) + VISU::CreatePlot( aVisuGen, aPlot, theTableSO ); + } + + //************************************************************ + // Others + VISU::Mesh_i* + CreateMesh(VisuGUI* theModule, + const Handle(SALOME_InteractiveObject)& theIO, + SVTK_ViewWindow* theViewWindow) + { + _PTR(Study) aStudy = GetCStudy(GetAppStudy(theModule)); + //if (CheckLock(aStudy)) + // return; + + _PTR(SObject) aResultSObj = aStudy->FindObjectID(theIO->getEntry()); + + // Get VISU::Result + VISU::Result_var aResult; + VISU::Result_i* pResult = CheckResult(theModule, aResultSObj, aResult); + if (pResult == NULL) + return NULL; + + Storable::TRestoringMap aMap = Storable::GetStorableMap(aResultSObj); + if (aMap.empty()) + return NULL; + + CORBA::Object_var aMesh; + string aComment = Storable::FindValue(aMap,"myComment").toLatin1().data(); + string aMeshName = Storable::FindValue(aMap,"myMeshName").toLatin1().data(); +#ifdef CHECKTIME + Utils_Timer timer; + timer.Start(); +#endif + if (aComment == "ENTITY") { + VISU::Entity anEntity = (VISU::Entity)Storable::FindValue(aMap,"myId").toInt(); + if (VISU::Mesh_i::IsPossible(pResult,aMeshName.c_str(),anEntity)) + aMesh = GetVisuGen(theModule)->MeshOnEntity(aResult,aMeshName.c_str(),anEntity); + } else if (aComment == "FAMILY") { + VISU::Entity anEntity = (VISU::Entity)Storable::FindValue(aMap,"myEntityId").toInt(); + string aFamilyName = Storable::FindValue(aMap,"myName").toLatin1().data(); + if (VISU::Mesh_i::IsPossible(pResult,aMeshName.c_str(),anEntity,aFamilyName.c_str())) + aMesh = GetVisuGen(theModule)->FamilyMeshOnEntity + (aResult,aMeshName.c_str(),anEntity,aFamilyName.c_str()); + } else if (aComment == "GROUP") { + string aGroupName = Storable::FindValue(aMap,"myName").toLatin1().data(); + if (VISU::Mesh_i::IsPossible(pResult,aMeshName.c_str(),aGroupName.c_str())) + aMesh = GetVisuGen(theModule)->GroupMesh(aResult,aMeshName.c_str(),aGroupName.c_str()); + } +#ifdef CHECKTIME + timer.Stop(); + MESSAGE("VisuGUI::CreateMesh() - CREATE MESH"); + timer.Show(); +#endif + + //QApplication::restoreOverrideCursor(); + VISU::Mesh_i* pPresent = NULL; + if (!CORBA::is_nil(aMesh)) + pPresent = dynamic_cast(VISU::GetServant(aMesh).in()); + if (pPresent == NULL) { + SUIT_MessageBox::warning (GetDesktop(theModule), + QObject::tr("WRN_VISU"), + QObject::tr("ERR_CANT_BUILD_PRESENTATION") ); + return NULL; + } + + if (theViewWindow) { + try { +#ifdef CHECKTIME + Utils_Timer timer; + timer.Start(); +#endif + if(GetResourceMgr()->booleanValue("VISU","display_only",false)){ + const VisuGUI* av = dynamic_cast(theModule); + if(av)(const_cast(av))->OnEraseAll(); + } + PublishMeshInView(theModule, pPresent, theViewWindow); + if(GetResourceMgr()->booleanValue("VISU","automatic_fit_all",false)){ + SetFitAll(theViewWindow); + } +#ifdef CHECKTIME + timer.Stop(); + MESSAGE("VisuGUI::CreateMesh() - DISPLAY MESH"); + timer.Show(); +#endif + } catch (std::runtime_error& exc) { + INFOS(exc.what()); + SUIT_MessageBox::warning(GetDesktop(theModule), QObject::tr("WRN_VISU"), + QObject::tr("ERR_CANT_CREATE_ACTOR") + ": " + QObject::tr(exc.what()) ); + } + } + + UpdateObjBrowser(theModule, false, aResultSObj); + + theModule->application()->putInfo(QObject::tr("INF_DONE")); + // Make "Save" button active + theModule->getApp()->updateActions(); + return pPresent; + } + + // ======================================================================================== + // GetPrs3dList: find list of presentations for the given object + // ======================================================================================== + std::vector GetPrs3dList (const SalomeApp_Module* theModule, + const Handle(SALOME_InteractiveObject)& theIO, + bool theGP) + { + std::vector aList; + if (!theIO.IsNull() && theIO->hasEntry()) { + _PTR(Study) aCStudy = GetCStudy(GetAppStudy(theModule)); + _PTR(SObject) aSObject = aCStudy->FindObjectID(theIO->getEntry()); + aList = GetPrs3dList(theModule, aSObject, theGP); + } + return aList; + } + + std::vector GetPrs3dList (const SalomeApp_Module* theModule, + _PTR(SObject) theObject, + bool theGP) + { + std::vector aList; int k = 0; + if (!theObject) + return aList; + + _PTR(Study) aCStudy = GetCStudy(GetAppStudy(theModule)); + + CORBA::Object_var aCORBAObject = VISU::ClientSObjectToObject(theObject); + if (!CORBA::is_nil(aCORBAObject)) { + VISU::Base_var aVisuObj = VISU::Base::_narrow(aCORBAObject); + if (!CORBA::is_nil(aVisuObj)) { + VISU::VISUType aType = aVisuObj->GetType(); + switch (aType) { + case VISU::TGAUSSPOINTS: + if ( !theGP ) break; + case VISU::TSCALARMAP: + case VISU::TISOSURFACES: + case VISU::TDEFORMEDSHAPE: + case VISU::TCUTPLANES: + case VISU::TCUTLINES: + case VISU::TCUTSEGMENT: + case VISU::TVECTORS: + case VISU::TSTREAMLINES: + case VISU::TPLOT3D: + case VISU::TSCALARMAPONDEFORMEDSHAPE: + case VISU::TDEFORMEDSHAPEANDSCALARMAP: + case VISU::TMESH: + { + PortableServer::ServantBase_var aServant = VISU::GetServant(aCORBAObject); + if (aServant.in()) { + VISU::Prs3d_i* aPrsObject = dynamic_cast(aServant.in()); + aList.resize(k+1); + aList[k] = aPrsObject; + k++; + } + } + break; + case VISU::TFIELD: + { + _PTR(ChildIterator) anIter = aCStudy->NewChildIterator(theObject); + _PTR(SObject) aTimeStamp; + anIter->Next(); // First is reference on support + for (; anIter->More(); anIter->Next()) { + aTimeStamp = anIter->Value(); + if (!aTimeStamp) continue; + std::vector aSubList = GetPrs3dList(theModule, aTimeStamp); + if (!aSubList.empty()) { + int n = aSubList.size(); + aList.resize(k+n); + for (int i = 0; i < n; i++) { + aList[k] = aSubList[i]; + k++; + } + } + } + } + break; + case VISU::TCOLOREDPRS3DHOLDER: + { + PortableServer::ServantBase_var aServant = VISU::GetServant(aCORBAObject); + if (aServant.in()) { + VISU::ColoredPrs3dHolder_i* aPrsHolderObject = dynamic_cast(aServant.in()); + if( aPrsHolderObject ) { + VISU::Prs3d_i* aPrsObject = aPrsHolderObject->GetPrs3dDevice(); + aList.resize(k+1); + aList[k] = aPrsObject; + k++; + } + } + } + } + } + } else { + VISU::VISUType aType = VISU::Storable::SObject2Type(theObject); + switch (aType) { + case VISU::TFIELD: { + _PTR(ChildIterator) anIter = aCStudy->NewChildIterator(theObject); + _PTR(SObject) aTimeStamp; + anIter->Next(); // First is reference on support + for (; anIter->More(); anIter->Next()) { + aTimeStamp = anIter->Value(); + if (!aTimeStamp) continue; + std::vector aSubList = GetPrs3dList(theModule, aTimeStamp); + if (!aSubList.empty()) { + int n = aSubList.size(); + aList.resize(k+n); + for (int i = 0; i < n; i++) { + aList[k] = aSubList[i]; + k++; + } + } + } + break; + } + case VISU::TTIMESTAMP: { + _PTR(ChildIterator) anIter = aCStudy->NewChildIterator(theObject); + _PTR(SObject) aPrs; + for (; anIter->More(); anIter->Next()) { + aPrs = anIter->Value(); + if (!aPrs) continue; + std::vector aSubList = GetPrs3dList(theModule, aPrs); + if (!aSubList.empty()) { + int n = aSubList.size(); + aList.resize(k+n); + for (int i = 0; i < n; i++) { + aList[k] = aSubList[i]; + k++; + } + } + } + break; + }} + } + return aList; + } + + //------------------------------------------------------------ + int GetFreePositionOfDefaultScalarBar(VisuGUI* theModule, SVTK_ViewWindow* theViewWindow) + { + int minIndx = 1; + std::set 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::const_iterator aIter = aIndexes.begin(); + for (int i = 1,length = aIndexes.size(); i <= length; i++) { + std::set::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->getScalarBarsMap(); + 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->getScalarBarsMap(); + TSetPrs3d::iterator aIter = aMap[theViewWindow].begin(); + for (; aIter != aMap[theViewWindow].end(); aIter++) + if ((*aIter).first == thePrs3d) { + aMap[theViewWindow].erase(*aIter); + return; } + } + //------------------------------------------------------------ + bool getClippingPlanesFolder(_PTR(Study) theStudy, _PTR(SObject)& theSObject) + { + _PTR(SComponent) aVisuSO = theStudy->FindComponent("VISU"); + if (!aVisuSO) return false; + _PTR(SObject) aFolder = theStudy->FindObject(CLIP_PLANES_FOLDER); + if (!aFolder) { + _PTR(StudyBuilder) aBuilder = theStudy->NewBuilder(); + aFolder = aBuilder->NewObject(aVisuSO); + + _PTR(GenericAttribute) anAttr; + anAttr = aBuilder->FindOrCreateAttribute(aFolder,"AttributeName"); + _PTR(AttributeName) aName(anAttr); + aName->SetValue(CLIP_PLANES_FOLDER); } - aPlot->Repaint(); + theSObject = aFolder; + return true; + } + + //------------------------------------------------------------ + void initSpinBox( SalomeApp_IntSpinBox* sb, + const int bottom, + const int top, + const int step ) + { + sb->setAcceptNames( false ); + sb->setRange( bottom, top ); + sb->setSingleStep( step ); + } + + //------------------------------------------------------------ + void initSpinBox( SalomeApp_DoubleSpinBox* sb, + const double& bottom, + const double& top, + const double& step, + const char* quantity ) + { + // Obtain precision from preferences + SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr(); + int precision = resMgr->integerValue( "VISU", quantity, 3 ); + + sb->setPrecision ( precision ); + sb->setDecimals ( qAbs(precision) ); + sb->setRange ( bottom, top ); + sb->setSingleStep ( step ); + sb->setDefaultValue( bottom ); + sb->setAcceptNames ( false ); + + // Add a hint for the user saying how to tune precision + QString userPropName = QObject::tr( QString( "VISU_PREF_%1" ).arg( quantity ).toLatin1().constData() ); + sb->setProperty( "validity_tune_hint", + QVariant( QObject::tr( "VISU_PRECISION_HINT" ).arg( userPropName ) ) ); } }