ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 02:00:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Adjust to OCC_development_generic_2006

Browse Source
This commit is contained in:
apo 2006-01-16 06:55:29 +00:00
parent 8f99cf3454
commit 475d3c5b4f
15 changed files with 1052 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
idl/SMESH_Gen.idl
View File

@ -138,9 +138,8 @@ module SMESH
raises ( SALOME::SALOME_Exception );
/*!
*
* Return true if hypotheses are defined well
*/
boolean IsReadyToCompute( in SMESH_Mesh theMesh,
in GEOM::GEOM_Object theSubObject )
raises ( SALOME::SALOME_Exception );
@ -161,10 +160,14 @@ module SMESH
raises ( SALOME::SALOME_Exception );
/*!
*
* Return geometrical object the given element is built on.
* The returned geometrical object, if not nil, is either found in the
* study or is published by this method with the given name
*/
// long_array GetSubMeshesState( in object_array theListOfSubShape )
// raises ( SALOME::SALOME_Exception );
GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
in long theElementID,
in string theGeomName)
raises ( SALOME::SALOME_Exception );
};

6
src/SMESHGUI/Makefile.in
View File

@ -108,7 +108,8 @@ LIB_SRC = SMESHGUI.cxx \
SMESHGUI_MeshDlg.cxx \
SMESHGUI_MeshOp.cxx \
SMESHGUI_Displayer.cxx \
SMESHGUI_Hypotheses.cxx
SMESHGUI_Hypotheses.cxx \
SMESHGUI_ShapeByMeshDlg.cxx
LIB_MOC = \
SMESHGUI.h \
@ -155,7 +156,8 @@ LIB_MOC = \
SMESHGUI_Dialog.h \
SMESHGUI_MeshDlg.h \
SMESHGUI_MeshOp.h \
SMESHGUI_Hypotheses.h
SMESHGUI_Hypotheses.h \
SMESHGUI_ShapeByMeshDlg.h
LIB_CLIENT_IDL = SALOME_Exception.idl \

14
src/SMESHGUI/SMESHGUI.cxx
View File

@ -3087,6 +3087,20 @@ LightApp_Operation* SMESHGUI::createOperation( const int id ) const
return op;
}
//================================================================================
/*!
* \brief Stops current operations and starts a given one
* \param id - The id of the operation to start
*/
//================================================================================
void SMESHGUI::switchToOperation(int id)
{
if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
activeStudy()->abortAllOperations();
startOperation( id );
}
LightApp_Displayer* SMESHGUI::displayer()
{
if( !myDisplayer )

1
src/SMESHGUI/SMESHGUI.h
View File

@ -83,6 +83,7 @@ public :
void ResetState() ;
void SetState(int aState) ;
bool DefineDlgPosition(QWidget* aDlg, int& x, int& y) ;
void switchToOperation(int id) ;
virtual bool OnGUIEvent ( int id );
virtual bool OnMousePress ( QMouseEvent*, SUIT_ViewWindow* );

5
src/SMESHGUI/SMESHGUI_GEOMGenUtils.cxx
View File

@ -37,8 +37,11 @@ namespace SMESH {
{
static GEOM::GEOM_Gen_var aGEOMGen;
if(CORBA::is_nil(aGEOMGen))
if(CORBA::is_nil(aGEOMGen)) {
if ( GeometryGUI::GetGeomGen()->_is_nil() )
GeometryGUI::InitGeomGen();
aGEOMGen = GeometryGUI::GetGeomGen();
}
return aGEOMGen;
}

38
src/SMESHGUI/SMESHGUI_MeshDlg.cxx
View File

@ -371,6 +371,7 @@ SMESHGUI_MeshDlg::SMESHGUI_MeshDlg( const bool theToCreate, const bool theIsMesh
createObject( tr( "MESH" ), aGrp, Mesh );
// geometry
createObject( tr( "GEOMETRY" ), aGrp, Geom );
myGeomPopup = 0;
// Create tab widget
@ -520,3 +521,40 @@ void SMESHGUI_MeshDlg::onHypoSetButton()
{
myHypoSetPopup->exec( QCursor::pos() );
}
//================================================================================
/*!
* \brief Enable showing of the popup when Geometry selection btn is clicked
* \param enable - true to enable
*/
//================================================================================
enum { DIRECT_GEOM_INDEX = 0, GEOM_BY_MESH_INDEX };
void SMESHGUI_MeshDlg::setGeomPopupEnabled( const bool enable )
{
if ( QButton* selBtn = dynamic_cast<QButton*>( objectWg( Geom, Btn )))
{
disconnect( selBtn, SIGNAL( toggled(bool) ), this, SLOT( onGeomSelectionButton(bool) ));
if ( enable ) {
if ( ! myGeomPopup ) {
myGeomPopup = new QPopupMenu();
myGeomPopup->insertItem( tr("DIRECT_GEOM_SELECTION"), DIRECT_GEOM_INDEX );
myGeomPopup->insertItem( tr("GEOM_BY_MESH_ELEM_SELECTION"), GEOM_BY_MESH_INDEX );
connect( myGeomPopup, SIGNAL( activated( int ) ), SLOT( onGeomPopup( int ) ) );
}
connect( selBtn, SIGNAL( toggled(bool) ), this, SLOT( onGeomSelectionButton(bool) ));
}
}
}
void SMESHGUI_MeshDlg::onGeomSelectionButton(bool isBtnOn)
{
if ( myGeomPopup && isBtnOn )
myGeomPopup->exec( QCursor::pos() );
}
void SMESHGUI_MeshDlg::onGeomPopup( int index )
{
emit geomSelectionByMesh( index == GEOM_BY_MESH_INDEX );
}

5
src/SMESHGUI/SMESHGUI_MeshDlg.h
View File

@ -71,21 +71,26 @@ public:
void setCurrentTab( const int );
void setMaxHypoDim( const int );
void setHypoSets( const QStringList& );
void setGeomPopupEnabled( const bool );
signals:
void hypoSet( const QString& );
void geomSelectionByMesh( bool );
private slots:
void onHypoSetPopup( int );
void onHypoSetButton();
void onGeomPopup( int );
void onGeomSelectionButton( bool );
private:
QMap< int, SMESHGUI_MeshTab* > myTabs;
QTabWidget* myTabWg;
QPopupMenu* myHypoSetPopup;
QPopupMenu* myGeomPopup;
};
/*!

256
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -31,6 +31,7 @@
#include "SMESHGUI_MeshOp.h"
#include "SMESHGUI_MeshDlg.h"
#include "SMESHGUI_ShapeByMeshDlg.h"
#include "SMESH_TypeFilter.hxx"
#include "SMESHGUI.h"
@ -38,11 +39,14 @@
#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 "GEOM_SelectionFilter.h"
#include "GEOMBase.h"
#include "GeometryGUI.h"
#include "SalomeApp_Tools.h"
#include "SALOMEDSClient_Study.hxx"
@ -51,14 +55,13 @@
#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 "GEOMBase.h"
#include "SALOME_InteractiveObject.hxx"
#include "SALOME_ListIO.hxx"
#include "utilities.h"
@ -68,6 +71,17 @@
#include <TopoDS_Shape.hxx>
#include <TopExp_Explorer.hxx>
enum { GLOBAL_ALGO_TAG =3,
GLOBAL_HYPO_TAG =2,
LOCAL_ALGO_TAG =2,
LOCAL_HYPO_TAG =1,
SUBMESH_ON_EDGE_TAG =5,
SUBMESH_ON_WIRE_TAG =6,
SUBMESH_ON_FACE_TAG =7,
SUBMESH_ON_SHELL_TAG =8,
SUBMESH_ON_SOLID_TAG =9,
SUBMESH_ON_COMPOUND_TAG=10 };
//================================================================================
/*!
* \brief Constructor
@ -81,8 +95,11 @@ SMESHGUI_MeshOp::SMESHGUI_MeshOp( const bool theToCreate, const bool theIsMesh )
: SMESHGUI_SelectionOp(),
myToCreate( theToCreate ),
myIsMesh( theIsMesh ),
myDlg( 0 )
myDlg( 0 ),
myShapeByMeshDlg( 0 )
{
if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists
GeometryGUI::InitGeomGen();
}
//================================================================================
@ -190,6 +207,7 @@ void SMESHGUI_MeshOp::startOperation()
this, SLOT( onEditHyp( const int, const int) ) );
}
connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));
connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));
}
SMESHGUI_SelectionOp::startOperation();
@ -253,6 +271,88 @@ SUIT_SelectionFilter* SMESHGUI_MeshOp::createFilter( const int theId ) const
return 0;
}
//================================================================================
/*!
* \brief check if selected shape is a subshape of the shape to mesh
* \retval bool - check result
*/
//================================================================================
bool SMESHGUI_MeshOp::isSubshapeOk() const
{
if ( !myToCreate || myIsMesh ) // not submesh creation
return false;
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() );
if ( pMesh && pGeom ) {
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
if ( !mesh->_is_nil() ) {
GEOM::GEOM_Object_var mainGeom, subGeom;
mainGeom = mesh->GetShapeToMesh();
subGeom = SMESH::SObjectToInterface<GEOM::GEOM_Object>( pGeom );
if ( !mainGeom->_is_nil() && !subGeom->_is_nil() ) {
TopoDS_Shape mainShape, subShape;
if ( GEOMBase::GetShape( mainGeom, mainShape ) &&
GEOMBase::GetShape( subGeom, subShape ) )
// 1 is index of mainShape itself
return GEOMBase::GetIndex( subShape, mainShape, 0 ) > 1;
}
}
}
return false;
}
//================================================================================
/*!
* \brief find an existing submesh by the selected shape
* \retval _PTR(SObject) - the found submesh SObject
*/
//================================================================================
_PTR(SObject) SMESHGUI_MeshOp::getSubmeshByGeom() const
{
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() );
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::EDGE: tag = SUBMESH_ON_EDGE_TAG ; break;
case GEOM::WIRE: tag = SUBMESH_ON_WIRE_TAG ; break;
case GEOM::FACE: tag = SUBMESH_ON_FACE_TAG ; break;
case GEOM::SHELL: tag = SUBMESH_ON_SHELL_TAG ; break;
case GEOM::SOLID: tag = SUBMESH_ON_SOLID_TAG ; break;
case GEOM::COMPOUND: tag = SUBMESH_ON_COMPOUND_TAG; break;
default:;
}
_PTR(SObject) aSubmeshRoot;
_PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
if ( pMesh->FindSubObject( tag, aSubmeshRoot ) )
{
_PTR(ChildIterator) smIter = aStudy->NewChildIterator( aSubmeshRoot );
for (; smIter->More(); smIter->Next() )
{
_PTR(SObject) aSmObj = smIter->Value();
_PTR(ChildIterator) anIter1 = aStudy->NewChildIterator(aSmObj);
for (; anIter1->More(); anIter1->Next()) {
_PTR(SObject) pGeom2 = anIter1->Value();
if ( pGeom2->ReferencedObject( pGeom2 ) &&
pGeom2->GetID() == pGeom->GetID() )
return aSmObj;
}
}
}
}
}
return _PTR(SObject)();
}
//================================================================================
/*!
* \brief Updates dialog's look and feel
@ -264,9 +364,9 @@ void SMESHGUI_MeshOp::selectionDone()
{
SMESHGUI_SelectionOp::selectionDone();
if ( !myToCreate )
{
try
{
if ( !myToCreate ) // edition
{
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
_PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.latin1() );
@ -282,6 +382,35 @@ void SMESHGUI_MeshOp::selectionDone()
}
else
myDlg->reset();
}
else if ( !myIsMesh ) // submesh creation
{
// if a submesh on the selected shape already exist, pass to submesh edition mode
if ( _PTR(SObject) pSubmesh = getSubmeshByGeom() ) {
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 ));
if ( editSubmesh )
{
selectionMgr()->clearFilters();
selectObject( pSubmesh );
SMESHGUI::GetSMESHGUI()->switchToOperation(704);
}
else
{
selectObject( _PTR(SObject)() );
myDlg->selectObject( "", SMESHGUI_MeshDlg::Geom, "" );
}
}
// enable/disable popup for choice of geom selection way
myDlg->setGeomPopupEnabled( !myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ).isEmpty() );
}
}
catch ( const SALOME::SALOME_Exception& S_ex )
{
@ -290,7 +419,7 @@ void SMESHGUI_MeshOp::selectionDone()
catch ( ... )
{
}
}
// Enable tabs according to shape dimension
@ -371,6 +500,20 @@ bool SMESHGUI_MeshOp::isValid( QString& theMess ) const
return false;
}
// Imported mesh, if create sub-mesh or edit mesh
if ( !myToCreate || ( myToCreate && !myIsMesh ))
{
QString aMeshEntry = myDlg->selectedObject
( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj );
if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() )) {
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
if ( !mesh->_is_nil() && CORBA::is_nil( mesh->GetShapeToMesh() )) {
theMess = tr( "IMPORTED_MESH" );
return false;
}
}
}
// Geom
if ( myToCreate )
{
@ -402,8 +545,14 @@ bool SMESHGUI_MeshOp::isValid( QString& theMess ) const
theMess = tr( "MESH_IS_NULL" );
return false;
}
if ( !isSubshapeOk() )
{
theMess = tr( "INVALID_SUBSHAPE" );
return false;
}
}
}
return true;
}
@ -468,9 +617,9 @@ void SMESHGUI_MeshOp::existingHyps( const int theDim,
bool isMesh = !_CAST( SComponent, theFather );
int aPart = -1;
if ( isMesh )
aPart = theHypType == Algo ? 3 : 2;
aPart = theHypType == Algo ? GLOBAL_ALGO_TAG : GLOBAL_HYPO_TAG;
else
aPart = theHypType == Algo ? 2 : 1;
aPart = theHypType == Algo ? LOCAL_ALGO_TAG : LOCAL_HYPO_TAG;
if ( theFather->FindSubObject( aPart, aHypRoot ) )
{
@ -1288,3 +1437,92 @@ bool SMESHGUI_MeshOp::isValid( SUIT_Operation* theOp ) const
{
return SMESHGUI_Operation::isValid( theOp ) && !theOp->inherits( "SMESHGUI_MeshOp" );
}
//================================================================================
/*!
* \brief SLOT. Is called when the user selects a way of geometry selection
* \param theByMesh - true if the user wants to find geometry by mesh element
*/
//================================================================================
void SMESHGUI_MeshOp::onGeomSelectionByMesh( bool theByMesh )
{
if ( theByMesh ) {
if ( !myShapeByMeshDlg ) {
myShapeByMeshDlg = new SMESHGUI_ShapeByMeshDlg( SMESHGUI::GetSMESHGUI(), "ShapeByMeshDlg");
connect(myShapeByMeshDlg, SIGNAL(PublishShape()), SLOT(onPublishShapeByMeshDlg()));
connect(myShapeByMeshDlg, SIGNAL(Close()), SLOT(onCloseShapeByMeshDlg()));
}
// set mesh object to dlg
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.latin1() )) {
SMESH::SMESH_Mesh_var aMeshVar =
SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if ( !aMeshVar->_is_nil() ) {
myDlg->hide();
myShapeByMeshDlg->Init();
myShapeByMeshDlg->SetMesh( aMeshVar );
myShapeByMeshDlg->show();
}
}
}
}
//================================================================================
/*!
* \brief SLOT. Is called when Ok is pressed in SMESHGUI_ShapeByMeshDlg
*/
//================================================================================
void SMESHGUI_MeshOp::onPublishShapeByMeshDlg()
{
onCloseShapeByMeshDlg();
if ( myShapeByMeshDlg ) {
// Select a found geometry object
GEOM::GEOM_Object_var aGeomVar = myShapeByMeshDlg->GetShape();
if ( !aGeomVar->_is_nil() )
{
QString ID = aGeomVar->GetStudyEntry();
if ( _PTR(SObject) aGeomSO = studyDS()->FindObjectID( ID )) {
selectObject( aGeomSO );
selectionDone();
}
}
}
}
//================================================================================
/*!
* \brief SLOT. Is called Close Ok is pressed in SMESHGUI_ShapeByMeshDlg
*/
//================================================================================
void SMESHGUI_MeshOp::onCloseShapeByMeshDlg()
{
if ( myDlg ) {
myDlg->show();
myDlg->selectObject( "", SMESHGUI_MeshDlg::Geom, "" );
myDlg->activateObject( SMESHGUI_MeshDlg::Geom );
}
}
//================================================================================
/*!
* \brief Selects a SObject
* \param theSObj - the SObject to select
*/
//================================================================================
void SMESHGUI_MeshOp::selectObject( _PTR(SObject) theSObj ) const
{
if ( LightApp_SelectionMgr* sm = selectionMgr() ) {
SALOME_ListIO anIOList;
if ( theSObj ) {
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject
( theSObj->GetID().c_str(), "SMESH", theSObj->GetName().c_str() );
anIOList.Append( anIO );
}
sm->setSelectedObjects( anIOList, false );
}
}

11
src/SMESHGUI/SMESHGUI_MeshOp.h
View File

@ -40,9 +40,7 @@
#include CORBA_SERVER_HEADER(SMESH_Mesh)
class SMESHGUI_MeshDlg;
class SMESH_TypeFilter;
class SMESH_NumberFilter;
class SMESHGUI_ShapeByMeshDlg;
/*!
* \brief Operation for mech creation or editing
@ -72,6 +70,9 @@ protected slots:
void onCreateHyp( const int theHypType, const int theIndex );
void onEditHyp( const int theHypType, const int theIndex );
void onHypoSet( const QString& theSetName );
void onGeomSelectionByMesh( bool );
void onPublishShapeByMeshDlg();
void onCloseShapeByMeshDlg();
private:
bool isValid( QString& ) const;
@ -99,12 +100,16 @@ private:
const QValueList<SMESH::SMESH_Hypothesis_var>& ) const;
SMESH::SMESH_Hypothesis_var getInitParamsHypothesis( const QString& aHypType,
const QString& aServerLib ) const;
bool isSubshapeOk() const;
_PTR(SObject) getSubmeshByGeom() const;
void selectObject( _PTR(SObject) ) const;
private:
typedef QMap< int, QValueList<SMESH::SMESH_Hypothesis_var> > IdToHypListMap;
typedef QMap< int, IdToHypListMap > DimToHypMap;
SMESHGUI_MeshDlg* myDlg;
SMESHGUI_ShapeByMeshDlg* myShapeByMeshDlg;
bool myToCreate;
bool myIsMesh;

469
src/SMESHGUI/SMESHGUI_ShapeByMeshDlg.cxx Normal file
View File

@ -0,0 +1,469 @@
// SMESH SMESHGUI : GUI for SMESH component
//
// Copyright (C) 2003 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.
//
// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHGUI_ShapeByMeshDlg.cxx
// Author : Edward AGAPOV
// Module : SMESH
#include "SMESHGUI_ShapeByMeshDlg.h"
#include "SMESHGUI.h"
#include "SMESHGUI_GEOMGenUtils.h"
#include "SMESHGUI_IdValidator.h"
#include "SMESHGUI_MeshUtils.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMESH_Actor.h"
#include "GEOMBase.h"
#include "GeometryGUI.h"
#include "LightApp_DataOwner.h"
#include "LightApp_SelectionMgr.h"
#include "SALOMEDSClient_SObject.hxx"
#include "SALOME_ListIO.hxx"
#include "SUIT_Desktop.h"
#include "SVTK_Selector.h"
#include "SVTK_ViewWindow.h"
#include "SVTK_ViewModel.h"
#include "SalomeApp_Tools.h"
// OCCT Includes
#include <TColStd_MapOfInteger.hxx>
#include <TopoDS_Shape.hxx>
#include <TopExp_Explorer.hxx>
// QT Includes
#include <qframe.h>
#include <qlayout.h>
#include <qlineedit.h>
#include <qpushbutton.h>
#include <qlabel.h>
#include <qradiobutton.h>
#include <qbuttongroup.h>
#include <qapplication.h>
#include <qstringlist.h>
#define SPACING 5
#define MARGIN 10
enum { EDGE = 0, FACE, VOLUME };
/*!
* \brief Dialog to publish a sub-shape of the mesh main shape
* by selecting mesh elements
*/
SMESHGUI_ShapeByMeshDlg::SMESHGUI_ShapeByMeshDlg( SMESHGUI* theModule,
const char* theName)
: QDialog( SMESH::GetDesktop( theModule ), theName, false,
WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu),
mySMESHGUI( theModule ),
mySelectionMgr( SMESH::GetSelectionMgr( theModule ) )
{
setCaption(tr("CAPTION"));
QVBoxLayout* aDlgLay = new QVBoxLayout (this, MARGIN, SPACING);
QFrame* aMainFrame = createMainFrame (this);
QFrame* aBtnFrame = createButtonFrame(this);
aDlgLay->addWidget(aMainFrame);
aDlgLay->addWidget(aBtnFrame);
aDlgLay->setStretchFactor(aMainFrame, 1);
myViewWindow = SMESH::GetViewWindow( mySMESHGUI );
Init();
}
//=======================================================================
// function : createMainFrame()
// purpose : Create frame containing dialog's input fields
//=======================================================================
QFrame* SMESHGUI_ShapeByMeshDlg::createMainFrame (QWidget* theParent)
{
QFrame* aMainGrp = new QFrame(theParent, "main frame");
QGridLayout* aLayout = new QGridLayout(aMainGrp, 3, 2);
aLayout->setSpacing(6);
aLayout->setAutoAdd(false);
// elem type
myElemTypeGroup = new QButtonGroup(1, Qt::Vertical, aMainGrp, "Group types");
myElemTypeGroup->setTitle(tr("SMESH_ELEMENT_TYPE"));
myElemTypeGroup->setExclusive(true);
(new QRadioButton( tr("SMESH_EDGE") , myElemTypeGroup))->setChecked(true);
new QRadioButton( tr("SMESH_FACE") , myElemTypeGroup);
new QRadioButton( tr("SMESH_VOLUME"), myElemTypeGroup);
// element id
QLabel* anIdLabel = new QLabel( aMainGrp, "element id label");
anIdLabel->setText( tr("ELEMENT_ID") );
myElementId = new QLineEdit( aMainGrp, "element id");
myElementId->setValidator( new SMESHGUI_IdValidator( theParent, "id validator", 1 ));
// shape name
QLabel* aNameLabel = new QLabel( aMainGrp, "geom name label");
aNameLabel->setText( tr("GEOMETRY_NAME") );
myGeomName = new QLineEdit( aMainGrp, "geom name");
aLayout->addMultiCellWidget(myElemTypeGroup, 0, 0, 0, 1);
aLayout->addWidget(anIdLabel, 1, 0);
aLayout->addWidget(myElementId, 1, 1);
aLayout->addWidget(aNameLabel, 2, 0);
aLayout->addWidget(myGeomName, 2, 1);
connect(myElemTypeGroup, SIGNAL(clicked(int)), SLOT(onTypeChanged(int)));
connect(myElementId, SIGNAL(textChanged(const QString&)), SLOT(onElemIdChanged(const QString&)));
return aMainGrp;
}
//=======================================================================
// function : createButtonFrame()
// purpose : Create frame containing buttons
//=======================================================================
QFrame* SMESHGUI_ShapeByMeshDlg::createButtonFrame (QWidget* theParent)
{
QFrame* aFrame = new QFrame(theParent);
aFrame->setFrameStyle(QFrame::Box | QFrame::Sunken);
myOkBtn = new QPushButton(tr("SMESH_BUT_OK" ), aFrame);
myCloseBtn = new QPushButton(tr("SMESH_BUT_CLOSE"), aFrame);
QSpacerItem* aSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
QHBoxLayout* aLay = new QHBoxLayout(aFrame, MARGIN, SPACING);
aLay->addWidget(myOkBtn);
aLay->addItem(aSpacer);
aLay->addWidget(myCloseBtn);
connect(myOkBtn, SIGNAL(clicked()), SLOT(onOk()));
connect(myCloseBtn, SIGNAL(clicked()), SLOT(onClose()));
return aFrame;
}
//=======================================================================
// function : ~SMESHGUI_ShapeByMeshDlg()
// purpose : Destructor
//=======================================================================
SMESHGUI_ShapeByMeshDlg::~SMESHGUI_ShapeByMeshDlg()
{
// no need to delete child widgets, Qt does it all for us
}
//=======================================================================
// function : Init()
// purpose : Init dialog fields, connect signals and slots, show dialog
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::Init()
{
SetMesh( SMESH::SMESH_Mesh::_nil() );
myIsManualIdEnter = false;
//erasePreview();
mySMESHGUI->SetActiveDialogBox((QDialog*)this);
// selection and SMESHGUI
connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate()));
connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(onClose()));
setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
qApp->processEvents();
updateGeometry();
adjustSize();
resize(minimumSize());
activateSelection();
onSelectionDone();
int x, y;
mySMESHGUI->DefineDlgPosition(this, x, y);
this->move(x, y);
this->show();
}
//=======================================================================
// function : SetMesh()
// purpose : Set mesh to dialog
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::SetMesh (SMESH::SMESH_Mesh_ptr thePtr)
{
myMesh = SMESH::SMESH_Mesh::_duplicate(thePtr);
myGeomObj = GEOM::GEOM_Object::_nil();
myHasSolids = false;
bool isValidMesh = false;
vector< bool > hasElement (myElemTypeGroup->count(), false);
if (!myMesh->_is_nil() && myViewWindow )
{
_PTR(SObject) aSobj = SMESH::FindSObject(myMesh.in());
SUIT_DataOwnerPtr anIObj (new LightApp_DataOwner(aSobj->GetID().c_str()));
isValidMesh = mySelectionMgr->isOk(anIObj);
int nb3dShapes = 0;
if (isValidMesh) // check that the mesh has a shape
{
isValidMesh = false;
_PTR(SObject) aSO = SMESH::FindSObject(myMesh.in());
GEOM::GEOM_Object_var mainShape = SMESH::GetGeom(aSO);
if ( !mainShape->_is_nil() )
{
if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists
GeometryGUI::InitGeomGen();
TopoDS_Shape aShape;
if ( GEOMBase::GetShape(mainShape, aShape)) {
isValidMesh = true;
TopExp_Explorer exp( aShape, TopAbs_SOLID );
myHasSolids = exp.More();
for ( ; exp.More(); exp.Next())
nb3dShapes++;
for ( exp.Init( aShape, TopAbs_SHELL, TopAbs_SOLID ); exp.More(); exp.Next())
nb3dShapes++;
}
}
}
if (isValidMesh)
{
hasElement[ EDGE ] = myMesh->NbEdges();
hasElement[ FACE ] = myMesh->NbFaces();
hasElement[ VOLUME ] = myMesh->NbVolumes() && nb3dShapes > 1;
if ( hasElement[ EDGE ] && myViewWindow->GetSelector() )
{
connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(onSelectionDone()));
}
}
}
// disable inexistant elem types
for ( int i = 0; i < myElemTypeGroup->count(); ++i ) {
if ( QButton* button = myElemTypeGroup->find( i ) )
button->setEnabled( hasElement[ i ] );
}
setElementID("");
}
//=======================================================================
// function : GetShape()
// purpose : Get published sub-shape
//=======================================================================
GEOM::GEOM_Object_ptr SMESHGUI_ShapeByMeshDlg::GetShape()
{
return myGeomObj.in();
}
//=======================================================================
// function : onOk()
// purpose : SLOT called when "Ok" button pressed.
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::onOk()
{
try {
int elemID = myElementId->text().toInt();
myGeomObj = SMESHGUI::GetSMESHGen()->GetGeometryByMeshElement
( myMesh.in(), elemID, myGeomName->text().latin1());
accept();
emit PublishShape();
}
catch (const SALOME::SALOME_Exception& S_ex) {
SalomeApp_Tools::QtCatchCorbaException(S_ex);
}
catch (...) {
}
myViewWindow->SetSelectionMode( ActorSelection );
disconnect(mySelectionMgr, 0, this, 0);
disconnect(mySMESHGUI, 0, this, 0);
mySMESHGUI->ResetState();
}
//=======================================================================
// function : onClose()
// purpose : SLOT called when "Close" button pressed. Close dialog
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::onClose()
{
myViewWindow->SetSelectionMode( ActorSelection );
disconnect(mySelectionMgr, 0, this, 0);
disconnect(mySMESHGUI, 0, this, 0);
mySMESHGUI->ResetState();
reject();
emit Close();
}
//=======================================================================
// function : onSelectionDone()
// purpose : SLOT called when selection changed
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::onSelectionDone()
{
myOkBtn->setEnabled( false );
setElementID("");
try {
SALOME_ListIO aList;
mySelectionMgr->selectedObjects(aList, SVTK_Viewer::Type());
if (aList.Extent() != 1)
return;
SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(aList.First());
if (aMesh->_is_nil() || myMesh->_is_nil() || aMesh->GetId() != myMesh->GetId() )
return;
QString aString;
int nbElems = SMESH::GetNameOfSelectedElements(myViewWindow->GetSelector(),
aList.First(), aString);
if ( nbElems == 1 ) {
setElementID( aString );
myOkBtn->setEnabled( true );
}
} catch (...) {
}
}
//=======================================================================
// function : onDeactivate()
// purpose : SLOT called when dialog must be deativated
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::onDeactivate()
{
if ( isEnabled() ) {
//disconnect(mySelectionMgr, 0, this, 0);
myViewWindow->SetSelectionMode( ActorSelection );
setEnabled(false);
}
}
//=======================================================================
// function : enterEvent()
// purpose : Event filter
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::enterEvent (QEvent*)
{
// there is a stange problem that enterEvent() comes after onSave()
if ( isVisible () && !isEnabled() ) {
mySMESHGUI->EmitSignalDeactivateDialog();
setEnabled(true);
activateSelection();
//connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(onSelectionDone()));
}
}
//=================================================================================
// function : closeEvent()
// purpose : Close dialog box
//=================================================================================
void SMESHGUI_ShapeByMeshDlg::closeEvent (QCloseEvent*)
{
onClose();
}
//=======================================================================
// function : activateSelection()
// purpose : Activate selection in accordance with current pattern type
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::activateSelection()
{
mySelectionMgr->clearFilters();
SMESH::SetPointRepresentation(false);
myGeomName->setText("");
if ( myViewWindow )
{
QString geomName;
Selection_Mode mode = EdgeSelection;
switch ( myElemTypeGroup->id( myElemTypeGroup->selected() )) {
case EDGE :
mode = EdgeSelection; geomName = tr("GEOM_EDGE"); break;
case FACE :
mode = FaceSelection; geomName = tr("GEOM_FACE"); break;
case VOLUME:
mode = VolumeSelection; geomName = tr(myHasSolids ? "GEOM_SOLID" : "GEOM_SHELL"); break;
default: return;
}
if ( myViewWindow->SelectionMode() != mode )
myViewWindow->SetSelectionMode( mode );
myGeomName->setText( GEOMBase::GetDefaultName( geomName ));
}
}
//=======================================================================
//function : onTypeChanged
//purpose : SLOT. Called when element type changed.
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::onTypeChanged (int theType)
{
setElementID("");
activateSelection();
}
//=======================================================================
//function : onTypeChanged
//purpose : SLOT. Called when element id is entered
// Highlight the element whose Ids the user entered manually
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::onElemIdChanged(const QString& theNewText)
{
if ( myIsManualIdEnter && !myMesh->_is_nil() && myViewWindow )
if ( SMESH_Actor* actor = SMESH::FindActorByObject(myMesh) )
if ( SMDS_Mesh* aMesh = actor->GetObject()->GetMesh() )
{
TColStd_MapOfInteger newIndices;
QStringList aListId = QStringList::split( " ", theNewText, false);
for ( int i = 0; i < aListId.count(); i++ ) {
if ( const SMDS_MeshNode * n = aMesh->FindNode( aListId[ i ].toInt() ))
newIndices.Add(n->GetID());
}
if ( !newIndices.IsEmpty() )
if ( SVTK_Selector* s = myViewWindow->GetSelector() ) {
s->AddOrRemoveIndex( actor->getIO(), newIndices, false );
myViewWindow->highlight( actor->getIO(), true, true );
}
}
}
//=======================================================================
//function : setElementID
//purpose : programmatically set element id
//=======================================================================
void SMESHGUI_ShapeByMeshDlg::setElementID(const QString& theText)
{
myIsManualIdEnter = false;
myElementId->setText(theText);
myIsManualIdEnter = true;
}

114
src/SMESHGUI/SMESHGUI_ShapeByMeshDlg.h Normal file
View File

@ -0,0 +1,114 @@
// Copyright (C) 2003 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.
//
// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHGUI_ShapeByMeshDlg.h
// Author : Edward AGAPOV
// Module : SMESH
#ifndef SMESHGUI_ShapeByMeshDlg_H
#define SMESHGUI_ShapeByMeshDlg_H
#include <qdialog.h>
// IDL Headers
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(GEOM_Gen)
#include CORBA_SERVER_HEADER(SMESH_Mesh)
class QCloseEvent;
class QFrame;
class QLineEdit;
class QPushButton;
class LightApp_SelectionMgr;
class SVTK_ViewWindow;
class QButtonGroup;
class SMESHGUI;
/*!
* \brief Dialog to publish a sub-shape of the mesh main shape
* by selecting mesh elements
*/
class SMESHGUI_ShapeByMeshDlg : public QDialog
{
Q_OBJECT
public:
SMESHGUI_ShapeByMeshDlg( SMESHGUI* theModule,
const char* theName = 0);
virtual ~SMESHGUI_ShapeByMeshDlg();
void Init();
void SetMesh (SMESH::SMESH_Mesh_ptr);
GEOM::GEOM_Object_ptr GetShape();
signals:
void PublishShape();
void Close();
private:
void closeEvent (QCloseEvent* e);
void enterEvent (QEvent*);
private slots:
void onOk();
void onClose();
void onDeactivate();
void onSelectionDone();
void onTypeChanged (int);
void onElemIdChanged (const QString&);
private:
QFrame* createButtonFrame (QWidget*);
QFrame* createMainFrame (QWidget*);
//void displayPreview();
//void erasePreview();
void activateSelection();
void setElementID(const QString&);
private:
QButtonGroup* myElemTypeGroup;
QLineEdit* myElementId;
QLineEdit* myGeomName;
QPushButton* myOkBtn;
QPushButton* myCloseBtn;
SMESHGUI* mySMESHGUI;
LightApp_SelectionMgr* mySelectionMgr;
SVTK_ViewWindow* myViewWindow;
SMESH::SMESH_Mesh_var myMesh;
GEOM::GEOM_Object_var myGeomObj;
bool myIsManualIdEnter;
bool myHasSolids;
};
#endif

45
src/SMESHGUI/SMESH_msg_en.po
View File

@ -1,3 +1,18 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR Free Software Foundation, Inc.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"PO-Revision-Date: 2006-01-13 13:50+0300\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"
# This is a Qt message file in .po format. Each msgid starts with
# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
# would be translated to "Pub", not "Foo::Pub".
@ -2893,6 +2908,26 @@ msgstr "Assign a set of hypotheses"
#-----------------------------------------------------------
msgid "SMESHGUI_ShapeByMeshDlg::CAPTION"
msgstr "Find geometry by mesh element"
msgid "SMESH_ELEMENT_TYPE"
msgstr "Element Type"
msgid "ELEMENT_ID"
msgstr "Element ID"
msgid "GEOMETRY_NAME"
msgstr "Geometry name"
msgid "DIRECT_GEOM_SELECTION"
msgstr "Direct geometry selection"
msgid "GEOM_BY_MESH_ELEM_SELECTION"
msgstr "Find geometry by mesh element selection"
#-----------------------------------------------------------
msgid "SMESHGUI_MeshTab::ALGORITHM"
msgstr "Algorithm"
@ -2931,9 +2966,17 @@ msgstr "Geometry object is not defined\nPlease specify it and try again"
msgid "SMESHGUI_MeshOp::THERE_IS_NO_OBJECT_FOR_EDITING"
msgstr "There is no object for editing. Please\nselect mesh or sub-mesh and try again"
msgid "SMESHGUI_MeshOp::EDIT_SUBMESH_QUESTION"
msgstr "A submesh on the selected geometry already exists.\n Do you want to edit this submesh?"
msgid "SMESHGUI_MeshOp::MESH_IS_NULL"
msgstr "Mesh is null"
msgid "SMESHGUI_MeshOp::IMPORTED_MESH"
msgstr "Mesh is not built on geometry"
msgid "SMESHGUI_MeshOp::INVALID_SUBSHAPE"
msgstr "Geometry object is not a subshape of the shape to mesh"
msgid "SMESHGUI_MeshOp::MESH_IS_NOT_DEFINED"
msgstr "Mesh is not defined\nPlease specify it and try again"

67
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -69,6 +69,7 @@
#include "SMESH_Mesh.hxx"
#include "SMESH_Hypothesis.hxx"
#include "SMESH_Group.hxx"
#include "SMESH_MeshEditor.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
@ -1012,6 +1013,63 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
return false;
}
//================================================================================
/*!
* \brief Return geometrical object the given element is built on
* \param theMesh - the mesh the element is in
* \param theElementID - the element ID
* \param theGeomName - the name of the result geom object if it is not yet published
* \retval GEOM::GEOM_Object_ptr - the found or just published geom object
*/
//================================================================================
GEOM::GEOM_Object_ptr
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID,
const char* theGeomName)
throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", SALOME::BAD_PARAM );
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
GEOM::GEOM_Gen_var geomGen = GetGeomEngine();
// get a core mesh DS
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
if ( meshServant && !geomGen->_is_nil() && !mainShape->_is_nil() )
{
::SMESH_Mesh & mesh = meshServant->GetImpl();
SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
// find the element in mesh
if ( const SMDS_MeshElement * elem = meshDS->FindElement( theElementID ) )
// find a shape id by the element
if ( int shapeID = ::SMESH_MeshEditor( &mesh ).FindShape( elem )) {
// get a geom object by the shape id
GEOM::GEOM_Object_var geom = ShapeToGeomObject( meshDS->IndexToShape( shapeID ));
if ( geom->_is_nil() ) {
GEOM::GEOM_IShapesOperations_var op =
geomGen->GetIShapesOperations( GetCurrentStudyID() );
if ( !op->_is_nil() )
geom = op->GetSubShape( mainShape, shapeID );
}
if ( !geom->_is_nil() ) {
// try to find the corresponding SObject
GeomObjectToShape( geom ); // geom client remembers the found shape
SALOMEDS::SObject_var SObj = ObjectToSObject( myCurrentStudy, geom.in() );
if ( SObj->_is_nil() )
// publish a new subshape
SObj = geomGen->AddInStudy( myCurrentStudy, geom, theGeomName, mainShape );
// return only published geometry
if ( !SObj->_is_nil() )
return geom._retn();
}
}
}
return GEOM::GEOM_Object::_nil();
}
//=============================================================================
/*!
* SMESH_Gen_i::Save
@ -1070,6 +1128,15 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
HDFgroup* aSubSubGroup;
hdf_size aSize[ 1 ];
//Remove the files if they exist: BugID: 11225
TCollection_AsciiString cmd("rm -f \"");
cmd+=filename;
cmd+="\" \"";
cmd+=meshfile;
cmd+="\"";
system(cmd.ToCString());
// MED writer to be used by storage process
DriverMED_W_SMESHDS_Mesh myWriter;
myWriter.SetFile( meshfile.ToCString() );

5
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -220,6 +220,11 @@ public:
const SMESH::object_array& theListOfSubShape )
throw ( SALOME::SALOME_Exception );
// Return geometrical object the given element is built on
GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID,
const char* theGeomName)
throw ( SALOME::SALOME_Exception );
// ****************************************************
// Interface inherited methods (from SALOMEDS::Driver)

19
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -1194,30 +1194,17 @@ static void PrepareForWriting (const char* file)
THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
}
} else {
// nonexisting file
TCollection_AsciiString aDirName = aPath.TrekValue(aPath.TrekLength());
aPath.UpTrek();
aPath.SetName(aDirName);
aPath.SetExtension("");
OSD_Directory aDir (aPath);
TCollection_AsciiString aFullDirName;
aPath.SystemName(aFullDirName);
if (aDir.Exists()) {
// nonexisting file; check if it can be created
aFile.Reset();
aFile.Build(OSD_WriteOnly, OSD_Protection());
if (aFile.Failed()) {
TCollection_AsciiString msg ("You cannot write to directory ");
msg += aFullDirName + ".";
TCollection_AsciiString msg ("You cannot create the file ");
msg += aFullName + ". Check the directory existance and access rights.";
THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
} else {
aFile.Close();
aFile.Remove();
}
} else {
TCollection_AsciiString msg ("Directory ");
msg += aFullDirName + " does not exist.";
THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
}
}
}