-// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// 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) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
-// 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.
+// 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.
//
-// 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 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.
//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// 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
-*
-* Copyright (C) 2005 CEA/DEN, EDF R&D
-*
-*
-*
-* File : SMESHGUI_MeshOp.h
-* Author : Sergey LITONIN
-* Module : SMESHGUI
-*/
+// SMESH SMESHGUI : GUI for SMESH component
+// File : SMESHGUI_MeshOp.cxx
+// Author : Sergey LITONIN, Open CASCADE S.A.S.
+// SMESH includes
+//
#include "SMESHGUI_MeshOp.h"
+
+#include "SMESHGUI.h"
#include "SMESHGUI_MeshDlg.h"
#include "SMESHGUI_ShapeByMeshDlg.h"
-#include "SMESH_TypeFilter.hxx"
-#include "SMESHGUI.h"
-
#include "SMESHGUI_HypothesesUtils.h"
#include "SMESHGUI_Hypotheses.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_GEOMGenUtils.h"
-#include "SMESHGUI_VTKUtils.h"
-
-#include "SMESH_TypeFilter.hxx"
-#include "SMESH_NumberFilter.hxx"
-
-#include CORBA_CLIENT_HEADER(SMESH_Gen)
-
-#include "GEOM_SelectionFilter.h"
-#include "GEOMBase.h"
-#include "GeometryGUI.h"
-
-#include "SalomeApp_Tools.h"
-#include "SalomeApp_Application.h"
-#include "SALOMEDSClient_Study.hxx"
-#include "SALOMEDSClient_AttributeIOR.hxx"
-#include "SALOMEDSClient_AttributeName.hxx"
-#include "SALOMEDS_SComponent.hxx"
-#include "SALOMEDS_SObject.hxx"
-
-#include "LightApp_SelectionMgr.h"
-#include "LightApp_UpdateFlags.h"
-#include "SUIT_MessageBox.h"
-#include "SUIT_Desktop.h"
-#include "SUIT_OverrideCursor.h"
-#include "SALOME_InteractiveObject.hxx"
-#include "SALOME_ListIO.hxx"
-
-#include "utilities.h"
-
-#include <qstringlist.h>
-#include <qlineedit.h>
+#include <SMESH_TypeFilter.hxx>
+#include <SMESH_NumberFilter.hxx>
+
+// SALOME GEOM includes
+#include <GEOM_SelectionFilter.h>
+#include <GEOMBase.h>
+#include <GeometryGUI.h>
+
+// SALOME GUI includes
+#include <SalomeApp_Tools.h>
+#include <SalomeApp_Application.h>
+#include <LightApp_SelectionMgr.h>
+#include <LightApp_UpdateFlags.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
+#include <SALOME_InteractiveObject.hxx>
+#include <SALOME_ListIO.hxx>
+
+// SALOME KERNEL includes
+#include <SALOMEDS_SComponent.hxx>
+#include <SALOMEDS_SObject.hxx>
+
+// Qt includes
+#include <QStringList>
+#include <QLineEdit>
+
+// OCCT includes
+#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
+#include <TopoDS_Shell.hxx>
#include <TopExp_Explorer.hxx>
+#include <BRep_Tool.hxx>
+
+// IDL includes
+#include <SALOMEconfig.h>
+#include CORBA_CLIENT_HEADER(SMESH_Gen)
//================================================================================
/*!
myToCreate( theToCreate ),
myIsMesh( theIsMesh ),
myDlg( 0 ),
- myShapeByMeshOp( 0 )
+ myShapeByMeshOp( 0 ),
+ myHypoSet( 0 )
{
if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists
GeometryGUI::InitGeomGen();
{
dlg()->show();
if ( aMess != "" )
- SUIT_MessageBox::warn1( myDlg,
- tr( "SMESH_WRN_WARNING" ), aMess, tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning( myDlg, tr( "SMESH_WRN_WARNING" ), aMess );
return false;
}
else if ( !myToCreate )
aResult = editMeshOrSubMesh( aMess );
if ( aResult )
+ {
+ SMESHGUI::Modified();
update( UF_ObjBrowser | UF_Model );
+ }
}
catch ( const SALOME::SALOME_Exception& S_ex )
{
{
if ( aMess == "" )
aMess = tr( "SMESH_OPERATION_FAILED" );
- SUIT_MessageBox::warn1( myDlg,
- tr( "SMESH_ERROR" ), aMess, tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning( myDlg, tr( "SMESH_ERROR" ), aMess );
}
return aResult;
// mesh
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() );
+ _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
if (!pMesh) return false;
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
// check all selected shapes
QStringList::const_iterator aSubShapesIter = aGEOMs.begin();
- for (; aSubShapesIter != aGEOMs.end(); aSubShapesIter++) {
+ for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++) {
QString aSubGeomEntry = (*aSubShapesIter);
- _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.latin1());
+ _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data());
if (!pSubGeom) return false;
GEOM::GEOM_Object_var aSubGeomVar =
while(1) {
if (mainObj->_is_nil())
return false;
- if (string(mainObj->GetEntry()) == string(mainGeom->GetEntry()))
+ if (std::string(mainObj->GetEntry()) == std::string(mainGeom->GetEntry()))
return true;
mainObj = op->GetMainShape(mainObj);
}
return false;
}
+//================================================================================
+/*!
+ * \brief Return name of the algorithm that does not support submeshes and makes
+ * submesh creation useless
+ * \retval char* - string is to be deleted!!!
+ */
+//================================================================================
+
+char* SMESHGUI_MeshOp::isSubmeshIgnored() const
+{
+ if ( myToCreate && !myIsMesh ) {
+
+ QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
+ QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
+ _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
+ if ( pMesh ) {
+
+ QStringList algoNames;
+ THypList algoList;
+ existingHyps(3, Algo, pMesh, algoNames, algoList);
+ if (!algoList.empty()) {
+ HypothesisData* algo = SMESH::GetHypothesisData( algoList[0].first->GetName() );
+ if ( algo &&
+ algo->InputTypes.empty() && // builds all dimensions it-self
+ !algo->IsSupportSubmeshes )
+ return CORBA::string_dup( algoNames[0].toLatin1().data() );
+ }
+
+// GEOM::GEOM_Object_var geom;
+// if (_PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() ))
+// geom = SMESH::SObjectToInterface<GEOM::GEOM_Object>( pGeom );
+
+// if ( !geom->_is_nil() && geom->GetShapeType() >= GEOM::FACE ) { // WIRE, EDGE as well
+ existingHyps(2, Algo, pMesh, algoNames, algoList);
+ if (!algoList.empty()) {
+ HypothesisData* algo = SMESH::GetHypothesisData( algoList[0].first->GetName() );
+ if ( algo &&
+ algo->InputTypes.empty() && // builds all dimensions it-self
+ !algo->IsSupportSubmeshes )
+ return CORBA::string_dup( algoNames[0].toLatin1().data() );
+ }
+// }
+ }
+ }
+ return 0;
+}
+
//================================================================================
/*!
* \brief find an existing submesh by the selected shape
- * \retval _PTR(SObject) - the found submesh SObject
+ * \retval _PTR(SObject) - the found submesh SObject
*/
//================================================================================
{
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() );
- _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.latin1() );
+ _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
+ _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
if ( pMesh && pGeom ) {
GEOM::GEOM_Object_var geom = SMESH::SObjectToInterface<GEOM::GEOM_Object>( pGeom );
if ( !geom->_is_nil() ) {
int tag = -1;
switch ( geom->GetShapeType() ) {
- case GEOM::VERTEX: tag = SMESH::Tag_SubMeshOnVertex ; break;
- case GEOM::EDGE: tag = SMESH::Tag_SubMeshOnEdge ; break;
- case GEOM::WIRE: tag = SMESH::Tag_SubMeshOnWire ; break;
- case GEOM::FACE: tag = SMESH::Tag_SubMeshOnFace ; break;
- case GEOM::SHELL: tag = SMESH::Tag_SubMeshOnShell ; break;
- case GEOM::SOLID: tag = SMESH::Tag_SubMeshOnSolid ; break;
+ case GEOM::VERTEX: tag = SMESH::Tag_SubMeshOnVertex; break;
+ case GEOM::EDGE: tag = SMESH::Tag_SubMeshOnEdge; break;
+ case GEOM::WIRE: tag = SMESH::Tag_SubMeshOnWire; break;
+ case GEOM::FACE: tag = SMESH::Tag_SubMeshOnFace; break;
+ case GEOM::SHELL: tag = SMESH::Tag_SubMeshOnShell; break;
+ case GEOM::SOLID: tag = SMESH::Tag_SubMeshOnSolid; break;
case GEOM::COMPOUND: tag = SMESH::Tag_SubMeshOnCompound; break;
default:;
}
if ( pMesh->FindSubObject( tag, aSubmeshRoot ) )
{
_PTR(ChildIterator) smIter = aStudy->NewChildIterator( aSubmeshRoot );
- for (; smIter->More(); smIter->Next() )
+ for ( ; smIter->More(); smIter->Next() )
{
_PTR(SObject) aSmObj = smIter->Value();
if ( ! aSmObj->FindAttribute( anAttr, "AttributeIOR" ))
continue;
_PTR(ChildIterator) anIter1 = aStudy->NewChildIterator(aSmObj);
- for (; anIter1->More(); anIter1->Next()) {
+ for ( ; anIter1->More(); anIter1->Next()) {
_PTR(SObject) pGeom2 = anIter1->Value();
if ( pGeom2->ReferencedObject( pGeom2 ) &&
pGeom2->GetID() == pGeom->GetID() )
//================================================================================
void SMESHGUI_MeshOp::selectionDone()
{
- if (!dlg()->isShown() || !myDlg->isEnabled())
+ if (!dlg()->isVisible() || !myDlg->isEnabled())
return;
SMESHGUI_SelectionOp::selectionDone();
//Check geometry for mesh
QString anObjEntry = myDlg->selectedObject(SMESHGUI_MeshDlg::Obj);
- _PTR(SObject) pObj = studyDS()->FindObjectID(anObjEntry.latin1());
+ _PTR(SObject) pObj = studyDS()->FindObjectID(anObjEntry.toLatin1().data());
if (pObj)
{
SMESH::SMESH_Mesh_var aMeshVar =
aSeq->length(aGEOMs.count());
QStringList::const_iterator aSubShapesIter = aGEOMs.begin();
int iSubSh = 0;
- for (; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
+ for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
QString aSubGeomEntry = (*aSubShapesIter);
- _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.latin1());
+ _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data());
GEOM::GEOM_Object_var aSubGeomVar =
GEOM::GEOM_Object::_narrow(_CAST(SObject,pSubGeom)->GetObject());
aSeq[iSubSh] = aSubGeomVar;
} else {
// get geometry by selected sub-mesh
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.latin1() );
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
if (!aGeomVar->_is_nil()) {
aSeq->length(1);
for (int iss = 0; iss < aSeq->length() && shapeDim < 3; iss++) {
GEOM::GEOM_Object_var aGeomVar = aSeq[iss];
switch ( aGeomVar->GetShapeType() ) {
- case GEOM::SOLID:
- case GEOM::SHELL: shapeDim = 3; break;
+ case GEOM::SOLID: shapeDim = 3; break;
+ case GEOM::SHELL:
+ {
+ //shapeDim = 3; // Bug 0016155: EDF PAL 447: If the shape is a Shell, disable 3D tab
+ shapeDim = (shapeDim < 2) ? 2 : shapeDim;
+ TopoDS_Shape aShape;
+ if (GEOMBase::GetShape(aGeomVar, aShape)) {
+ if (/*aShape.Closed()*/BRep_Tool::IsClosed(aShape))
+ shapeDim = 3;
+ }
+ }
+ break;
case GEOM::FACE: shapeDim = (shapeDim < 2) ? 2 : shapeDim; break;
case GEOM::WIRE:
case GEOM::EDGE: shapeDim = (shapeDim < 1) ? 1 : shapeDim; break;
case GEOM::VERTEX: break;
default:
- TopoDS_Shape aShape;
- if ( GEOMBase::GetShape(aGeomVar, aShape)) {
- TopExp_Explorer exp( aShape, TopAbs_SHELL );
- if ( exp.More() )
- shapeDim = 3;
- else if ( exp.Init( aShape, TopAbs_FACE ), exp.More() )
- shapeDim = (shapeDim < 2) ? 2 : shapeDim;
- else if ( exp.Init( aShape, TopAbs_EDGE ), exp.More() )
- shapeDim = (shapeDim < 1) ? 1 : shapeDim;
- else
- ;//shapeDim = 0;
+ {
+ TopoDS_Shape aShape;
+ if (GEOMBase::GetShape(aGeomVar, aShape)) {
+ TopExp_Explorer exp (aShape, TopAbs_SHELL);
+ if (exp.More()) {
+ //shapeDim = 3; // Bug 0016155: EDF PAL 447: If the shape is a Shell, disable 3D tab
+ shapeDim = (shapeDim < 2) ? 2 : shapeDim;
+ for (; exp.More() && shapeDim == 2; exp.Next()) {
+ if (/*exp.Current().Closed()*/BRep_Tool::IsClosed(exp.Current()))
+ shapeDim = 3;
+ }
+ }
+ else if ( exp.Init( aShape, TopAbs_FACE ), exp.More() )
+ shapeDim = (shapeDim < 2) ? 2 : shapeDim;
+ else if ( exp.Init( aShape, TopAbs_EDGE ), exp.More() )
+ shapeDim = (shapeDim < 1) ? 1 : shapeDim;
+ else
+ ;//shapeDim = 0;
+ }
}
}
}
}
+ for (int i = SMESH::DIM_3D; i > shapeDim; i--) {
+ // reset algos before disabling tabs (0020138)
+ onAlgoSelected(-1, i);
+ }
myDlg->setMaxHypoDim( shapeDim );
SMESH::SMESH_subMesh_var sm =
SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( pSubmesh );
bool editSubmesh = ( !sm->_is_nil() &&
- SUIT_MessageBox::question2( myDlg, tr( "SMESH_WARNING" ),
- tr( "EDIT_SUBMESH_QUESTION"),
- tr( "SMESH_BUT_YES" ),
- tr( "SMESH_BUT_NO" ), 1, 0, 0 ));
+ SUIT_MessageBox::question( myDlg, tr( "SMESH_WARNING" ),
+ tr( "EDIT_SUBMESH_QUESTION"),
+ SUIT_MessageBox::Yes |
+ SUIT_MessageBox::No,
+ SUIT_MessageBox::No )
+ == SUIT_MessageBox::Yes );
if ( editSubmesh )
{
selectionMgr()->clearFilters();
myDlg->selectObject( "", SMESHGUI_MeshDlg::Geom, "" );
selectObject( _PTR(SObject)() );
selectionDone();
+ return;
}
}
+ // discard selected mesh if submesh creation not allowed because of
+ // a global algorithm that does not support submeshes
+ if ( char* algoName = isSubmeshIgnored() ) {
+ SUIT_MessageBox::warning( myDlg, tr( "SMESH_ERROR" ),
+ tr("SUBMESH_NOT_ALLOWED").arg(algoName));
+ CORBA::string_free( algoName );
+ myDlg->selectObject( "", SMESHGUI_MeshDlg::Mesh, "" );
+ selectObject( _PTR(SObject)() );
+ selectionDone();
+ return;
+ }
// enable/disable popup for choice of geom selection way
bool enable = false;
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() )) {
+ if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() )) {
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
if ( !mesh->_is_nil() )
enable = ( shapeDim > 1 ) && ( mesh->NbEdges() > 0 );
}
// Name
- QString aMeshName = myDlg->objectText( SMESHGUI_MeshDlg::Obj );
- aMeshName = aMeshName.stripWhiteSpace();
- if ( aMeshName == "" )
+ QString aMeshName = myDlg->objectText( SMESHGUI_MeshDlg::Obj ).trimmed();
+ if ( aMeshName.isEmpty() )
{
theMess = myIsMesh ? tr( "NAME_OF_MESH_IS_EMPTY" ) : tr( "NAME_OF_SUBMESH_IS_EMPTY" );
return false;
{
QString aMeshEntry = myDlg->selectedObject
( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj );
- if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() )) {
+ if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() )) {
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
if ( !mesh->_is_nil() && CORBA::is_nil( mesh->GetShapeToMesh() )) {
theMess = tr( "IMPORTED_MESH" );
theMess = tr( "GEOMETRY_OBJECT_IS_NOT_DEFINED" );
return false;
}
- _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.latin1() );
+ _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
if ( !pGeom || GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() )->_is_nil() )
{
theMess = tr( "GEOMETRY_OBJECT_IS_NULL" );
theMess = tr( "MESH_IS_NOT_DEFINED" );
return false;
}
- _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() );
+ _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
if ( !pMesh || SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() )->_is_nil() )
{
theMess = tr( "MESH_IS_NULL" );
{
_PTR(ChildIterator) anIter =
SMESH::GetActiveStudyDocument()->NewChildIterator( aHypRoot );
- for (; anIter->More(); anIter->Next() )
+ for ( ; anIter->More(); anIter->Next() )
{
_PTR(SObject) anObj = anIter->Value();
if ( isMesh ) // i.e. mesh or submesh
SMESH::SMESH_Hypothesis_var aHypVar = SMESH::SMESH_Hypothesis::_narrow( aVar );
if ( !aHypVar->_is_nil() )
{
- CORBA::String_var aHypType( aHypVar->GetName() );
- HypothesisData* aData = SMESH::GetHypothesisData( aHypType );
+ HypothesisData* aData = SMESH::GetHypothesisData( aHypVar->GetName() );
if ( ( theDim == -1 || aData->Dim.contains( theDim ) ) &&
( isCompatible ( theAlgoData, aData, theHypType )) &&
( isAux == aData->IsAux ))
const int nbColonsInMeshEntry = 3;
bool isSubMesh = myToCreate ?
!myIsMesh :
- myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ).contains(':') > nbColonsInMeshEntry;
+ myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ).count(':') > nbColonsInMeshEntry;
+ // get mesh and geom object
+ SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_nil();
+ GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_nil();
+
+ QString anEntry;
if ( isSubMesh )
{
- // get mesh and geom object
- SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_nil();
- GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_nil();
-
- QString anEntry = myDlg->selectedObject
+ anEntry = myDlg->selectedObject
( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj );
- if ( _PTR(SObject) pObj = studyDS()->FindObjectID( anEntry.latin1() ))
+ if ( _PTR(SObject) pObj = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
{
CORBA::Object_ptr Obj = _CAST( SObject,pObj )->GetObject();
if ( myToCreate ) // mesh and geom may be selected
{
aMeshVar = SMESH::SMESH_Mesh::_narrow( Obj );
anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.latin1() ))
+ if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
else // edition: sub-mesh may be selected
}
}
}
-
- if ( !aMeshVar->_is_nil() && !aGeomVar->_is_nil() )
- return SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType,
- aServerLib,
- aMeshVar,
- aGeomVar );
}
- return SMESH::SMESH_Hypothesis::_nil();
+ else // mesh
+ {
+ if ( !myToCreate ) // mesh to edit can be selected
+ {
+ anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
+ if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
+ {
+ aMeshVar = SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
+ if ( !aMeshVar->_is_nil() )
+ aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pMesh );
+ }
+ }
+ if ( aGeomVar->_is_nil() ) {
+ anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
+ if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
+ {
+ aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
+ }
+ }
+ }
+
+ SMESH::SMESH_Hypothesis_var hyp =
+ SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toLatin1().data(),
+ aServerLib.toLatin1().data(),
+ aMeshVar,
+ aGeomVar,
+ /*byMesh = */isSubMesh);
+ if ( hyp->_is_nil() && isSubMesh )
+ hyp = SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toLatin1().data(),
+ aServerLib.toLatin1().data(),
+ aMeshVar,
+ aGeomVar,
+ /*byMesh = */false);
+ return hyp;
}
//================================================================================
createHypothesis(aDim, theHypType, aHypTypeName);
}
-//================================================================================
-/*!
- * Create hypothesis and update dialog.
- * \param theDim - dimension of hypothesis to be created
- * \param theType - hypothesis category (algorithm, hypothesis, additional hypothesis)
- * \param theTypeName - specifies hypothesis to be created
- */
-//================================================================================
namespace
{
QString GetUniqueName (const QStringList& theHypNames,
}
}
-void SMESHGUI_MeshOp::createHypothesis (const int theDim,
+//================================================================================
+/*!
+ * Create hypothesis and update dialog.
+ * \param theDim - dimension of hypothesis to be created
+ * \param theType - hypothesis category (algorithm, hypothesis, additional hypothesis)
+ * \param theTypeName - specifies hypothesis to be created
+ */
+//================================================================================
+
+void SMESHGUI_MeshOp::createHypothesis(const int theDim,
const int theType,
const QString& theTypeName)
{
- // During a hypothesis creation we might need to select some objects.
- // Main dialog must not update it's own selected objects in this case.
- dlg()->deactivateAll();
-
- HypothesisData* aData = SMESH::GetHypothesisData(theTypeName.latin1());
+ HypothesisData* aData = SMESH::GetHypothesisData(theTypeName);
if (!aData)
return;
+ myDim = theDim;
+ myType = theType;
QStringList aHypNames;
TDim2Type2HypList::const_iterator aDimIter = myExistingHyps.begin();
- for (; aDimIter != myExistingHyps.end(); aDimIter++) {
- const TType2HypList& aType2HypList = aDimIter.data();
+ for ( ; aDimIter != myExistingHyps.end(); aDimIter++) {
+ const TType2HypList& aType2HypList = aDimIter.value();
TType2HypList::const_iterator aTypeIter = aType2HypList.begin();
- for (; aTypeIter != aType2HypList.end(); aTypeIter++) {
- const THypList& aHypList = aTypeIter.data();
+ for ( ; aTypeIter != aType2HypList.end(); aTypeIter++) {
+ const THypList& aHypList = aTypeIter.value();
THypList::const_iterator anIter = aHypList.begin();
- for (; anIter != aHypList.end(); anIter++) {
+ for ( ; anIter != aHypList.end(); anIter++) {
const THypItem& aHypItem = *anIter;
const QString& aHypName = aHypItem.second;
aHypNames.append(aHypName);
QString aHypName = GetUniqueName( aHypNames, aData->Label);
// existing hypos
- int nbHyp = myExistingHyps[theDim][theType].count();
+ bool dialog = false;
QString aClientLibName = aData->ClientLibName;
if (aClientLibName == "") {
SMESH::CreateHypothesis(theTypeName, aHypName, false);
} else {
// Get hypotheses creator client (GUI)
+ // BUG 0020378
+ //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(theTypeName);
SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(theTypeName);
// Create hypothesis
if (aCreator) {
- // When create or edit a submesh, try to initialize a new hypothesis
- // with values used to mesh a subshape
+ // Get parameters appropriate to initialize a new hypothesis
SMESH::SMESH_Hypothesis_var initParamHyp =
getInitParamsHypothesis(theTypeName, aData->ServerLibName);
+
+ removeCustomFilters(); // Issue 0020170
+
+ // Get Entry of the Geom object
+ QString aGeomEntry = "";
+ QString aMeshEntry = "";
+ QString anObjEntry = "";
+ aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
+ aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
+ anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
+
+ if ( aMeshEntry != "" ) { // Get Geom object from Mesh
+ _PTR(SObject) pObj = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
+ GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
+ aMeshEntry = ( aGeomVar->_is_nil() ) ? "" : aMeshEntry = aGeomVar->GetStudyEntry();
+ }
+
+ if ( aMeshEntry == "" && aGeomEntry == "" ) {
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
+ GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
+ if ( !aGeomVar->_is_nil() )
+ aGeomEntry = aGeomVar->GetStudyEntry();
+ }
+
+ if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) { // take geometry from submesh
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
+ if ( pObj ) {
+ // if current object is sub-mesh
+ SMESH::SMESH_subMesh_var aSubMeshVar =
+ SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
+ if ( !aSubMeshVar->_is_nil() ) {
+ SMESH::SMESH_Mesh_var aMeshVar = aSubMeshVar->GetFather();
+ if ( !aMeshVar->_is_nil() ) {
+ _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar );
+ GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( aMeshSO );
+ if ( !aGeomVar->_is_nil() )
+ aMeshEntry = aGeomVar->GetStudyEntry();
+ }
+ }
+ }
+ }
+
+ aCreator->setShapeEntry( aGeomEntry );
+ if ( aMeshEntry != "" )
+ aCreator->setMainShapeEntry( aMeshEntry );
myDlg->setEnabled( false );
- aCreator->create(initParamHyp, aHypName, myDlg);
- myDlg->setEnabled( true );
- } else {
- SMESH::CreateHypothesis(theTypeName, aHypName, false);
+ aCreator->create(initParamHyp, aHypName, myDlg, this, SLOT( onHypoCreated( int ) ) );
+ dialog = true;
}
+ else
+ SMESH::CreateHypothesis(theTypeName, aHypName, false);
+ }
+
+ if( !dialog )
+ onHypoCreated(2);
+}
+
+//================================================================================
+/*!
+ * Necessary steps after hypothesis creation
+ * \param result - creation result:
+ * 0 = rejected
+ * 1 = accepted
+ * 2 = additional value meaning that slot is called not from dialog box
+ */
+//================================================================================
+void SMESHGUI_MeshOp::onHypoCreated( int result )
+{
+ if( result != 2 )
+ {
+ int obj = myDlg->getActiveObject();
+ onActivateObject( obj ); // Issue 0020170. Restore filters
+ myDlg->setEnabled( true );
}
_PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent("SMESH");
- HypothesisData* algoData = hypData( theDim, Algo, currentHyp( theDim, Algo ));
+ int nbHyp = myExistingHyps[myDim][myType].count();
+ HypothesisData* algoData = hypData( myDim, Algo, currentHyp( myDim, Algo ));
QStringList aNewHyps;
- existingHyps(theDim, theType, aFather, aNewHyps, myExistingHyps[theDim][theType], algoData);
- if (aNewHyps.count() > nbHyp) {
+ existingHyps(myDim, myType, aFather, aNewHyps, myExistingHyps[myDim][myType], algoData);
+ if (aNewHyps.count() > nbHyp)
+ {
for (int i = nbHyp; i < aNewHyps.count(); i++)
- myDlg->tab(theDim)->addHyp(theType, aNewHyps[i]);
+ myDlg->tab(myDim)->addHyp(myType, aNewHyps[i]);
}
+
+ if( result!=2 && myHypoSet )
+ processSet();
}
//================================================================================
if ( aHyp->_is_nil() )
return;
- CORBA::String_var aTypeName = aHyp->GetName();
- SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator( aTypeName );
- if ( aCreator ) {
+ // BUG 0020378
+ //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHyp->GetName());
+ SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHyp->GetName());
+ if ( aCreator )
+ {
+ // Get initial parameters
+ SMESH::SMESH_Hypothesis_var initParamHyp =
+ getInitParamsHypothesis( aHyp->GetName(), aHyp->GetLibName());
+ aCreator->setInitParamsHypothesis( initParamHyp );
+
+ // Get Entry of the Geom object
+ QString aGeomEntry = "";
+ QString aMeshEntry = "";
+ QString anObjEntry = "";
+ aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
+ aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
+ anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
+
+ if ( aMeshEntry != "" ) { // Get Geom object from Mesh
+ _PTR(SObject) pObj = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
+ GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
+ aMeshEntry = ( aGeomVar->_is_nil() ) ? "" : aMeshEntry = aGeomVar->GetStudyEntry();
+ }
+
+ if ( aMeshEntry == "" && aGeomEntry == "" ) {
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
+ GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
+ if ( !aGeomVar->_is_nil() )
+ aGeomEntry = aGeomVar->GetStudyEntry();
+ }
+
+ if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) { // take geometry from submesh
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
+ if ( pObj ) {
+ // if current object is sub-mesh
+ SMESH::SMESH_subMesh_var aSubMeshVar =
+ SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
+ if ( !aSubMeshVar->_is_nil() ) {
+ SMESH::SMESH_Mesh_var aMeshVar = aSubMeshVar->GetFather();
+ if ( !aMeshVar->_is_nil() ) {
+ _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar );
+ GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( aMeshSO );
+ if ( !aGeomVar->_is_nil() )
+ aMeshEntry = aGeomVar->GetStudyEntry();
+ }
+ }
+ }
+ }
+
+ aCreator->setShapeEntry( aGeomEntry );
+ if ( aMeshEntry != "" )
+ aCreator->setMainShapeEntry( aMeshEntry );
+ removeCustomFilters(); // Issue 0020170
myDlg->setEnabled( false );
- aCreator->edit( aHyp.in(), aHypItem.second, dlg() );
- myDlg->setEnabled( true );
+ aCreator->edit( aHyp.in(), aHypItem.second, dlg(), this, SLOT( onHypoEdited( int ) ) );
}
}
+//================================================================================
+/*!
+ * Necessary steps after hypothesis edition
+ * \param result - creation result:
+ * 0 = rejected
+ * 1 = accepted
+ */
+//================================================================================
+void SMESHGUI_MeshOp::onHypoEdited( int result )
+{
+ int obj = myDlg->getActiveObject();
+ onActivateObject( obj ); // Issue 0020170. Restore filters
+ myDlg->setEnabled( true );
+}
+
//================================================================================
/*!
* \brief access to hypothesis data
}
HypothesisData* prevAlgo = algoData;
bool noCompatible = false;
- for (; dim * dir <= lastDim * dir; dim += dir)
+ for ( ; dim * dir <= lastDim * dir; dim += dir)
{
if ( !isAccessibleDim( dim ))
continue;
noCompatible = anAvailable.isEmpty();
// restore previously selected algo
- algoIndex = myAvailableHypData[dim][Algo].findIndex( curAlgo );
+ algoIndex = myAvailableHypData[dim][Algo].indexOf( curAlgo );
if ( !isSubmesh && algoIndex < 0 && soleCompatible && !forward && dim != SMESH::DIM_0D)
// select the sole compatible algo
- algoIndex = myAvailableHypData[dim][Algo].findIndex( soleCompatible );
+ algoIndex = myAvailableHypData[dim][Algo].indexOf( soleCompatible );
setCurrentHyp( dim, Algo, algoIndex );
// remember current algo
CORBA::String_var curHypType = curHyp->GetName();
if ( !algoDeselectedByUser &&
myObjHyps[ dim ][ type ].count() > 0 &&
- curHypType == myObjHyps[ dim ][ type ].first().first->GetName())
+ !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
{
- CORBA::String_var aName = curHyp->GetName();
- HypothesisData* hypData = SMESH::GetHypothesisData( aName );
+ HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
for (int i = 0; i < myAvailableHypData[ dim ][ Algo ].count(); ++i) {
curAlgo = myAvailableHypData[ dim ][ Algo ][ i ];
if (curAlgo && hypData && isCompatible(curAlgo, hypData, type))
{
// check if a selected hyp is compatible with the curAlgo
if ( !curHyp->_is_nil() ) {
- CORBA::String_var aName = curHyp->GetName();
- HypothesisData* hypData = SMESH::GetHypothesisData( aName );
+ HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
if ( !isCompatible( curAlgo, hypData, type ))
curHyp = SMESH::SMESH_Hypothesis::_nil();
}
//================================================================================
void SMESHGUI_MeshOp::onHypoSet( const QString& theSetName )
{
- HypothesesSet* aHypoSet = SMESH::GetHypothesesSet(theSetName);
- if (!aHypoSet) return;
+ myHypoSet = SMESH::GetHypothesesSet(theSetName);
+ if (!myHypoSet)
+ return;
// clear all hyps
for (int dim = SMESH::DIM_0D; dim <= SMESH::DIM_3D; dim++) {
setCurrentHyp(dim, MainHyp, -1);
}
- for (int aHypType = Algo; aHypType < AddHyp; aHypType++) {
- bool isAlgo = (aHypType == Algo);
+ myHypoSet->init(true); //algorithms
+ processSet();
+ myHypoSet->init(false); //hypotheses
+ processSet();
+ myHypoSet = 0;
+}
- // set hyps from the set
- QStringList* aHypoList = isAlgo ? &aHypoSet->AlgoList : &aHypoSet->HypoList;
- for (int i = 0, n = aHypoList->count(); i < n; i++) {
- const QString& aHypoTypeName = (*aHypoList)[ i ];
- HypothesisData* aHypData = SMESH::GetHypothesisData(aHypoTypeName);
- if (!aHypData)
- continue;
+//================================================================================
+/*!
+ * \brief One step of hypothesis/algorithm list creation
+ *
+ * Creates a hypothesis or an algorithm for current item of internal list of names myHypoSet
+ */
+//================================================================================
+void SMESHGUI_MeshOp::processSet()
+{
+ myHypoSet->next();
+ if( !myHypoSet->more() )
+ return;
- int aDim = aHypData->Dim[0];
- // create or/and set
- if (isAlgo) {
- int index = myAvailableHypData[aDim][Algo].findIndex( aHypData );
- if ( index < 0 ) {
- QStringList anAvailable;
- availableHyps( aDim, Algo, anAvailable, myAvailableHypData[aDim][Algo] );
- myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
- index = myAvailableHypData[aDim][Algo].findIndex( aHypData );
- }
- setCurrentHyp( aDim, Algo, index );
- onAlgoSelected( index, aDim );
- }
- else {
- bool mainHyp = true;
- QStringList anAvailable;
- availableHyps( aDim, MainHyp, anAvailable, myAvailableHypData[aDim][MainHyp] );
- myDlg->tab( aDim )->setAvailableHyps( MainHyp, anAvailable );
- int index = myAvailableHypData[aDim][MainHyp].findIndex( aHypData );
- if ( index < 0 ) {
- mainHyp = false;
- index = myAvailableHypData[aDim][AddHyp].findIndex( aHypData );
- }
- if (index >= 0)
- createHypothesis(aDim, mainHyp ? MainHyp : AddHyp, aHypoTypeName);
- }
- } // loop on hypos in the set
- } // loop on algo/hypo
+ bool isAlgo = myHypoSet->isAlgo();
+ QString aHypoTypeName = myHypoSet->current();
+ HypothesisData* aHypData = SMESH::GetHypothesisData(aHypoTypeName);
+ if (!aHypData)
+ {
+ processSet();
+ return;
+ }
+
+ int aDim = aHypData->Dim[0];
+ // create or/and set
+ if (isAlgo)
+ {
+ int index = myAvailableHypData[aDim][Algo].indexOf( aHypData );
+ if ( index < 0 )
+ {
+ QStringList anAvailable;
+ availableHyps( aDim, Algo, anAvailable, myAvailableHypData[aDim][Algo] );
+ myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
+ index = myAvailableHypData[aDim][Algo].indexOf( aHypData );
+ }
+ setCurrentHyp( aDim, Algo, index );
+ onAlgoSelected( index, aDim );
+ processSet();
+ }
+ else
+ {
+ bool mainHyp = true;
+ QStringList anAvailable;
+ availableHyps( aDim, MainHyp, anAvailable, myAvailableHypData[aDim][MainHyp] );
+ myDlg->tab( aDim )->setAvailableHyps( MainHyp, anAvailable );
+ int index = myAvailableHypData[aDim][MainHyp].indexOf( aHypData );
+ if ( index < 0 )
+ {
+ mainHyp = false;
+ index = myAvailableHypData[aDim][AddHyp].indexOf( aHypData );
+ }
+ if (index >= 0)
+ createHypothesis(aDim, mainHyp ? MainHyp : AddHyp, aHypoTypeName);
+ else
+ processSet();
+ }
}
//================================================================================
QStringList aList;
myDlg->selectedObject( SMESHGUI_MeshDlg::Geom, aList );
QStringList::Iterator it = aList.begin();
- for (; it!=aList.end(); it++)
+ for ( ; it!=aList.end(); it++)
{
QString aGeomEntry = *it;
- _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.latin1() );
+ _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
GEOM::GEOM_Object_var aGeomVar =
GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
return false;
_PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar.in() );
if ( aMeshSO )
- SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ).latin1() );
+ SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ ) {
if ( !isAccessibleDim( aDim )) continue;
// get mesh object
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() );
+ _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
SMESH::SMESH_Mesh_var aMeshVar =
SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if (aMeshVar->_is_nil())
{
//QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
QString aGeomEntry = aGEOMs.first();
- _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.latin1() );
+ _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
aGeomVar = GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
else if (aGEOMs.count() > 1)
GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
aSeq->length(aGEOMs.count());
QStringList::const_iterator aSubShapesIter = aGEOMs.begin();
- for (; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
+ for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
QString aSubGeomEntry = (*aSubShapesIter);
- _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.latin1());
+ _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data());
GEOM::GEOM_Object_var aSubGeomVar =
GEOM::GEOM_Object::_narrow(_CAST(SObject,pSubGeom)->GetObject());
TopAbs_ShapeEnum aSubShapeType = (TopAbs_ShapeEnum)aSubGeomVar->GetShapeType();
QString aNewGeomGroupName ("Auto_group_for_");
aNewGeomGroupName += aName;
SALOMEDS::SObject_var aNewGroupSO =
- geomGen->AddInStudy(aSMESHGen->GetCurrentStudy(), aGeomVar, aNewGeomGroupName, mainGeom);
+ geomGen->AddInStudy(aSMESHGen->GetCurrentStudy(), aGeomVar,
+ aNewGeomGroupName.toLatin1().data(), mainGeom);
}
}
}
SUIT_OverrideCursor aWaitCursor;
// create sub-mesh
- SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.latin1() );
+ SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toLatin1().data() );
+ _PTR(SObject) aSubMeshSO = SMESH::FindSObject( aSubMeshVar.in() );
+ if ( aSubMeshSO )
+ SMESH::SetName( aSubMeshSO, aName.toLatin1().data() );
for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ )
{
//================================================================================
bool SMESHGUI_MeshOp::isAccessibleDim( const int theDim ) const
{
- return myDlg->tab( theDim )->isEnabled();
+ return myDlg->isTabEnabled( theDim );
}
//================================================================================
do
{
aResName = aPrefix + QString::number( i++ );
- anObj = aStudy->FindObject( aResName.latin1() );
+ anObj = aStudy->FindObject( aResName.toLatin1().data() );
}
while ( anObj );
QStringList tmp;
existingHyps( theDim, Algo, pObj, tmp, myExistingHyps[ theDim ][ Algo ]);
- // look for anexisting algo of such a type
+ // look for an existing algo of such a type
THypList& aHypVarList = myExistingHyps[ theDim ][ Algo ];
THypList::iterator anIter = aHypVarList.begin();
- for (; anIter != aHypVarList.end(); anIter++)
+ for ( ; anIter != aHypVarList.end(); anIter++)
{
SMESH::SMESH_Hypothesis_var aHypVar = (*anIter).first;
CORBA::String_var aName = aHypVar->GetName();
- if ( !aHypVar->_is_nil() && aHypName == aName )
+ if ( !aHypVar->_is_nil() && !strcmp(aHypName.toLatin1().data(), aName) )
{
anAlgoVar = aHypVar;
break;
}
}
- if (anAlgoVar->_is_nil()) {
+ if (anAlgoVar->_is_nil())
+ {
HypothesisData* aHypData = SMESH::GetHypothesisData( aHypName );
- if (aHypData) {
+ if (aHypData)
+ {
QString aClientLibName = aHypData->ClientLibName;
- if (aClientLibName == "") {
+ if (aClientLibName == "")
+ {
// Call hypothesis creation server method (without GUI)
SMESH::CreateHypothesis(aHypName, aHypData->Label, true);
- } else {
+ }
+ else
+ {
// Get hypotheses creator client (GUI)
+ // BUG 0020378
+ //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypName);
SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypName);
// Create algorithm
if (aCreator)
- aCreator->create(true, aHypName, myDlg);
+ aCreator->create(true, aHypName, myDlg, 0, QString::null );
else
SMESH::CreateHypothesis(aHypName, aHypData->Label, true);
}
{
SMESH::SMESH_Hypothesis_var aHypVar = (*anIter).first;
CORBA::String_var aName = aHypVar->GetName();
- if ( !aHypVar->_is_nil() && aHypName == aName )
+ if ( !aHypVar->_is_nil() && !strcmp(aHypName.toLatin1().data(), aName) )
{
anAlgoVar = aHypVar;
break;
void SMESHGUI_MeshOp::readMesh()
{
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.latin1() );
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
if ( !pObj )
return;
if ( myObjHyps[ dim ][ Algo ].count() > 0 )
{
SMESH::SMESH_Hypothesis_var aVar = myObjHyps[ dim ][ Algo ].first().first;
- CORBA::String_var aHypTypeName = aVar->GetName();
- HypothesisData* algoData = SMESH::GetHypothesisData( aHypTypeName );
- aHypIndex = myAvailableHypData[ dim ][ Algo ].findIndex ( algoData );
+ HypothesisData* algoData = SMESH::GetHypothesisData( aVar->GetName() );
+ aHypIndex = myAvailableHypData[ dim ][ Algo ].indexOf ( algoData );
// if ( aHypIndex < 0 && algoData ) {
// // assigned algo is incompatible with other algorithms
// myAvailableHypData[ dim ][ Algo ].push_back( algoData );
{
int i = 0;
THypList::const_iterator anIter = theHypList.begin();
- for (; anIter != theHypList.end(); ++ anIter)
+ for ( ; anIter != theHypList.end(); ++ anIter)
{
if ( theHyp->_is_equivalent( (*anIter).first ) )
{
return false;
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.latin1() );
+ _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
if ( !pObj )
return false;
// Set new name
QString aName = myDlg->objectText( SMESHGUI_MeshDlg::Obj );
- SMESH::SetName( pObj, aName.latin1() );
+ SMESH::SetName( pObj, aName );
int aDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_3D;
// First, remove old algos in order to avoid messages on algorithm hiding
// remove old hypotheses
if ( myObjHyps[ dim ][ hypType ].count() > 0 )
{
- anOldHypIndex = find( myObjHyps[ dim ][ hypType ].first().first ,
+ anOldHypIndex = find( myObjHyps[ dim ][ hypType ].first().first,
myExistingHyps[ dim ][ hypType ] );
if ( aNewHypIndex != anOldHypIndex || // different hyps
anOldHypIndex == -1 ) // hyps of different algos
}
// set mesh object to SMESHGUI_ShapeByMeshOp and start it
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() )) {
+ if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() )) {
SMESH::SMESH_Mesh_var aMeshVar =
SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if ( !aMeshVar->_is_nil() ) {
if ( !aGeomVar->_is_nil() )
{
QString ID = aGeomVar->GetStudyEntry();
- if ( _PTR(SObject) aGeomSO = studyDS()->FindObjectID( ID.latin1() )) {
+ if ( _PTR(SObject) aGeomSO = studyDS()->FindObjectID( ID.toLatin1().data() )) {
selectObject( aGeomSO );
selectionDone();
}
