#include <TDF_Reference.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_LabelMapHasher.hxx>
+#include <TDF_LabelMap.hxx>
+#include <TDF_ListIteratorOfLabelList.hxx>
static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features, results)
{
myDoc = theDoc;
// update all fields and recreate features and result objects if needed
- synchronizeFeatures(false, true, true);
+ TDF_LabelList aNoUpdated;
+ synchronizeFeatures(aNoUpdated, true, true);
myHistory.clear();
}
{
// delete all features of this document
Events_Loop* aLoop = Events_Loop::loop();
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeaturesIter(myFeatures);
- for(; aFeaturesIter.More(); aFeaturesIter.Next()) {
+ // 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());
}
- myFeatures.Clear();
+ aLoop->activateFlushes(isActive);
+ aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
// 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);
if (aData && !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);
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)
return feature(theLabel);
TDF_Label aFeatureLabel = theLabel.Father().Father(); // let's suppose it is result
aFeature = feature(aFeatureLabel);
+ bool isSubResult = false;
+ if (!aFeature.get() && aFeatureLabel.Depth() > 1) { // let's suppose this is sub-result of result
+ aFeatureLabel = aFeatureLabel.Father().Father();
+ aFeature = feature(aFeatureLabel);
+ isSubResult = true;
+ }
if (aFeature) {
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++) {
- std::shared_ptr<Model_Data> aResData = std::dynamic_pointer_cast<Model_Data>(
- (*aRIter)->data());
- if (aResData->label().Father().IsEqual(theLabel))
- return *aRIter;
+ if (isSubResult) {
+ ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
+ if (aCompRes) {
+ int aNumSubs = aCompRes->numberOfSubs();
+ for(int a = 0; a < aNumSubs; a++) {
+ ResultPtr aSub = aCompRes->subResult(a);
+ if (aSub.get()) {
+ std::shared_ptr<Model_Data> aSubData = std::dynamic_pointer_cast<Model_Data>(
+ aSub->data());
+ if (aSubData->label().Father().IsEqual(theLabel))
+ return aSub;
+ }
+ }
+ }
+ } else {
+ std::shared_ptr<Model_Data> aResData = std::dynamic_pointer_cast<Model_Data>(
+ (*aRIter)->data());
+ if (aResData->label().Father().IsEqual(theLabel))
+ return *aRIter;
+ }
}
}
return FeaturePtr(); // not found
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);
- }
+ //}
}
}
}
}
void Model_Objects::synchronizeFeatures(
- const bool theMarkUpdated, const bool theUpdateReferences, const bool theFlush)
+ const TDF_LabelList& theUpdated, const bool theUpdateReferences, const bool theFlush)
{
Model_Document* anOwner = std::dynamic_pointer_cast<Model_Document>(myDoc).get();
if (!anOwner) // this may happen on creation of document: nothing there, so nothing to synchronize
static Events_ID aToHideEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
bool isActive = aLoop->activateFlushes(false);
+ // collect all updated labels map
+ TDF_LabelMap anUpdatedMap;
+ TDF_ListIteratorOfLabelList anUpdatedIter(theUpdated);
+ for(; anUpdatedIter.More(); anUpdatedIter.Next()) {
+ TDF_Label& aFeatureLab = anUpdatedIter.Value();
+ while(aFeatureLab.Depth() > 3)
+ aFeatureLab = aFeatureLab.Father();
+ if (myFeatures.IsBound(aFeatureLab))
+ anUpdatedMap.Add(aFeatureLab);
+ }
+
// update all objects by checking are they on labels or not
std::set<FeaturePtr> aNewFeatures, aKeptFeatures;
TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
} else { // nothing is changed, both iterators are incremented
aFeature = myFeatures.Find(aFeatureLabel);
aKeptFeatures.insert(aFeature);
- if (theMarkUpdated) {
+ 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);
+ }
+ }
+ }
}
}
}
if (theUpdateReferences) {
synchronizeBackRefs();
}
- if (theMarkUpdated) { // this means there is no control what was modified => remove history cash
+ if (!theUpdated.IsEmpty()) { // this means there is no control what was modified => remove history cash
myHistory.clear();
}
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);
}
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();
+ }
+ }
+ }
}
}
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());
}
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
- ObjectPtr anOldObject = object(aLab);
+ // for feature create compsolid, but for result sub create body:
+ // only one level of recursion is supported now
+ ResultPtr aResultOwner = std::dynamic_pointer_cast<ModelAPI_Result>(theFeatureData->owner());
+ ObjectPtr anOldObject;
+ if (aResultOwner.get()) {
+ TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
+ } else { // in compsolid (higher level result) old object probably may be found
+ TDataStd_Comment::Set(aLab, ModelAPI_ResultCompSolid::group().c_str());
+ anOldObject = object(aLab);
+ }
std::shared_ptr<ModelAPI_ResultBody> aResult;
if (anOldObject) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anOldObject);
}
if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
- storeResult(theFeatureData, aResult, theIndex);
- }
- return aResult;
-}
-
-std::shared_ptr<ModelAPI_ResultCompSolid> Model_Objects::createCompSolid(
- const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
-{
- TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultCompSolid::group().c_str());
- ObjectPtr anOldObject = object(aLab);
- std::shared_ptr<ModelAPI_ResultCompSolid> aResult;
- if (anOldObject) {
- aResult = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(anOldObject);
- }
- if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultCompSolid>(new Model_ResultCompSolid);
+ // 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);
+ } else {
+ aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultCompSolid);
+ }
storeResult(theFeatureData, aResult, theIndex);
}
return aResult;
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theResult->data());
if (aData) {
TDF_Label aFeatureLab = aData->label().Father().Father().Father();
- return feature(aFeatureLab);
+ FeaturePtr aFeature = feature(aFeatureLab);
+ if (!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result
+ aFeatureLab = aFeatureLab.Father().Father();
+ aFeature = feature(aFeatureLab);
+ }
+ return aFeature;
}
return FeaturePtr();
}
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
TDF_Label anArgLab = aLabIter.Value();
Handle(TDataStd_Comment) aGroup;
if (anArgLab.FindAttribute(TDataStd_Comment::GetID(), aGroup)) {
- if (aGroup->Get() == ModelAPI_ResultBody::group().c_str()) {
+ if (aGroup->Get() == ModelAPI_ResultBody::group().c_str() ||
+ aGroup->Get() == ModelAPI_ResultCompSolid::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);
TCollection_AsciiString(aGroup->Get()).ToCString());
}
}
- if (aNewBody) {
+ if (aNewBody && !aNewBody->data()->isDeleted()) {
theFeature->setResult(aNewBody, aResIndex);
}
}
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 && aLaterD->isValid() && aCurrentD && 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;