}
+void SMESH_ActorDef::SetControl(SMESH::Controls::FunctorPtr theFunctor)
+{
+ myFunctor = theFunctor;
+ if ( !theFunctor )
+ SetControlMode( eNone, true );
+ else
+ SetControlMode( eCustomControl, true );
+}
+
void SMESH_ActorDef::SetControlMode(eControl theMode)
{
SetControlMode(theMode,true);
}
-
void SMESH_ActorDef::SetControlMode( eControl theMode, bool theCheckEntityMode )
{
vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
myControlActor = myNodeActor;
break;
}
+ case eCustomControl:
+ {
+ if ( !myFunctor )
+ return;
+ switch ( myFunctor->GetType() ) {
+ case SMDSAbs_Node : myControlActor = myNodeActor; break;
+ case SMDSAbs_Edge : myControlActor = my1DActor; break;
+ case SMDSAbs_Face : myControlActor = my2DActor; break;
+ case SMDSAbs_Volume : myControlActor = my3DActor; break;
+ default : return;
+ }
+ break;
+ }
default:
return;
}
}
QString aTitle = QString(myScalarBarActor->GetTitle());
aTitle.replace(QRegExp("(:\\s).*"),"\\1"+ QString::number(GetNumberControlEntities()));
- myScalarBarActor->SetTitle(aTitle.toLatin1().constData());
+ myScalarBarActor->SetTitle(aTitle.toUtf8().constData());
}
else {
#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"
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 )
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 = "";
}
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;
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::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" );
//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::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 );
// 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);
}
// 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());
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 =
if( !aGroupObject->_is_nil() ) {
aGroupObject->SetName( qPrintable(name) );
if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
- anActor->setName( qPrintable(name) );
+ anActor->setName( qUtf8Printable(name) );
}
return true;
}
myDlg( new SMESHGUI_Add0DElemsOnAllNodesDlg ),
myFilterDlg( 0 )
{
- myHelpFileName = "adding_nodes_and_elements_page.html#adding_0delems_on_all_nodes_anchor";
+ myHelpFileName = "adding_nodes_and_elements.html#adding-0delems-on-all-nodes-anchor";
connect( myDlg, SIGNAL( selTypeChanged(int) ), SLOT( onSelTypeChange(int)));
connect( myDlg->myFilterBtn, SIGNAL( clicked()), SLOT( onSetFilter() ));
QString groupName = myDlg->myGroupListCmBox->currentText();
SMESH::SMESH_IDSource_var newObj =
- editor->Create0DElementsOnAllNodes( meshObject, groupName.toLatin1().data(),
+ editor->Create0DElementsOnAllNodes( meshObject, groupName.toUtf8().data(),
myDlg->myDuplicateElemsChkBox->isChecked() );
int newNb0D = mesh->Nb0DElements() - prevNb0D;
aTopLayout->addWidget(GroupArgs);
aTopLayout->addWidget(GroupButtons);
- myHelpFileName = "building_compounds_page.html";
+ myHelpFileName = "building_compounds.html";
Init(); // Initialisations
}
bool isUnique = false;
while (!isUnique) {
aName = theOperation + "_" + QString::number(++aNumber);
- isUnique = (aSet.count(aName.toLatin1().data()) == 0);
+ isUnique = (aSet.count(aName.toUtf8().data()) == 0);
}
return aName;
try {
aMesh = myMeshArray[0]->GetMesh();
- aMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ aMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
// concatenate meshes
myBadMeshDisplayer = 0;
//myHelpFileName = "/files/about_meshes.htm"; // V3
- myHelpFileName = "about_meshes_page.html"; // V4
+ myHelpFileName = "about_meshes.html"; // V4
}
SMESH::SMESH_Mesh_ptr SMESHGUI_BaseComputeOp::getMesh()
{
QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( myMainShape, "MAIN_SHAPE" ));
SALOMEDS::SObject_wrap so = geomGen->AddInStudy( myMainShape,
- name.toLatin1().data(),
+ name.toUtf8().data(),
GEOM::GEOM_Object::_nil());
// look for myMainShape in the table
for ( int r = 0, nr = table()->rowCount(); r < nr; ++r ) {
}
QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( shape, "ERROR_SHAPE" ));
SALOMEDS::SObject_wrap so = geomGen->AddInStudy( shape,
- name.toLatin1().data(), myMainShape);
+ name.toUtf8().data(), myMainShape);
if ( !so->_is_nil() ) {
CORBA::String_var name = so->GetName();
CORBA::String_var entry = so->GetID();
else grName = "bad mesh of " + grName;
SMESH::SMESH_Gen_var gen = getSMESHGUI()->GetSMESHGen();
SMESH::ListOfGroups_var groups
- ( gen->MakeGroupsOfBadInputElements(myMesh,curSub,grName.toLatin1().data()) );
+ ( gen->MakeGroupsOfBadInputElements(myMesh,curSub,grName.toUtf8().data()) );
update( UF_ObjBrowser | UF_Model );
if( LightApp_Application* anApp = dynamic_cast<LightApp_Application*>( application() ))
{
SMESHGUI_ComputeOp::SMESHGUI_ComputeOp()
: SMESHGUI_BaseComputeOp()
{
- myHelpFileName = "constructing_meshes_page.html#compute_anchor";
+ myHelpFileName = "constructing_meshes.html#compute-anchor";
}
void SMESHGUI_PrecomputeOp::startOperation()
{
- myHelpFileName = "constructing_meshes_page.html#preview_anchor"; // other anchor onCompute()
+ myHelpFileName = "constructing_meshes.html#preview-anchor"; // other anchor onCompute()
if ( !myDlg )
{
myOrderMgr->SetMeshOrder();
myMapShapeId.clear();
myActiveDlg = computeDlg();
- myHelpFileName = "constructing_meshes_page.html#compute_anchor";
+ myHelpFileName = "constructing_meshes.html#compute-anchor";
computeMesh();
}
{
computeFailed = false;
myPreviewDisplayer->SetData( previewRes );
- // append shape indeces with computed mesh entities
+ // append shape indices with computed mesh entities
for ( int i = 0, n = aShapesId->length(); i < n; i++ )
myMapShapeId[ aShapesId[ i ] ] = 0;
}
SMESHGUI_EvaluateOp::SMESHGUI_EvaluateOp()
: SMESHGUI_BaseComputeOp()
{
- myHelpFileName = "constructing_meshes_page.html#evaluate_anchor";
+ myHelpFileName = "constructing_meshes.html#evaluate-anchor";
}
}
connect( myDlg, SIGNAL( onClicked( int ) ), SLOT( ConnectRadioButtons( int ) ) );
- myHelpFileName = "convert_to_from_quadratic_mesh_page.html";
+ myHelpFileName = "convert_to_from_quadratic_mesh.html";
SMESHGUI_SelectionOp::startOperation();
try
{
QString anObjEntry = myDlg->selectedObject( 0 );
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
if ( !pObj ) return;
SMESH::SMESH_IDSource_var idSource =
QString aMess;
QString anObjEntry = myDlg->selectedObject( 0 );
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
if ( !pObj )
{
dlg()->show();
void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id )
{
QString anObjEntry = myDlg->selectedObject( 0 );
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
if ( !pObj ) return;
SMESH::SMESH_IDSource_var idSource =
// Selection filter
myIdSourceFilter = new SMESH_TypeFilter( SMESH::IDSOURCE );
- myHelpFileName = "copy_mesh_page.html";
+ myHelpFileName = "copy_mesh.html";
Init();
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
aPartToCopy = aMeshEditor->MakeIDSource( anElementsId, SMESH::ALL );
}
- QByteArray meshName = myMeshNameEdit->text().toLatin1();
+ QByteArray meshName = myMeshNameEdit->text().toUtf8();
bool toCopyGroups = ( myCopyGroupsCheck->isChecked() );
bool toKeepIDs = ( myKeepIdsCheck->isChecked() );
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- // hilight entered elements
+ // highlight entered elements
SMDS_Mesh* aMesh = 0;
if (myActor)
aMesh = myActor->GetObject()->GetMesh();
aDlgLay->setStretchFactor( aMainFrame, 1 );
- myHelpFileName = "pattern_mapping_page.html";
+ myHelpFileName = "pattern_mapping.html";
Init( theType );
}
QFile aFile( fName );
aFile.open( QIODevice::WriteOnly );
- long aWritten = aFile.write( aData.toLatin1(), aLen );
+ long aWritten = aFile.write( aData.toUtf8(), aLen );
aFile.close();
if ( aWritten != aLen ) {
//=======================================================================
// function : onDeactivate()
-// purpose : SLOT called when dialog must be deativated
+// purpose : SLOT called when dialog must be deactivated
//=======================================================================
void SMESHGUI_CreatePatternDlg::onDeactivate()
{
for ( int i = 0; i < myGroups1.count(); i++ )
{
SMESH::SMESH_Group_var group =
- aMeshEditor->DoubleElements( myGroups1[i], groupName.toLatin1().data() );
+ aMeshEditor->DoubleElements( myGroups1[i], groupName.toUtf8().data() );
if ( group->_is_nil() )
{
if ( toCreateElemGroup )
}
/*!
- \brief SLOT called when dialog shoud be deativated.
+ \brief SLOT called when dialog should be deactivated.
*/
void SMESHGUI_DuplicateNodesDlg::onDeactivate()
{
myPathMeshFilter = new SMESH_TypeFilter(SMESH::MESHorSUBMESH);
- myHelpFileName = "extrusion_along_path_page.html";
+ myHelpFileName = "extrusion_along_path.html";
Init();
SMESH::SMESH_Mesh_var mesh = SelectorWdg->GetMesh();
- mesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ mesh->SetParameters( aParameters.join(":").toUtf8().constData() );
SMESH::ListOfIDSources_var nodes = new SMESH::ListOfIDSources();
SMESH::ListOfIDSources_var edges = new SMESH::ListOfIDSources();
myBusy = true;
- // hilight entered elements/nodes
+ // highlight entered elements/nodes
myIDSource[ iType ]->length( 0 );
mySMESHGUI->SetActiveDialogBox(this);
- myHelpFileName = "extrusion_page.html";
+ myHelpFileName = "extrusion.html";
Init();
SMESH::SMESH_MeshEditor_var meshEditor = mesh->GetMeshEditor();
SMESH::ListOfGroups_var groups;
- mesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ mesh->SetParameters( aParameters.join(":").toUtf8().constData() );
if ( ExtrMethod_RBut2->isVisible() &&
ExtrMethod_RBut2->isChecked() ) // Extrusion by normal
#endif
SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
- arg(app->resourceMgr()->stringValue("ExternalBrowser",
+ arg(app->resourceMgr()->stringValue("ExternalBrowser",
platform)).
arg(myHelpFileName));
}
return;
const SMDS_MeshFace* face =
- dynamic_cast<const SMDS_MeshFace*>(aMesh->FindElement(aMapIndex(1)));
+ aMesh->DownCast< SMDS_MeshFace >(aMesh->FindElement(aMapIndex(1)));
if (!face)
return;
/*
Class : SMESHGUI_FilterTable
- Description : Frame containig
+ Description : Frame containing
- Button group for switching entity type
- Table for displaying filter criterions
- Buttons for editing table and filter libraries
}
myIsLocked = false;
- // IPAL19372 - to prevent calling onCriterionChaged() slot before completion of setItem()
+ // IPAL19372 - to prevent calling onCriterionChanged() slot before completion of setItem()
bool isSignalsBlocked = theTable->signalsBlocked();
theTable->blockSignals( true );
aDlgLay->setStretchFactor(myMainFrame, 1);
- myHelpFileName = "selection_filter_library_page.html";
+ myHelpFileName = "selection_filter_library.html";
Init(myTypes);
}
//=======================================================================
// name : SMESHGUI_FilterDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
//=======================================================================
void SMESHGUI_FilterDlg::onDeactivate()
{
QString aName;
myTable->GetThreshold(i, aName);
- std::vector<_PTR(SObject)> aList = SMESH::getStudy()->FindObjectByName(aName.toLatin1().constData(), "GEOM");
+ std::vector<_PTR(SObject)> aList = SMESH::getStudy()->FindObjectByName(aName.toUtf8().constData(), "GEOM");
if (aList.size() == 0) {
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
tr("BAD_SHAPE_NAME").arg(aName));
aDlgLay->setStretchFactor(myMainFrame, 1);
- myHelpFileName = "selection_filter_library_page.html";
+ myHelpFileName = "selection_filter_library.html";
Init(myTypes, myMode);
}
}
if (myFileName->text() != myLibrary->GetFileName())
- myLibrary->SetFileName( myFileName->text().toLatin1().constData() );
+ myLibrary->SetFileName( myFileName->text().toUtf8().constData() );
bool aResult = false;
} else if (myMode == EDIT || myMode == ADD_TO) {
SMESH::Filter_var aFilter = createFilter();
if (!myListBox->selectedItems().empty() &&
- !myLibrary->Replace(myCurrFilterName.toLatin1().constData(),
- myName->text().toLatin1().constData(),
+ !myLibrary->Replace(myCurrFilterName.toUtf8().constData(),
+ myName->text().toUtf8().constData(),
aFilter.in())) {
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_ERROR"),
tr("ERROR_OF_EDITING"));
//=======================================================================
// name : SMESHGUI_FilterLibraryDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
//=======================================================================
void SMESHGUI_FilterLibraryDlg::onDeactivate()
{
//================================================================
// Function : onBrowse
-// Purpose : SLOT. Display "Open file" dialog for chosing library name
+// Purpose : SLOT. Display "Open file" dialog for choosing library name
//================================================================
void SMESHGUI_FilterLibraryDlg::onBrowse()
{
if (aFilterMgr->_is_nil())
return;
- myLibrary = aFilterMgr->LoadLibrary(autoExtension(getFileName()).toLatin1().constData());
+ myLibrary = aFilterMgr->LoadLibrary(autoExtension(getFileName()).toUtf8().constData());
if (myLibrary->_is_nil()) {
if (myMode == COPY_FROM) {
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_ERROR"),
return;
} else {
myLibrary = aFilterMgr->CreateLibrary();
- myLibrary->SetFileName(getFileName().toLatin1().constData());
+ myLibrary->SetFileName(getFileName().toUtf8().constData());
}
}
}
SMESH::Filter_var aFilter = createFilter();
- myLibrary->Replace(myCurrFilterName.toLatin1().constData(),
- myName->text().toLatin1().constData(),
+ myLibrary->Replace(myCurrFilterName.toUtf8().constData(),
+ myName->text().toUtf8().constData(),
aFilter);
}
// Fill table with filter parameters
- SMESH::Filter_var aFilter = myLibrary->Copy(theName.toLatin1().constData());
+ SMESH::Filter_var aFilter = myLibrary->Copy(theName.toUtf8().constData());
myCurrFilterName = theName;
myCurrFilter = myListBox->currentRow();
myName->setText(theName);
//=======================================================================
// name : SMESHGUI_FilterLibraryDlg::createFilter
-// Purpose : Cerate filter in accordance with library
+// Purpose : Create filter in accordance with library
//=======================================================================
SMESH::Filter_ptr SMESHGUI_FilterLibraryDlg::createFilter(const int theType)
{
return;
SMESH::Filter_var aFilter = createFilter();
- myLibrary->Replace(myCurrFilterName.toLatin1().constData(),
- myName->text().toLatin1().constData(),
+ myLibrary->Replace(myCurrFilterName.toUtf8().constData(),
+ myName->text().toUtf8().constData(),
aFilter);
}
myTable->Clear(myTable->GetType());
// add new filter in library
bool aResult = !aFilter->GetPredicate()->_is_nil()
- ? myLibrary->Add(aName.toLatin1().constData(), aFilter)
- : myLibrary->AddEmpty(aName.toLatin1().constData(), (SMESH::ElementType)myTable->GetType());
+ ? myLibrary->Add(aName.toUtf8().constData(), aFilter)
+ : myLibrary->AddEmpty(aName.toUtf8().constData(), (SMESH::ElementType)myTable->GetType());
if (!aResult) {
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_ERROR"),
int anIndex = getIndex(myCurrFilterName);
- if (anIndex == -1 || !myLibrary->Delete(myCurrFilterName.toLatin1().constData())) {
+ if (anIndex == -1 || !myLibrary->Delete(myCurrFilterName.toUtf8().constData())) {
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_ERROR"),
tr("ERROR_OF_DELETING"));
} else {
if (valid)
{
SMESH::Filter_var aFilter = createFilter(myTable->GetType());
- myLibrary->Replace(myCurrFilterName.toLatin1().constData(),
- myName->text().toLatin1().constData(),
+ myLibrary->Replace(myCurrFilterName.toUtf8().constData(),
+ myName->text().toUtf8().constData(),
aFilter);
}
}
QPixmap image0( SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap( "SMESH", tr( "ICON_SELECT" ) ) );
setWindowTitle( create ? tr( "SMESH_CREATE_GROUP_TITLE" ) : tr( "SMESH_EDIT_GROUP_TITLE" ) );
- myHelpFileName = create ? "creating_groups_page.html" : "editing_groups_page.html";
+ myHelpFileName = create ? "creating_groups.html" : "editing_groups.html";
setSizeGripEnabled( true);
bool isUnique = false;
while (!isUnique) {
aName = theOperation + "_" + QString::number(++aNumber);
- isUnique = (aSet.count(std::string(SMESH::toUtf8(aName))) == 0);
+ isUnique = (aSet.count(std::string(aName.toUtf8().constData())) == 0);
}
return aName;
do
{
aResName = aPrefix + QString::number( i++ );
- anObj = SMESH::getStudy()->FindObject( SMESH::toUtf8(aResName) );
+ anObj = SMESH::getStudy()->FindObject( aResName.toUtf8().constData() );
}
while ( anObj );
myName->setText(aResName);
SALOMEDS::Color aColor = theGroup->GetColor();
setGroupColor( aColor );
- myMeshGroupLine->setText(SMESH::fromUtf8(theGroup->GetName()));
+ myMeshGroupLine->setText(theGroup->GetName());
int aType = 0;
switch(theGroup->GetType()) {
{
myNameChanged = true;
myName->blockSignals(true);
- myName->setText(SMESH::fromUtf8(theGroup->GetName()));
+ myName->setText(theGroup->GetName());
myName->blockSignals(false);
}
if (myGeomObjects->length() == 1) {
myGroupOnGeom = myMesh->CreateGroupFromGEOM(aType,
- SMESH::toUtf8(myName->text()),
+ myName->text().toUtf8(),
myGeomObjects[0]);
}
else {
aNewGeomGroupName += myName->text();
SALOMEDS::SObject_var aNewGroupSO =
geomGen->AddInStudy(aGroupVar,
- SMESH::toUtf8(aNewGeomGroupName), aMeshShape);
+ aNewGeomGroupName.toUtf8(), aMeshShape);
}
myGroupOnGeom = myMesh->CreateGroupFromGEOM(aType,
- SMESH::toUtf8(myName->text()),
+ myName->text().toUtf8(),
aGroupVar);
}
resultGroup = SMESH::SMESH_GroupBase::_narrow( myGroupOnGeom );
return false;
myGroupOnFilter = myMesh->CreateGroupFromFilter(aType,
- SMESH::toUtf8(myName->text()),
- myFilter);
+ myName->text().toUtf8(),
+ myFilter);
resultGroup = SMESH::SMESH_GroupBase::_narrow( myGroupOnFilter );
isCreation = true;
}
if( aMeshGroupSO )
anEntryList.append( aMeshGroupSO->GetID().c_str() );
- resultGroup->SetName(SMESH::toUtf8(myName->text().trimmed()));
+ resultGroup->SetName(myName->text().trimmed().toUtf8());
if ( isCreation )
{
if ( !anActor ) return false;
myActorsList.append( anActor );
}
- anActor->setName(SMESH::toUtf8(myName->text()));
+ anActor->setName(myName->text().toUtf8());
QColor c;
int delta;
switch ( myTypeId ) {
anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta ); break;
break;
}
- // update a visible group accoding to a changed contents
+ // update a visible group according to a changed contents
if ( !isConversion && anActor->GetVisibility() )
{
SMESH::Update( anIO, true );
aGroupMainShape = aGeomGroup;
aGroupMainShape->Register();
}
+ CORBA::String_var entry = aGroupMainShape->GetStudyEntry();
_PTR(SObject) aGroupMainShapeSO =
- SMESH::getStudy()->FindObjectID(aGroupMainShape->GetStudyEntry());
+ SMESH::getStudy()->FindObjectID( entry.in() );
_PTR(SObject) anObj, aRef;
bool isRefOrSubShape = false;
myGeomObjects->length(i);
if ( i == 0 )
- {
- myIsBusy = false;
- return;
- }
+ {
+ myIsBusy = false;
+ return;
+ }
aNbSel = i;
}
//=================================================================================
// function : SMESHGUI_GroupDlg::onDeactivate
-// purpose : SLOT called when dialog must be deativated
+// purpose : SLOT called when dialog must be deactivated
//=================================================================================
void SMESHGUI_GroupDlg::onDeactivate()
{
//================================================================================
/*!
- * \brief slot to enable/diable [Apply]
+ * \brief slot to enable/disable [Apply]
*/
//================================================================================
: SMESHGUI_SelectionOp(ActorSelection),
myDlg( 0 )
{
- myHelpFileName = "create_groups_from_geometry_page.html";
+ myHelpFileName = "create_groups_from_geometry.html";
}
SMESHGUI_GroupOnShapeOp::~SMESHGUI_GroupOnShapeOp()
if ( !aStudy ) return false;
// mesh
- _PTR(SObject) meshSO = aStudy->FindObjectID( myMeshID.toLatin1().data() );
+ _PTR(SObject) meshSO = aStudy->FindObjectID( myMeshID.toUtf8().data() );
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( meshSO );
if ( mesh->_is_nil() ) return false;
for ( int i = 0; geomID != geomEnd; ++geomID, ++i )
{
// selected geom
- _PTR(SObject) geomSO = aStudy->FindObjectID( geomID->toLatin1().data() );
+ _PTR(SObject) geomSO = aStudy->FindObjectID( geomID->toUtf8().data() );
GEOM::GEOM_Object_var geom = SMESH::SObjectToInterface<GEOM::GEOM_Object>(geomSO);
if ( geom->_is_nil() ) continue;
// groupNames.append( name );
//printf( "apply() %s %s\n", (*geomID).latin1(), name.latin1() );
- group = mesh->CreateGroupFromGEOM( elemType, name.toLatin1().data(), geom );
+ group = mesh->CreateGroupFromGEOM( elemType, name.toUtf8().data(), geom );
if( !group->_is_nil() )
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( group ) )
anEntryList.append( aSObject->GetID().c_str() );
// study
if (_PTR(Study) aStudy = SMESH::getStudy()) {
// mesh
- if (_PTR(SObject) meshSO = aStudy->FindObjectID( myMeshID.toLatin1().data() )) {
+ if (_PTR(SObject) meshSO = aStudy->FindObjectID( myMeshID.toUtf8().data() )) {
// shape to mesh
_PTR(SObject) anObj, shapeToMesh;
if (meshSO->FindSubObject(1, anObj) && anObj->ReferencedObject(shapeToMesh)) {
QStringList::iterator name = names.begin(), id = ids.begin(), idEnd = ids.end();
for (; id != idEnd; ++id, ++name ) {
// shape SO
- if (_PTR(SObject) shapeSO = aStudy->FindObjectID( id->toLatin1().data() )) {
+ if (_PTR(SObject) shapeSO = aStudy->FindObjectID( id->toUtf8().data() )) {
// check if shape SO is a child of shape to mesh
while ( shapeSO && shapeSO->GetID() != shapeToMesh->GetID() )
if ( shapeSO->Depth() < 2 )
myNodeGeoIDs = goodIds;
}
- // enable/diable Apply, which can change at selection
+ // enable/disable Apply, which can change at selection
myDlg->updateButtons();
}
}
/*!
- \brief SLOT called when dialog must be deativated
+ \brief SLOT called when dialog must be deactivated
*/
void SMESHGUI_GroupOpDlg::onDeactivate()
{
/*!
\brief Resets state of the dialog, initializes its fields with default value, etc.
Usually called by onApply() slot to reinitialize dialog fields. This virtual method
- should be redefined in derived class to update its own fileds
+ should be redefined in derived class to update its own fields
*/
void SMESHGUI_GroupOpDlg::reset()
{
: SMESHGUI_GroupOpDlg( theModule )
{
setWindowTitle(tr("UNION_OF_GROUPS"));
- setHelpFileName( "using_operations_on_groups_page.html#union_anchor" );
+ setHelpFileName( "using_operations_on_groups.html#union-anchor" );
QGroupBox* anArgGrp = getArgGrp();
myListWg = new QListWidget( anArgGrp );
{
SMESH::ListOfGroups_var aList = convert( myGroups );
SMESH::SMESH_Group_var aNewGrp =
- aMesh->UnionListOfGroups( aList, aName.toLatin1().constData() );
+ aMesh->UnionListOfGroups( aList, aName.toUtf8().constData() );
if ( !CORBA::is_nil( aNewGrp ) )
{
aNewGrp->SetColor( getColor() );
: SMESHGUI_GroupOpDlg( theModule )
{
setWindowTitle(tr("INTERSECTION_OF_GROUPS"));
- setHelpFileName( "using_operations_on_groups_page.html#intersection_anchor" );
+ setHelpFileName( "using_operations_on_groups.html#intersection-anchor" );
QGroupBox* anArgGrp = getArgGrp();
myListWg = new QListWidget( anArgGrp );
{
SMESH::ListOfGroups_var aList = convert( myGroups );
SMESH::SMESH_Group_var aNewGrp =
- aMesh->IntersectListOfGroups( aList, aName.toLatin1().constData() );
+ aMesh->IntersectListOfGroups( aList, aName.toUtf8().constData() );
if ( !CORBA::is_nil( aNewGrp ) )
{
aNewGrp->SetColor( getColor() );
: SMESHGUI_GroupOpDlg( theModule )
{
setWindowTitle(tr("CUT_OF_GROUPS"));
- setHelpFileName( "using_operations_on_groups_page.html#cut_anchor" );
+ setHelpFileName( "using_operations_on_groups.html#cut-anchor" );
QGroupBox* anArgGrp = getArgGrp();
SMESH::ListOfGroups_var aList1 = convert( myGroups1 );
SMESH::ListOfGroups_var aList2 = convert( myGroups2 );
SMESH::SMESH_Group_var aNewGrp =
- aMesh->CutListOfGroups( aList1, aList2, aName.toLatin1().constData() );
+ aMesh->CutListOfGroups( aList1, aList2, aName.toUtf8().constData() );
if ( !CORBA::is_nil( aNewGrp ) )
{
aNewGrp->SetColor( getColor() );
: SMESHGUI_GroupOpDlg( theModule )
{
setWindowTitle( tr( "CREATE_GROUP_OF_UNDERLYING_ELEMS" ) );
- setHelpFileName( "group_of_underlying_elements_page.html" );
+ setHelpFileName( "group_of_underlying_elements.html" );
QGroupBox* anArgGrp = getArgGrp();
(SMESH::NB_COMMON_NODES_ENUM) myNbNoCombo->currentIndex();
SMESH::SMESH_Group_var aNewGrp =
- aMesh->CreateDimGroup( aList, anElemType, aName.toLatin1().constData(),
+ aMesh->CreateDimGroup( aList, anElemType, aName.toUtf8().constData(),
aNbCoNodes, myUnderlOnlyChk->isChecked() );
if ( !CORBA::is_nil( aNewGrp ) )
{
if( !myDlg )
myDlg = new SMESHGUI_Make2DFrom3DDlg( desktop() );
- myHelpFileName = "make_2dmesh_from_3d_page.html";
+ myHelpFileName = "make_2dmesh_from_3d.html";
SMESHGUI_SelectionOp::startOperation();
bool isMesh = true;
for ( int i = 0; i < ids.count() && isMesh; ++i )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( ids[i].toLatin1().constData() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( ids[i].toUtf8().constData() );
mySrcMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( sobj );
//isMesh = !mySrcMesh->_is_nil(); // EAP - it's sometimes necessary to copy to a new mesh
}
for ( int i = 0; i < entries.count(); ++i )
{
SMESH::SMESH_GroupBase_var grp;
- if ( _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entries[i].toLatin1().constData() ))
+ if ( _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entries[i].toUtf8().constData() ))
grp = SMESH::SObjectToInterface<SMESH::SMESH_GroupBase>( sobj );
if ( grp->_is_nil() ) {
msg = tr( "SMESH_NOT_ONLY_GROUPS" );
for ( int i = 0; i < entries.count(); ++i )
{
SMESH::SMESH_IDSource_var idSource;
- if ( _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entries[i].toLatin1().constData() ))
+ if ( _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entries[i].toUtf8().constData() ))
idSource = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( sobj );
if ( !idSource->_is_nil() ) {
SMESH::array_of_ElementType_var types = idSource->GetTypes();
groups->length( entries.count() );
for ( int i = 0; i < entries.count(); ++i )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entries[i].toLatin1().constData() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entries[i].toUtf8().constData() );
SMESH::SMESH_IDSource_var grp = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( sobj );
SMESH::array_of_ElementType_var types = grp->GetTypes();
if ( types->length() < 1 || types[0] != goodType )
SMESH::SMESH_Group_var newGrp;
SMESH::SMESH_Mesh_var newMesh;
CORBA::Long nbAdded = aMeshEditor->MakeBoundaryElements( mode,
- groupName.toLatin1().constData(),
- meshName.toLatin1().constData(),
+ groupName.toUtf8().constData(),
+ meshName.toUtf8().constData(),
copyAll,
groups,
newMesh.out(),
ok = true;
for ( int i = 0; i < entries.count(); ++i )
- if ( SMESH_Actor* actor = SMESH::FindActorByEntry( entries[i].toLatin1().constData() ))
+ if ( SMESH_Actor* actor = SMESH::FindActorByEntry( entries[i].toUtf8().constData() ))
SMESH::Update(actor->getIO(),actor->GetVisibility());
SMESH::RepaintCurrentView();
}
mySMESHGUI = 0;
myDlg = new SMESHGUI_MakeNodeAtPointDlg;
myFilter = 0;
- myHelpFileName = "mesh_through_point_page.html";
+ myHelpFileName = "mesh_through_point.html";
myNoPreview = false;
myUpdateDestination = false;
if (aMeshEditor->_is_nil())
return true;
- aMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ aMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
bool ok;
int anId = myDlg->myId->text().toInt( &ok );
connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));
connect( myDlg, SIGNAL( selectMeshType( const int, const int ) ), SLOT( onAlgoSetByMeshType( const int, const int)));
if ( myToCreate ) {
- if ( myIsMesh ) myHelpFileName = "constructing_meshes_page.html";
- else myHelpFileName = "constructing_submeshes_page.html";
+ if ( myIsMesh ) myHelpFileName = "constructing_meshes.html";
+ else myHelpFileName = "constructing_submeshes.html";
}
else {
- myHelpFileName = "editing_meshes_page.html";
+ myHelpFileName = "editing_meshes.html";
}
}
SMESHGUI_SelectionOp::startOperation();
// mesh
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() );
+ _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
if (!pMesh) return false;
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
QStringList::const_iterator aSubShapesIter = aGEOMs.begin();
for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++) {
QString aSubGeomEntry = (*aSubShapesIter);
- _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toLatin1().data());
+ _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toUtf8().data());
if (!pSubGeom) return false;
GEOM::GEOM_Object_var aSubGeomVar =
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() );
+ _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
if ( pMesh ) {
QStringList algoNames;
if ( algo &&
algo->InputTypes.empty() && // builds all dimensions it-self
!algo->IsSupportSubmeshes )
- return CORBA::string_dup( algoNames[0].toLatin1().data() );
+ return CORBA::string_dup( algoNames[0].toUtf8().data() );
}
// GEOM::GEOM_Object_var geom;
- // if (_PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toLatin1().data() ))
+ // if (_PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() ))
// geom = SMESH::SObjectToInterface<GEOM::GEOM_Object>( pGeom );
// if ( !geom->_is_nil() && geom->GetShapeType() >= GEOM::FACE ) { // WIRE, EDGE as well
if ( algo &&
algo->InputTypes.empty() && // builds all dimensions it-self
!algo->IsSupportSubmeshes )
- return CORBA::string_dup( algoNames[0].toLatin1().data() );
+ return CORBA::string_dup( algoNames[0].toUtf8().data() );
}
// }
}
{
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() );
- _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toLatin1().data() );
+ _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
+ _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() );
if ( pMesh && pGeom ) {
GEOM::GEOM_Object_var geom = SMESH::SObjectToInterface<GEOM::GEOM_Object>( pGeom );
if ( !geom->_is_nil() ) {
//Check geometry for mesh
QString anObjEntry = myDlg->selectedObject(SMESHGUI_MeshDlg::Obj);
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID(anObjEntry.toLatin1().data());
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID(anObjEntry.toUtf8().data());
if (pObj)
{
SMESH::SMESH_Mesh_var aMeshVar =
int iSubSh = 0;
for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
QString aSubGeomEntry = (*aSubShapesIter);
- _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toLatin1().data());
+ _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toUtf8().data());
if( pSubGeom ) {
SALOMEDS_SObject* sobj = _CAST(SObject,pSubGeom);
} else {
// get geometry by selected sub-mesh
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
if (!aGeomVar->_is_nil()) {
aSeq->length(1);
// enable/disable popup for choice of geom selection way
bool enable = false;
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() )) {
+ if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() )) {
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
if ( !mesh->_is_nil() ) {
//rnv: issue 21056: EDF 1608 SMESH: Dialog Box "Create Sub Mesh": focus should automatically switch to geometry
QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toLatin1().data() );
+ _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() );
if ( !pGeom || GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() )->_is_nil() )
myDlg->activateObject(SMESHGUI_MeshDlg::Geom);
enable = ( shapeDim > 1 ) && ( mesh->NbEdges() > 0 );
{
QString aMeshEntry = myDlg->selectedObject
( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj );
- if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() )) {
+ if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() )) {
SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pMesh );
if ( !mesh->_is_nil() && CORBA::is_nil( mesh->GetShapeToMesh() )) {
theMess = tr( "IMPORTED_MESH" );
}
return true;
}
- _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toLatin1().data() );
+ _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() );
if ( !pGeom || GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() )->_is_nil() )
{
theMess = tr( "GEOMETRY_OBJECT_IS_NULL" );
theMess = tr( "MESH_IS_NOT_DEFINED" );
return false;
}
- _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() );
+ _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
if ( !pMesh || SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() )->_is_nil() )
{
theMess = tr( "MESH_IS_NULL" );
QString aCurrentGeomToSelect;
if ( !theMeshType.isEmpty() ) {
aCurrentGeomToSelect = myDlg->selectedObject( myToCreate ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Obj );
- if ( _PTR(SObject) so = SMESH::getStudy()->FindObjectID( aCurrentGeomToSelect.toLatin1().data() )) {
+ if ( _PTR(SObject) so = SMESH::getStudy()->FindObjectID( aCurrentGeomToSelect.toUtf8().data() )) {
aGeomVar = SMESH::GetGeom( so );
}
if ( aCurrentGeomToSelect != myLastGeomToSelect )
{
anEntry = myDlg->selectedObject
( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj );
- if ( _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anEntry.toLatin1().data() ))
+ if ( _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() ))
{
CORBA::Object_ptr Obj = _CAST( SObject,pObj )->GetObject();
if ( myToCreate ) // mesh and geom may be selected
{
aMeshVar = SMESH::SMESH_Mesh::_narrow( Obj );
anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- if ( _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( anEntry.toLatin1().data() ))
+ if ( _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() ))
aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
else // edition: sub-mesh may be selected
if ( !myToCreate ) // mesh to edit can be selected
{
anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( anEntry.toLatin1().data() ))
+ if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() ))
{
aMeshVar = SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if ( !aMeshVar->_is_nil() )
}
if ( aGeomVar->_is_nil() ) {
anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- if ( _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( anEntry.toLatin1().data() ))
+ if ( _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() ))
{
aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
}
SMESH::SMESH_Hypothesis_var hyp =
- SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toLatin1().data(),
- aServerLib.toLatin1().data(),
+ SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toUtf8().data(),
+ aServerLib.toUtf8().data(),
aMeshVar,
aGeomVar,
/*byMesh = */isSubMesh);
if ( hyp->_is_nil() && isSubMesh )
hyp = SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toLatin1().data(),
- aServerLib.toLatin1().data(),
+ aServerLib.toUtf8().data(),
aMeshVar,
aGeomVar,
/*byMesh = */false);
aMeshEntry = aGeomEntry;
if ( aMeshEntry != aGeomEntry ) { // Get Geom object from Mesh of a sub-mesh being edited
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
aMeshEntry = ( aGeomVar->_is_nil() ) ? QString() : SMESH::toQStr( aGeomVar->GetStudyEntry() );
}
if ( aMeshEntry == "" && aGeomEntry == "" ) { // get geom of an object being edited
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
bool isMesh;
GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj, &isMesh );
if ( !aGeomVar->_is_nil() )
if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) {
// take geometry from submesh being created
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
if ( pObj ) {
// if current object is sub-mesh
SMESH::SMESH_subMesh_var aSubMeshVar =
/*!
* \brief Create hypothesis
* \param theHypType - hypothesis category (main or additional)
- * \param theIndex - index of type of hypothesis to be cerated
+ * \param theIndex - index of type of hypothesis to be created
*
* Specifies dimension of hypothesis to be created (using sender() method),
* specifies its type and calls method for hypothesis creation
for ( int i = 0; it!=aList.end(); it++, ++i )
{
QString aGeomEntry = *it;
- _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toLatin1().data() );
+ _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() );
GEOM::GEOM_Object_var aGeomVar =
GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
// get mesh object
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() );
+ _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
SMESH::SMESH_Mesh_var aMeshVar =
SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if (aMeshVar->_is_nil())
{
//QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
QString aGeomEntry = aGEOMs.first();
- _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toLatin1().data() );
+ _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() );
aGeomVar = GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
else if (aGEOMs.count() > 1)
QStringList::const_iterator aSubShapesIter = aGEOMs.begin();
for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
QString aSubGeomEntry = (*aSubShapesIter);
- _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toLatin1().data());
+ _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toUtf8().data());
GEOM::GEOM_Object_var aSubGeomVar =
GEOM::GEOM_Object::_narrow(_CAST(SObject,pSubGeom)->GetObject());
TopAbs_ShapeEnum aSubShapeType = (TopAbs_ShapeEnum)aSubGeomVar->GetShapeType();
aNewGeomGroupName += aName;
SALOMEDS::SObject_wrap aNewGroupSO =
geomGen->AddInStudy( aGeomVar,
- aNewGeomGroupName.toLatin1().data(), mainGeom);
+ aNewGeomGroupName.toUtf8().data(), mainGeom);
}
}
}
SUIT_OverrideCursor aWaitCursor;
// create sub-mesh
- SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toLatin1().data() );
+ SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toUtf8().data() );
_PTR(SObject) aSubMeshSO = SMESH::FindSObject( aSubMeshVar.in() );
if ( aSubMeshSO ) {
- SMESH::SetName( aSubMeshSO, aName.toLatin1().data() );
+ SMESH::SetName( aSubMeshSO, aName.toUtf8().data() );
theEntryList.append( aSubMeshSO->GetID().c_str() );
}
do
{
aResName = aPrefix + QString::number( i++ );
- anObj = aStudy->FindObject( aResName.toLatin1().data() );
+ anObj = aStudy->FindObject( aResName.toUtf8().data() );
}
while ( anObj );
void SMESHGUI_MeshOp::readMesh()
{
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
if ( !pObj )
return;
return false;
QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() );
if ( !pObj )
return false;
}
// set mesh object to SMESHGUI_ShapeByMeshOp and start it
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
- if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toLatin1().data() )) {
+ if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() )) {
SMESH::SMESH_Mesh_var aMeshVar =
SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if ( !aMeshVar->_is_nil() ) {
if ( !aGeomVar->_is_nil() )
{
QString ID = SMESH::toQStr( aGeomVar->GetStudyEntry() );
- if ( _PTR(SObject) aGeomSO = SMESH::getStudy()->FindObjectID( ID.toLatin1().data() )) {
+ if ( _PTR(SObject) aGeomSO = SMESH::getStudy()->FindObjectID( ID.toUtf8().data() )) {
selectObject( aGeomSO );
selectionDone();
}
mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
- myHelpFileName = "pattern_mapping_page.html";
+ myHelpFileName = "pattern_mapping.html";
Init();
}
aParameters << myNode1->text();
if(myType == Type_3d )
aParameters << myNode2->text();
- myMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ myMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
}
QList<int> ids;
getIds(ids);
//=======================================================================
// name : SMESHGUI_MeshPatternDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
//=======================================================================
void SMESHGUI_MeshPatternDlg::onDeactivate()
{
//=======================================================================
// name : SMESHGUI_MeshPatternDlg::onReverse
-// Purpose : SLOT. Called when state of "Reverse order..." checkbox chaged
+// Purpose : SLOT. Called when state of "Reverse order..." checkbox changed
// Calculate new points of the mesh to be created. Redisplay preview
//=======================================================================
void SMESHGUI_MeshPatternDlg::onReverse (bool)
try {
SMESH::SMESH_Pattern_var aPattern = SMESH::GetPattern();
- if (!aPattern->LoadFromFile(theName.toLatin1().data()) ||
+ if (!aPattern->LoadFromFile(theName.toUtf8().data()) ||
(myType == Type_2d && !aPattern->Is2D())) {
SMESH::SMESH_Pattern::ErrorCode aCode = aPattern->GetErrorCode();
QString aMess;
activateSelection();
}
- // hilight entered elements/nodes
+ // highlight entered elements/nodes
SMDS_Mesh* aMesh = 0;
SMESH_Actor* anActor = SMESH::FindActorByObject(myMesh);
if (anActor)
//=======================================================================
// name : SMESHGUI_MultiEditDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
//=======================================================================
void SMESHGUI_MultiEditDlg::onDeactivate()
{
if (myListBox->item(i)->isSelected())
{
int anId = myListBox->item(i)->text().toInt();
- if (anObj->GetElemVTKId(anId) >= 0) // avoid exception in hilight
+ if (anObj->GetElemVTKId(anId) >= 0) // avoid exception in highlight
anIndexes.Add(anId);
}
}
SMESHGUI_MultiEditDlg(theModule, SMESH::FaceFilter, true)
{
setWindowTitle(tr("CAPTION"));
- myHelpFileName = "changing_orientation_of_elements_page.html";
+ myHelpFileName = "changing_orientation_of_elements.html";
}
SMESHGUI_ChangeOrientationDlg::~SMESHGUI_ChangeOrientationDlg()
myPreviewCheckBox->setChecked(false);
onDisplaySimulation(false);
- myHelpFileName = "uniting_set_of_triangles_page.html";
+ myHelpFileName = "uniting_set_of_triangles.html";
}
SMESHGUI_UnionOfTrianglesDlg::~SMESHGUI_UnionOfTrianglesDlg()
{
QStringList aParameters;
aParameters << myMaxAngleSpin->text();
- myMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ myMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
}
SMESH::NumericalFunctor_var aCriterion = getNumericalFunctor();
double aMaxAngle = myMaxAngleSpin->GetValue() * M_PI / 180.0;
connect(myComboBoxFunctor, SIGNAL(activated(int)), this, SLOT(onPreviewChk()));
connect(this, SIGNAL(ListContensChanged()), this, SLOT(onPreviewChk()));
- myHelpFileName = "cutting_quadrangles_page.html";
+ myHelpFileName = "cutting_quadrangles.html";
}
SMESHGUI_CuttingOfQuadsDlg::~SMESHGUI_CuttingOfQuadsDlg()
: SMESHGUI_MultiEditDlg(theModule, SMESH::VolumeFilter, /*the3d2d=*/true, /*doInit=*/false)
{
setWindowTitle(tr("CAPTION"));
- myHelpFileName = "split_to_tetra_page.html";
+ myHelpFileName = "split_to_tetra.html";
myEntityType = 1;
myCellSize = -1.;
gb->setTitle( tr("TARGET_ELEM_TYPE"));
}
- myToAllChk->setChecked( true ); //aplly to the whole mesh by default
+ myToAllChk->setChecked( true ); //apply to the whole mesh by default
bool hasHexa = true;//myMesh->_is_nil() ? false : myMesh->NbHexas();
if ( hasHexa )
aParameters << myDirSpin[0]->text();
aParameters << myDirSpin[1]->text();
aParameters << myDirSpin[2]->text();
- myMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ myMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
SMESH::PointStruct_var point = new SMESH::PointStruct;
point->x = myPointSpin[0]->GetValue();
try {
_PTR(SObject) aSobj = SMESH::FindSObject( theMesh );
SMESH::SMESH_MeshEditor_var aMeshEditor = theMesh->GetMeshEditor();
- theMesh->SetParameters( theParameters.join(":").toLatin1().constData() );
+ theMesh->SetParameters( theParameters.join(":").toUtf8().constData() );
aNodeId = aMeshEditor->AddNode( x, y, z );
if (TVisualObjPtr aVisualObj = SMESH::GetVisualObj( aSobj->GetID().c_str() ) ) {
aVisualObj->Update( true );
SMESHGUI_NodesDlgLayout->addWidget( GroupGroups );
SMESHGUI_NodesDlgLayout->addWidget( GroupButtons );
- myHelpFileName = "adding_nodes_and_elements_page.html#adding_nodes_anchor";
+ myHelpFileName = "adding_nodes_and_elements.html#adding-nodes-anchor";
/* Initialisation and display */
Init();
//=======================================================================
/*!
- * \brief Dialog to reorient faces acoording to vector
+ * \brief Dialog to reorient faces according to vector
*/
//=======================================================================
:SMESHGUI_SelectionOp( ActorSelection )
{
//myVectorPreview = 0;
- myHelpFileName = "reorient_faces_page.html";
+ myHelpFileName = "reorient_faces.html";
myDlg = new SMESHGUI_ReorientFacesDlg;
myDlg->constructorChange( CONSTRUCTOR_POINT );
point.y = myDlg->myY->GetValue();
point.z = myDlg->myZ->GetValue();
- aMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ aMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
aResult = aMeshEditor->Reorient2D( myObject, direction, face, point );
}
{
// check object
QString objectEntry = myDlg->selectedObject( EObject );
- _PTR(SObject) pSObject = SMESH::getStudy()->FindObjectID( objectEntry.toLatin1().data() );
+ _PTR(SObject) pSObject = SMESH::getStudy()->FindObjectID( objectEntry.toUtf8().data() );
myObject = SMESH::SMESH_IDSource::_narrow( _CAST( SObject,pSObject )->GetObject() );
if ( myObject->_is_nil() )
{
if ( myDlg->myConstructorGrp->checkedId() == CONSTRUCTOR_VOLUME )
{
objectEntry = myDlg->selectedObject( EVolumes );
- _PTR(SObject) pSObject = SMESH::getStudy()->FindObjectID( objectEntry.toLatin1().data() );
+ _PTR(SObject) pSObject = SMESH::getStudy()->FindObjectID( objectEntry.toUtf8().data() );
myVolumeObj = SMESH::SObjectToInterface< SMESH::SMESH_IDSource>( pSObject );
if ( myVolumeObj->_is_nil() )
{
mySMESHGUI->SetActiveDialogBox((QDialog*)this);
- myHelpFileName = "revolution_page.html";
+ myHelpFileName = "revolution.html";
Init();
SMESH::SMESH_Mesh_var mesh = SelectorWdg->GetMesh();
- mesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ mesh->SetParameters( aParameters.join(":").toUtf8().constData() );
SMESH::ListOfIDSources_var nodes = new SMESH::ListOfIDSources();
SMESH::ListOfIDSources_var edges = new SMESH::ListOfIDSources();
else if ( isFaceSelected )
{
const SMDS_MeshFace* face =
- dynamic_cast<const SMDS_MeshFace*>(aMesh->FindElement(aMapIndex(1)));
+ SMDS_Mesh::DownCast<SMDS_MeshFace>( aMesh->FindElement( aMapIndex( 1 )));
if (!face)
return;
gp_XYZ aNormale = SMESH::getNormale(face);
myMeshOrSubMeshOrGroupFilter =
new SMESH_LogicalFilter (aListOfFilters, SMESH_LogicalFilter::LO_OR);
- myHelpFileName = "rotation_page.html";
+ myHelpFileName = "rotation.html";
Init();
if(CheckBoxMesh->isChecked()) {
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->RotateObject(myObjects[i], anAxis, anAngle, false);
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Rotate(anElementsId, anAxis, anAngle, false);
}
break;
if(CheckBoxMesh->isChecked()) {
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->RotateObjectMakeGroups(myObjects[i], anAxis, anAngle);
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->RotateMakeGroups(anElementsId, anAxis, anAngle);
}
}
if(CheckBoxMesh->isChecked()) {
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->RotateObject(myObjects[i], anAxis, anAngle, true);
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Rotate(anElementsId, anAxis, anAngle, true);
}
}
for ( int i = 0; i < myObjects.count(); i++ ) {
QString aName = SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ) );
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->RotateObjectMakeMesh(myObjects[i], anAxis, anAngle, makeGroups,
- aName.toLatin1().data());
+ aName.toUtf8().data());
if (!mesh->_is_nil()) {
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->RotateMakeMesh(anElementsId, anAxis, anAngle, makeGroups,
- LineEditNewMesh->text().toLatin1().data());
+ LineEditNewMesh->text().toUtf8().data());
if (!mesh->_is_nil()) {
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- // hilight entered elements
+ // highlight entered elements
SMDS_Mesh* aMesh = 0;
if (myActor)
aMesh = myActor->GetObject()->GetMesh();
myMeshOrSubMeshOrGroupFilter =
new SMESH_LogicalFilter(aListOfFilters, SMESH_LogicalFilter::LO_OR);
- myHelpFileName = "scale_page.html";
+ myHelpFileName = "scale.html";
Init();
if ( CheckBoxMesh->isChecked() )
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
+ myMeshes[i]->SetParameters( aParameters.join( ":" ).toUtf8().constData() );
aMeshEditor->Scale(myObjects[i], aPoint, aScaleFact, false);
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::ALL);
- myMeshes[0]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
+ myMeshes[0]->SetParameters( aParameters.join( ":" ).toUtf8().constData() );
aMeshEditor->Scale( src, aPoint, aScaleFact, false);
}
break;
if(CheckBoxMesh->isChecked())
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->ScaleMakeGroups(myObjects[i], aPoint, aScaleFact);
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::ALL);
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->ScaleMakeGroups( src, aPoint, aScaleFact);
}
}
if(CheckBoxMesh->isChecked()) {
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Scale(myObjects[i], aPoint, aScaleFact, true);
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::ALL);
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Scale( src, aPoint, aScaleFact, true);
}
}
for ( int i = 0; i < myObjects.count(); i++ ) {
QString aName = SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ) );
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->ScaleMakeMesh(myObjects[i], aPoint, aScaleFact, makeGroups,
- aName.toLatin1().data());
+ aName.toUtf8().data());
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::ALL);
mesh = aMeshEditor->ScaleMakeMesh( src, aPoint, aScaleFact, makeGroups,
- LineEditNewMesh->text().toLatin1().data());
+ LineEditNewMesh->text().toUtf8().data());
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- // hilight entered elements
+ // highlight entered elements
SMDS_Mesh* aMesh = 0;
if (myActor)
aMesh = myActor->GetObject()->GetMesh();
{
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( obj );
if ( !CORBA::is_nil( idSrc ) )
bool SMESHGUI_Selection::isQuadratic( int ind ) const
{
- _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
if ( !so )
return false;
SMESH::SMESH_IDSource_var idSource = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( so );
case SMESH_Actor::eCoincidentElems1D: mode = "eCoincidentElems1D"; break;
case SMESH_Actor::eCoincidentElems2D: mode = "eCoincidentElems2D"; break;
case SMESH_Actor::eCoincidentElems3D: mode = "eCoincidentElems3D"; break;
+ case SMESH_Actor::eCustomControl: mode = "eCustomControl"; break;
default:break;
}
}
{
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
if ( !CORBA::is_nil( obj ) ) {
{
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
if ( !CORBA::is_nil( obj ) ) {
int dim = -1;
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
if ( !CORBA::is_nil( obj ) ) {
myTypes[ind].startsWith("Mesh " )))
{
QMap<int,int> modeMap;
- _PTR(SObject) meshSO = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) meshSO = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
_PTR(SComponent) component = meshSO->GetFatherComponent();
if ( meshSO->Depth() - component->Depth() > 1 ) // sub-mesh, get a mesh
if ( maxDim < 2 ) // we can preview 1D or 2D
{
QMap<int,int> modeMap;
- _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
SMESHGUI_PrecomputeOp::getAssignedAlgos( pMesh, modeMap );
if ( modeMap.size() > 1 )
return (( modeMap.contains( SMESH::DIM_3D )) ||
{
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
{
- _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
GEOM::GEOM_Object_var shape = SMESH::GetShapeOnMeshOrSubMesh( so );
return !shape->_is_nil();
}
bool isEditable = true;
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Hypothesis" )
{
- _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
SMESH::SMESH_Hypothesis_var hyp = SMESH::SObjectToInterface<SMESH::SMESH_Hypothesis>( so );
if ( !hyp->_is_nil() )
{
{
if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
{
- SMESH_Actor* actor = SMESH::FindActorByEntry( entry( ind ).toLatin1().data() );
+ SMESH_Actor* actor = SMESH::FindActorByEntry( entry( ind ).toUtf8().data() );
if ( actor && actor->hasIO() ) {
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetCurrentVtkView() )
return aViewWindow->isVisible( actor->getIO() );
{
if ( ind >= 0 )
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
if ( sobj )
return SMESH::getStudy()->GetUseCaseBuilder()->HasChildren( sobj );
}
if ( ind >= 0 )
{
_PTR(Study) study = SMESH::getStudy();
- _PTR(SObject) sobj = study->FindObjectID( entry( ind ).toLatin1().data() );
+ _PTR(SObject) sobj = study->FindObjectID( entry( ind ).toUtf8().data() );
if ( sobj && study->GetUseCaseBuilder()->IsUseCaseNode( sobj ) ) {
_PTR(UseCaseIterator) it = study->GetUseCaseBuilder()->GetUseCaseIterator( sobj );
for ( it->Init( false ); it->More(); it->Next() ) nb++;
int SMESHGUI_Selection::type( const QString& entry )
{
int res = -1;
- _PTR(SObject) obj = SalomeApp_Application::getStudy()->FindObjectID( entry.toLatin1().data() );
+ _PTR(SObject) obj = SalomeApp_Application::getStudy()->FindObjectID( entry.toUtf8().data() );
if ( obj ) {
_PTR(SObject) ref;
if ( obj->ReferencedObject( ref ) )
bool SMESHGUI_Selection::isImported( const int ind ) const
{
bool res = false;
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().constData() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().constData() );
if ( sobj )
{
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( sobj ) );
QString SMESHGUI_Selection::groupType( int ind ) const
{
- _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toLatin1().constData() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().constData() );
if ( sobj )
{
SMESH::SMESH_Group_var g = SMESH::SObjectToInterface<SMESH::SMESH_Group>( sobj );
// Purpose : Highlight object in 3d viewer
//=======================================================================
void SMESHGUI_SelectionOp::highlight( const Handle( SALOME_InteractiveObject )& obj,
- const bool hilight, const bool immediately )
+ const bool highlight, const bool immediately )
{
SVTK_ViewWindow* wnd = viewWindow();
if( wnd )
- wnd->highlight( obj, hilight, immediately );
+ wnd->highlight( obj, highlight, immediately );
}
//=======================================================================
if( t<0 )
{
//try to get GEOM type
- _PTR( SObject ) sobj = aStudy->FindObjectID( str.toLatin1().data() );
+ _PTR( SObject ) sobj = aStudy->FindObjectID( str.toUtf8().data() );
if( sobj )
{
GEOM::GEOM_Object_var obj = GEOM::GEOM_Object::_narrow(
int id = _id.toInt( &ok );
if( ok )
{
- _PTR( SObject ) sobj = aStudy->FindObjectID( entry.toLatin1().data() );
+ _PTR( SObject ) sobj = aStudy->FindObjectID( entry.toUtf8().data() );
SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow(
dynamic_cast<SALOMEDS_SObject*>( sobj.get() )->GetObject() );
SMESH::SMESH_subMesh_var submesh = SMESH::SMESH_subMesh::_narrow(
myHasSolids = nbShapes[ TopAbs_SOLID ];
}
- // disable inexistant elem types
+ // disable inexistent elem types
for ( int i = 0; i < myDlg->myElemTypeGroup->buttons().count(); ++i ) {
if ( QAbstractButton* button = myDlg->myElemTypeGroup->button( i ) )
button->setEnabled( hasElement[ i ] );
// GEOM_Object is published -> no need to UnRegister()
myGeomObj = GEOM::GEOM_Object::_duplicate
(SMESHGUI::GetSMESHGen()->GetGeometryByMeshElement
- ( myMesh.in(), elemID, myDlg->myGeomName->text().toLatin1().constData()) );
+ ( myMesh.in(), elemID, myDlg->myGeomName->text().toUtf8().constData()) );
}
else
{
QString aNewGeomGroupName ( myDlg->myGeomName->text() );
SALOMEDS::SObject_wrap aNewGroupSO =
geomGen->AddInStudy( aGeomObject,
- aNewGeomGroupName.toLatin1().data(), aMeshShape);
+ aNewGeomGroupName.toUtf8().data(), aMeshShape);
// get a GEOM_Object already published, which doesn't need UnRegister()
CORBA::Object_var obj = aNewGroupSO->GetObject();
myMeshOrSubMeshOrGroupFilter =
new SMESH_LogicalFilter (aListOfFilters, SMESH_LogicalFilter::LO_OR);
- myHelpFileName = "smoothing_page.html";
+ myHelpFileName = "smoothing.html";
Init();
SUIT_OverrideCursor aWaitCursor;
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
- myMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+ myMesh->SetParameters( aParameters.join(":").toUtf8().constData() );
if ( CheckBoxParametric->isChecked() ) {
if(CheckBoxMesh->isChecked())
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- // hilight entered elements/nodes
+ // highlight entered elements/nodes
SMDS_Mesh* aMesh = myActor ? myActor->GetObject()->GetMesh() : 0;
QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
{
myDlg = new SMESHGUI_SplitBiQuadDlg();
}
- myHelpFileName = "split_biquad_to_linear_page.html";
+ myHelpFileName = "split_biquad_to_linear.html";
SMESHGUI_SelectionOp::startOperation();
int nbObj = 0;
for ( int i = 0; i < entries.count() ; ++i )
{
- _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( entries[i].toLatin1().data() );
+ _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( entries[i].toUtf8().data() );
SMESH::SMESH_IDSource_var obj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( pObj );
if( !CORBA::is_nil( obj ))
{
myMeshOrSubMeshOrGroupFilter =
new SMESH_LogicalFilter (aListOfFilters, SMESH_LogicalFilter::LO_OR);
- myHelpFileName = "symmetry_page.html";
+ myHelpFileName = "symmetry.html";
Init();
if(CheckBoxMesh->isChecked())
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->MirrorObject(myObjects[i], aMirror, aMirrorType, false );
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Mirror(anElementsId, aMirror, aMirrorType, false );
}
break;
if(CheckBoxMesh->isChecked())
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->MirrorObjectMakeGroups(myObjects[i], aMirror, aMirrorType);
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->MirrorMakeGroups(anElementsId, aMirror, aMirrorType);
}
}
if(CheckBoxMesh->isChecked())
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->MirrorObject(myObjects[i], aMirror, aMirrorType, true);
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Mirror(anElementsId, aMirror, aMirrorType, true);
}
}
for ( int i = 0; i < myObjects.count(); i++ ) {
QString aName = SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ) );
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->MirrorObjectMakeMesh(myObjects[i], aMirror, aMirrorType, makeGroups,
- aName.toLatin1().data());
+ aName.toUtf8().data());
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->MirrorMakeMesh(anElementsId, aMirror, aMirrorType, makeGroups,
- LineEditNewMesh->text().toLatin1().data());
+ LineEditNewMesh->text().toUtf8().data());
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- // hilight entered elements
+ // highlight entered elements
SMDS_Mesh* aMesh = 0;
if (myActor)
aMesh = myActor->GetObject()->GetMesh();
myMeshOrSubMeshOrGroupFilter =
new SMESH_LogicalFilter(aListOfFilters, SMESH_LogicalFilter::LO_OR);
- myHelpFileName = "translation_page.html";
+ myHelpFileName = "translation.html";
Init();
if(CheckBoxMesh->isChecked())
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->TranslateObject(myObjects[i], aVector, false);
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Translate(anElementsId, aVector, false);
}
break;
if(CheckBoxMesh->isChecked()) {
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->TranslateObjectMakeGroups(myObjects[i],aVector);
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
groups = aMeshEditor->TranslateMakeGroups(anElementsId, aVector);
}
}
if(CheckBoxMesh->isChecked()) {
for ( int i = 0; i < myObjects.count(); i++ ) {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->TranslateObject(myObjects[i], aVector, true);
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
aMeshEditor->Translate(anElementsId, aVector, true);
}
}
for ( int i = 0; i < myObjects.count(); i++ ) {
QString aName = SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ) );
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
- myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->TranslateObjectMakeMesh(myObjects[i], aVector, makeGroups,
- aName.toLatin1().data());
+ aName.toUtf8().data());
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
}
else {
SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
- myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toUtf8().constData());
mesh = aMeshEditor->TranslateMakeMesh(anElementsId, aVector, makeGroups,
- LineEditNewMesh->text().toLatin1().data());
+ LineEditNewMesh->text().toUtf8().data());
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
anEntryList.append( aSObject->GetID().c_str() );
}
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- // hilight entered elements
+ // highlight entered elements
SMDS_Mesh* aMesh = 0;
if (myActor)
aMesh = myActor->GetObject()->GetMesh();
myStepSpin->SetStep( 1. );
myStepSpin->SetValue( myStep = 1. );
- // 3) Coodrinates/Spacing group
+ // 3) Coordinates/Spacing group
QFrame* csFrame = new QFrame( this );
QVBoxLayout* scLay = new QVBoxLayout( csFrame );
scLay->setMargin( 0 );
try
{
if( isCreation() )
- SMESH::SetName( SMESH::FindSObject( h ), myName->text().toLatin1().constData() );
+ SMESH::SetName( SMESH::FindSObject( h ), myName->text().toUtf8().constData() );
// threshold
h->SetVarParameter( myThreshold->text().toLatin1().constData(), "SetSizeThreshold" );
params << myPointSpin[0]->text();
params << myPointSpin[1]->text();
params << myPointSpin[2]->text();
- h->SetVarParameter( params.join(":").toLatin1().constData(), "SetFixedPoint" );
+ h->SetVarParameter( params.join(":").toUtf8().constData(), "SetFixedPoint" );
params.clear();
SMESH::PointStruct ps;
params << spins[ax][1]->text();
params << spins[ax][2]->text();
}
- h->SetVarParameter( params.join(":").toLatin1().constData(), "SetAxesDirs" );
+ h->SetVarParameter( params.join(":").toUtf8().constData(), "SetAxesDirs" );
SMESH::DirStruct axDir[3];
for ( int ax = 0; ax < 3; ++ax )
QString StdMeshersGUI_CartesianParamCreator::helpPage() const
{
- return "cartesian_algo_page.html#cartesian_hyp_anchor";
+ return "cartesian_algo.html#cartesian-hyp-anchor";
}
//================================================================================
QString StdMeshersGUI_QuadrangleParamCreator::helpPage() const
{
- return "a2d_meshing_hypo_page.html#hypo_quad_params_anchor";
+ return "2d_meshing_hypo.html#hypo-quad-params-anchor";
}
//=======================================================================
// name
if( myName )
- SMESH::SetName( SMESH::FindSObject( h ), myName->text().toLatin1().constData() );
+ SMESH::SetName( SMESH::FindSObject( h ), myName->text().toUtf8().constData() );
// transition
h->SetQuadType( StdMeshers::QuadType( myTypeWdg->GetType()) );