#include "SMESHGUI_CopyMeshDlg.h"
#include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
#include "SMESHGUI_DeleteGroupDlg.h"
+#include "SMESHGUI_DisplayEntitiesDlg.h"
#include "SMESHGUI_Displayer.h"
#include "SMESHGUI_DuplicateNodesDlg.h"
#include "SMESHGUI_ExtrusionAlongPathDlg.h"
#include "SMESHGUI_ExtrusionDlg.h"
+#include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
#include "SMESHGUI_FieldSelectorWdg.h"
#include "SMESHGUI_FileInfoDlg.h"
#include "SMESHGUI_FileValidator.h"
#include "SMESHGUI_FilterDlg.h"
#include "SMESHGUI_FilterLibraryDlg.h"
+#include "SMESHGUI_FilterUtils.h"
#include "SMESHGUI_FindElemByPointDlg.h"
+#include "SMESHGUI_GEOMGenUtils.h"
#include "SMESHGUI_GroupDlg.h"
#include "SMESHGUI_GroupOnShapeDlg.h"
#include "SMESHGUI_GroupOpDlg.h"
+#include "SMESHGUI_GroupUtils.h"
#include "SMESHGUI_Hypotheses.h"
+#include "SMESHGUI_HypothesesUtils.h"
#include "SMESHGUI_Make2DFrom3DOp.h"
#include "SMESHGUI_MakeNodeAtPointDlg.h"
#include "SMESHGUI_Measurements.h"
#include "SMESHGUI_MeshOp.h"
#include "SMESHGUI_MeshOrderOp.h"
#include "SMESHGUI_MeshPatternDlg.h"
+#include "SMESHGUI_MeshUtils.h"
#include "SMESHGUI_MultiEditDlg.h"
#include "SMESHGUI_NodesDlg.h"
+#include "SMESHGUI_OffsetDlg.h"
#include "SMESHGUI_Operations.h"
+#include "SMESHGUI_PatternUtils.h"
#include "SMESHGUI_Preferences_ScalarBarDlg.h"
#include "SMESHGUI_PropertiesDlg.h"
#include "SMESHGUI_RemoveElementsDlg.h"
#include "SMESHGUI_SewingDlg.h"
#include "SMESHGUI_SingleEditDlg.h"
#include "SMESHGUI_SmoothingDlg.h"
+#include "SMESHGUI_SpinBox.h"
+#include "SMESHGUI_SplitBiQuad.h"
#include "SMESHGUI_SymmetryDlg.h"
#include "SMESHGUI_TranslationDlg.h"
#include "SMESHGUI_TransparencyDlg.h"
-#include "SMESHGUI_DisplayEntitiesDlg.h"
-#include "SMESHGUI_SplitBiQuad.h"
-
-#include "SMESHGUI_FilterUtils.h"
-#include "SMESHGUI_GEOMGenUtils.h"
-#include "SMESHGUI_GroupUtils.h"
-#include "SMESHGUI_HypothesesUtils.h"
-#include "SMESHGUI_MeshUtils.h"
-#include "SMESHGUI_PatternUtils.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
#include "SMESH_ActorUtils.h"
#include "SMESH_Client.hxx"
#include "SMESH_ScalarBarActor.h"
+#include <SMESH_Comment.hxx>
#include "SMESH_TypeFilter.hxx"
// SALOME GUI includes
-#include <SalomeApp_Application.h>
-#include <SalomeApp_CheckFileDlg.h>
-#include <SalomeApp_DataObject.h>
-#include <SalomeApp_Study.h>
-#include <SalomeApp_Tools.h>
-
#include <LightApp_DataOwner.h>
#include <LightApp_NameDlg.h>
#include <LightApp_Preferences.h>
#include <LightApp_SelectionMgr.h>
#include <LightApp_UpdateFlags.h>
-
-#include <SVTK_ViewManager.h>
-#include <SVTK_ViewModel.h>
-#include <SVTK_ViewWindow.h>
-
-#include <VTKViewer_Algorithm.h>
-
+#include <QtxFontEdit.h>
+#include <QtxPopupMgr.h>
+#include <SALOME_ListIO.hxx>
#include <SUIT_Desktop.h>
#include <SUIT_FileDlg.h>
#include <SUIT_MessageBox.h>
#include <SUIT_OverrideCursor.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
-
-#include <QtxPopupMgr.h>
-#include <QtxFontEdit.h>
-
-#include <SALOME_ListIO.hxx>
+#include <SVTK_Renderer.h>
+#include <SVTK_ViewManager.h>
+#include <SVTK_ViewModel.h>
+#include <SVTK_ViewWindow.h>
+#include <SalomeApp_Application.h>
+#include <SalomeApp_CheckFileDlg.h>
+#include <SalomeApp_DataObject.h>
+#include <SalomeApp_Study.h>
+#include <SalomeApp_Tools.h>
+#include <VTKViewer_Algorithm.h>
#ifndef DISABLE_PLOT2DVIEWER
#include <SPlot2d_ViewModel.h>
// Qt includes
// #define INCLUDE_MENUITEM_DEF // VSR commented ????????
#include <QApplication>
+#include <QCheckBox>
+#include <QDialogButtonBox>
+#include <QLayout>
+#include <QListView>
#include <QMenu>
#include <QTextStream>
-#include <QListView>
#include <QTreeView>
-#include <QCheckBox>
-#include <QLayout>
-#include <QDialogButtonBox>
// BOOST includes
#include <boost/shared_ptr.hpp>
QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
- if(msgBox.exec() == QMessageBox::Ok)
- {
- if(dontShowCheckBox.checkState() == Qt::Checked)
- {
- if ( resMgr )
- resMgr->setValue( "SMESH", "show_warning", false);
- }
- aCheckWarn = false;
- }
- else
+ if ( msgBox.exec() != QMessageBox::Ok )
return;
+
+ if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
+ resMgr->setValue( "SMESH", "show_warning", false);
}
QString aMeshName = anIObject->getName();
}
}
}
-
+
// Warn the user about presence of not supported elements
QString format;
std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
// Get parameters of export operation
QString aFilename;
+ int aFormat =-1; // for MED version used for write
+ 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;
toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
bool toOverwrite = true;
bool toFindOutDim = true;
+ double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
QString anInitialPath = "";
QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
- // Get a file name to write in and additional otions
+ // Get a file name to write in and additional options
if ( isUNV || isDAT || isGMF ) // Export w/o options
{
if ( isUNV )
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
{
- QStringList filters;
+ int defaultVersion = 0;
+ QMap<QString, int> aFilterMap;
if ( isMED ) {
- filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
+ //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
+ //QString vmed (aMesh->GetVersionString(-1, 2));
+ SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
+ if ( mvok->length() > 0)
+ defaultVersion = mvok[0]; // the current version to set the default filter on it
+ for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
+ {
+ QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
+ MESSAGE("MED version: " << vs.toStdString());
+ aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
+ }
}
else { // isSAUV
- filters << QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)";
+ aFilterMap.insert("All files (*)", -1 );
+ aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
+ aFilterMap.insert("SAUV files (*.sauve)", -1 );
+ }
+ QStringList filters;
+ QMap<QString, int>::const_iterator it = aFilterMap.begin();
+ QString aDefaultFilter = it.key();
+ for ( ; it != aFilterMap.end(); ++it ) {
+ filters.push_back( it.key() );
+ if (it.value() == defaultVersion) // explicit default for MED = current MED version
+ aDefaultFilter = it.key();
}
-
QStringList checkBoxes;
checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
wdgList.append( fieldSelWdg );
+ QWidget* zTolWdg = new QWidget();
+ QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
+ SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
+ QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
+ zTolLayout->addWidget( zTolCheck );
+ zTolLayout->addWidget( zTolSpin );
+ zTolLayout->setMargin( 0 );
+ zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
+ zTolSpin->setValue( zTol );
+ QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
+ zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
+ zTolSpin ->setEnabled( zTolCheck->isChecked() );
+ wdgList.append( zTolWdg );
+
SalomeApp_CheckFileDlg* fd =
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() )
fd->setDirectory( anInitialPath );
fd->selectFile(aMeshName);
-
-
+
+
QListView *lview = fd->findChild<QListView*>("listView");
if( lview ) {
lview->setMinimumHeight(200);
fd->setValidator( fv );
bool is_ok = false;
- while (!is_ok) {
+ while (!is_ok)
+ {
+ //MESSAGE("******* Loop on file dialog ***********");
+ isOkToWrite =true;
if ( fd->exec() )
aFilename = fd->selectedFile();
else {
aFilename = QString::null;
break;
}
- toOverwrite = fv->isOverwrite();
+ aFormat = aFilterMap[fd->selectedNameFilter()];
+ //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
+ toOverwrite = fv->isOverwrite(aFilename);
+ //MESSAGE("toOverwrite:" << toOverwrite);
is_ok = true;
if ( !aFilename.isEmpty() ) {
if( !toOverwrite ) {
- // can't append to an existing using other format
- bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckCompatibility( aFilename.toUtf8().constData() );
+ // append is only possible if the existing file format is compatible
+ 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_BUT_YES"),
QObject::tr("SMESH_BUT_NO"), 0, 1);
if (aRet == 0)
+ {
toOverwrite = true;
+ //MESSAGE("incompatible MED file version for add, overwrite accepted");
+ }
else
+ {
+ 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() ) {
+ 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;
}
}
toCreateGroups = fd->IsChecked(0);
toFindOutDim = fd->IsChecked(1);
+ zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
fieldSelWdg->GetSelectedFields();
+ if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
+
if ( !fieldSelWdg->parent() )
delete fieldSelWdg;
+ if ( !zTolWdg->parent() )
+ delete zTolWdg;
delete fd;
}
else
try {
// Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
-// bool Renumber = false;
-// // PAL 14172 : Check of we have to renumber or not from the preferences before export
-// if (resMgr)
-// Renumber= resMgr->booleanValue("renumbering");
-// if (Renumber){
-// SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
+ // bool Renumber = false;
+ // // PAL 14172 : Check of we have to renumber or not from the preferences before export
+ // if (resMgr)
+ // Renumber= resMgr->booleanValue("renumbering");
+ // if (Renumber){
+ // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
// aMeshEditor->RenumberNodes();
// aMeshEditor->RenumberElements();
// 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 GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
- if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
- aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups,
+ if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
+ aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
toOverwrite && aMeshIndex == 0, toFindOutDim );
else
- aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
+ aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
+ toCreateGroups, aFormat,
toOverwrite && aMeshIndex == 0, toFindOutDim,
- fields, geoAssFields.toLatin1().data() );
+ fields, geoAssFields.toLatin1().data(), zTol );
}
}
else if ( isSAUV )
wc.suspend();
SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_EXPORT_FAILED"));
+ QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
wc.resume();
}
}
presentEntities = presentEntities | SMESH_Actor::e0DElements;
if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
presentEntities = presentEntities | SMESH_Actor::eBallElem;
-
+
// as we know that all types of elements are present, we can exit the loop
if ( presentEntities == SMESH_Actor::eAllEntity )
break;
dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
// hide unused controls
dlg.showControls( presentEntities, hasNodes );
-
+
if ( dlg.exec() ) {
nodeColor = dlg.nodeColor();
markerType = dlg.nodeMarkerType();
if ( !IObject->hasEntry() ) continue;
SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
if ( !anActor ) continue;
-
+
// nodes: color, marker
anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
if ( markerType != VTK::MT_USER ) {
aColor = nodeColor; break;
case SMESH::EDGE:
aColor = edgeColor; break;
- case SMESH::FACE:
+ case SMESH::FACE:
aColor = faceColor; break;
case SMESH::VOLUME:
aColor = volumeColor; break;
- case SMESH::ELEM0D:
+ case SMESH::ELEM0D:
aColor = elem0dColor; break;
- case SMESH::BALL:
+ case SMESH::BALL:
aColor = ballColor; break;
default: break;
}
-
+
if ( aColor.isValid() ) {
SALOMEDS::Color aGroupColor;
aGroupColor.R = aColor.redF();
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 )
v = qMax( uint(0), qMin ( v, size-1 ) );
return v;
}
-
+
} //namespace
void SMESHGUI::OnEditDelete()
_PTR(GenericAttribute) anAttr;
_PTR(AttributeIOR) anIOR;
+ const int objectCountLimit = 30; // PAL23599
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", name;
+
+ _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() );
+ name = QString::fromStdString ( aRefSObj->GetName() );
+ father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
}
else
- aNameList.append(anIO->getName());
+ name = anIO->getName();
objectCount++;
}
+ if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
+ aNameList.append("\n - ");
+ aNameList.append( name );
+ }
if( aParentComponent.isNull() )
- aParentComponent = cur;
- else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
+ aParentComponent = father;
+ else if( !aParentComponent.isEmpty() && aParentComponent!=father )
aParentComponent = "";
}
+ if ( objectCount >= objectCountLimit )
+ aNameList.append("\n - ...");
if ( objectCount == 0 )
return; // No Valid Objects Selected
SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
- // Put the whole hierarchy of sub-objects of the selected SO's into a list and
- // then treat them all starting from the deepest objects (at list back)
+ // Put one level of sub-objects of the selected SO's into a list
+ // in order to get objects inside folders like "Assigned Algorithms"
std::list< _PTR(SObject) > listSO;
SALOME_ListIteratorOfListIO It(selected);
for( ; It.More(); It.Next()) // loop on selected IO's
aSO = aRefSObject; // Delete main Object instead of reference
listSO.push_back( aSO );
- std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
- for ( ; itSO != listSO.end(); ++itSO ) {
- _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
- for (it->InitEx(false); it->More(); it->Next())
- listSO.push_back( it->Value() );
- }
+
+ _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
+ for (it->InitEx(false); it->More(); it->Next())
+ listSO.push_back( it->Value() );
}
}
// Check if none of objects to delete is referred from outside
std::list< _PTR(SObject) >::reverse_iterator ritSO;
+ std::vector< _PTR(SObject) > subSO;
for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
{
_PTR(SObject) SO = *ritSO;
if ( !SO ) continue;
- std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
- for (size_t i = 0; i < aReferences.size(); i++) {
- _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
- std::string type = aComponent->ComponentDataType();
- if ( type != "SMESH" )
- {
- SUIT_MessageBox::warning( anApp->desktop(),
- QObject::tr("WRN_WARNING"),
- QObject::tr("DEP_OBJECT") );
- return; // outside SMESH, there is an object depending on a SMESH object
+
+ int nbChildren = SO->GetLastChildTag();
+ subSO.clear();
+ subSO.reserve( 1 + nbChildren );
+ subSO.push_back( SO );
+ if ( nbChildren > 0 )
+ {
+ _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
+ for ( it->InitEx( true ); it->More(); it->Next() )
+ subSO.push_back( it->Value() );
+ }
+ for ( size_t i = 0; i < subSO.size(); ++i )
+ {
+ std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
+ for ( size_t j = 0; j < aReferences.size(); j++ ) {
+ _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
+ std::string type = aComponent->ComponentDataType();
+ if ( type != "SMESH" )
+ {
+ SUIT_MessageBox::warning( anApp->desktop(),
+ QObject::tr("WRN_WARNING"),
+ QObject::tr("DEP_OBJECT") );
+ return; // outside SMESH, there is an object depending on a SMESH object
+ }
}
}
}
- // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
- for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
- {
- Handle(SALOME_InteractiveObject) IObject = It.Value();
- SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
- if ( !mesh->_is_nil() )
- mesh->Clear();
- }
-
// Treat SO's in the list starting from the back
aStudyBuilder->NewCommand(); // There is a transaction
for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
std::string anEntry = SO->GetID();
/** Erase graphical object and remove all its data **/
- if(SO->FindAttribute(anAttr, "AttributeIOR")) {
+ if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
}
/** Remove an object from data structures **/
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
SMESH::long_array_var info = theMesh->GetMeshInfo();
long nbOdElems = info[SMDSEntity_0D];
long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
- long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
- info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
+ long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
+ info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
- long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
- info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
- info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
+ long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
+ info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
+ info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
- info[SMDSEntity_Polyhedra] +
+ info[SMDSEntity_Polyhedra] +
info[SMDSEntity_Hexagonal_Prism];
long nbBalls = info[SMDSEntity_Ball];
long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
*nbElements = requestedSize;
-
+
*entities = SMESH_Actor::eAllEntity;
*hidden = 0;
#ifndef DISABLE_PLOT2DVIEWER
SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
#endif
+ anActor->UpdateFilter();
}
}
}
else
aSel->setSelectedObjects( to_process );
+ if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
+ ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
+ vtkwnd->GetRenderer()->AdjustActors();
+
break;
}
break;
}
+ case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
+ {
+ if ( isStudyLocked() )
+ break;
+
+ EmitSignalDeactivateDialog();
+ SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
+ aDlg->show();
+
+ break;
+ }
+
case SMESHOp::OpDeleteGroup: // Delete groups with their contents
{
if ( !vtkwnd )
SALOME_ListIteratorOfListIO It( selected );
for ( ; It.More(); It.Next() ) {
SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
- dlg->showInfo( It.Value() );
+ dlg->showInfo( It.Value() );
dlg->show();
}
}
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::getStudy()->NewChildIterator( aMeshSObj );
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(isStudyLocked()) break;
case SMESHOp::OpPropertiesVolume:
case SMESHOp::OpMinimumDistance:
case SMESHOp::OpBoundingBox:
+ case SMESHOp::OpAngle:
{
int page = SMESHGUI_MeasureDlg::MinDistance;
if ( theCommandID == SMESHOp::OpBoundingBox )
page = SMESHGUI_MeasureDlg::Area;
else if ( theCommandID == SMESHOp::OpPropertiesVolume )
page = SMESHGUI_MeasureDlg::Volume;
+ else if ( theCommandID == SMESHOp::OpAngle )
+ page = SMESHGUI_MeasureDlg::Angle;
EmitSignalDeactivateDialog();
SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
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::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
+ createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
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" );
createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
+ createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
createMenu( SMESHOp::OpCutGroups, meshId, -1 );
createMenu( separator(), meshId, -1 );
createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
+ createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
createMenu( separator(), meshId, -1 );
createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
//createMenu( SMESHOp::OpStdInfo, meshId, -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 );
+ createMenu( SMESHOp::OpAngle, measureId, -1 );
createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
- //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
- transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
+ //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
+ transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
//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 );
_PTR(Study) study = appStudy->studyDS();
_PTR(SObject) obj = study->FindObjectID( io->getEntry() );
if ( obj ) {
- QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
- while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
- aName.remove( (aName.length() - 1), 1 );
+ QString aName = SMESH::fromUtf8( obj->GetName());
+ while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
+ aName.remove(( aName.length() - 1 ), 1 );
title = aName;
}
}
int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
setPreferenceProperty( dispgroup, "columns", 2 );
+
+ addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
+
int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
QStringList modes;
modes.append( tr("MEN_WIRE") );
setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
+ /*
+ int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
+ setPreferenceProperty( cinc, "min", 0 );
+ setPreferenceProperty( cinc, "max", 5 );
+ */
int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
setPreferenceProperty( exportgroup, "columns", 2 );
addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
+ int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
+ setPreferenceProperty( zTol, "precision", 10 );
+ setPreferenceProperty( zTol, "min", 0.0000000001 );
+ setPreferenceProperty( zTol, "max", 1000000.0 );
+ setPreferenceProperty( zTol, "step", 1. );
//addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
setPreferenceProperty( numGroup, "columns", 2 );
-
+
addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
+ int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
+ setPreferenceProperty( sinc, "min", 0 );
+ setPreferenceProperty( sinc, "max", 5 );
+
// Scalar Bar tab ------------------------------------------------------------------------
int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
std::string aWarning;
SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
- if ( name== "selection_object_color" ||
- name=="selection_element_color" ||
- name== "highlight_color" ||
- name=="selection_precision_node" ||
- name=="selection_precision_element" ||
- name=="selection_precision_object" )
+ if ( name == "selection_object_color" ||
+ name == "selection_element_color" ||
+ name == "highlight_color" ||
+ name == "selection_precision_node" ||
+ name == "selection_precision_element" ||
+ name == "selection_precision_object" ||
+ name == "selection_increment")
{
SMESH::UpdateSelectionProp( this );
}
* \brief Store visual parameters
*
* This method is called just before the study document is saved.
- * Store visual parameters in AttributeParameter attribue(s)
+ * Store visual parameters in AttributeParameter attribute(s)
*/
void SMESHGUI::storeVisualParameters (int savePoint)
{
* \brief Restore visual parameters
*
* This method is called after the study document is opened.
- * Restore visual parameters from AttributeParameter attribue(s)
+ * Restore visual parameters from AttributeParameter attribute(s)
*/
void SMESHGUI::restoreVisualParameters (int savePoint)
{
aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
if( !ok )
continue;
-
+
ok = false;
aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
if( !ok )
// 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);
}
// Clipping
else if (paramNameStr.startsWith("ClippingPlane")) {
QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
- // old format - val looks like "Off" or "1:0:0:0.5:0:0"
+ // old format - val looks like "Off" or "1:0:0:0.5:0:0"
// (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
- // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
+ // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
// (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
// new format - val looks like "Off" or "0" (plane id)
// (note: in new format "Off" value is used only for consistency,
break;
}
}
-
+
}
}
-
+
// update all VTK views
QList<SUIT_ViewManager*> lst;
while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
anActor->SetOpenGLClippingPlane();
-
+
vtkView->getRenderer()->ResetCameraClippingRange();
vtkView->Repaint();
}
// 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());
if ( name.isEmpty() )
return;
-
+
if ( data.last() == "stop" )
application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
else
return false;
SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
-
+
if(!obj)
return false;
SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
if( !anApp )
return false;
-
+
SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
if(!appStudy)
return false;
-
+
_PTR(Study) aStudy = appStudy->studyDS();
-
+
if(!aStudy)
return false;
-
+
bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
if ( aLocked ) {
SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
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;
}
