#include "SMESHGUI_RevolutionDlg.h"
#include "SMESHGUI_RotationDlg.h"
#include "SMESHGUI_ScaleDlg.h"
+#include "SMESHGUI_OffsetDlg.h"
#include "SMESHGUI_Selection.h"
#include "SMESHGUI_SewingDlg.h"
#include "SMESHGUI_SingleEditDlg.h"
#include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
#include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
#include CORBA_CLIENT_HEADER(SMESH_Measurements)
+#include CORBA_CLIENT_HEADER(SMESH_Mesh)
// Qt includes
// #define INCLUDE_MENUITEM_DEF // VSR commented ????????
void ExportMeshToFile(int theCommandID);
- void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
+ void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
void SetDisplayEntity(int theCommandID);
}
else if ( theCommandID == SMESHOp::OpImportSAUV ||
theCommandID == SMESHOp::OpPopupImportSAUV ) {
- filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
- filter.append( QObject::tr( "All files (*)" ) );
+ filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
+ filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
}
else if ( theCommandID == SMESHOp::OpImportGMF ||
theCommandID == SMESHOp::OpPopupImportGMF ) {
if ( filenames.count() > 0 )
{
SUIT_OverrideCursor wc;
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
QStringList errors;
QStringList anEntryList;
"SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
"SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
"SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
- "SMESH_BIQUADRATIC_PENTAHEDRONS",
+ "SMESH_BIQUADRATIC_PENTAHEDRONS",
"SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
};
// is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
// Get parameters of export operation
- QString aFilename;
- SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
+ QString aFilename;
+ int aFormat =-1; // for MED minor versions
+ bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
+
// Init the parameters with the default values
bool aIsASCII_STL = true;
bool toCreateGroups = false;
if ( fd->exec() )
aFilename = fd->selectedFile();
- toOverwrite = fv->isOverwrite();
+ toOverwrite = fv->isOverwrite(aFilename);
toCreateGroups = fd->IsChecked(0);
SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
}
else if ( isMED || isSAUV ) // Export to MED or SAUV
{
- QMap<QString, SMESH::MED_VERSION> aFilterMap;
- //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
+ QMap<QString, int> aFilterMap;
if ( isMED ) {
- QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
- //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
- aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
+ //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
+ QString vmed (aMesh->GetVersionString(-1, 2));
+ //MESSAGE("MED version: " << vmed.toStdString());
+ int minor = vmed.split(".").last().toInt();
+ //MESSAGE("MED version minor: "<< minor);
+ //minor +=3; // TODO remove: test multiple minor
+ aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vmed ) + " (*.med)", minor );
+ for (int ii=0; ii<minor; ii++)
+ {
+ QString vs = aMesh->GetVersionString(ii, 2);
+ //std::ostringstream vss; // TODO remove: test multiple minor
+ //vss << "4."; // TODO remove: test multiple minor
+ //vss << ii; // TODO remove: test multiple minor
+ //vs = vss.str().c_str(); // TODO remove: test multiple minor
+ //MESSAGE("MED version: " << vs.toStdString());
+ aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", ii);
+ }
}
else { // isSAUV
- aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
- aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
- aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
+ aFilterMap.insert("All files (*)", -1 );
+ aFilterMap.insert("SAUV files (*.sauv)", -1 );
+ aFilterMap.insert("SAUV files (*.sauve)", -1 );
}
QStringList filters;
QString aDefaultFilter;
- QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
+ QMap<QString, int>::const_iterator it = aFilterMap.begin();
for ( ; it != aFilterMap.end(); ++it ) {
filters.push_back( it.key() );
- if (it.value() == SMESH::MED_V2_2)
+ if (it.key() == 0)
aDefaultFilter = it.key();
}
QStringList checkBoxes;
new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
fd->setWindowTitle( aTitle );
fd->setNameFilters( filters );
- fd->selectNameFilter( aDefaultFilter );
fd->SetChecked( toCreateGroups, 0 );
fd->SetChecked( toFindOutDim, 1 );
if ( !anInitialPath.isEmpty() )
bool is_ok = false;
while (!is_ok) {
+ MESSAGE("******* Loop on file dialog ***********");
+ isOkToWrite =true;
if ( fd->exec() )
aFilename = fd->selectedFile();
else {
break;
}
aFormat = aFilterMap[fd->selectedNameFilter()];
- toOverwrite = fv->isOverwrite();
+ MESSAGE("selected minor: " << aFormat << " file: " << aFilename.toUtf8().constData());
+ toOverwrite = fv->isOverwrite(aFilename);
+ MESSAGE("toOverwrite:" << toOverwrite);
is_ok = true;
if ( !aFilename.isEmpty() ) {
- // med-2.1 does not support poly elements
- if ( aFormat==SMESH::MED_V2_1 )
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
- SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
- SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
- if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
- nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
- {
- int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
- QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
- QObject::tr("SMESH_BUT_YES"),
- QObject::tr("SMESH_BUT_NO"), 0, 1);
- if (aRet != 0) {
- is_ok = false;
- break;
- }
- }
- }
if( !toOverwrite ) {
// can't append to an existing using other format
- SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
- bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
- if( !isVersionOk || aVersion != aFormat ) {
+ bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
+ MESSAGE("Append check, isVersionOk:" << isVersionOk);
+ if ( !isVersionOk ) {
int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
QObject::tr("SMESH_BUT_YES"),
QObject::tr("SMESH_BUT_NO"), 0, 1);
if (aRet == 0)
- toOverwrite = true;
+ {
+ toOverwrite = true;
+ MESSAGE("incompatible MED file version for add, overwrite accepted");
+ }
else
- is_ok = false;
+ {
+ isOkToWrite = false;
+ is_ok = false;
+ MESSAGE("incompatible MED file version for add, overwrite refused");
+ }
}
-
QStringList aMeshNamesCollisionList;
SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
}
}
}
- if( !aMeshNamesCollisionList.isEmpty() ) {
+ if( !aMeshNamesCollisionList.isEmpty() ) {
+ isOkToWrite = false;
QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_BUT_YES"),
QObject::tr("SMESH_BUT_NO"),
QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
- if (aRet == 0)
+ MESSAGE("answer collision name " << aRet);
+ if (aRet == 0) {
toOverwrite = true;
+ isOkToWrite = true;
+ }
else if (aRet == 2)
is_ok = false;
}
}
}
}
+ MESSAGE(" ****** end of file dialog loop, toOverwrite:" << toOverwrite << " isOkToWrite:" << isOkToWrite);
toCreateGroups = fd->IsChecked(0);
toFindOutDim = fd->IsChecked(1);
fieldSelWdg->GetSelectedFields();
// if ( SMESHGUI::automaticUpdate() )
// SMESH::UpdateView();
// }
- if ( isMED )
+ if ( isMED && isOkToWrite)
{
+ MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
aMeshIter = aMeshList.begin();
for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
{
const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
- aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
- aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
+ aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
+ toOverwrite && aMeshIndex == 0, toFindOutDim );
else
- aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
- aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
+ aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups, aFormat,
+ toOverwrite && aMeshIndex == 0, toFindOutDim,
fields, geoAssFields.toLatin1().data() );
}
}
type = QObject::tr( "LENGTH_EDGES" );
else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
type = QObject::tr( "LENGTH2D_EDGES" );
+ else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
+ type = QObject::tr( "DEFLECTION2D_FACES" );
else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
type = QObject::tr( "MULTI_BORDERS" );
else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
if ( selected.Extent() )
{
Handle(SALOME_InteractiveObject) anIObject = selected.First();
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
_PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
if (aSObj) {
if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
}
}
- void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
+ void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
{
SALOME_ListIO selected;
SalomeApp_Application* app =
return;
}
- _PTR(Study) aStudy = appStudy->studyDS();
-
aSel->selectedObjects( selected );
if ( selected.Extent() >= 1 )
break;
}
- SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
+ SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
// nodes: color, marker
dlg.setNodeColor( nodeColor );
if( markerType != VTK::MT_USER )
orientation3d = dlg.orientation3d();
shrinkCoef = dlg.shrinkCoef() / 100.;
- // store point markers map that might be changed by the user
- theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
+ // store point markers that might be changed by the user
+ theMarkerMap = dlg.customMarkers();
// set properties from dialog box to the presentations
SALOME_ListIteratorOfListIO It( selected );
anActor->SetMarkerStd( markerType, markerScale );
}
else {
- const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
- VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
- if ( iter != markerMap.end() )
+ VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
+ if ( iter != theMarkerMap.end() )
anActor->SetMarkerTexture( markerId, iter->second.second );
}
// volumes: normal color, reversed color (delta)
ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
+ ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
- return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
+ if ( theReversed )
+ return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
+ return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
}
void Control( int theCommandID )
{
SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
SALOME_ListIO selected;
if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
if ( !anIDSrc->_is_nil() ) {
SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
if (( !anActor && selected.Extent() == 1 ) &&
- ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
+ ( anActor = SMESH::CreateActor( anIO->getEntry() )))
{
anActor->SetControlMode( aControl );
SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
{
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
_PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
if (aSObj) {
_PTR(SComponent) aSComp = aSObj->GetFatherComponent();
LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
_PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
_PTR(GenericAttribute) anAttr;
_PTR(AttributeIOR) anIOR;
int objectCount = 0;
QString aNameList;
QString aParentComponent = QString::null;
- Handle(SALOME_InteractiveObject) anIO;
+
for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
{
- anIO = anIt.Value();
- QString cur = anIO->getComponentDataType();
- _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
+ Handle(SALOME_InteractiveObject) anIO = anIt.Value();
+ if ( anIO.IsNull() ) continue;
+
+ QString father = "unknown";
+
+ _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
if (aSO) {
+ father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
// check if object is reference
_PTR(SObject) aRefSObj;
aNameList.append("\n - ");
if ( aSO->ReferencedObject( aRefSObj ) ) {
QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
aNameList.append( aRefName );
- cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
+ father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
}
else
aNameList.append(anIO->getName());
}
if( aParentComponent.isNull() )
- aParentComponent = cur;
- else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
+ aParentComponent = father;
+ else if( !aParentComponent.isEmpty() && aParentComponent!=father )
aParentComponent = "";
}
else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
aMesh->RemoveSubMesh( aSubMesh );
-
- _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
- if (aMeshSO)
- SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
}
else {
Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
smeshMod = dynamic_cast<SMESHGUI*>( module );
}
- if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
- {
- SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
- if ( study )
- {
- _PTR(Study) aStudy = study->studyDS();
- if ( aStudy )
- GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
- }
- }
-
return smeshMod;
}
return true;
}
-//=============================================================================
/*!
- *
- */
-//=============================================================================
-static int isStudyLocked(_PTR(Study) theStudy){
- return theStudy->GetProperties()->IsLocked();
-}
-
-static bool checkLock(_PTR(Study) theStudy) {
- if (isStudyLocked(theStudy)) {
- SUIT_MessageBox::warning( SMESHGUI::desktop(),
- QObject::tr("WRN_WARNING"),
- QObject::tr("WRN_STUDY_LOCKED") );
+ * \brief Verifies whether study of operation is locked
+ * \param theMess - specifies whether message box must be shown if study is locked
+ * \return State of study.
+*
+* Verifies whether study of operation is locked. If second parameter is TRUE and study
+* is locked when corresponding message box appears
+*/
+bool SMESHGUI::isStudyLocked( bool theMessage )
+{
+ if ( SMESH::getStudy()->GetProperties()->IsLocked() )
+ {
+ if ( theMessage )
+ SUIT_MessageBox::warning( SMESHGUI::desktop(),
+ QObject::tr( "WRN_WARNING" ),
+ QObject::tr( "WRN_STUDY_LOCKED" ) );
return true;
}
return false;
}
-//=======================================================================
-//function : CheckActiveStudyLocked
-//purpose :
-//=======================================================================
-
-bool SMESHGUI::isActiveStudyLocked()
-{
- _PTR(Study) aStudy = activeStudy()->studyDS();
- return checkLock( aStudy );
-}
-
//=============================================================================
/*!
*
if( !anApp )
return false;
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
SUIT_ResourceMgr* mgr = resourceMgr();
if( !mgr )
return false;
- if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
- GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
- }
-
SUIT_ViewWindow* view = application()->desktop()->activeWindow();
SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
switch (theCommandID) {
case SMESHOp::OpDelete:
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
OnEditDelete();
break;
case SMESHOp::OpImportDAT:
case SMESHOp::OpPopupImportSAUV:
case SMESHOp::OpPopupImportGMF:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
break;
}
case SMESHOp::OpUpdate:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
SUIT_OverrideCursor wc;
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
SMESH::UpdateView();
}
catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
}
// PAL13338 + PAL15161 -->
- if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
+ if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
SMESH::UpdateView();
SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
}
case SMESHOp::OpNode:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
break;
case SMESHOp::OpCopyMesh:
{
- if (checkLock(aStudy)) break;
+ if (isStudyLocked()) break;
EmitSignalDeactivateDialog();
( new SMESHGUI_CopyMeshDlg( this ) )->show();
}
break;
case SMESHOp::OpBuildCompoundMesh:
{
- if (checkLock(aStudy)) break;
+ if (isStudyLocked()) break;
EmitSignalDeactivateDialog();
( new SMESHGUI_BuildCompoundDlg( this ) )->show();
}
break;
}
- if ( checkLock( aStudy ) )
+ if ( isStudyLocked() )
break;
/*Standard_Boolean aRes;
break;
}
- if ( checkLock( aStudy ) )
+ if ( isStudyLocked() )
break;
EmitSignalDeactivateDialog();
}
case SMESHOp::OpSmoothing:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SmoothingDlg( this ) )->show();
}
case SMESHOp::OpExtrusion:
{
- if (checkLock(aStudy)) break;
+ if (isStudyLocked()) break;
if (vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_ExtrusionDlg ( this ) )->show();
}
case SMESHOp::OpExtrusionAlongAPath:
{
- if (checkLock(aStudy)) break;
+ if (isStudyLocked()) break;
if (vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
}
case SMESHOp::OpRevolution:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RevolutionDlg( this ) )->show();
}
case SMESHOp::OpPatternMapping:
{
- if ( checkLock( aStudy ) )
+ if ( isStudyLocked() )
break;
if ( vtkwnd )
{
break;
}
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
EmitSignalDeactivateDialog();
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
break;
}
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
EmitSignalDeactivateDialog();
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
// check if submesh is selected
Handle(SALOME_InteractiveObject) IObject = selected.First();
if (IObject->hasEntry()) {
- _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
+ _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
if( aSObj ) {
SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
if (!aSubMesh->_is_nil()) {
break;
}
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
EmitSignalDeactivateDialog();
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
case SMESHOp::OpAddElemGroupPopup: // Add elements to group
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if (myState == 800) {
SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
if (aDlg) aDlg->onAdd();
case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if (myState == 800) {
SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
if (aDlg) aDlg->onRemove();
break;
}
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
EmitSignalDeactivateDialog();
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
break;
}
- if ( checkLock( aStudy ) )
+ if ( isStudyLocked() )
break;
EmitSignalDeactivateDialog();
case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
{
- if ( checkLock( aStudy ) )
+ if ( isStudyLocked() )
break;
EmitSignalDeactivateDialog();
break;
}
- if ( checkLock( aStudy ) )
+ if ( isStudyLocked() )
break;
EmitSignalDeactivateDialog();
case SMESHOp::OpEditHypothesis:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
SALOME_ListIO selected;
}
case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
SUIT_OverrideCursor wc;
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
case SMESHOp::OpPyramid:
case SMESHOp::OpHexagonalPrism:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
SMDSAbs_EntityType type = SMDSEntity_Edge;
}
case SMESHOp::OpPolyhedron:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
case SMESHOp::OpQuadraticHexahedron:
case SMESHOp::OpTriQuadraticHexahedron:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
SMDSAbs_EntityType type = SMDSEntity_Last;
}
case SMESHOp::OpRemoveNodes:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RemoveNodesDlg( this ) )->show();
}
case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RemoveElementsDlg( this ) )->show();
}
case SMESHOp::OpClearMesh: {
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
SALOME_ListIO selected;
if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
_PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
- SMESH::ModifiedMesh( aMeshSObj, false, true);
// hide groups and submeshes
_PTR(ChildIterator) anIter =
- SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
+ SMESH::getStudy()->NewChildIterator( aMeshSObj );
for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
{
_PTR(SObject) so = anIter->Value();
}
case SMESHOp::OpRemoveOrphanNodes:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
SALOME_ListIO selected;
if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
aSel->selectedObjects( selected );
}
case SMESHOp::OpRenumberingNodes:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
}
case SMESHOp::OpRenumberingElements:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
}
case SMESHOp::OpTranslation:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_TranslationDlg( this ) )->show();
}
case SMESHOp::OpRotation:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RotationDlg( this ) )->show();
}
case SMESHOp::OpSymmetry:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SymmetryDlg( this ) )->show();
}
case SMESHOp::OpScale:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_ScaleDlg( this ) )->show();
break;
}
+ case SMESHOp::OpOffset:
+ {
+ if(isStudyLocked()) break;
+ if ( vtkwnd ) {
+ EmitSignalDeactivateDialog();
+ ( new SMESHGUI_OffsetDlg( this ) )->show();
+ }
+ else {
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+ }
+ break;
+ }
+
case SMESHOp::OpSewing:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SewingDlg( this ) )->show();
}
case SMESHOp::OpMergeNodes:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_MergeDlg( this, 0 ) )->show();
}
case SMESHOp::OpMergeElements:
{
- if (checkLock(aStudy)) break;
+ if (isStudyLocked()) break;
if (vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_MergeDlg( this, 1 ) )->show();
case SMESHOp::OpDuplicateNodes:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
case SMESHOp::OpBareBorderFace:
case SMESHOp::OpOverConstrainedFace:
case SMESHOp::OpLength2D:
+ case SMESHOp::OpDeflection2D:
case SMESHOp::OpConnection2D:
case SMESHOp::OpArea:
case SMESHOp::OpTaper:
popupMgr()->insert( action( id ), pId, 0 );
QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
- QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
+ QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
QString rule = "(%1) and (%2) and (%3)";
rule = rule.arg( QString( "%1>0" ).arg( dc ) );
if( clients.isEmpty() )
createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
+ createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
+ createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
<< SMESHOp::OpNodeConnectivityNb // node controls
<< SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
<< SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
+ << SMESHOp::OpDeflection2D
<< SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
<< SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
<< SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
createMenu( SMESHOp::OpSkew, faceId, -1 );
createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
createMenu( SMESHOp::OpEqualFace, faceId, -1 );
+ createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
createMenu( SMESHOp::OpVolume, volumeId, -1 );
createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
//createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
//createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
+ createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
+ createMenu( SMESHOp::OpMergeElements, transfId, -1 );
createMenu( SMESHOp::OpTranslation, transfId, -1 );
createMenu( SMESHOp::OpRotation, transfId, -1 );
createMenu( SMESHOp::OpSymmetry, transfId, -1 );
createMenu( SMESHOp::OpScale, transfId, -1 );
+ createMenu( SMESHOp::OpOffset, transfId, -1 );
createMenu( SMESHOp::OpSewing, transfId, -1 );
- createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
- createMenu( SMESHOp::OpMergeElements, transfId, -1 );
createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
+ createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
+ createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
+ createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
+ createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
+ createMenu( SMESHOp::OpRevolution, modifyId, -1 );
+ createMenu( SMESHOp::OpOrientation, modifyId, -1 );
+ createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
- createMenu( SMESHOp::OpOrientation, modifyId, -1 );
- createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
- createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
- createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
- createMenu( SMESHOp::OpRevolution, modifyId, -1 );
createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
- createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
- createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
createTool( SMESHOp::OpSkew, ctrl2dTb );
createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
createTool( SMESHOp::OpEqualFace, ctrl2dTb );
+ createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
createTool( SMESHOp::OpVolume, ctrl3dTb );
//createTool( SMESHOp::OpRenumberingNodes, renumbTb );
//createTool( SMESHOp::OpRenumberingElements, renumbTb );
+ createTool( SMESHOp::OpMergeNodes, transformTb );
+ createTool( SMESHOp::OpMergeElements, transformTb );
createTool( SMESHOp::OpTranslation, transformTb );
createTool( SMESHOp::OpRotation, transformTb );
createTool( SMESHOp::OpSymmetry, transformTb );
createTool( SMESHOp::OpScale, transformTb );
+ createTool( SMESHOp::OpOffset, transformTb );
createTool( SMESHOp::OpSewing, transformTb );
- createTool( SMESHOp::OpMergeNodes, transformTb );
- createTool( SMESHOp::OpMergeElements, transformTb );
createTool( SMESHOp::OpDuplicateNodes, transformTb );
+ createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
+ createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
+ createTool( SMESHOp::OpExtrusion, modifyTb );
+ createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
+ createTool( SMESHOp::OpRevolution, modifyTb );
+ createTool( SMESHOp::OpOrientation, modifyTb );
+ createTool( SMESHOp::OpReorientFaces, modifyTb );
createTool( SMESHOp::OpMoveNode, modifyTb );
createTool( SMESHOp::OpDiagonalInversion, modifyTb );
createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
- createTool( SMESHOp::OpOrientation, modifyTb );
- createTool( SMESHOp::OpReorientFaces, modifyTb );
createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
createTool( SMESHOp::OpSplitVolumes, modifyTb );
createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
createTool( SMESHOp::OpSmoothing, modifyTb );
- createTool( SMESHOp::OpExtrusion, modifyTb );
- createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
- createTool( SMESHOp::OpRevolution, modifyTb );
createTool( SMESHOp::OpPatternMapping, modifyTb );
- createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
- createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
createTool( SMESHOp::OpMinimumDistance, measuremTb );
popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
+
popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
+ popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
+ popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
+
aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
// 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
- GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
- if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
- if ( _PTR(Study) aStudy = s->studyDS() )
- GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
- }
+ GetSMESHGen()->UpdateStudy();
// get all view currently opened in the study and connect their signals to
// the corresponding slots of the class.
{
if( !s )
return;
- SMESH::RemoveVisuData( s->id() );
+ SMESH::RemoveVisuData();
SalomeApp_Module::studyClosed( s );
}
SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
{
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
if ( CORBA::is_nil( myComponentSMESH ) )
- {
- SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
- if ( aStudy )
- aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
- return aGUI.myComponentSMESH;
- }
- if ( aStudy )
- myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
+ {
+ SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
+ return aGUI.myComponentSMESH;
+ }
return myComponentSMESH;
}
void SMESHGUI::switchToOperation(int id)
{
- if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
- activeStudy()->abortAllOperations();
+ activeStudy()->abortAllOperations();
startOperation( id );
}
savePoint);
_PTR(IParameters) ip = ClientFactory::getIParameters(ap);
- // store map of custom markers
- const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
- if( !aMarkerMap.empty() )
+ // store custom markers
+ if( !myMarkerMap.empty() )
{
- VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
- for( ; anIter != aMarkerMap.end(); anIter++ )
+ VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
+ for( ; anIter != myMarkerMap.end(); anIter++ )
{
int anId = anIter->first;
VTK::MarkerData aMarkerData = anIter->second;
savePoint);
_PTR(IParameters) ip = ClientFactory::getIParameters(ap);
- // restore map of custom markers and map of clipping planes
- VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
+ // restore custom markers and map of clipping planes
TPlaneDataMap aPlaneDataMap;
std::vector<std::string> properties = ip->getProperties();
aMarkerTexture.push_back( aChar.digitValue() );
}
- aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
+ myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
}
else if( aPropertyType == "ClippingPlane" )
{
// Check that the entry corresponds to a real object in the Study
// as the object may be deleted or modified after the visual state is saved.
- _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
+ _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
if (!so) continue; //Skip the not existent entry
std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
if (aGeomAc->hasIO()) {
Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
- if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
+ if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
isFound = true;
vtkActors.Bind(viewIndex, aGeomAc);
}
aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
}
else if( data[0] == "custom" ) {
- VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
- if( markerIt != aMarkerMap.end() ) {
+ VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
+ if( markerIt != myMarkerMap.end() ) {
VTK::MarkerData aMarkerData = markerIt->second;
aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
}
// get study
_PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
// get mesh name
- _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
+ _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
QString name;
if ( obj )
name = SMESH::fromUtf8(obj->GetName());
return false;
// check type to prevent renaming of inappropriate objects
- int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
+ int aType = SMESHGUI_Selection::type(qPrintable(entry));
if (aType == SMESH::MESH || aType == SMESH::GROUP ||
aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
if ( obj->FindAttribute(anAttr, "AttributeName") ) {
aName = anAttr;
// check type to prevent renaming of inappropriate objects
- int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
+ int aType = SMESHGUI_Selection::type( qPrintable(entry));
if (aType == SMESH::MESH || aType == SMESH::GROUP ||
aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
if ( !name.isEmpty() ) {
- SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
+ SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
// update name of group object and its actor
Handle(SALOME_InteractiveObject) IObject =
SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
if( !aGroupObject->_is_nil() ) {
- aGroupObject->SetName( qPrintable(name) );
+ aGroupObject->SetName( qUtf8Printable(name) );
if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
- anActor->setName( qPrintable(name) );
+ anActor->setName( qUtf8Printable(name) );
}
return true;
}
