// delete all features of this document
Events_Loop* aLoop = Events_Loop::loop();
// erase one by one to avoid access from the feature destructor itself from he map
+ // blocks the flush signals to avoid the temporary objects visualization in the viewer
+ // they should not be shown in order to do not lose highlight by erasing them
+ bool isActive = aLoop->activateFlushes(false);
+
while(!myFeatures.IsEmpty()) {
NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeaturesIter(myFeatures);
FeaturePtr aFeature = aFeaturesIter.Value();
static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
ModelAPI_EventCreator::get()->sendDeleted(myDoc, ModelAPI_Feature::group());
ModelAPI_EventCreator::get()->sendUpdated(aFeature, EVENT_DISP);
- aFeature->eraseResults();
+ aFeature->removeResults(0, false);
+ //aFeature->eraseResults();
aFeature->erase();
myFeatures.UnBind(aFeaturesIter.Key());
}
+ aLoop->activateFlushes(isActive);
+ // erase update, because features are destroyed and update should not performed for them anywhere
+ aLoop->eraseMessages(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
+ aLoop->eraseMessages(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+ // deleted and redisplayed is correctly performed: they know that features are destroyed
aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
// event: feature is added
static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
ModelAPI_EventCreator::get()->sendUpdated(theFeature, anEvent);
- theFeature->setDisabled(false); // by default created feature is enabled
updateHistory(ModelAPI_Feature::group());
} else { // make feature has not-null data anyway
theFeature->setData(Model_Data::invalidData());
// check the feature: it must have no depended objects on it
// the dependencies can be in the feature results
std::list<ResultPtr>::const_iterator aResIter = theFeature->results().cbegin();
- for(; aResIter != theFeature->results().cend(); aResIter++) {
+ for (; aResIter != theFeature->results().cend(); aResIter++) {
ResultPtr aResult = (*aResIter);
std::shared_ptr<Model_Data> aData =
- std::dynamic_pointer_cast<Model_Data>(aResult->data());
+ std::dynamic_pointer_cast<Model_Data>(aResult->data());
if (aData.get() != NULL) {
const std::set<AttributePtr>& aRefs = aData->refsToMe();
std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin(), aRefLast = aRefs.end();
- for(; aRefIt != aRefLast; aRefIt++) {
+ for (; aRefIt != aRefLast; aRefIt++) {
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRefIt)->owner());
if (aFeature.get() != NULL)
theRefs.insert(aFeature);
// the dependencies can be in the feature itself
std::shared_ptr<Model_Data> aData =
std::dynamic_pointer_cast<Model_Data>(theFeature->data());
- if (aData && !aData->refsToMe().empty()) {
+ if (aData.get() && !aData->refsToMe().empty()) {
const std::set<AttributePtr>& aRefs = aData->refsToMe();
std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin(), aRefLast = aRefs.end();
- for(; aRefIt != aRefLast; aRefIt++) {
+ for (; aRefIt != aRefLast; aRefIt++) {
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRefIt)->owner());
if (aFeature.get() != NULL)
theRefs.insert(aFeature);
void Model_Objects::removeFeature(FeaturePtr theFeature)
{
std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theFeature->data());
- if (aData && aData->isValid()) {
+ if (aData.get() && aData->isValid()) {
// checking that the sub-element of composite feature is removed: if yes, inform the owner
std::set<std::shared_ptr<ModelAPI_Feature> > aRefs;
refsToFeature(theFeature, aRefs, false);
aRefs->SetInternalArray(aNewArray);
// update the feature and the history
clearHistory(theMoved);
+ // make sure all (selection) attributes of moved feature will be updated
+ theMoved->data()->setUpdateID(0);
static Events_ID EVENT_UPD = Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED);
ModelAPI_EventCreator::get()->sendUpdated(theMoved, EVENT_UPD);
+ ModelAPI_EventCreator::get()->sendReordered(theMoved->document(), theMoved->groupName());
}
void Model_Objects::clearHistory(ObjectPtr theObj)
{
- if (theObj) {
+ if (theObj.get()) {
const std::string aGroup = theObj->groupName();
std::map<std::string, std::vector<ObjectPtr> >::iterator aHIter = myHistory.find(aGroup);
if (aHIter != myHistory.end())
{
// try feature by label
FeaturePtr aFeature = feature(theLabel);
- if (aFeature)
+ if (aFeature.get())
return feature(theLabel);
TDF_Label aFeatureLabel = theLabel.Father().Father(); // let's suppose it is result
aFeature = feature(aFeatureLabel);
aFeature = feature(aFeatureLabel);
isSubResult = true;
}
- if (aFeature) {
+ if (aFeature.get()) {
const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.cbegin();
for (; aRIter != aResults.cend(); aRIter++) {
if (isSubResult) {
ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
- if (aCompRes) {
+ if (aCompRes.get()) {
int aNumSubs = aCompRes->numberOfSubs();
for(int a = 0; a < aNumSubs; a++) {
ResultPtr aSub = aCompRes->subResult(a);
for (; aRIter != aResults.cend(); aRIter++) {
ResultPtr aRes = *aRIter;
if (aRes->groupName() != theGroupID) break; // feature have only same group results
- if (aRes->isInHistory() && !aRes->isConcealed()) {
+ // iterate also concealed: ALL RESULTS (for translation parts undo/redo management)
+ //if (aRes->isInHistory() && !aRes->isConcealed()) {
theResults.push_back(*aRIter);
- }
+ //}
}
}
}
theObj->setDoc(myDoc);
theObj->setData(aData);
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
- if (aFeature) {
+ if (aFeature.get()) {
setUniqueName(aFeature); // must be before "initAttributes" because duplicate part uses name
}
theObj->initAttributes();
aFeature = std::dynamic_pointer_cast<Model_Session>(ModelAPI_Session::get())->createFeature(
TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(aLabIter.Value())->Get())
.ToCString(), anOwner);
- if (!aFeature) { // somethig is wrong, most probably, the opened document has invalid structure
+ if (!aFeature.get()) { // somethig is wrong, most probably, the opened document has invalid structure
Events_Error::send("Invalid type of object in the document");
aLabIter.Value()->Label().ForgetAllAttributes();
continue;
}
+ aFeature->init();
// this must be before "setData" to redo the sketch line correctly
myFeatures.Bind(aFeatureLabel, aFeature);
aNewFeatures.insert(aFeature);
initData(aFeature, aFeatureLabel, TAG_FEATURE_ARGUMENTS);
updateHistory(aFeature);
- aFeature->setDisabled(false); // by default created feature is enabled (this allows to recreate the results before "setCurrent" is called)
// event: model is updated
ModelAPI_EventCreator::get()->sendUpdated(aFeature, aCreateEvent);
aKeptFeatures.insert(aFeature);
if (anUpdatedMap.Contains(aFeatureLabel)) {
ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent);
+ if (aFeature->getKind() == "Parameter") { // if parameters are changed, update the results (issue 937)
+ 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++) {
+ std::shared_ptr<ModelAPI_Result> aRes = *aRIter;
+ if (aRes->data()->isValid() && !aRes->isDisabled()) {
+ ModelAPI_EventCreator::get()->sendUpdated(aRes, anUpdateEvent);
+ }
+ }
+ }
}
}
}
aLoop->flush(aCreateEvent);
aLoop->flush(aDeleteEvent);
aLoop->flush(anUpdateEvent);
+ aLoop->flush(aCreateEvent); // after update of features, there could be results created
+ aLoop->flush(aDeleteEvent); // or deleted
aLoop->flush(aRedispEvent);
aLoop->flush(aToHideEvent);
}
FeaturePtr aFeature = aFeatures.Value();
std::shared_ptr<Model_Data> aFData =
std::dynamic_pointer_cast<Model_Data>(aFeature->data());
- if (aFData) {
+ if (aFData.get()) {
aFData->eraseBackReferences();
}
const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
for (; aRIter != aResults.cend(); aRIter++) {
std::shared_ptr<Model_Data> aResData =
std::dynamic_pointer_cast<Model_Data>((*aRIter)->data());
- if (aResData) {
+ if (aResData.get()) {
aConcealed.push_back(std::pair<ResultPtr, bool>(*aRIter, (*aRIter)->isConcealed()));
aResData->eraseBackReferences();
}
+ // iterate sub-bodies of compsolid
+ ResultCompSolidPtr aComp = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
+ if (aComp.get()) {
+ int aNumSub = aComp->numberOfSubs();
+ for(int a = 0; a < aNumSub; a++) {
+ ResultPtr aSub = aComp->subResult(a);
+ std::shared_ptr<Model_Data> aResData =
+ std::dynamic_pointer_cast<Model_Data>(aSub->data());
+ if (aResData.get()) {
+ aConcealed.push_back(std::pair<ResultPtr, bool>(aSub, aSub->isConcealed()));
+ aResData->eraseBackReferences();
+ }
+ }
+ }
}
}
FeaturePtr aFeature = aFeatures.Value();
std::shared_ptr<Model_Data> aFData =
std::dynamic_pointer_cast<Model_Data>(aFeature->data());
- if (aFData) {
+ if (aFData.get()) {
std::list<std::pair<std::string, std::list<ObjectPtr> > > aRefs;
aFData->referencesToObjects(aRefs);
std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator
}
std::list<std::pair<ResultPtr, bool> >::iterator aCIter = aConcealed.begin();
for(; aCIter != aConcealed.end(); aCIter++) {
- if (aCIter->first->isConcealed() != aCIter->second) { // somethign is changed => produce event
+ if (aCIter->first->isConcealed() != aCIter->second) { // something is changed => produce event
if (aCIter->second) { // was concealed become not => creation event
static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
ModelAPI_EventCreator::get()->sendUpdated(aCIter->first, anEvent);
std::shared_ptr<ModelAPI_Result> theResult,
const int theResultIndex)
{
+ 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::stringstream aNewName;
aNewName<<theFeatureData->name();
- if (theResultIndex > 0) // if there are several results, add unique prefix starting from second
+ // 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())
aNewName<<"_"<<theResultIndex + 1;
theResult->data()->setName(aNewName.str());
}
TDataStd_Comment::Set(aLab, ModelAPI_ResultConstruction::group().c_str());
ObjectPtr anOldObject = object(aLab);
std::shared_ptr<ModelAPI_ResultConstruction> aResult;
- if (anOldObject) {
+ if (anOldObject.get()) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(anOldObject);
}
- if (!aResult) {
+ if (!aResult.get()) {
aResult = std::shared_ptr<ModelAPI_ResultConstruction>(new Model_ResultConstruction);
storeResult(theFeatureData, aResult, theIndex);
}
anOldObject = object(aLab);
}
std::shared_ptr<ModelAPI_ResultBody> aResult;
- if (anOldObject) {
+ if (anOldObject.get()) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anOldObject);
}
- if (!aResult) {
+ if (!aResult.get()) {
// create compsolid anyway; if it is compsolid, it will create sub-bodies internally
if (aResultOwner.get()) {
aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
TDataStd_Comment::Set(aLab, ModelAPI_ResultPart::group().c_str());
ObjectPtr anOldObject = object(aLab);
std::shared_ptr<ModelAPI_ResultPart> aResult;
- if (anOldObject) {
+ if (anOldObject.get()) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultPart>(anOldObject);
}
- if (!aResult) {
+ if (!aResult.get()) {
aResult = std::shared_ptr<ModelAPI_ResultPart>(new Model_ResultPart);
storeResult(theFeatureData, aResult, theIndex);
}
TDataStd_Comment::Set(aLab, ModelAPI_ResultGroup::group().c_str());
ObjectPtr anOldObject = object(aLab);
std::shared_ptr<ModelAPI_ResultGroup> aResult;
- if (anOldObject) {
+ if (anOldObject.get()) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultGroup>(anOldObject);
}
- if (!aResult) {
+ if (!aResult.get()) {
aResult = std::shared_ptr<ModelAPI_ResultGroup>(new Model_ResultGroup(theFeatureData));
storeResult(theFeatureData, aResult, theIndex);
}
TDataStd_Comment::Set(aLab, ModelAPI_ResultParameter::group().c_str());
ObjectPtr anOldObject = object(aLab);
std::shared_ptr<ModelAPI_ResultParameter> aResult;
- if (anOldObject) {
+ if (anOldObject.get()) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(anOldObject);
}
- if (!aResult) {
+ if (!aResult.get()) {
aResult = std::shared_ptr<ModelAPI_ResultParameter>(new Model_ResultParameter);
storeResult(theFeatureData, aResult, theIndex);
}
const std::shared_ptr<ModelAPI_Result>& theResult)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theResult->data());
- if (aData) {
+ if (aData.get()) {
TDF_Label aFeatureLab = aData->label().Father().Father().Father();
FeaturePtr aFeature = feature(aFeatureLab);
if (!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result
while(aResIter != theFeature->results().cend()) {
ResultPtr aBody = std::dynamic_pointer_cast<ModelAPI_Result>(*aResIter);
if (aBody.get()) {
- if (!aBody->data()->isValid()) {
+ std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(aBody->data());
+ if (!aData.get() || !aData->isValid() || (!aBody->isDisabled() && aData->isDeleted())) {
// found a disappeared result => remove it
theFeature->eraseResultFromList(aBody);
// start iterate from beginning because iterator is corrupted by removing
TCollection_AsciiString(aGroup->Get()).ToCString());
}
}
- if (aNewBody) {
+ if (aNewBody && !aNewBody->data()->isDeleted()) {
theFeature->setResult(aNewBody, aResIndex);
}
}
FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, const bool theReverse)
{
std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
- if (aData && aData->isValid()) {
+ if (aData.get() && aData->isValid()) {
TDF_Label aFeatureLabel = aData->label().Father();
Handle(TDataStd_ReferenceArray) aRefs;
if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { // iterate all existing features
- if (aRefs->Value(a).IsEqual(aFeatureLabel)) {
+ TDF_Label aCurLab = aRefs->Value(a);
+ if (aCurLab.IsEqual(aFeatureLabel)) {
a += theReverse ? -1 : 1;
if (a >= aRefs->Lower() && a <= aRefs->Upper())
return feature(aRefs->Value(a));
return FeaturePtr(); // no features at all
}
+bool Model_Objects::isLater(FeaturePtr theLater, FeaturePtr theCurrent) const
+{
+ 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()) {
+ TDF_Label aLaterL = aLaterD->label().Father();
+ TDF_Label aCurrentL = aCurrentD->label().Father();
+ int aLaterI = -1, aCurentI = -1; // not found yet state
+ Handle(TDataStd_ReferenceArray) aRefs;
+ if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
+ for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { // iterate all existing features
+ TDF_Label aCurLab = aRefs->Value(a);
+ if (aCurLab.IsEqual(aLaterL)) {
+ aLaterI = a;
+ } else if (aCurLab.IsEqual(aCurrentL)) {
+ aCurentI = a;
+ } else continue;
+ if (aLaterI != -1 && aCurentI != -1) // both are found
+ return aLaterI > aCurentI;
+ }
+ }
+ }
+ return false; // not found, or something is wrong
+}
+
std::list<std::shared_ptr<ModelAPI_Feature> > Model_Objects::allFeatures()
{
std::list<std::shared_ptr<ModelAPI_Feature> > aResult;
