-// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2023 CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or
-// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include <Model_Objects.h>
#include <Model_ResultGroup.h>
#include <Model_ResultField.h>
#include <Model_ResultParameter.h>
+#include <Model_AttributeRefList.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Tools.h>
+#include <ModelAPI_Filter.h>
+
#include <Events_Loop.h>
#include <Events_InfoMessage.h>
+#include <Locale_Convert.h>
+
#include <TDataStd_Integer.hxx>
#include <TDataStd_Comment.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDataStd_ReferenceArray.hxx>
#include <TDataStd_HLabelArray1.hxx>
-#include <TDataStd_Name.hxx>
#include <TDF_Reference.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_LabelMapHasher.hxx>
#include <TDF_LabelMap.hxx>
#include <TDF_ListIteratorOfLabelList.hxx>
+// for TDF_Label map usage
+static Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper);
+static Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2);
+
+int kUNDEFINED_FEATURE_INDEX = -1;
+
static const std::string& groupNameFoldering(const std::string& theGroupID,
const bool theAllowFolder)
{
} else { // extend array by one more element
Handle(TDataStd_HLabelArray1) aNewArray = new TDataStd_HLabelArray1(aRefs->Lower(),
aRefs->Upper() + 1);
- int aPassedPrev = 0; // prev feature is found and passed
+ int aPassedPrev = 0; // previous feature is found and passed
if (thePrevLab.IsNull()) { // null means that inserted feature must be the first
aNewArray->SetValue(aRefs->Lower(), theReferenced);
aPassedPrev = 1;
for(; aRefIter != aRefs.end(); aRefIter++) {
std::shared_ptr<ModelAPI_CompositeFeature> aComposite =
std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aRefIter);
- if (aComposite.get() && aComposite->isSub(theFeature)) {
+ if (aComposite.get() && aComposite->data()->isValid() && aComposite->isSub(theFeature)) {
aComposite->removeFeature(theFeature);
}
}
}
kCreator->sendDeleted(myDoc, ModelAPI_Feature::group());
myFeatures.Clear(); // just remove features without modification of DS
- updateHistory(ModelAPI_Feature::group());
+ myHistory.clear();
}
void Model_Objects::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis)
if (theAfterThis.get())
anAfterLab = std::dynamic_pointer_cast<Model_Data>(theAfterThis->data())->label().Father();
+ // check whether some folder refers to the moved feature by start or end: if yes, remove from it
+ removeFromFolder(std::list<FeaturePtr>(1, theMoved));
+
Handle(TDataStd_HLabelArray1) aNewArray =
new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper());
- int aPassedMovedFrom = 0; // the prev feature location is found and passed
+ int aPassedMovedFrom = 0; // the previous feature location is found and passed
int aPassedMovedTo = 0; // the feature is added and this location is passed
if (!theAfterThis.get()) { // null means that inserted feature must be the first
aNewArray->SetValue(aRefs->Lower(), aMovedLab);
const std::list<ResultPtr>& aResults = aFeature->results();
std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.cbegin();
for(; aRIter != aResults.cend(); aRIter++) {
- std::shared_ptr<Model_Data> aResData = std::dynamic_pointer_cast<Model_Data>((*aRIter)->data());
+ std::shared_ptr<Model_Data> aResData =
+ std::dynamic_pointer_cast<Model_Data>((*aRIter)->data());
if (aResData->label().Father().IsEqual(aSubLab.ChangeValue())) {
aCurrentResult = *aRIter;
break;
return ObjectPtr();
createHistory(theGroupID);
const std::string& aGroupID = groupNameFoldering(theGroupID, theAllowFolder);
- const std::vector<ObjectPtr>& aVec = myHistory[theGroupID];
- //if (aVec.size() <= theIndex)
- // return aVec[aVec.size() - 1]; // too high index requested (to avoid crash in #2360)
return aGroupID.empty() ? myHistory[theGroupID][theIndex] : myHistory[aGroupID][theIndex];
}
std::shared_ptr<ModelAPI_Object> Model_Objects::objectByName(
- const std::string& theGroupID, const std::string& theName)
+ const std::string& theGroupID, const std::wstring& theName)
{
createHistory(theGroupID);
if (theGroupID == ModelAPI_Feature::group()) { // searching among features (in history or not)
std::list<std::shared_ptr<ModelAPI_Feature> > allObjs = allFeatures();
- std::list<std::shared_ptr<ModelAPI_Feature> >::iterator anObjIter = allObjs.begin();
- for(; anObjIter != allObjs.end(); anObjIter++) {
+ // from the end to find the latest result with such name
+ std::list<std::shared_ptr<ModelAPI_Feature> >::reverse_iterator anObjIter = allObjs.rbegin();
+ for(; anObjIter != allObjs.rend(); anObjIter++) {
if ((*anObjIter)->data()->name() == theName)
return *anObjIter;
}
} else { // searching among results (concealed or not)
std::list<std::shared_ptr<ModelAPI_Feature> > allObjs = allFeatures();
- std::list<std::shared_ptr<ModelAPI_Feature> >::iterator anObjIter = allObjs.begin();
- for(; anObjIter != allObjs.end(); anObjIter++) {
+ // from the end to find the latest result with such name
+ std::list<std::shared_ptr<ModelAPI_Feature> >::reverse_iterator anObjIter = allObjs.rbegin();
+ for(; anObjIter != allObjs.rend(); anObjIter++) {
std::list<ResultPtr> allRes;
ModelAPI_Tools::allResults(*anObjIter, allRes);
for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
return myMain.FindChild(TAG_OBJECTS);
}
-static std::string composeName(const std::string& theFeatureKind, const int theIndex)
+static std::wstring composeName(const std::string& theFeatureKind, const int theIndex)
{
std::stringstream aNameStream;
aNameStream << theFeatureKind << "_" << theIndex;
- return aNameStream.str();
+ return Locale::Convert::toWString(aNameStream.str());
}
void Model_Objects::setUniqueName(FeaturePtr theFeature)
{
if (!theFeature->data()->name().empty())
return; // not needed, name is already defined
- std::string aName; // result
+ std::wstring aName; // result
// first count all features of such kind to start with index = count + 1
int aNumObjects = -1; // this feature is already in this map
NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFIter(myFeatures);
+ std::set<std::wstring> allNames;
for (; aFIter.More(); aFIter.Next()) {
if (aFIter.Value()->getKind() == theFeature->getKind())
aNumObjects++;
+ allNames.insert(aFIter.Value()->data()->name());
}
// generate candidate name
aName = composeName(theFeature->getKind(), aNumObjects + 1);
// check this is unique, if not, increase index by 1
- for (aFIter.Initialize(myFeatures); aFIter.More();) {
- FeaturePtr aFeature = aFIter.Value();
- bool isSameName = aFeature->data()->name() == aName;
- if (!isSameName) { // check also results to avoid same results names (actual for Parts)
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- isSameName = (*aRIter)->data()->name() == aName;
- }
- }
-
- if (isSameName) {
- aNumObjects++;
- aName = composeName(theFeature->getKind(), aNumObjects + 1);
- // reinitialize iterator to make sure a new name is unique
- aFIter.Initialize(myFeatures);
- } else
- aFIter.Next();
+ for(aNumObjects++; allNames.find(aName) != allNames.end(); aNumObjects++) {
+ aName = composeName(theFeature->getKind(), aNumObjects + 1);
}
theFeature->data()->setName(aName);
}
return; // name is already defined
int aNbFolders = myFolders.Size();
- std::string aName = composeName(ModelAPI_Folder::ID(), aNbFolders);
+ std::wstring aName = composeName(ModelAPI_Folder::ID(), aNbFolders);
// check the uniqueness of the name
NCollection_DataMap<TDF_Label, ObjectPtr>::Iterator anIt(myFolders);
while (anIt.More()) {
if (anIt.Value()->data()->name() == aName) {
- aName = composeName(ModelAPI_Folder::ID(), aNbFolders);
+ aName = composeName(ModelAPI_Folder::ID(), ++aNbFolders);
// reinitialize iterator to make sure a new name is unique
anIt.Initialize(myFolders);
} else
theObj->initAttributes();
}
-std::shared_ptr<ModelAPI_Feature> Model_Objects::featureById(const int theId)
-{
- if (theId > 0) {
- TDF_Label aLab = featuresLabel().FindChild(theId, Standard_False);
- return feature(aLab);
- }
- return std::shared_ptr<ModelAPI_Feature>(); // not found
-}
-
void Model_Objects::synchronizeFeatures(
const TDF_LabelList& theUpdated, const bool theUpdateReferences,
const bool theExecuteFeatures, const bool theOpen, const bool theFlush)
return;
// after all updates, sends a message that groups of features were created or updated
Events_Loop* aLoop = Events_Loop::loop();
- static Events_ID aDispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
- static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
+ //static Events_ID aDispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+ static Events_ID aCreateEvent = aLoop->eventByName(EVENT_OBJECT_CREATED);
+ static Events_ID anUpdateEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED);
static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- static Events_ID aDeleteEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED);
+ static Events_ID aDeleteEvent = aLoop->eventByName(EVENT_OBJECT_DELETED);
static Events_ID aToHideEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
bool isActive = aLoop->activateFlushes(false);
ObjectPtr aFeature = isFolder ? ObjectPtr(new ModelAPI_Folder)
: ObjectPtr(aSession->createFeature(aFeatureID, anOwner));
if (!aFeature.get()) {
- // somethig is wrong, most probably, the opened document has invalid structure
+ // something is wrong, most probably, the opened document has invalid structure
Events_InfoMessage("Model_Objects", "Invalid type of object in the document").send();
aLabIter.Value()->Label().ForgetAllAttributes();
continue;
if (anUpdatedMap.Contains(aFeatureLabel)) {
if (!theOpen) { // on abort/undo/redo reinitialize attributes if something is changed
- std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs =
- anObject->data()->attributes("");
- std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
- for(; anAttr != anAttrs.end(); anAttr++)
- (*anAttr)->reinit();
+ FiltersFeaturePtr aFilter = std::dynamic_pointer_cast<ModelAPI_FiltersFeature>(anObject);
+ if (aFilter.get()) { // for filters attributes may be added/removed on undo/redo
+ std::dynamic_pointer_cast<Model_Data>(aFilter->data())->clearAttributes();
+ aFilter->initAttributes();
+ } else {
+ std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs =
+ anObject->data()->attributes("");
+ std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
+ for(; anAttr != anAttrs.end(); anAttr++)
+ (*anAttr)->reinit();
+ // if feature contains results, re-init them too
+ if (aFeature.get()) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ std::list<ResultPtr>::iterator aResIter = aResults.begin();
+ for(; aResIter != aResults.end(); aResIter++) {
+ anAttrs = (*aResIter)->data()->attributes("");
+ for(anAttr = anAttrs.begin(); anAttr != anAttrs.end(); anAttr++)
+ (*anAttr)->reinit();
+ }
+ }
+ }
}
ModelAPI_EventCreator::get()->sendUpdated(anObject, anUpdateEvent);
if (aFeature && aFeature->getKind() == "Parameter") {
}
// update results of the features (after features created because
// they may be connected, like sketch and sub elements)
- // After synchronisation of back references because sketch
+ // After synchronization of back references because sketch
// must be set in sub-elements before "execute" by updateResults
std::set<FeaturePtr> aProcessed; // composites must be updated after their subs (issue 360)
TDF_ChildIDIterator aLabIter2(featuresLabel(), TDataStd_Comment::GetID());
anOwner->setExecuteFeatures(true);
}
-/// synchronises back references for the given object basing on the collected data
+/// synchronizes back references for the given object basing on the collected data
void Model_Objects::synchronizeBackRefsForObject(const std::set<AttributePtr>& theNewRefs,
ObjectPtr theObject)
{
if (!theObject.get() || !theObject->data()->isValid())
return; // invalid
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theObject->data());
- // iterate new list to compare with curent
+ // iterate new list to compare with current
std::set<AttributePtr>::iterator aNewIter = theNewRefs.begin();
for(; aNewIter != theNewRefs.end(); aNewIter++) {
+ // for the Model_AttributeRefList erase cash (issue #2819)
+ std::shared_ptr<Model_AttributeRefList> aRefList =
+ std::dynamic_pointer_cast<Model_AttributeRefList>(*aNewIter);
+ if (aRefList)
+ aRefList->eraseHash();
+
if (aData->refsToMe().find(*aNewIter) == aData->refsToMe().end()) {
FeaturePtr aRefFeat = std::dynamic_pointer_cast<ModelAPI_Feature>((*aNewIter)->owner());
if (aRefFeat)
void Model_Objects::synchronizeBackRefs()
{
// collect all back references in the separated container: to update everything at once,
- // without additional Concealment switchin on and off: only the final modification
+ // without additional Concealment switching on and off: only the final modification
- // referenced (slave) objects to referencing attirbutes
+ // referenced (slave) objects to referencing attributes
std::map<ObjectPtr, std::set<AttributePtr> > allRefs;
NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeatures(myFeatures);
for(; aFeatures.More(); aFeatures.Next()) {
FeaturePtr aFeature = aFeatures.Value();
std::list<ResultPtr> aResults;
ModelAPI_Tools::allResults(aFeature, aResults);
- // update the concealment status for disply in isConcealed of ResultBody
+ // update the concealment status for display in isConcealed of ResultBody
std::list<ResultPtr>::iterator aRIter = aResults.begin();
for(; aRIter != aResults.cend(); aRIter++) {
(*aRIter)->isConcealed();
bool Model_Objects::hasCustomName(DataPtr theFeatureData,
ResultPtr theResult,
- int theResultIndex,
- std::string& theParentName) const
+ int /*theResultIndex*/,
+ std::wstring& theParentName) const
{
ResultBodyPtr aBodyRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theFeatureData->owner());
- if (aBodyRes && std::dynamic_pointer_cast<Model_Data>(theFeatureData)->label().Depth() < 7) {
+ if (aBodyRes) {
// only for top-results (works for the cases when results are not yet added to the feature)
FeaturePtr anOwner = ModelAPI_Feature::feature(theResult);
// names of sub-solids in CompSolid should be default (for example,
// result of boolean operation 'Boolean_1' is a CompSolid which is renamed to 'MyBOOL',
// however, sub-elements of 'MyBOOL' should be named 'Boolean_1_1', 'Boolean_1_2' etc.)
- std::ostringstream aDefaultName;
- aDefaultName << anOwner->name();
- // compute default name of CompSolid (name of feature + index of CompSolid's result)
- int aBodyResultIndex = 0;
- const std::list<ResultPtr>& aResults = anOwner->results();
- std::list<ResultPtr>::const_iterator anIt = aResults.begin();
- for(; anIt != aResults.end(); ++anIt, ++aBodyResultIndex)
- if(aBodyRes == *anIt)
- break;
- aDefaultName << "_" << (aBodyResultIndex + 1);
- theParentName = aDefaultName.str();
+ if (std::dynamic_pointer_cast<Model_Data>(aBodyRes->data())->label().Depth() == 6) {
+ std::wostringstream aDefaultName;
+ // compute default name of CompSolid (name of feature + index of CompSolid's result)
+ int aBodyResultIndex = 0;
+ const std::list<ResultPtr>& aResults = anOwner->results();
+ std::list<ResultPtr>::const_iterator anIt = aResults.begin();
+ for (; anIt != aResults.end(); ++anIt, ++aBodyResultIndex)
+ if (aBodyRes == *anIt)
+ break;
+ aDefaultName << anOwner->name();
+ aDefaultName << "_" << (aBodyResultIndex + 1);
+ theParentName = aDefaultName.str();
+ } else { // just name of the parent result if it is deeper than just a sub-result
+ theParentName = aBodyRes->data()->name();
+ }
return false;
}
- std::pair<std::string, bool> aName = ModelAPI_Tools::getDefaultName(theResult);
+ std::pair<std::wstring, bool> aName = ModelAPI_Tools::getDefaultName(theResult);
if (aName.second)
theParentName = aName.first;
return aName.second;
void Model_Objects::storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
std::shared_ptr<ModelAPI_Result> theResult,
- const int theResultIndex)
+ const int theResultIndex,
+ const std::wstring& theNameShape)
{
theResult->init();
theResult->setDoc(myDoc);
initData(theResult, resultLabel(theFeatureData, theResultIndex), TAG_FEATURE_ARGUMENTS);
if (theResult->data()->name().empty()) {
// if was not initialized, generate event and set a name
- std::string aNewName = theFeatureData->name();
+ std::wstring aNewName = theFeatureData->name();
if (hasCustomName(theFeatureData, theResult, theResultIndex, aNewName)) {
// if the name of result is user-defined, then, at first time, assign name of the result
// by empty string to be sure that corresponding flag in the data model is set
- theResult->data()->setName("");
+ theResult->data()->setName(L"");
} else {
- std::stringstream aName;
- aName << aNewName;
- // if there are several results (issue #899: any number of result),
- // add unique prefix starting from second
- if (theResultIndex > 0 || theResult->groupName() == ModelAPI_ResultBody::group())
- aName << "_" << theResultIndex + 1;
+ std::wstringstream aName;
+ if ( theNameShape != L"" ){
+ aName << theNameShape;
+ } else {
+ aName << aNewName;
+ // if there are several results (issue #899: any number of result),
+ // add unique prefix starting from second
+ if (theResultIndex > 0 || theResult->groupName() == ModelAPI_ResultBody::group())
+ aName << "_" << theResultIndex + 1;
+ }
aNewName = aName.str();
}
theResult->data()->setName(aNewName);
}
std::shared_ptr<ModelAPI_ResultBody> Model_Objects::createBody(
- const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData,
+ const int theIndex,
+ const std::wstring& theNameShape)
{
TDF_Label aLab = resultLabel(theFeatureData, theIndex);
TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
}
if (!aResult.get()) {
aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
- storeResult(theFeatureData, aResult, theIndex);
+ storeResult(theFeatureData, aResult, theIndex, theNameShape);
}
return aResult;
}
std::shared_ptr<Model_Data> aPrevData =
std::dynamic_pointer_cast<Model_Data>(theBeforeThis->data());
if (aPrevData.get()) {
- aPrevFeatureLab = nextLabel(aPrevData->label().Father(), true);
+ int anIndex = kUNDEFINED_FEATURE_INDEX;
+ aPrevFeatureLab = nextLabel(aPrevData->label().Father(), anIndex, true);
}
} else { // find the label of the last feature
Handle(TDataStd_ReferenceArray) aRefs;
if (theBelow)
continue;
- // if feature is in sub-component, skip it
- FeaturePtr aCurFeature = feature(aCurLabel);
- if (isSkippedFeature(aCurFeature))
- continue;
-
+ // issue #18733: check for the last feature in folder before checking the sub-feature,
+ // because the folder may end by the feature which is
+ // neither a sub-feature nor a feature in history.
if (!aLastFeatureInFolder.IsNull()) {
if (IsEqual(aCurLabel, aLastFeatureInFolder))
- aLastFeatureInFolder.Nullify(); // the last feature in the folder is achived
+ aLastFeatureInFolder.Nullify(); // the last feature in the folder is achieved
continue;
}
+ // if feature is in sub-component, skip it
+ FeaturePtr aCurFeature = feature(aCurLabel);
+ if (isSkippedFeature(aCurFeature))
+ continue;
+
const ObjectPtr& aFolderObj = folder(aCurLabel);
if (aFolderObj.get()) {
aFoundFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(aFolderObj);
const std::shared_ptr<ModelAPI_Result>& theResult)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theResult->data());
- if (aData.get()) {
+ if (aData.get() && aData->isValid()) {
TDF_Label aFeatureLab = aData->label().Father().Father().Father();
FeaturePtr aFeature = feature(aFeatureLab);
while(!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result
if (aLabIter.More()) {
TDF_Label anArgLab = aLabIter.Value();
Handle(TDataStd_Comment) aGroup;
- if (aLabIter.Value().FindAttribute(TDataStd_Comment::GetID(), aGroup)) {
+ if (anArgLab.FindAttribute(TDataStd_Comment::GetID(), aGroup)) {
return TCollection_AsciiString(aGroup->Get()).ToCString();
}
}
}
}
- // for not persistent is will be done by parametric updater automatically
- //if (!theFeature->isPersistentResult()) return;
+ // it may be on undo
+ if (!theFeature->data() || !theFeature->data()->isValid() || theFeature->isDisabled())
+ return;
+
// check the existing results and remove them if there is nothing on the label
std::list<ResultPtr>::const_iterator aResIter = theFeature->results().cbegin();
while(aResIter != theFeature->results().cend()) {
}
aResIter++;
}
- // it may be on undo
- if (!theFeature->data() || !theFeature->data()->isValid() || theFeature->isDisabled())
- return;
// check that results are presented on all labels
int aResSize = int(theFeature->results().size());
TDF_ChildIterator aLabIter(resultLabel(theFeature->data(), 0).Father());
if (aGroup->Get() == ModelAPI_ResultBody::group().c_str()) {
aNewBody = createBody(theFeature->data(), aResIndex);
} else if (aGroup->Get() == ModelAPI_ResultPart::group().c_str()) {
- std::shared_ptr<ModelAPI_ResultPart> aNewP = createPart(theFeature->data(), aResIndex);
- theFeature->setResult(aNewP, aResIndex);
- if (!aNewP->partDoc().get())
- // create the part result: it is better to restore the previous result if it is possible
- theFeature->execute();
+ if (aResIndex <= (int)theFeature->results().size()) {// to avoid crash if previous execute
+ // for index = 0 erases result
+ std::shared_ptr<ModelAPI_ResultPart> aNewP = createPart(theFeature->data(), aResIndex);
+ if (!aNewP->data()->isDeleted()) {
+ theFeature->setResult(aNewP, aResIndex);
+ if (!aNewP->partDoc().get())
+ // create the part result: it is better to restore the previous result if possible
+ theFeature->execute();
+ }
+ }
} else if (aGroup->Get() == ModelAPI_ResultConstruction::group().c_str()) {
- theFeature->execute(); // construction shapes are needed for sketch solver
+ ResultConstructionPtr aConstr = createConstruction(theFeature->data(), aResIndex);
+ if (!aConstr->data()->isDeleted()) {
+ if (!aConstr->updateShape())
+ theFeature->execute(); // not stored shape in the data structure, execute to have it
+ else
+ theFeature->setResult(aConstr, aResIndex); // result is ready without execution
+ }
} else if (aGroup->Get() == ModelAPI_ResultGroup::group().c_str()) {
aNewBody = createGroup(theFeature->data(), aResIndex);
} else if (aGroup->Get() == ModelAPI_ResultField::group().c_str()) {
- aNewBody = createField(theFeature->data(), aResIndex);
+ ResultFieldPtr aField = createField(theFeature->data(), aResIndex);
+ aField->updateSteps(); // to refresh the internal data
+ aNewBody = aField;
} else if (aGroup->Get() == ModelAPI_ResultParameter::group().c_str()) {
theFeature->attributeChanged("expression"); // just produce a value
} else {
}
}
}
+ if (aResSize > 0) { // check there exist a body that must be updated
+ std::list<ResultPtr>::const_iterator aRes = theFeature->results().cbegin();
+ for (; aResSize && aRes != theFeature->results().cend(); aRes++, aResSize++) {
+ if ((*aRes)->data()->isValid()) {
+ if ((*aRes)->groupName() == ModelAPI_ResultBody::group()) {
+ ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(*aRes);
+ aBody->updateSubs(aBody->shape(), false);
+ } else if ((*aRes)->groupName() == ModelAPI_ResultConstruction::group()) {
+ // update the cashed myShape presented in construction
+ ResultConstructionPtr aConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aRes);
+ aConstr->updateShape();
+ }
+ }
+ }
+ }
}
-ResultPtr Model_Objects::findByName(const std::string theName)
+ResultPtr Model_Objects::findByName(const std::wstring theName)
{
ResultPtr aResult;
FeaturePtr aResFeature; // keep feature to return the latest one
return aResult;
}
-TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, const bool theReverse)
+TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, int& theIndex, const bool theReverse)
{
Handle(TDataStd_ReferenceArray) aRefs;
if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
- for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { // iterate all existing features
+ int aStart = theIndex == kUNDEFINED_FEATURE_INDEX ? aRefs->Lower() : theIndex;
+ for(int a = aStart; a <= aRefs->Upper(); a++) { // iterate all existing features
TDF_Label aCurLab = aRefs->Value(a);
if (aCurLab.IsEqual(theCurrent)) {
a += theReverse ? -1 : 1;
- if (a >= aRefs->Lower() && a <= aRefs->Upper())
+ if (a >= aRefs->Lower() && a <= aRefs->Upper()) {
+ theIndex = a;
return aRefs->Value(a);
- break; // finish iiteration: it's last feature
+ }
+ break; // finish iteration: it's last feature
}
}
}
return TDF_Label();
}
-FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, const bool theReverse)
+FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, int& theIndex, const bool theReverse)
{
std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
if (aData.get() && aData->isValid()) {
TDF_Label aFeatureLabel = aData->label().Father();
do {
- TDF_Label aNextLabel = nextLabel(aFeatureLabel, theReverse);
+ TDF_Label aNextLabel = nextLabel(aFeatureLabel, theIndex, theReverse);
if (aNextLabel.IsNull())
- break; // last or something is wrong
+ break; // the last or something is wrong
FeaturePtr aFound = feature(aNextLabel);
if (aFound)
return aFound; // the feature is found
{
Handle(TDataStd_ReferenceArray) aRefs;
if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
- FeaturePtr aLast = feature(aRefs->Value(aRefs->Upper()));
+ // comment this because of #2674 - features are removed from array on deactivation of Part
+ /*FeaturePtr aLast = feature(aRefs->Value(aRefs->Upper()));
if (!aLast.get() && aRefs->Length() != 0) { // erase the invalid feature from the array
RemoveFromRefArray(featuresLabel(), aRefs->Value(aRefs->Upper()));
return lastFeature(); // try once again, after the last was removed
- }
+ }*/
return feature(aRefs->Value(aRefs->Upper()));
}
return FeaturePtr(); // no features at all
bool Model_Objects::isLater(FeaturePtr theLater, FeaturePtr theCurrent) const
{
+ if (theLater->getKind() == "InternalSelectionInPartFeature")
+ return true;
std::shared_ptr<Model_Data> aLaterD = std::static_pointer_cast<Model_Data>(theLater->data());
std::shared_ptr<Model_Data> aCurrentD = std::static_pointer_cast<Model_Data>(theCurrent->data());
if (aLaterD.get() && aLaterD->isValid() && aCurrentD.get() && aCurrentD->isValid()) {
Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper)
{
return TDF_LabelMapHasher::HashCode(theLab, theUpper);
-
}
Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2)
{
