X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_Selection.cxx;h=8d8f46a271026143d9028e70674a38fb1173e5d4;hp=a77ff9a407146f775b2884cf1da1aa480f7fbb8b;hb=09607afb276900e0f0a7b95a01751fe628020a39;hpb=656c73ce33943675389576c4b17446b18d530e1e diff --git a/src/SMESHGUI/SMESHGUI_Selection.cxx b/src/SMESHGUI/SMESHGUI_Selection.cxx index a77ff9a40..8d8f46a27 100644 --- a/src/SMESHGUI/SMESHGUI_Selection.cxx +++ b/src/SMESHGUI/SMESHGUI_Selection.cxx @@ -1,31 +1,61 @@ - +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 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, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// 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 +// + +// SMESH SMESHGUI_Selection +// File : SMESHGUI_Selection.cxx +// Author : Alexander SOLOVYOV, Open CASCADE S.A.S. +// + +// SMESH includes #include "SMESHGUI_Selection.h" + +#include "SMESHGUI.h" +#include "SMESHGUI_ComputeDlg.h" +#include "SMESHGUI_ConvToQuadOp.h" +#include "SMESHGUI_GEOMGenUtils.h" #include "SMESHGUI_Utils.h" #include "SMESHGUI_VTKUtils.h" -#include "SMESHGUI_MeshUtils.h" -#include "SMESHGUI_GEOMGenUtils.h" -#include "SMESH_Type.h" -#include "SMESH_Actor.h" +#include +#include +#include -#include "SalomeApp_SelectionMgr.h" -#include "SalomeApp_Study.h" -#include "SalomeApp_VTKSelector.h" +// SALOME GUI includes +#include +#include +#include -#include "SUIT_Session.h" - -#include "SVTK_RenderWindowInteractor.h" -#include "SVTK_ViewWindow.h" - -#include CORBA_SERVER_HEADER(SMESH_Mesh) -#include CORBA_SERVER_HEADER(SMESH_Group) +// IDL includes +#include +#include CORBA_CLIENT_HEADER(SMESH_Gen) +#include CORBA_CLIENT_HEADER(SMESH_Mesh) +#include CORBA_CLIENT_HEADER(SMESH_Group) //======================================================================= //function : SMESHGUI_Selection //purpose : //======================================================================= SMESHGUI_Selection::SMESHGUI_Selection() -: SalomeApp_Selection() +: LightApp_Selection() { } @@ -41,88 +71,156 @@ SMESHGUI_Selection::~SMESHGUI_Selection() //function : init //purpose : //======================================================================= -void SMESHGUI_Selection::init( const QString& client, SalomeApp_SelectionMgr* mgr ) +void SMESHGUI_Selection::init( const QString& client, LightApp_SelectionMgr* mgr ) { - SalomeApp_Selection::init( client, mgr ); + LightApp_Selection::init( client, mgr ); if( mgr && study() ) { - _PTR(Study) aStudy = study()->studyDS(); - - SUIT_DataOwnerPtrList sel; - mgr->selected( sel, client ); - myDataOwners = sel; - SUIT_DataOwnerPtrList::const_iterator anIt = sel.begin(), - aLast = sel.end(); - for( ; anIt!=aLast; anIt++ ) - { - SUIT_DataOwner* owner = ( SUIT_DataOwner* )( (*anIt ).get() ); - SalomeApp_DataOwner* sowner = dynamic_cast( owner ); - if( sowner ) - myTypes.append( typeName( type( sowner, aStudy ) ) ); - else - myTypes.append( "Unknown" ); + SalomeApp_Study* aSStudy = dynamic_cast(study()); + if (!aSStudy) + return; + _PTR(Study) aStudy = aSStudy->studyDS(); + + for( int i=0, n=count(); i ( ow ); + if( owner ) { + myActors.append( dynamic_cast( owner->GetActor() ) ); + } + else if ( ow ) { // SVTK selection disabled + QString entry = ow->entry(); + myActors.append( SMESH::FindActorByEntry( entry.toStdString().c_str() )); + } + else { + myActors.append( 0 ); + } + return true; +} -// printf( "--> param() : [%s] = %s (%s)\n", p.latin1(), val.toString().latin1(), val.typeName() ); -// if ( val.type() == QVariant::List ) -// cout << "size: " << val.toList().count() << endl; - return val; +//======================================================================= +//function : parameter +//purpose : +//======================================================================= +QVariant SMESHGUI_Selection::parameter( const int ind, const QString& p ) const +{ + QVariant val; + if ( p=="client" ) val = QVariant( LightApp_Selection::parameter( p ) ); + else if ( p=="type" ) val = QVariant( myTypes[ind] ); + else if ( p=="hasActor" ) val = QVariant( getActor( ind ) != 0 ); + else if ( p=="elemTypes" ) val = QVariant( elemTypes( ind, false ) ); + else if ( p=="objElemTypes" ) val = QVariant( elemTypes( ind, true ) ); + else if ( p=="isAutoColor" ) val = QVariant( isAutoColor( ind ) ); + else if ( p=="numberOfNodes" ) val = QVariant( numberOfNodes( ind ) ); + else if ( p=="dim" ) val = QVariant( dim( ind ) ); + else if ( p=="labeledTypes" ) val = QVariant( labeledTypes( ind ) ); + else if ( p=="shrinkMode" ) val = QVariant( shrinkMode( ind ) ); + else if ( p=="entityMode" ) val = QVariant( entityMode( ind ) ); + else if ( p=="isNumFunctor" ) val = QVariant( isNumFunctor( ind ) ); + else if ( p=="displayMode" ) val = QVariant( displayMode( ind ) ); + else if ( p=="isComputable" ) val = QVariant( isComputable( ind ) ); + else if ( p=="isPreComputable" ) val = QVariant( isPreComputable( ind ) ); + else if ( p=="hasGeomReference" ) val = QVariant( hasGeomReference( ind ) ); + else if ( p=="isEditableHyp" ) val = QVariant( isEditableHyp( ind ) ); + else if ( p=="isImported" ) val = QVariant( isImported( ind ) ); + else if ( p=="facesOrientationMode" ) val = QVariant( facesOrientationMode( ind ) ); + else if ( p=="groupType" ) val = QVariant( groupType( ind ) ); + else if ( p=="isQuadratic" ) val = QVariant( isQuadratic( ind ) ); + else if ( p=="quadratic2DMode") val = QVariant( quadratic2DMode( ind ) ); + else if ( p=="isDistributionVisible") val = QVariant( isDistributionVisible( ind ) ); + else if ( p=="isScalarBarVisible") val = QVariant( isScalarBarVisible( ind ) ); + else if ( p=="hasChildren") val = QVariant( hasChildren( ind ) ); + else if ( p=="nbChildren") val = QVariant( nbChildren( ind ) ); + else if ( p=="isContainer") val = QVariant( isContainer( ind ) ); + else if ( p=="guiState") val = QVariant( guiState() ); + + if ( val.isValid() ) + return val; + else + return LightApp_Selection::parameter( ind, p ); +} + +//======================================================================= +//function : parameter +//purpose : +//======================================================================= +QVariant SMESHGUI_Selection::parameter( const QString& p ) const +{ + QVariant val; + if ( p=="controlMode" ) val = QVariant( controlMode() ); + + if ( val.isValid() ) + return val; + else + return LightApp_Selection::parameter( p ); } //======================================================================= //function : getVtkOwner -//purpose : +//purpose : //======================================================================= SMESH_Actor* SMESHGUI_Selection::getActor( int ind ) const { - if ( ind >= 0 && ind < myDataOwners.count() ) { - const SalomeApp_SVTKDataOwner* owner = - dynamic_cast ( myDataOwners[ ind ].get() ); - if ( owner ) - return dynamic_cast( owner->GetActor() ); - } - return 0; + if( ind >= 0 && ind < count() ) + return myActors.isEmpty() ? 0 : myActors.at( ind ); + else + return 0; } //======================================================================= //function : elemTypes -//purpose : may return {'Edge' 'Face' 'Volume'} at most +//purpose : may return {'Elem0d' 'Edge' 'Face' 'Volume' 'BallElem'} at most //======================================================================= -QValueList SMESHGUI_Selection::elemTypes( int ind ) const +QList SMESHGUI_Selection::elemTypes( int ind, bool fromObj ) const { - QValueList types; + QList types; SMESH_Actor* actor = getActor( ind ); if ( actor ) { TVisualObjPtr object = actor->GetObject(); if ( object ) { - if ( object->GetNbEntities( SMDSAbs_Edge )) types.append( "Edge" ); - if ( object->GetNbEntities( SMDSAbs_Face )) types.append( "Face" ); - if ( object->GetNbEntities( SMDSAbs_Volume )) types.append( "Volume" ); + if ( object->GetNbEntities( SMDSAbs_Edge )) types.append( "Edge" ); + if ( object->GetNbEntities( SMDSAbs_Face )) types.append( "Face" ); + if ( object->GetNbEntities( SMDSAbs_Volume )) types.append( "Volume" ); + if ( object->GetNbEntities( SMDSAbs_0DElement )) types.append( "Elem0d" ); + if ( object->GetNbEntities( SMDSAbs_Ball )) types.append( "BallElem" ); + } + } + else if ( fromObj ) + { + if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" ) + { + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + CORBA::Object_var obj = SMESH::SObjectToObject( sobj, SMESH::GetActiveStudyDocument() ); + SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( obj ); + if ( !CORBA::is_nil( idSrc ) ) + { + SMESH::array_of_ElementType_var typeVar = idSrc->GetTypes(); + for ( CORBA::ULong i = 0; i < typeVar->length(); ++i ) + switch ( typeVar[i] ) { + case SMESH::EDGE: types.append( "Edge" ); break; + case SMESH::FACE: types.append( "Face" ); break; + case SMESH::VOLUME: types.append( "Volume" ); break; + case SMESH::ELEM0D: types.append( "Elem0d" ); break; + case SMESH::BALL: types.append( "BallElem" ); break; + case SMESH::ALL: + case SMESH::NODE: + case SMESH::NB_ELEMENT_TYPES: break; + } + } } } return types; @@ -133,13 +231,13 @@ QValueList SMESHGUI_Selection::elemTypes( int ind ) const //purpose : may return {'Point' 'Cell'} at most //======================================================================= -QValueList SMESHGUI_Selection::labeledTypes( int ind ) const +QList SMESHGUI_Selection::labeledTypes( int ind ) const { - QValueList types; + QList types; SMESH_Actor* actor = getActor( ind ); if ( actor ) { if ( actor->GetPointsLabeled()) types.append( "Point" ); - if ( actor->GetCellsLabeled()) types.append( "Cell" ); + if ( actor->GetCellsLabeled()) types.append( "Cell" ); } return types; } @@ -157,12 +255,68 @@ QString SMESHGUI_Selection::displayMode( int ind ) const case SMESH_Actor::eEdge: return "eEdge"; case SMESH_Actor::eSurface: return "eSurface"; case SMESH_Actor::ePoint: return "ePoint"; - default:; + default: break; } } return "Unknown"; } +//======================================================================= +//function : isQuadratic +//purpose : return true if the mesh has quadratic/bi-quadratic type +//======================================================================= + +bool SMESHGUI_Selection::isQuadratic( int ind ) const +{ + _PTR(SObject) so = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + if ( !so ) + return false; + SMESH::SMESH_IDSource_var idSource = SMESH::SObjectToInterface( so ); + if ( idSource->_is_nil() ) + return false; + SMESHGUI_ConvToQuadOp::MeshDestinationType meshTgtType = SMESHGUI_ConvToQuadOp::DestinationMesh( idSource ); + if ( meshTgtType & SMESHGUI_ConvToQuadOp::Linear ) + return true; + return false; +} + +//======================================================================= +//function : quadratic2DMode +//purpose : return SMESH_Actor::EQuadratic2DRepresentation +//======================================================================= +QString SMESHGUI_Selection::quadratic2DMode( int ind ) const +{ + SMESH_Actor* actor = getActor( ind ); + if ( actor ) { + switch( actor->GetQuadratic2DRepresentation() ) { + case SMESH_Actor::eLines: return "eLines"; + case SMESH_Actor::eArcs: return "eArcs"; + default: break; + } + } + return "Unknown"; +} + +//======================================================================= +//function : isDistributionVisible +//purpose : Visible/Invisible distribution of the ScalarBar Actor +//======================================================================= + +bool SMESHGUI_Selection::isDistributionVisible(int ind) const { + SMESH_Actor* actor = getActor( ind ); + return (actor && actor->GetScalarBarActor() && actor->GetScalarBarActor()->GetDistributionVisibility()); +} + +//======================================================================= +//function : isScalarBarVisible +//purpose : Visible/Invisible Scalar Bar +//======================================================================= + +bool SMESHGUI_Selection::isScalarBarVisible(int ind) const { + SMESH_Actor* actor = getActor( ind ); + return (actor && actor->GetScalarBarActor() && actor->GetScalarBarActor()->GetVisibility()); +} + //======================================================================= //function : shrinkMode //purpose : return either 'IsSrunk', 'IsNotShrunk' or 'IsNotShrinkable' @@ -172,27 +326,27 @@ QString SMESHGUI_Selection::shrinkMode( int ind ) const { SMESH_Actor* actor = getActor( ind ); if ( actor && actor->IsShrunkable() ) { - if ( actor->IsShrunk() ) - return "IsShrunk"; - return "IsNotShrunk"; + return actor->IsShrunk() ? "IsShrunk" : "IsNotShrunk"; } return "IsNotShrinkable"; } //======================================================================= //function : entityMode -//purpose : may return {'Edge' 'Face' 'Volume'} at most +//purpose : may return {'Elem0d' 'Edge' 'Face' 'Volume' 'BallElem' } at most //======================================================================= -QValueList SMESHGUI_Selection::entityMode( int ind ) const +QList SMESHGUI_Selection::entityMode( int ind ) const { - QValueList types; + QList types; SMESH_Actor* actor = getActor( ind ); if ( actor ) { unsigned int aMode = actor->GetEntityMode(); - if ( aMode & SMESH_Actor::eVolumes) types.append( "Volume"); - if ( aMode & SMESH_Actor::eFaces ) types.append( "Face" ); - if ( aMode & SMESH_Actor::eEdges ) types.append( "Edge" ); + if ( aMode & SMESH_Actor::eVolumes ) types.append( "Volume" ); + if ( aMode & SMESH_Actor::eFaces ) types.append( "Face" ); + if ( aMode & SMESH_Actor::eEdges ) types.append( "Edge" ); + if ( aMode & SMESH_Actor::e0DElements ) types.append( "Elem0d" ); + if ( aMode & SMESH_Actor::eBallElem ) types.append( "BallElem" ); } return types; } @@ -205,93 +359,272 @@ QValueList SMESHGUI_Selection::entityMode( int ind ) const QString SMESHGUI_Selection::controlMode( int ind ) const { SMESH_Actor* actor = getActor( ind ); + QString mode = "eNone"; if ( actor ) { switch( actor->GetControlMode() ) { - case SMESH_Actor::eLength: return "eLength"; - case SMESH_Actor::eLength2D: return "eLength2D"; - case SMESH_Actor::eFreeEdges: return "eFreeEdges"; - case SMESH_Actor::eFreeBorders: return "eFreeBorders"; - case SMESH_Actor::eMultiConnection: return "eMultiConnection"; - case SMESH_Actor::eMultiConnection2D: return "eMultiConnection2D"; - case SMESH_Actor::eArea: return "eArea"; - case SMESH_Actor::eTaper: return "eTaper"; - case SMESH_Actor::eAspectRatio: return "eAspectRatio"; - case SMESH_Actor::eAspectRatio3D: return "eAspectRatio3D"; - case SMESH_Actor::eMinimumAngle: return "eMinimumAngle"; - case SMESH_Actor::eWarping: return "eWarping"; - case SMESH_Actor::eSkew: return "eSkew"; - default:; + case SMESH_Actor::eLength: mode = "eLength"; break; + case SMESH_Actor::eLength2D: mode = "eLength2D"; break; + case SMESH_Actor::eDeflection2D: mode = "eDeflection2D"; break; + case SMESH_Actor::eFreeEdges: mode = "eFreeEdges"; break; + case SMESH_Actor::eFreeNodes: mode = "eFreeNodes"; break; + case SMESH_Actor::eFreeBorders: mode = "eFreeBorders"; break; + case SMESH_Actor::eFreeFaces: mode = "eFreeFaces"; break; + case SMESH_Actor::eMultiConnection: mode = "eMultiConnection"; break; + case SMESH_Actor::eMultiConnection2D: mode = "eMultiConnection2D"; break; + case SMESH_Actor::eArea: mode = "eArea"; break; + case SMESH_Actor::eVolume3D: mode = "eVolume3D"; break; + case SMESH_Actor::eMaxElementLength2D: mode = "eMaxElementLength2D"; break; + case SMESH_Actor::eMaxElementLength3D: mode = "eMaxElementLength3D"; break; + case SMESH_Actor::eTaper: mode = "eTaper"; break; + case SMESH_Actor::eAspectRatio: mode = "eAspectRatio"; break; + case SMESH_Actor::eAspectRatio3D: mode = "eAspectRatio3D"; break; + case SMESH_Actor::eMinimumAngle: mode = "eMinimumAngle"; break; + case SMESH_Actor::eWarping: mode = "eWarping"; break; + case SMESH_Actor::eSkew: mode = "eSkew"; break; + case SMESH_Actor::eBareBorderFace: mode = "eBareBorderFace"; break; + case SMESH_Actor::eBareBorderVolume: mode = "eBareBorderVolume"; break; + case SMESH_Actor::eOverConstrainedFace: mode = "eOverConstrainedFace"; break; + case SMESH_Actor::eOverConstrainedVolume: mode = "eOverConstrainedVolume"; break; + case SMESH_Actor::eCoincidentNodes: mode = "eCoincidentNodes"; break; + case SMESH_Actor::eCoincidentElems1D: mode = "eCoincidentElems1D"; break; + case SMESH_Actor::eCoincidentElems2D: mode = "eCoincidentElems2D"; break; + case SMESH_Actor::eCoincidentElems3D: mode = "eCoincidentElems3D"; break; + case SMESH_Actor::eCustomControl: mode = "eCustomControl"; break; + default:break; } } + return mode; +} + +//======================================================================= +//function : controlMode +//purpose : gets global control mode; return SMESH_Actor::eControl +//======================================================================= +QString SMESHGUI_Selection::controlMode() const +{ + if( myControls.count() > 0 ) { + QString mode = myControls[0]; + for( int ind = 1; ind < myControls.count(); ind++ ) { + if( mode != myControls[ind] ) + return "eMixed"; // different controls used for different actors + } + return mode; + } return "eNone"; } //======================================================================= -//function : numberOfNodes +//function : isNumFunctor +//purpose : return true if a given actor is shown using a numeric functor +//======================================================================= + +bool SMESHGUI_Selection::isNumFunctor( int ind ) const +{ + bool result = false; + SMESH_Actor* actor = getActor( ind ); + if ( actor ) { + switch( actor->GetControlMode() ) { + case SMESH_Actor::eLength: + case SMESH_Actor::eLength2D: + case SMESH_Actor::eDeflection2D: + case SMESH_Actor::eMultiConnection: + case SMESH_Actor::eMultiConnection2D: + case SMESH_Actor::eArea: + case SMESH_Actor::eVolume3D: + case SMESH_Actor::eMaxElementLength2D: + case SMESH_Actor::eMaxElementLength3D: + case SMESH_Actor::eTaper: + case SMESH_Actor::eAspectRatio: + case SMESH_Actor::eAspectRatio3D: + case SMESH_Actor::eMinimumAngle: + case SMESH_Actor::eWarping: + case SMESH_Actor::eSkew: + result = true; + break; + default: + break; + } + } + return result; +} + +//======================================================================= +//function : facesOrientationMode +//purpose : +//======================================================================= + +QString SMESHGUI_Selection::facesOrientationMode( int ind ) const +{ + SMESH_Actor* actor = getActor( ind ); + if ( actor ) { + return actor->GetFacesOriented() ? "IsOriented" : "IsNotOriented"; + } + return "Unknown"; +} + +//======================================================================= +//function : isAutoColor //purpose : //======================================================================= +bool SMESHGUI_Selection::isAutoColor( int ind ) const +{ + if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" ) + { + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + CORBA::Object_var obj = SMESH::SObjectToObject( sobj, SMESH::GetActiveStudyDocument() ); + SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( obj ); + if ( !CORBA::is_nil( mesh ) ) + return mesh->GetAutoColor(); + } + return false; +} + +//======================================================================= +//function : numberOfNodes +//purpose : this method is actually used to check if an object is empty or not +//======================================================================= + int SMESHGUI_Selection::numberOfNodes( int ind ) const { if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" ) { - CORBA::Object_var obj = - SMESH::DataOwnerToObject( static_cast( myDataOwners[ ind ].get() )); - if ( ! CORBA::is_nil( obj )) { + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + CORBA::Object_var obj = SMESH::SObjectToObject( sobj, SMESH::GetActiveStudyDocument() ); + + if ( !CORBA::is_nil( obj ) ) { SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( obj ); - if ( ! mesh->_is_nil() ) + if ( !CORBA::is_nil( mesh ) ) return mesh->NbNodes(); SMESH::SMESH_subMesh_var aSubMeshObj = SMESH::SMESH_subMesh::_narrow( obj ); - if ( !aSubMeshObj->_is_nil() ) + if ( !CORBA::is_nil( aSubMeshObj ) ) return aSubMeshObj->GetNumberOfNodes(true); SMESH::SMESH_GroupBase_var aGroupObj = SMESH::SMESH_GroupBase::_narrow( obj ); - if ( !aGroupObj->_is_nil() ) - return aGroupObj->Size(); + if ( !CORBA::is_nil( aGroupObj ) ) + return aGroupObj->IsEmpty() ? 0 : 1; // aGroupObj->Size(); } } return 0; } -//======================================================================= -//function : isComputable -//purpose : -//======================================================================= +//================================================================================ +/*! + * \brief return dimension of elements of the selected object + * + * \retval int - 0 for 0D elements, -1 for an empty object (the rest as usual) + */ +//================================================================================ -QVariant SMESHGUI_Selection::isComputable( int ind ) const +int SMESHGUI_Selection::dim( int ind ) const { + int dim = -1; if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" ) { - Handle(SALOME_InteractiveObject) io = - static_cast( myDataOwners[ ind ].get() )->IO(); - if ( !io.IsNull() ) { - SMESH::SMESH_Mesh_var mesh = SMESH::GetMeshByIO(io) ; // m,sm,gr->m - if ( !mesh->_is_nil() ) { - _PTR(SObject) so = SMESH::FindSObject( mesh ); - if ( so ) { - GEOM::GEOM_Object_var shape = SMESH::GetShapeOnMeshOrSubMesh( so ); - return QVariant( !shape->_is_nil(), 0 ); + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + CORBA::Object_var obj = SMESH::SObjectToObject( sobj, SMESH::GetActiveStudyDocument() ); + + if ( !CORBA::is_nil( obj ) ) { + SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( obj ); + if ( !CORBA::is_nil( idSrc ) ) + { + SMESH::array_of_ElementType_var types = idSrc->GetTypes(); + for ( size_t i = 0; i < types->length(); ++ i) { + switch ( types[i] ) { + case SMESH::EDGE : dim = std::max( dim, 1 ); break; + case SMESH::FACE : dim = std::max( dim, 2 ); break; + case SMESH::VOLUME: dim = std::max( dim, 3 ); break; + case SMESH::ELEM0D: dim = std::max( dim, 0 ); break; + case SMESH::BALL : dim = std::max( dim, 0 ); break; + default: break; + } } } } } - return QVariant( false, 0 ); + return dim; } //======================================================================= -//function : hasReference -//purpose : +//function : isComputable +//purpose : return true for a ready-to-compute mesh +//======================================================================= + +bool SMESHGUI_Selection::isComputable( int ind ) const +{ + if ( ind >= 0 && ind < myTypes.count() && ( myTypes[ind] == "Mesh" || + myTypes[ind].startsWith("Mesh " ))) + { + QMap modeMap; + _PTR(SObject) meshSO = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + + _PTR(SComponent) component = meshSO->GetFatherComponent(); + if ( meshSO->Depth() - component->Depth() > 1 ) // sub-mesh, get a mesh + while ( meshSO->Depth() - component->Depth() > 1 ) + meshSO = meshSO->GetFather(); + + SMESHGUI_PrecomputeOp::getAssignedAlgos( meshSO, modeMap ); + return modeMap.size() > 0; + } + return false; +} + +//======================================================================= +//function : isPreComputable +//purpose : returns true for a mesh with algorithms +//======================================================================= + +bool SMESHGUI_Selection::isPreComputable( int ind ) const +{ + if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Mesh" ) + { + int maxDim = dim( ind ); + if ( maxDim < 2 ) // we can preview 1D or 2D + { + QMap modeMap; + _PTR(SObject) pMesh = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + SMESHGUI_PrecomputeOp::getAssignedAlgos( pMesh, modeMap ); + if ( modeMap.size() > 1 ) + return (( modeMap.contains( SMESH::DIM_3D )) || + ( modeMap.contains( SMESH::DIM_2D ) && maxDim < 1 )); + } + } + return false; +} + +//======================================================================= +//function : hasGeomReference +//purpose : returns true for a mesh or sub-mesh on geometry //======================================================================= -QVariant SMESHGUI_Selection::hasReference( int ind ) const +bool SMESHGUI_Selection::hasGeomReference( int ind ) const { if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" ) { - Handle(SALOME_InteractiveObject) io = - static_cast( myDataOwners[ ind ].get() )->IO(); - if ( !io.IsNull() ) - return QVariant( io->hasReference(), 0 ); + _PTR(SObject) so = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + GEOM::GEOM_Object_var shape = SMESH::GetShapeOnMeshOrSubMesh( so ); + return !shape->_is_nil(); } - return QVariant( false, 0 ); + return false; +} + +//======================================================================= +//function : isEditableHyp +//purpose : +//======================================================================= + +bool SMESHGUI_Selection::isEditableHyp( int ind ) const +{ + bool isEditable = true; + if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Hypothesis" ) + { + _PTR(SObject) so = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + SMESH::SMESH_Hypothesis_var hyp = SMESH::SObjectToInterface( so ); + if ( !hyp->_is_nil() ) + { + isEditable = hyp->HasParameters(); + } + } + return isEditable; } //======================================================================= @@ -299,85 +632,122 @@ QVariant SMESHGUI_Selection::hasReference( int ind ) const //purpose : //======================================================================= -QVariant SMESHGUI_Selection::isVisible( int ind ) const +bool SMESHGUI_Selection::isVisible( int ind ) const { if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" ) { - QString entry = static_cast( myDataOwners[ ind ].get() )->entry(); - SMESH_Actor* actor = SMESH::FindActorByEntry( entry.latin1() ); + SMESH_Actor* actor = SMESH::FindActorByEntry( entry( ind ).toLatin1().data() ); if ( actor && actor->hasIO() ) { - SVTK_RenderWindowInteractor* renderInter = SMESH::GetCurrentVtkView()->getRWInteractor(); - return QVariant( renderInter->isVisible( actor->getIO() ), 0 ); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetCurrentVtkView() ) + return aViewWindow->isVisible( actor->getIO() ); } } - return QVariant( false, 0 ); + return false; } +//======================================================================= +//function : hasChildren +//purpose : +//======================================================================= + +bool SMESHGUI_Selection::hasChildren( int ind ) const +{ + if ( ind >= 0 ) + { + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + if ( sobj ) + return SMESH::GetActiveStudyDocument()->GetUseCaseBuilder()->HasChildren( sobj ); + } + return false; +} //======================================================================= -//function : type +//function : hasChildren //purpose : //======================================================================= -int SMESHGUI_Selection::type( SalomeApp_DataOwner* owner, - _PTR(Study) study ) +int SMESHGUI_Selection::nbChildren( int ind ) const { - QString entry = owner->entry(); + int nb = 0; + if ( ind >= 0 ) + { + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().data() ); + if ( sobj && sobj->GetStudy()->GetUseCaseBuilder()->IsUseCaseNode( sobj ) ) { + _PTR(UseCaseIterator) it = sobj->GetStudy()->GetUseCaseBuilder()->GetUseCaseIterator( sobj ); + for ( it->Init( false ); it->More(); it->Next() ) nb++; + } + } + return nb; +} - _PTR(SObject) obj (study->FindObjectID(entry.latin1())); - if( !obj ) - return -1; +//======================================================================= +//function : isContainer +//purpose : +//======================================================================= - _PTR(SObject) objFather = obj->GetFather(); - _PTR(SComponent) objComponent = obj->GetFatherComponent(); +bool SMESHGUI_Selection::isContainer( int ind ) const +{ + return ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Unknown"; +} - int aLevel = obj->Depth() - objComponent->Depth(), - aFTag = objFather->Tag(), - anOTag = obj->Tag(), - res = -1; +//======================================================================= +//function : type +//purpose : +//======================================================================= - switch( aLevel ) - { - case 1: - if( anOTag>=3 ) - res = MESH; - break; - case 2: - switch( aFTag ) - { - case 1: - res = HYPOTHESIS; - break; - case 2: - res = ALGORITHM; - break; - } - break; - case 3: - switch( aFTag ) - { - case 4: - res = SUBMESH_VERTEX; - break; - case 5: - res = SUBMESH_EDGE; - break; - case 7: - res = SUBMESH_FACE; - break; - case 9: - res = SUBMESH_SOLID; - break; - case 10: - res = SUBMESH_COMPOUND; - break; +int SMESHGUI_Selection::type( const QString& entry, _PTR(Study) study ) +{ + int res = -1; + _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().data() ); + if ( obj ) { + _PTR(SObject) ref; + if ( obj->ReferencedObject( ref ) ) + obj = ref; + + _PTR(SObject) objFather = obj->GetFather(); + _PTR(SComponent) objComponent = obj->GetFatherComponent(); + + if ( objComponent->ComponentDataType() == "SMESH" ) { + if ( objComponent->GetIOR() == obj->GetIOR() ) { + res = SMESH::COMPONENT; + } + else { + int aLevel = obj->Depth() - objComponent->Depth(), + aFTag = objFather->Tag(), + anOTag = obj->Tag(); + + switch ( aLevel ) + { + case 1: + if ( anOTag >= SMESH::Tag_FirstMeshRoot ) + res = SMESH::MESH; + break; + case 2: + switch ( aFTag ) + { + case SMESH::Tag_HypothesisRoot: res = SMESH::HYPOTHESIS; break; + case SMESH::Tag_AlgorithmsRoot: res = SMESH::ALGORITHM; break; + default: break; + } + break; + case 3: + switch ( aFTag ) + { + case SMESH::Tag_SubMeshOnVertex: res = SMESH::SUBMESH_VERTEX; break; + case SMESH::Tag_SubMeshOnEdge: res = SMESH::SUBMESH_EDGE; break; + case SMESH::Tag_SubMeshOnFace: res = SMESH::SUBMESH_FACE; break; + case SMESH::Tag_SubMeshOnSolid: res = SMESH::SUBMESH_SOLID; break; + case SMESH::Tag_SubMeshOnCompound: res = SMESH::SUBMESH_COMPOUND; break; + default: + if ( aFTag >= SMESH::Tag_FirstGroup) res = SMESH::GROUP; + else res = SMESH::SUBMESH; + break; + } + break; + } + } } - if( aFTag>10 ) - res = GROUP; - - break; } - return res; } @@ -388,31 +758,84 @@ int SMESHGUI_Selection::type( SalomeApp_DataOwner* owner, QString SMESHGUI_Selection::typeName( const int t ) { + QString res = "Unknown"; switch( t ) { - case HYPOTHESIS: - return "Hypothesis"; - case ALGORITHM: - return "Algorithm"; - case MESH: - return "Mesh"; - case SUBMESH: - return "SubMesh"; - case MESHorSUBMESH: - return "Mesh or submesh"; - case SUBMESH_VERTEX: - return "Mesh vertex"; - case SUBMESH_EDGE: - return "Mesh edge"; - case SUBMESH_FACE: - return "Mesh face"; - case SUBMESH_SOLID: - return "Mesh solid"; - case SUBMESH_COMPOUND: - return "Mesh compound"; - case GROUP: - return "Group"; + case SMESH::HYPOTHESIS: + res = "Hypothesis"; break; + case SMESH::ALGORITHM: + res = "Algorithm"; break; + case SMESH::MESH: + res = "Mesh"; break; + case SMESH::SUBMESH: + res = "SubMesh"; break; + case SMESH::MESHorSUBMESH: + res = "Mesh or submesh"; break; + case SMESH::SUBMESH_VERTEX: + res = "Mesh vertex"; break; + case SMESH::SUBMESH_EDGE: + res = "Mesh edge"; break; + case SMESH::SUBMESH_FACE: + res = "Mesh face"; break; + case SMESH::SUBMESH_SOLID: + res = "Mesh solid"; break; + case SMESH::SUBMESH_COMPOUND: + res = "Mesh compound"; break; + case SMESH::GROUP: + res = "Group"; break; + case SMESH::COMPONENT: + res = "Component"; break; default: - return "Unknown"; + break; + } + return res; +} + +bool SMESHGUI_Selection::isImported( const int ind ) const +{ + bool res = false; + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().constData() ); + if ( sobj ) + { + SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( sobj ) ); + if( !aMesh->_is_nil() ) + { + SMESH::MedFileInfo_var inf = aMesh->GetMEDFileInfo(); + res = strlen( (char*)inf->fileName ) > 0; + } + } + return res; +} + +//======================================================================= +//function : guiState +//purpose : +//======================================================================= + +int SMESHGUI_Selection::guiState() +{ + return SMESHGUI::GetSMESHGUI() ? SMESHGUI::GetSMESHGUI()->GetState() : -1; +} + +//======================================================================= +//function : groupType +//purpose : +//======================================================================= + +QString SMESHGUI_Selection::groupType( int ind ) const +{ + _PTR(SObject) sobj = SMESH::GetActiveStudyDocument()->FindObjectID( entry( ind ).toLatin1().constData() ); + if ( sobj ) + { + SMESH::SMESH_Group_var g = SMESH::SObjectToInterface( sobj ); + if ( !CORBA::is_nil( g ) ) + return "Group"; + SMESH::SMESH_GroupOnGeom_var gog = SMESH::SObjectToInterface( sobj ); + if( !CORBA::is_nil( gog ) ) + return "GroupOnGeom"; + SMESH::SMESH_GroupOnFilter_var gof = SMESH::SObjectToInterface( sobj ); + if ( !CORBA::is_nil( gof ) ) + return "GroupOnFilter"; } + return ""; }