-// Copyright (C) 2014-2020 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include <GeomAlgoAPI_NExplode.h>
#include <Selector_Selector.h>
+#include <Locale_Convert.h>
+
#include <TNaming_NamedShape.hxx>
#include <TNaming_Tool.hxx>
#include <TNaming_Builder.hxx>
Standard_GUID kELLIPSE_CENTER2("1395ae73-8e02-4cf8-b204-06ff35873a32");
// prefix for the whole feature context identification
-const static std::string kWHOLE_FEATURE = "all-in-";
+const static std::wstring kWHOLE_FEATURE = L"all-in-";
// on this label is stored:
// TNaming_NamedShape - selected shape
} else { // face with name is already in the data model, so try to take it by name
Handle(TDataStd_Name) aName;
if (aSelLab.FindAttribute(TDataStd_Name::GetID(), aName)) {
- std::string aSubShapeName(TCollection_AsciiString(aName->Get()).ToCString());
- std::size_t aPartEnd = aSubShapeName.find('/');
- if (aPartEnd != std::string::npos && aPartEnd != aSubShapeName.rfind('/')) {
- std::string aNameInPart = aSubShapeName.substr(aPartEnd + 1);
+ std::wstring aSubShapeName = Locale::Convert::toWString(aName->Get().ToExtString());
+ std::size_t aPartEnd = aSubShapeName.find(L'/');
+ if (aPartEnd != std::wstring::npos && aPartEnd != aSubShapeName.rfind(L'/')) {
+ std::wstring aNameInPart = aSubShapeName.substr(aPartEnd + 1);
int anInd;
std::string aType; // to reuse already existing selection the type is not needed
return aPart->shapeInPart(aNameInPart, aType, anInd);
Model_AttributeSelection::Model_AttributeSelection(TDF_Label& theLabel)
: myRef(theLabel),
+ myTmpCenterType(NOT_CENTER),
+ myParent(NULL),
myIsGeometricalSelection(false)
{
myIsInitialized = myRef.isInitialized();
- myParent = NULL;
}
void Model_AttributeSelection::setID(const std::string theID)
aResult = aSelector.restore(aContextShape);
bool aWasInvalid = aSelLab.IsAttribute(kINVALID_SELECTION);
setInvalidIfFalse(aSelLab, aResult);
+ if (!aResult)
+ aWasInvalid = false;
TopoDS_Shape aNewShape;
if (aSelLab.FindAttribute(TNaming_NamedShape::GetID(), aNS))
aNewShape = aNS->Get();
+ // check the selected value is a part of the context
+ if (aResult && !aNewShape.IsNull() && !aContextShape.IsNull() &&
+ !aContextShape.IsSame(aNewShape)) {
+ TopoDS_Shape aNewS = aNewShape;
+ // take only sub-shape of composite for checking
+ if (aNewS.ShapeType() == TopAbs_WIRE || aNewS.ShapeType() == TopAbs_SHELL ||
+ aNewS.ShapeType() == TopAbs_COMPOUND || aNewS.ShapeType() == TopAbs_COMPSOLID) {
+ TopoDS_Iterator anIter(aNewS);
+ if (anIter.More())
+ aNewS = anIter.Value();
+ }
+ bool anIsInside = false;
+ TopExp_Explorer anExp(aContextShape, aNewS.ShapeType());
+ for (; anExp.More() && !anIsInside; anExp.Next()) {
+ if (anExp.Current().IsSame(aNewS))
+ anIsInside = true;
+ }
+ if (!anIsInside) {
+ aResult = false;
+ aNewShape.Nullify();
+ setInvalidIfFalse(aSelLab, aResult);
+ }
+ }
+
if (anOldShape.IsNull() || aNewShape.IsNull() || !anOldShape.IsEqual(aNewShape) || aWasInvalid)
{
// shape type should not be changed: if shape becomes compound of such shapes, then split
}
// store the shape (in case part is not loaded it should be useful
TopoDS_Shape aShape;
- std::string aName = theContext->data()->name();
+ std::wstring aName = theContext->data()->name();
if (!theSubShape.get() || theSubShape->isNull()) {// the whole part shape is selected
aShape = theContext->shape()->impl<TopoDS_Shape>();
} else {
aShape = theSubShape->impl<TopoDS_Shape>();
int anIndex;
- aName += "/" + aPart->nameInPart(theSubShape, anIndex);
+ aName += L"/" + aPart->nameInPart(theSubShape, anIndex);
TDataStd_Integer::Set(selectionLabel(), anIndex);
}
TNaming_Builder aBuilder(selectionLabel());
}
/// prefixes of the shape names with centers defined
-static std::map<ModelAPI_AttributeSelection::CenterType, std::string> kCENTERS_PREFIX;
+static std::map<ModelAPI_AttributeSelection::CenterType, std::wstring> kCENTERS_PREFIX;
/// returns the map that contains all possible prefixes of the center-names
-static std::map<ModelAPI_AttributeSelection::CenterType, std::string>& centersMap()
+static std::map<ModelAPI_AttributeSelection::CenterType, std::wstring>& centersMap()
{
if (kCENTERS_PREFIX.empty()) { // fill map by initial values
- kCENTERS_PREFIX[ModelAPI_AttributeSelection::CIRCLE_CENTER] = "__cc";
- kCENTERS_PREFIX[ModelAPI_AttributeSelection::ELLIPSE_FIRST_FOCUS] = "__eff";
- kCENTERS_PREFIX[ModelAPI_AttributeSelection::ELLIPSE_SECOND_FOCUS] = "__esf";
+ kCENTERS_PREFIX[ModelAPI_AttributeSelection::CIRCLE_CENTER] = L"__cc";
+ kCENTERS_PREFIX[ModelAPI_AttributeSelection::ELLIPSE_FIRST_FOCUS] = L"__eff";
+ kCENTERS_PREFIX[ModelAPI_AttributeSelection::ELLIPSE_SECOND_FOCUS] = L"__esf";
}
return kCENTERS_PREFIX;
}
-std::string Model_AttributeSelection::namingName(const std::string& theDefaultName)
+std::wstring Model_AttributeSelection::namingName(const std::wstring& theDefaultName)
{
- std::string aName;
+ std::wstring aName(L"");
if(!this->isInitialized())
return !theDefaultName.empty() ? theDefaultName : aName;
GeomShapePtr aShape = value();
if (!aShape.get() && context().get())
aShape = context()->shape();
+ std::wstring aNotArgName;
if (aShape.get()) {
- aName = aShape->shapeTypeStr();
+ aNotArgName = Locale::Convert::toWString(aShape->shapeTypeStr());
if (myParent) {
- aName += std::string("_") +
- TCollection_AsciiString(selectionLabel().Father().Tag()).ToCString();
+ std::wostringstream aStream;
+ aStream << "_" << selectionLabel().Father().Tag();
+ aNotArgName += aStream.str();
}
}
- return aName;
+ return aNotArgName;
}
CenterType aCenterType = NOT_CENTER;
FeaturePtr aContFeature = contextFeature();
if (aContFeature.get()) {
- std::string aResName;
+ std::wstring aResName;
// checking part-owner
if (aContFeature->document() != owner()->document())
- aResName += aContFeature->document()->kind() + "/";
+ aResName += Locale::Convert::toWString(aContFeature->document()->kind()) + L"/";
// selection of a full feature
if (aContFeature.get()) {
return aResName + kWHOLE_FEATURE + aContFeature->name();
}
// in case of selection of removed result
- return "";
+ return L"";
}
ResultPtr aCont = context();
if (!aCont.get()) {
- return ""; // invalid case
+ return L""; // invalid case
}
TDF_Label aSelLab = selectionLabel();
if (aSelLab.IsAttribute(kSIMPLE_REF_ID)) { // whole context, no value
if (aCont->groupName() == ModelAPI_ResultPart::group()) {
ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aCont);
int anIndex;
- std::string aResult = aSubSh.get() ?
- aPart->data()->name() + "/" + aPart->nameInPart(aSubSh, anIndex) : aPart->data()->name();
+ std::wstring aResult = aSubSh.get() ?
+ aPart->data()->name() + L"/" + aPart->nameInPart(aSubSh, anIndex)
+ : aPart->data()->name();
if (aCenterType != NOT_CENTER)
aResult += centersMap()[aCenterType];
return aResult;
}
Selector_Selector aSelector(aSelLab, baseDocumentLab());
- std::string aResult;
+ std::wstring aResult;
if (aCont->shape().get() && aSelector.restore(aCont->shape()->impl<TopoDS_Shape>()))
aResult = aSelector.name(this);
if (aCenterType != NOT_CENTER) {
}
// returns the center type and modifies the shape name if this name is center-name
-static ModelAPI_AttributeSelection::CenterType centerTypeByName(std::string& theShapeName)
+static ModelAPI_AttributeSelection::CenterType centerTypeByName(std::wstring& theShapeName)
{
- std::map<ModelAPI_AttributeSelection::CenterType, std::string>::iterator aPrefixIter =
+ std::map<ModelAPI_AttributeSelection::CenterType, std::wstring>::iterator aPrefixIter =
centersMap().begin();
for(; aPrefixIter != centersMap().end(); aPrefixIter++) {
std::size_t aFound = theShapeName.find(aPrefixIter->second);
- if (aFound != std::string::npos &&
+ if (aFound != std::wstring::npos &&
aFound == theShapeName.size() - aPrefixIter->second.size()) {
theShapeName = theShapeName.substr(0, aFound);
return aPrefixIter->first;
// type ::= COMP | COMS | SOLD | SHEL | FACE | WIRE | EDGE | VERT
void Model_AttributeSelection::selectSubShape(
- const std::string& theType, const std::string& theSubShapeName)
+ const std::string& theType, const std::wstring& theSubShapeName)
{
if(theSubShapeName.empty() || theType.empty()) return;
- std::string aSubShapeName = theSubShapeName;
+ std::wstring aSubShapeName = theSubShapeName;
CenterType aCenterType = theType[0] == 'v' || theType[0] == 'V' ? // only for vertex-type
centerTypeByName(aSubShapeName) : NOT_CENTER;
std::string aType = aCenterType == NOT_CENTER ? theType : "EDGE"; // search for edge now
std::shared_ptr<Model_Document> aDoc =
std::dynamic_pointer_cast<Model_Document>(owner()->document());
// check this is Part-name: 2 delimiters in the name
- std::size_t aPartEnd = aSubShapeName.find('/');
- if (aPartEnd != std::string::npos) {
- std::string aPartName = aSubShapeName.substr(0, aPartEnd);
+ std::size_t aPartEnd = aSubShapeName.find(L'/');
+ if (aPartEnd != std::wstring::npos) {
+ std::wstring aPartName = aSubShapeName.substr(0, aPartEnd);
DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
- if (aPartName == aRootDoc->kind()) {
+ if (aPartName == Locale::Convert::toWString(aRootDoc->kind())) {
aDoc = std::dynamic_pointer_cast<Model_Document>(aRootDoc);
aSubShapeName = aSubShapeName.substr(aPartEnd + 1);
}
owner()->document()->objectByName(ModelAPI_ResultPart::group(), aPartName);
if (aFound.get()) { // found such part, so asking it for the name
ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aFound);
- std::string aNameInPart = aSubShapeName.substr(aPartEnd + 1);
+ std::wstring aNameInPart = aSubShapeName.substr(aPartEnd + 1);
if (aNameInPart.empty()) { // whole part
setValue(aPart, anEmptyShape);
return;
// check this is a whole feature context
if (aSubShapeName.size() > kWHOLE_FEATURE.size() &&
aSubShapeName.substr(0, kWHOLE_FEATURE.size()) == kWHOLE_FEATURE) {
- std::string aFeatureName = aSubShapeName.substr(kWHOLE_FEATURE.size());
+ std::wstring aFeatureName = aSubShapeName.substr(kWHOLE_FEATURE.size());
ObjectPtr anObj = aDoc->objectByName(ModelAPI_Feature::group(), aFeatureName);
if (anObj.get()) {
setValue(anObj, anEmptyShape);
}
// the whole result selection check
- if (aSubShapeName.find('/') == std::string::npos) {
+ if (aSubShapeName.find(L'/') == std::wstring::npos) {
ObjectPtr aRes = aDoc->objectByName(ModelAPI_ResultConstruction::group(), aSubShapeName);
if (!aRes.get()) {
aRes = aDoc->objectByName(ModelAPI_ResultBody::group(), aSubShapeName);
// collect features from PartSet and the current part
SessionPtr aSession = ModelAPI_Session::get();
std::list<FeaturePtr> aFeatures = aSession->moduleDocument()->allFeatures();
- if (aSession->moduleDocument() != owner()->document()) {
+ if (anOwner->getKind() == "ImportResult") {
+ // special case: feature "ImportResult" refers to the results from another parts,
+ // thus, it is necessary to go through the features of these parts too.
+ std::list<FeaturePtr> aPartSetFeatures = aFeatures;
+ aFeatures.clear();
+ for (std::list<FeaturePtr>::iterator it = aPartSetFeatures.begin();
+ it != aPartSetFeatures.end(); ++it) {
+ aFeatures.push_back(*it);
+ if ((*it)->firstResult()->groupName() == ModelAPI_ResultPart::group()) {
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>((*it)->firstResult());
+ std::list<FeaturePtr> aPartFeatures = aPart->partDoc()->allFeatures();
+ aFeatures.insert(aFeatures.end(), aPartFeatures.begin(), aPartFeatures.end());
+ }
+ }
+ }
+ else if (aSession->moduleDocument() != owner()->document()) {
std::list<FeaturePtr> aPartFeatures = owner()->document()->allFeatures();
aFeatures.insert(aFeatures.end(), aPartFeatures.begin(), aPartFeatures.end());
}
}
void Model_AttributeSelection::selectSubShape(const std::string& theType,
- const std::string& theContextName, const int theIndex)
+ const std::wstring& theContextName, const int theIndex)
{
// selection of context by name
selectSubShape(theType, theContextName);
setValue(aContextRes, aSelection);
}
-std::string Model_AttributeSelection::contextName(const ResultPtr& theContext) const
+std::wstring Model_AttributeSelection::contextName(const ResultPtr& theContext) const
{
- std::string aResult;
+ std::wstring aResult;
if (owner()->document() != theContext->document()) {
if (theContext->document() == ModelAPI_Session::get()->moduleDocument()) {
- aResult = theContext->document()->kind() + "/";
+ aResult = Locale::Convert::toWString(theContext->document()->kind()) + L"/";
} else {
ResultPtr aDocRes = ModelAPI_Tools::findPartResult(
ModelAPI_Session::get()->moduleDocument(), theContext->document());
if (aDocRes.get()) {
- aResult = aDocRes->data()->name() + "/";
+ aResult = aDocRes->data()->name() + L"/";
}
}
}
void Model_AttributeSelection::concealedFeature(
const FeaturePtr theFeature, const FeaturePtr theStop, const bool theCheckCopy,
- std::list<FeaturePtr>& theConcealers, const ResultPtr theResultOfFeature)
+ std::list<FeaturePtr>& theConcealers, const ResultPtr theResultOfFeature,
+ const bool theCheckWholeFeature)
{
std::set<FeaturePtr> alreadyProcessed;
alreadyProcessed.insert(theFeature);
}
std::list<ResultPtr>::const_iterator aRootIter = aRootRes.cbegin();
for(; aRootIter != aRootRes.cend(); aRootIter++) {
- std::list<ResultPtr> allRes;
- allRes.push_back(*aRootIter);
+ std::list<DataPtr> allRes;
+ allRes.push_back((*aRootIter)->data());
ResultBodyPtr aRootBody = ModelAPI_Tools::bodyOwner(*aRootIter, true);
if (!aRootBody.get())
aRootBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(*aRootIter);
if (aRootBody.get()) {
- ModelAPI_Tools::allSubs(aRootBody, allRes);
- }
- for(std::list<ResultPtr>::iterator aRIter = allRes.begin(); aRIter != allRes.end(); aRIter++) {
- const std::set<AttributePtr>& aRefs = (*aRIter)->data()->refsToMe();
+ std::list<ResultPtr> allSub;
+ ModelAPI_Tools::allSubs(aRootBody, allSub);
+ for(std::list<ResultPtr>::iterator anIt = allSub.begin(); anIt != allSub.end(); anIt++)
+ allRes.push_back((*anIt)->data());
+ }
+ if (theCheckWholeFeature)
+ allRes.push_back(theFeature->data());
+ for(std::list<DataPtr>::iterator aRIter = allRes.begin(); aRIter != allRes.end(); aRIter++) {
+ const std::set<AttributePtr>& aRefs = (*aRIter)->refsToMe();
std::set<AttributePtr>::const_iterator aRef = aRefs.cbegin();
for (; aRef != aRefs.cend(); aRef++) {
if (!aRef->get() || !(*aRef)->owner().get())
myParent = theParent;
}
-std::string Model_AttributeSelection::contextName(const TDF_Label theSelectionLab)
+std::wstring Model_AttributeSelection::contextName(const TDF_Label theSelectionLab)
{
std::shared_ptr<Model_Document> aDoc = myRestoreDocument.get() ? myRestoreDocument :
std::dynamic_pointer_cast<Model_Document>(owner()->document());
}
if (aResult.get()) {
// this is to avoid duplicated names of results problem
- std::string aContextName = aResult->data()->name();
+ std::wstring aContextName = aResult->data()->name();
// myLab corresponds to the current time
TDF_Label aCurrentLab = selectionLabel();
while(aCurrentLab.Depth() > 3)
int aNumInHistoryNames =
aDoc->numberOfNameInHistory(aResult, aCurrentLab);
while(aNumInHistoryNames > 1) { // add "_" before name the needed number of times
- aContextName = "_" + aContextName;
+ aContextName = L"_" + aContextName;
aNumInHistoryNames--;
}
if (aBaseDocumnetUsed)
- aContextName = aDoc->kind() + "/" + aContextName;
+ aContextName = Locale::Convert::toWString(aDoc->kind()) + L"/" + aContextName;
return aContextName;
}
}
- return ""; // invalid case
+ return L""; // invalid case
}
/// This method restores by the context and value name the context label and
/// sub-label where the value is. Returns true if it is valid.
-bool Model_AttributeSelection::restoreContext(std::string theName,
+bool Model_AttributeSelection::restoreContext(std::wstring theName,
TDF_Label& theContext, TDF_Label& theValue)
{
static const GeomShapePtr anEmptyShape; // to store context only
- std::string aName = theName;
+ std::wstring aName = theName;
std::shared_ptr<Model_Document> aDoc = myRestoreDocument.get() ? myRestoreDocument :
std::dynamic_pointer_cast<Model_Document>(owner()->document());
// remove the sub-value part if exists
- std::string aSubShapeName = aName;
- std::string::size_type n = aName.find('/');
- if (n != std::string::npos) {
+ std::wstring aSubShapeName = aName;
+ std::wstring::size_type n = aName.find(L'/');
+ if (n != std::wstring::npos) {
aName = aName.substr(0, n);
}
// name in PartSet?
aDoc = std::dynamic_pointer_cast<Model_Document>(
ModelAPI_Session::get()->moduleDocument());
- if (theName.find(aDoc->kind()) == 0) { // remove the document identifier from name if exists
+ if (theName.find(Locale::Convert::toWString(aDoc->kind())) == 0) {
+ // remove the document identifier from name if exists
aSubShapeName = theName.substr(aDoc->kind().size() + 1);
aName = aSubShapeName;
- n = aName.find('/');
- if (n != std::string::npos) {
+ n = aName.find(L'/');
+ if (n != std::wstring::npos) {
aName = aName.substr(0, n);
}
}
// sketch sub-component shape and name is located in separated feature label, try the sub-name
if (theValue.IsNull() && aCont->groupName() == ModelAPI_ResultConstruction::group()) {
- std::string::size_type aSlash = aSubShapeName.rfind('/');
- if (aSlash != std::string::npos) {
- std::string aCompName = aSubShapeName.substr(aSlash + 1);
+ std::wstring::size_type aSlash = aSubShapeName.rfind(L'/');
+ if (aSlash != std::wstring::npos) {
+ std::wstring aCompName = aSubShapeName.substr(aSlash + 1);
CompositeFeaturePtr aComposite =
std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aDoc->feature(aCont));
if (aComposite.get() && aComposite->numberOfSubs()) {
}
}
+ // Fix for opened study (aDoc->myNamingNames is empty)
+ if (theValue.IsNull() && aCont->groupName() != ModelAPI_ResultConstruction::group()) {
+ std::wstring::size_type aSlash = aSubShapeName.rfind(L'/');
+ if (aSlash != std::wstring::npos) {
+ std::wstring aCompName = aSubShapeName.substr(aSlash + 1);
+ TDF_Label aLab = std::dynamic_pointer_cast<Model_Data>(aCont->data())->shapeLab();
+ TDF_ChildIDIterator aSubNames (aLab, TDataStd_Name::GetID());
+ for (; aSubNames.More(); aSubNames.Next()) {
+ if (Handle(TDataStd_Name)::DownCast(aSubNames.Value())->Get().IsEqual(aCompName.c_str())) {
+ theValue = aSubNames.Value()->Label();
+ aDoc->addNamingName(theValue, aSubShapeName);
+ break;
+ }
+ }
+ }
+ }
+
if (aCont.get()) {
theContext = std::dynamic_pointer_cast<Model_Data>(aCont->data())->label();
}
//if (aResult->groupName() == ModelAPI_ResultBody::group()) {
// try to search newer context by the concealment references
// take references to all results: root one, any sub
- std::list<ResultPtr> allRes;
+ std::list<DataPtr> allRes;
ResultPtr aCompContext;
ResultBodyPtr aCompBody = ModelAPI_Tools::bodyOwner(aResult, true);
if (aCompBody.get()) {
- ModelAPI_Tools::allSubs(aCompBody, allRes);
- allRes.push_back(aCompBody);
+ std::list<ResultPtr> allSub;
+ ModelAPI_Tools::allSubs(aCompBody, allSub);
+ for(std::list<ResultPtr>::iterator anIt = allSub.begin(); anIt != allSub.end(); anIt++)
+ allRes.push_back((*anIt)->data());
+ allRes.push_back(aCompBody->data());
aCompContext = aCompBody;
}
if (allRes.empty())
- allRes.push_back(aResult);
+ allRes.push_back(aResult->data());
+ allRes.push_back(aResult->document()->feature(aResult)->data());
bool aFoundReferernce = false;
- for (std::list<ResultPtr>::iterator aSub = allRes.begin(); aSub != allRes.end(); aSub++) {
- ResultPtr aResCont = *aSub;
- ResultBodyPtr aResBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResCont);
+ for (std::list<DataPtr>::iterator aSub = allRes.begin(); aSub != allRes.end(); aSub++) {
+ DataPtr aResCont = *aSub;
+ ResultBodyPtr aResBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResCont->owner());
if (aResBody.get() && aResBody->numberOfSubs() > 0 && aResBody != aCompContext)
continue; // only lower and higher level subs are counted
- const std::set<AttributePtr>& aRefs = aResCont->data()->refsToMe();
+ const std::set<AttributePtr>& aRefs = aResCont->refsToMe();
std::set<AttributePtr>::const_iterator aRef = aRefs.begin();
for (; !aFindNewContext && aRef != aRefs.end(); aRef++) {
if (!aRef->get() || !(*aRef)->owner().get())
}
}
}
- // in case sketch line was selected for wire, but wire was concealed and not such line anymore,
- // so, actually, the sketch element was selected (which is never concealed)
- if (aResult != theCurrent && aResult->isConcealed())
- aResult = theCurrent;
+ // in case sketch line was selected for wire, but wire was concealed and there is no such line
+ // anymore, so, actually, the sketch element was selected (which is never concealed)
+ if (aResult != theCurrent && theCurrent->groupName() == ModelAPI_ResultConstruction::group()) {
+ std::list<FeaturePtr> aConcealers;
+ FeaturePtr aResFeature = aDoc->feature(aResult);
+ FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
+ concealedFeature(aResFeature, aThisFeature, false, aConcealers, aResult, true);
+ if (aConcealers.size())
+ aResult = theCurrent;
+ }
return aResult;
}
Handle(TDataStd_Integer) anIndex;
if (aSelLab.FindAttribute(TDataStd_Integer::GetID(), anIndex)) {
if (anIndex->Get()) { // special selection attribute was created, use it
- std::string aNewName;
+ std::wstring aNewName;
aPart->combineGeometrical(anIndex->Get(), aNewName);
TDataStd_Name::Set(aSelLab, aNewName.c_str());
}
