X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Objects.cpp;h=b4e516cd64e75305d523ad0c750635d14376c1f0;hb=cb2bfff600626039e210f08de27b5229541d367a;hp=17c62335760b13c2b0b1f26e037b2ef1a1b9f565;hpb=7c8c1517e8638583eadf37db82ac57f21441973e;p=modules%2Fshaper.git diff --git a/src/Model/Model_Objects.cpp b/src/Model/Model_Objects.cpp index 17c623357..b4e516cd6 100644 --- a/src/Model/Model_Objects.cpp +++ b/src/Model/Model_Objects.cpp @@ -49,6 +49,34 @@ #include #include +static const std::string& groupNameFoldering(const std::string& theGroupID, + const bool theAllowFolder) +{ + if (theAllowFolder) { + static const std::string anOutOfFolderName = std::string("__") + ModelAPI_Feature::group(); + static const std::string aDummyName; + return theGroupID == ModelAPI_Feature::group() ? anOutOfFolderName : aDummyName; + } + return theGroupID; +} + +// Check theFeature is a first or last feature in folder and return this folder +static FolderPtr inFolder(const FeaturePtr& theFeature, const std::string& theFolderAttr) +{ + const std::set& aRefs = theFeature->data()->refsToMe(); + for (std::set::iterator anIt = aRefs.begin(); anIt != aRefs.end(); ++anIt) { + if ((*anIt)->id() != theFolderAttr) + continue; + + ObjectPtr anOwner = (*anIt)->owner(); + FolderPtr aFolder = std::dynamic_pointer_cast(anOwner); + if (aFolder.get()) + return aFolder; + } + return FolderPtr(); +} + + static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features, results) // feature sub-labels @@ -92,6 +120,15 @@ Model_Objects::~Model_Objects() aFeature->erase(); myFeatures.UnBind(aFeaturesIter.Key()); } + while (!myFolders.IsEmpty()) { + NCollection_DataMap::Iterator aFoldersIter(myFolders); + ObjectPtr aFolder = aFoldersIter.Value(); + static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendDeleted(myDoc, ModelAPI_Folder::group()); + ModelAPI_EventCreator::get()->sendUpdated(aFolder, EVENT_DISP); + aFolder->erase(); + myFolders.UnBind(aFoldersIter.Key()); + } myHistory.clear(); aLoop->activateFlushes(isActive); // erase update, because features are destroyed and update should not performed for them anywhere @@ -139,12 +176,24 @@ void Model_Objects::addFeature(FeaturePtr theFeature, const FeaturePtr theAfterT // store feature in the features array: before "initData" because in macro features // in initData it creates new features, appeared later than this TDF_Label aPrevFeateureLab; + FolderPtr aParentFolder; if (theAfterThis.get()) { // searching for the previous feature label std::shared_ptr aPrevData = std::dynamic_pointer_cast(theAfterThis->data()); if (aPrevData.get()) { aPrevFeateureLab = aPrevData->label().Father(); } + // Check if the previous feature is the last feature in a folder, + // then the folder should be updated to contain additional feature. + // Macro features are not stored in folder. + if (!theFeature->isMacro()) { + // If the last feature is a sub-feature of composite, use parent feature + // to check belonging to a folder. + FeaturePtr afterThis = ModelAPI_Tools::compositeOwner(theAfterThis); + if (!afterThis) + afterThis = theAfterThis; + aParentFolder = inFolder(afterThis, ModelAPI_Folder::LAST_FEATURE_ID()); + } } AddToRefArray(aFeaturesLab, aFeatureLab, aPrevFeateureLab); @@ -162,6 +211,12 @@ void Model_Objects::addFeature(FeaturePtr theFeature, const FeaturePtr theAfterT // must be after binding to the map because of "Box" macro feature that // creates other features in "initData" initData(theFeature, aFeatureLab, TAG_FEATURE_ARGUMENTS); + // put feature to the end of folder if it is added while + // the history line is set to the last feature from the folder + if (aParentFolder) { + aParentFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(theFeature); + updateHistory(ModelAPI_Folder::group()); + } // event: feature is added, mist be before "initData" to update OB correctly on Duplicate: // first new part, then the content static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); @@ -260,6 +315,8 @@ void Model_Objects::removeFeature(FeaturePtr theFeature) aComposite->removeFeature(theFeature); } } + // remove feature from folder + removeFromFolder(std::list(1, theFeature)); // this must be before erase since theFeature erasing removes all information about // the feature results and groups of results // To reproduce: create sketch, extrusion, remove sketch => constructions tree is not updated @@ -367,9 +424,8 @@ void Model_Objects::clearHistory(ObjectPtr theObj) { if (theObj.get()) { const std::string aGroup = theObj->groupName(); - std::map >::iterator aHIter = myHistory.find(aGroup); - if (aHIter != myHistory.end()) - myHistory.erase(aHIter); // erase from map => this means that it is not synchronized + updateHistory(aGroup); + if (theObj->groupName() == ModelAPI_Feature::group()) { // clear results group of the feature FeaturePtr aFeature = std::dynamic_pointer_cast(theObj); std::string aResultGroup = featureResultGroup(aFeature); @@ -387,9 +443,12 @@ void Model_Objects::createHistory(const std::string& theGroupID) { std::map >::iterator aHIter = myHistory.find(theGroupID); if (aHIter == myHistory.end()) { - std::vector aResult = std::vector(); + std::vector aResult; + std::vector aResultOutOfFolder; + FeaturePtr aLastFeatureInFolder; // iterate the array of references and get feature by feature from the array bool isFeature = theGroupID == ModelAPI_Feature::group(); + bool isFolder = theGroupID == ModelAPI_Folder::group(); Handle(TDataStd_ReferenceArray) aRefs; if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) { for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { @@ -401,6 +460,9 @@ void Model_Objects::createHistory(const std::string& theGroupID) if (isFeature) { // here may be also disabled features if (!isSub && aFeature->isInHistory()) { aResult.push_back(aFeature); + // the feature is out of the folders + if (aLastFeatureInFolder.get() == NULL) + aResultOutOfFolder.push_back(aFeature); } } else if (!aFeature->isDisabled()) { // iterate all results of not-disabled feature // construction results of sub-features should not be in the tree @@ -418,12 +480,40 @@ void Model_Objects::createHistory(const std::string& theGroupID) } } } + + // the feature closes the folder, so the next features will be treated as out-of-folder + if (aLastFeatureInFolder.get() && aLastFeatureInFolder == aFeature) + aLastFeatureInFolder = FeaturePtr(); + + } else { + // it may be a folder + const ObjectPtr& aFolder = folder(aRefs->Value(a)); + if (aFolder.get()) { + // store folder information for the Features group only + if (isFeature || isFolder) { + aResult.push_back(aFolder); + if (!isFolder) + aResultOutOfFolder.push_back(aFolder); + } + + // get the last feature in the folder + AttributeReferencePtr aLastFeatAttr = + aFolder->data()->reference(ModelAPI_Folder::LAST_FEATURE_ID()); + if (aLastFeatAttr) + aLastFeatureInFolder = ModelAPI_Feature::feature(aLastFeatAttr->value()); + } } } } // to be sure that isConcealed did not update the history (issue 1089) during the iteration - if (myHistory.find(theGroupID) == myHistory.end()) + if (myHistory.find(theGroupID) == myHistory.end()) { myHistory[theGroupID] = aResult; + + // store the features placed out of any folder + const std::string& anOutOfFolderGroupID = groupNameFoldering(theGroupID, true); + if (!anOutOfFolderGroupID.empty()) + myHistory[anOutOfFolderGroupID] = aResultOutOfFolder; + } } } @@ -435,8 +525,22 @@ void Model_Objects::updateHistory(const std::shared_ptr theObje void Model_Objects::updateHistory(const std::string theGroup) { std::map >::iterator aHIter = myHistory.find(theGroup); - if (aHIter != myHistory.end()) + if (aHIter != myHistory.end()) { myHistory.erase(aHIter); // erase from map => this means that it is not synchronized + + // erase history for the group of objects placed out of any folder + const std::string& anOutOfFolderGroupID = groupNameFoldering(theGroup, true); + if (!anOutOfFolderGroupID.empty()) + myHistory.erase(anOutOfFolderGroupID); + } +} + +const ObjectPtr& Model_Objects::folder(TDF_Label theLabel) const +{ + if (myFolders.IsBound(theLabel)) + return myFolders.Find(theLabel); + static ObjectPtr anEmptyResult; + return anEmptyResult; } FeaturePtr Model_Objects::feature(TDF_Label theLabel) const @@ -489,12 +593,18 @@ ObjectPtr Model_Objects::object(TDF_Label theLabel) return FeaturePtr(); // not found } -ObjectPtr Model_Objects::object(const std::string& theGroupID, const int theIndex) +ObjectPtr Model_Objects::object(const std::string& theGroupID, + const int theIndex, + const bool theAllowFolder) { if (theIndex == -1) return ObjectPtr(); createHistory(theGroupID); - return myHistory[theGroupID][theIndex]; + const std::string& aGroupID = groupNameFoldering(theGroupID, theAllowFolder); + const std::vector& 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 Model_Objects::objectByName( @@ -538,10 +648,19 @@ std::shared_ptr Model_Objects::objectByName( return ObjectPtr(); } -const int Model_Objects::index(std::shared_ptr theObject) +const int Model_Objects::index(std::shared_ptr theObject, + const bool theAllowFolder) { std::string aGroup = theObject->groupName(); + // treat folder as feature + if (aGroup == ModelAPI_Folder::group()) + aGroup = ModelAPI_Feature::group(); createHistory(aGroup); + + // get the group of features out of folder (if enabled) + if (theAllowFolder && !groupNameFoldering(aGroup, theAllowFolder).empty()) + aGroup = groupNameFoldering(aGroup, theAllowFolder); + std::vector& allObjs = myHistory[aGroup]; std::vector::iterator anObjIter = allObjs.begin(); // iterate to search object for(int anIndex = 0; anObjIter != allObjs.end(); anObjIter++, anIndex++) { @@ -552,10 +671,11 @@ const int Model_Objects::index(std::shared_ptr theObject) return -1; } -int Model_Objects::size(const std::string& theGroupID) +int Model_Objects::size(const std::string& theGroupID, const bool theAllowFolder) { createHistory(theGroupID); - return int(myHistory[theGroupID].size()); + const std::string& aGroupID = groupNameFoldering(theGroupID, theAllowFolder); + return aGroupID.empty() ? int(myHistory[theGroupID].size()) : int(myHistory[aGroupID].size()); } void Model_Objects::allResults(const std::string& theGroupID, std::list& theResults) @@ -587,6 +707,13 @@ TDF_Label Model_Objects::featuresLabel() const return myMain.FindChild(TAG_OBJECTS); } +static std::string composeName(const std::string& theFeatureKind, const int theIndex) +{ + std::stringstream aNameStream; + aNameStream << theFeatureKind << "_" << theIndex; + return aNameStream.str(); +} + void Model_Objects::setUniqueName(FeaturePtr theFeature) { if (!theFeature->data()->name().empty()) @@ -600,9 +727,7 @@ void Model_Objects::setUniqueName(FeaturePtr theFeature) aNumObjects++; } // generate candidate name - std::stringstream aNameStream; - aNameStream << theFeature->getKind() << "_" << aNumObjects + 1; - aName = aNameStream.str(); + 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(); @@ -617,9 +742,7 @@ void Model_Objects::setUniqueName(FeaturePtr theFeature) if (isSameName) { aNumObjects++; - std::stringstream aNameStream; - aNameStream << theFeature->getKind() << "_" << aNumObjects + 1; - aName = aNameStream.str(); + aName = composeName(theFeature->getKind(), aNumObjects + 1); // reinitialize iterator to make sure a new name is unique aFIter.Initialize(myFeatures); } else @@ -628,6 +751,28 @@ void Model_Objects::setUniqueName(FeaturePtr theFeature) theFeature->data()->setName(aName); } +void Model_Objects::setUniqueName(FolderPtr theFolder) +{ + if (!theFolder->name().empty()) + return; // name is already defined + + int aNbFolders = myFolders.Size(); + std::string aName = composeName(ModelAPI_Folder::ID(), aNbFolders); + + // check the uniqueness of the name + NCollection_DataMap::Iterator anIt(myFolders); + while (anIt.More()) { + if (anIt.Value()->data()->name() == aName) { + aName = composeName(ModelAPI_Folder::ID(), aNbFolders); + // reinitialize iterator to make sure a new name is unique + anIt.Initialize(myFolders); + } else + anIt.Next(); + } + + theFolder->data()->setName(aName); +} + void Model_Objects::initData(ObjectPtr theObj, TDF_Label theLab, const int theTag) { std::shared_ptr aData(new Model_Data); @@ -638,6 +783,10 @@ void Model_Objects::initData(ObjectPtr theObj, TDF_Label theLab, const int theTa FeaturePtr aFeature = std::dynamic_pointer_cast(theObj); if (aFeature.get()) { setUniqueName(aFeature); // must be before "initAttributes" because duplicate part uses name + } else { // is it a folder? + FolderPtr aFolder = std::dynamic_pointer_cast(theObj); + if (aFolder) + setUniqueName(aFolder); } theObj->initAttributes(); } @@ -675,21 +824,28 @@ void Model_Objects::synchronizeFeatures( TDF_Label& aFeatureLab = anUpdatedIter.Value(); while(aFeatureLab.Depth() > 3) aFeatureLab = aFeatureLab.Father(); - if (myFeatures.IsBound(aFeatureLab)) + if (myFeatures.IsBound(aFeatureLab) || myFolders.IsBound(aFeatureLab)) anUpdatedMap.Add(aFeatureLab); } // update all objects by checking are they on labels or not - std::set aNewFeatures, aKeptFeatures; + std::set aNewFeatures, aKeptFeatures; TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID()); for (; aLabIter.More(); aLabIter.Next()) { TDF_Label aFeatureLabel = aLabIter.Value()->Label(); - FeaturePtr aFeature; - if (!myFeatures.IsBound(aFeatureLabel)) { // a new feature is inserted + if (!myFeatures.IsBound(aFeatureLabel) && !myFolders.IsBound(aFeatureLabel)) { + // a new feature or folder is inserted + + std::string aFeatureID = TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast( + aLabIter.Value())->Get()).ToCString(); + bool isFolder = aFeatureID == ModelAPI_Folder::ID(); + + std::shared_ptr aSession = + std::dynamic_pointer_cast(ModelAPI_Session::get()); + // create a feature - aFeature = std::dynamic_pointer_cast(ModelAPI_Session::get())->createFeature( - TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(aLabIter.Value())->Get()) - .ToCString(), anOwner); + 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 Events_InfoMessage("Model_Objects", "Invalid type of object in the document").send(); @@ -698,7 +854,10 @@ void Model_Objects::synchronizeFeatures( } aFeature->init(); // this must be before "setData" to redo the sketch line correctly - myFeatures.Bind(aFeatureLabel, aFeature); + if (isFolder) + myFolders.Bind(aFeatureLabel, aFeature); + else + myFeatures.Bind(aFeatureLabel, std::dynamic_pointer_cast(aFeature)); aNewFeatures.insert(aFeature); initData(aFeature, aFeatureLabel, TAG_FEATURE_ARGUMENTS); updateHistory(aFeature); @@ -706,18 +865,25 @@ void Model_Objects::synchronizeFeatures( // event: model is updated ModelAPI_EventCreator::get()->sendUpdated(aFeature, aCreateEvent); } else { // nothing is changed, both iterators are incremented - aFeature = myFeatures.Find(aFeatureLabel); - aKeptFeatures.insert(aFeature); + ObjectPtr anObject; + FeaturePtr aFeature; + if (myFeatures.Find(aFeatureLabel, aFeature)) { + aKeptFeatures.insert(aFeature); + anObject = aFeature; + } else + if (myFolders.Find(aFeatureLabel, anObject)) + aKeptFeatures.insert(anObject); + if (anUpdatedMap.Contains(aFeatureLabel)) { if (!theOpen) { // on abort/undo/redo reinitialize attributes if something is changed std::list > anAttrs = - aFeature->data()->attributes(""); + anObject->data()->attributes(""); std::list >::iterator anAttr = anAttrs.begin(); for(; anAttr != anAttrs.end(); anAttr++) (*anAttr)->reinit(); } - ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent); - if (aFeature->getKind() == "Parameter") { + ModelAPI_EventCreator::get()->sendUpdated(anObject, anUpdateEvent); + if (aFeature && aFeature->getKind() == "Parameter") { // if parameters are changed, update the results (issue 937) const std::list >& aResults = aFeature->results(); std::list >::const_iterator aRIter = aResults.begin(); @@ -756,6 +922,26 @@ void Model_Objects::synchronizeFeatures( } else aFIter.Next(); } + // verify folders are checked: if not => is was removed + for (NCollection_DataMap::Iterator aFldIt(myFolders); + aFldIt.More(); aFldIt.Next()) { + ObjectPtr aCurObj = aFldIt.Value(); + if (aKeptFeatures.find(aCurObj) == aKeptFeatures.end() && + aNewFeatures.find(aCurObj) == aNewFeatures.end()) { + ModelAPI_EventCreator::get()->sendDeleted(myDoc, ModelAPI_Folder::group()); + // results of this feature must be redisplayed (hided) + // redisplay also removed feature (used for sketch and AISObject) + ModelAPI_EventCreator::get()->sendUpdated(aCurObj, aRedispEvent); + updateHistory(aCurObj); + aCurObj->erase(); + + // unbind after the "erase" call: on abort sketch + // is removes sub-objects that corrupts aFIter + myFolders.UnBind(aFldIt.Key()); + // reinitialize iterator because unbind may corrupt the previous order in the map + aFldIt.Initialize(myFolders); + } + } if (theUpdateReferences) { synchronizeBackRefs(); @@ -813,7 +999,10 @@ void Model_Objects::synchronizeBackRefsForObject(const std::set& t for(; aNewIter != theNewRefs.end(); aNewIter++) { if (aData->refsToMe().find(*aNewIter) == aData->refsToMe().end()) { FeaturePtr aRefFeat = std::dynamic_pointer_cast((*aNewIter)->owner()); - aData->addBackReference(aRefFeat, (*aNewIter)->id()); + if (aRefFeat) + aData->addBackReference(aRefFeat, (*aNewIter)->id()); + else // add back reference to a folder + aData->addBackReference((*aNewIter)->owner(), (*aNewIter)->id()); } } if (theNewRefs.size() != aData->refsToMe().size()) { // some back ref must be removed @@ -849,9 +1038,61 @@ void Model_Objects::synchronizeBackRefsForObject(const std::set& t } else aCurrentIter++; } } + // for the last feature in the folder, check if it is a sub-feature, + // then refer the folder to a top-level parent composite feature + const std::set& aRefs = aData->refsToMe(); + std::set::iterator anIt = aRefs.begin(); + for (; anIt != aRefs.end(); ++anIt) + if ((*anIt)->id() == ModelAPI_Folder::LAST_FEATURE_ID()) + break; + if (anIt != aRefs.end()) { + FeaturePtr aFeature = ModelAPI_Feature::feature(theObject); + if (aFeature) { + CompositeFeaturePtr aParent; + CompositeFeaturePtr aGrandParent = ModelAPI_Tools::compositeOwner(aFeature); + do { + aParent = aGrandParent; + if (aGrandParent) + aGrandParent = ModelAPI_Tools::compositeOwner(aParent); + } while (aGrandParent.get()); + if (aParent) { + ObjectPtr aFolder = (*anIt)->owner(); + // remove reference from the current feature + aData->removeBackReference(aFolder, ModelAPI_Folder::LAST_FEATURE_ID()); + // set reference to a top-level parent + aFolder->data()->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(aParent); + std::shared_ptr aParentData = + std::dynamic_pointer_cast(aParent->data()); + aParentData->addBackReference(aFolder, ModelAPI_Folder::LAST_FEATURE_ID()); + } + } + } aData->updateConcealmentFlag(); } +static void collectReferences(std::shared_ptr theData, + std::map >& theRefs) +{ + if (theData.get()) { + std::list > > aRefs; + theData->referencesToObjects(aRefs); + std::list > >::iterator aRefsIt = aRefs.begin(); + for(; aRefsIt != aRefs.end(); aRefsIt++) { + std::list::iterator aRefTo = aRefsIt->second.begin(); + for(; aRefTo != aRefsIt->second.end(); aRefTo++) { + if (*aRefTo) { + std::map >::iterator aFound = theRefs.find(*aRefTo); + if (aFound == theRefs.end()) { + theRefs[*aRefTo] = std::set(); + aFound = theRefs.find(*aRefTo); + } + aFound->second.insert(theData->attribute(aRefsIt->first)); + } + } + } + } +} + void Model_Objects::synchronizeBackRefs() { // collect all back references in the separated container: to update everything at once, @@ -862,25 +1103,12 @@ void Model_Objects::synchronizeBackRefs() NCollection_DataMap::Iterator aFeatures(myFeatures); for(; aFeatures.More(); aFeatures.Next()) { FeaturePtr aFeature = aFeatures.Value(); - std::shared_ptr aFData = std::dynamic_pointer_cast(aFeature->data()); - if (aFData.get()) { - std::list > > aRefs; - aFData->referencesToObjects(aRefs); - std::list > >::iterator aRefsIt = aRefs.begin(); - for(; aRefsIt != aRefs.end(); aRefsIt++) { - std::list::iterator aRefTo = aRefsIt->second.begin(); - for(; aRefTo != aRefsIt->second.end(); aRefTo++) { - if (*aRefTo) { - std::map >::iterator aFound = allRefs.find(*aRefTo); - if (aFound == allRefs.end()) { - allRefs[*aRefTo] = std::set(); - aFound = allRefs.find(*aRefTo); - } - aFound->second.insert(aFeature->data()->attribute(aRefsIt->first)); - } - } - } - } + collectReferences(aFeature->data(), allRefs); + } + NCollection_DataMap::Iterator aFolders(myFolders); + for(; aFolders.More(); aFolders.Next()) { + ObjectPtr aFolder = aFolders.Value(); + collectReferences(aFolder->data(), allRefs); } // second iteration: just compare back-references with existing in features and results for(aFeatures.Initialize(myFeatures); aFeatures.More(); aFeatures.Next()) { @@ -960,8 +1188,10 @@ bool Model_Objects::hasCustomName(DataPtr theFeatureData, return false; } - theParentName = ModelAPI_Tools::getDefaultName(theResult, theResultIndex); - return true; + std::pair aName = ModelAPI_Tools::getDefaultName(theResult, theResultIndex); + if (aName.second) + theParentName = aName.first; + return aName.second; } void Model_Objects::storeResult(std::shared_ptr theFeatureData, @@ -974,7 +1204,11 @@ void Model_Objects::storeResult(std::shared_ptr theFeatureData, if (theResult->data()->name().empty()) { // if was not initialized, generate event and set a name std::string aNewName = theFeatureData->name(); - if (!hasCustomName(theFeatureData, theResult, theResultIndex, aNewName)) { + 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(""); + } else { std::stringstream aName; aName << aNewName; // if there are several results (issue #899: any number of result), @@ -1111,6 +1345,444 @@ std::shared_ptr Model_Objects::createParameter( return aResult; } +std::shared_ptr Model_Objects::createFolder( + const std::shared_ptr& theBeforeThis) +{ + FolderPtr aFolder(new ModelAPI_Folder); + if (!aFolder) + return aFolder; + + TDF_Label aFeaturesLab = featuresLabel(); + TDF_Label aFolderLab = aFeaturesLab.NewChild(); + // store feature in the features array: before "initData" because in macro features + // in initData it creates new features, appeared later than this + TDF_Label aPrevFeatureLab; + if (theBeforeThis.get()) { // searching for the previous feature label + std::shared_ptr aPrevData = + std::dynamic_pointer_cast(theBeforeThis->data()); + if (aPrevData.get()) { + aPrevFeatureLab = nextLabel(aPrevData->label().Father(), true); + } + } else { // find the label of the last feature + Handle(TDataStd_ReferenceArray) aRefs; + if (aFeaturesLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) + aPrevFeatureLab = aRefs->Value(aRefs->Upper()); + } + AddToRefArray(aFeaturesLab, aFolderLab, aPrevFeatureLab); + + // keep the feature ID to restore document later correctly + TDataStd_Comment::Set(aFolderLab, ModelAPI_Folder::ID().c_str()); + myFolders.Bind(aFolderLab, aFolder); + // must be before the event sending: for OB the feature is already added + updateHistory(ModelAPI_Folder::group()); + updateHistory(ModelAPI_Feature::group()); + + // must be after binding to the map because of "Box" macro feature that + // creates other features in "initData" + initData(aFolder, aFolderLab, TAG_FEATURE_ARGUMENTS); + // event: folder is added, must be before "initData" to update OB correctly on Duplicate: + // first new part, then the content + static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); + ModelAPI_EventCreator::get()->sendUpdated(aFolder, anEvent); + + return aFolder; +} + +void Model_Objects::removeFolder(std::shared_ptr theFolder) +{ + std::shared_ptr aData = std::static_pointer_cast(theFolder->data()); + if (!aData.get() || !aData->isValid()) + return; + + // this must be before erase since theFolder erasing removes all information about it + clearHistory(theFolder); + // erase fields + theFolder->erase(); + + TDF_Label aFolderLabel = aData->label().Father(); + if (myFolders.IsBound(aFolderLabel)) + myFolders.UnBind(aFolderLabel); + + static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(theFolder, EVENT_DISP); + // erase all attributes under the label of feature + aFolderLabel.ForgetAllAttributes(); + // remove it from the references array + RemoveFromRefArray(featuresLabel(), aFolderLabel); + // event: feature is deleted + ModelAPI_EventCreator::get()->sendDeleted(theFolder->document(), ModelAPI_Folder::group()); + updateHistory(ModelAPI_Folder::group()); + updateHistory(ModelAPI_Feature::group()); +} + +// Returns one of the limiting features of the list +static FeaturePtr limitingFeature(std::list& theFeatures, const bool isLast) +{ + FeaturePtr aFeature; + if (isLast) { + aFeature = theFeatures.back(); + theFeatures.pop_back(); + } else { + aFeature = theFeatures.front(); + theFeatures.pop_front(); + } + return aFeature; +} + +// Verify the feature is sub-element in composite feature or it is not used in the history +static bool isSkippedFeature(FeaturePtr theFeature) +{ + bool isSub = ModelAPI_Tools::compositeOwner(theFeature).get() != NULL; + return isSub || (theFeature && !theFeature->isInHistory()); +} + +std::shared_ptr Model_Objects::findFolder( + const std::list >& theFeatures, + const bool theBelow) +{ + if (theFeatures.empty()) + return FolderPtr(); // nothing to move + + TDF_Label aFeaturesLab = featuresLabel(); + Handle(TDataStd_ReferenceArray) aRefs; + if (!aFeaturesLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) + return FolderPtr(); // no reference array (something is wrong) + + std::list > aFeatures = theFeatures; + std::shared_ptr aLimitingFeature = limitingFeature(aFeatures, theBelow); + + std::shared_ptr aData = + std::static_pointer_cast(aLimitingFeature->data()); + if (!aData || !aData->isValid()) + return FolderPtr(); // invalid feature + + // label of the first feature in the list for fast searching + TDF_Label aFirstFeatureLabel = aData->label().Father(); + + // find a folder above the features and + // check the given features represent a sequential list of objects following the folder + FolderPtr aFoundFolder; + TDF_Label aLastFeatureInFolder; + int aRefIndex = aRefs->Lower(); + for(; aRefIndex <= aRefs->Upper(); ++aRefIndex) { // iterate all existing features + TDF_Label aCurLabel = aRefs->Value(aRefIndex); + if (IsEqual(aCurLabel, aFirstFeatureLabel)) + break; // no need to continue searching + + // searching the folder below, just continue to search last feature from the list + if (theBelow) + continue; + + // if feature is in sub-component, skip it + FeaturePtr aCurFeature = feature(aCurLabel); + if (isSkippedFeature(aCurFeature)) + continue; + + if (!aLastFeatureInFolder.IsNull()) { + if (IsEqual(aCurLabel, aLastFeatureInFolder)) + aLastFeatureInFolder.Nullify(); // the last feature in the folder is achived + continue; + } + + const ObjectPtr& aFolderObj = folder(aCurLabel); + if (aFolderObj.get()) { + aFoundFolder = std::dynamic_pointer_cast(aFolderObj); + AttributeReferencePtr aLastFeatAttr = + aFoundFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID()); + if (aLastFeatAttr) { + // setup iterating inside a folder to find last feature + ObjectPtr aLastFeature = aLastFeatAttr->value(); + if (aLastFeature) { + aData = std::static_pointer_cast(aLastFeature->data()); + if (aData && aData->isValid()) + aLastFeatureInFolder = aData->label().Father(); + } + } + } + } + + if (theBelow && aRefIndex < aRefs->Upper()) { + TDF_Label aLabel; + // skip following features which are sub-components or not in history + for (int anIndex = aRefIndex + 1; anIndex <= aRefs->Upper(); ++anIndex) { + aLabel = aRefs->Value(anIndex); + FeaturePtr aCurFeature = feature(aLabel); + if (!isSkippedFeature(aCurFeature)) + break; + } + // check the next object is a folder + aFoundFolder = std::dynamic_pointer_cast(folder(aLabel)); + } + + if (!aLastFeatureInFolder.IsNull() || // the last feature of the folder above is not found + !aFoundFolder) + return FolderPtr(); + + // check the given features are sequential list + int aStep = theBelow ? -1 : 1; + for (aRefIndex += aStep; + !aFeatures.empty() && aRefIndex >= aRefs->Lower() && aRefIndex <= aRefs->Upper(); + aRefIndex += aStep) { + TDF_Label aCurLabel = aRefs->Value(aRefIndex); + // if feature is in sub-component, skip it + FeaturePtr aCurFeature = feature(aCurLabel); + if (isSkippedFeature(aCurFeature)) + continue; + + aLimitingFeature = limitingFeature(aFeatures, theBelow); + if (!aCurFeature->data()->isEqual(aLimitingFeature->data())) + return FolderPtr(); // not a sequential list + } + + return aFoundFolder; +} + +bool Model_Objects::moveToFolder( + const std::list >& theFeatures, + const std::shared_ptr& theFolder) +{ + if (theFeatures.empty() || !theFolder) + return false; + + // labels for the folder and last feature in the list + TDF_Label aFolderLabel, aLastFeatureLabel; + std::shared_ptr aData = + std::static_pointer_cast(theFolder->data()); + if (aData && aData->isValid()) + aFolderLabel = aData->label().Father(); + aData = std::static_pointer_cast(theFeatures.back()->data()); + if (aData && aData->isValid()) + aLastFeatureLabel = aData->label().Father(); + + if (aFolderLabel.IsNull() || aLastFeatureLabel.IsNull()) + return false; + + AttributeReferencePtr aFirstFeatAttr = + theFolder->reference(ModelAPI_Folder::FIRST_FEATURE_ID()); + AttributeReferencePtr aLastFeatAttr = + theFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID()); + bool initFirstAttr = !aFirstFeatAttr->value().get(); + bool initLastAttr = !aLastFeatAttr->value().get(); + + // check the folder is below the list of features + bool isFolderBelow = false; + TDF_Label aFeaturesLab = featuresLabel(); + Handle(TDataStd_ReferenceArray) aRefs; + if (!aFeaturesLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) + return false; // no reference array (something is wrong) + for (int aRefIndex = aRefs->Lower(); aRefIndex <= aRefs->Upper(); ++aRefIndex) { + TDF_Label aCurLabel = aRefs->Value(aRefIndex); + if (aCurLabel == aFolderLabel) + break; // folder is above the features + else if (aCurLabel == aLastFeatureLabel) { + isFolderBelow = true; + break; + } + } + + if (isFolderBelow) { + aData = std::static_pointer_cast(theFeatures.front()->data()); + if (!aData || !aData->isValid()) + return false; + TDF_Label aPrevFeatureLabel = aData->label().Father(); + // label of the feature before the first feature in the list + for (int aRefIndex = aRefs->Lower(); aRefIndex <= aRefs->Upper(); ++aRefIndex) + if (aPrevFeatureLabel == aRefs->Value(aRefIndex)) { + if (aRefIndex == aRefs->Lower()) + aPrevFeatureLabel.Nullify(); + else + aPrevFeatureLabel = aRefs->Value(aRefIndex - 1); + break; + } + + // move the folder in the list of references before the first feature + RemoveFromRefArray(aFeaturesLab, aFolderLabel); + AddToRefArray(aFeaturesLab, aFolderLabel, aPrevFeatureLabel); + // update first feature of the folder + initFirstAttr = true; + } else { + // update last feature of the folder + initLastAttr = true; + } + + if (initFirstAttr) + aFirstFeatAttr->setValue(theFeatures.front()); + if (initLastAttr) + aLastFeatAttr->setValue(theFeatures.back()); + + updateHistory(ModelAPI_Feature::group()); + return true; +} + +static FolderPtr isExtractionCorrect(const FolderPtr& theFirstFeatureFolder, + const FolderPtr& theLastFeatureFolder, + bool& isExtractBefore) +{ + if (theFirstFeatureFolder.get()) { + if (theLastFeatureFolder.get()) + return theFirstFeatureFolder == theLastFeatureFolder ? theFirstFeatureFolder : FolderPtr(); + else + isExtractBefore = true; + return theFirstFeatureFolder; + } else if (theLastFeatureFolder.get()) { + isExtractBefore = false; + return theLastFeatureFolder; + } + // no folder found + return FolderPtr(); +} + +bool Model_Objects::removeFromFolder( + const std::list >& theFeatures, + const bool theBefore) +{ + if (theFeatures.empty()) + return false; + + FolderPtr aFirstFeatureFolder = + inFolder(theFeatures.front(), ModelAPI_Folder::FIRST_FEATURE_ID()); + FolderPtr aLastFeatureFolder = + inFolder(theFeatures.back(), ModelAPI_Folder::LAST_FEATURE_ID()); + + bool isExtractBeforeFolder = theBefore; + FolderPtr aFoundFolder = + isExtractionCorrect(aFirstFeatureFolder, aLastFeatureFolder, isExtractBeforeFolder); + if (!aFoundFolder) + return false; // list of features cannot be extracted + + // references of the current folder + ObjectPtr aFolderStartFeature; + ObjectPtr aFolderEndFeature; + if (aFirstFeatureFolder != aLastFeatureFolder) { + aFolderStartFeature = aFoundFolder->reference(ModelAPI_Folder::FIRST_FEATURE_ID())->value(); + aFolderEndFeature = aFoundFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID())->value(); + } + + FeaturePtr aFeatureToFind = isExtractBeforeFolder ? theFeatures.back() : theFeatures.front(); + std::shared_ptr aData = + std::static_pointer_cast(aFeatureToFind->data()); + if (!aData || !aData->isValid()) + return false; + TDF_Label aLabelToFind = aData->label().Father(); + + // search the label in the list of references + TDF_Label aFeaturesLab = featuresLabel(); + Handle(TDataStd_ReferenceArray) aRefs; + if (!aFeaturesLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) + return false; // no reference array (something is wrong) + int aRefIndex = aRefs->Lower(); + for (; aRefIndex <= aRefs->Upper(); ++aRefIndex) + if (aRefs->Value(aRefIndex) == aLabelToFind) + break; + + // update folder position + if (isExtractBeforeFolder) { + aData = std::dynamic_pointer_cast(aFoundFolder->data()); + TDF_Label aFolderLabel = aData->label().Father(); + TDF_Label aPrevFeatureLabel = aRefs->Value(aRefIndex); + // update start reference of the folder + if (aFolderStartFeature.get()) { + FeaturePtr aNewStartFeature; + do { // skip all features placed in the composite features + aPrevFeatureLabel = aRefs->Value(aRefIndex++); + aNewStartFeature = + aRefIndex <= aRefs->Upper() ? feature(aRefs->Value(aRefIndex)) : FeaturePtr(); + } while (aNewStartFeature && isSkippedFeature(aNewStartFeature)); + aFolderStartFeature = aNewStartFeature; + } + // move the folder in the list of references after the last feature from the list + RemoveFromRefArray(aFeaturesLab, aFolderLabel); + AddToRefArray(aFeaturesLab, aFolderLabel, aPrevFeatureLabel); + } else { + // update end reference of the folder + if (aFolderEndFeature.get()) { + FeaturePtr aNewEndFeature; + do { // skip all features placed in the composite features + --aRefIndex; + aNewEndFeature = + aRefIndex >= aRefs->Lower() ? feature(aRefs->Value(aRefIndex)) : FeaturePtr(); + } while (aNewEndFeature && isSkippedFeature(aNewEndFeature)); + aFolderEndFeature = aNewEndFeature; + } + } + + // update folder references + aFoundFolder->reference(ModelAPI_Folder::FIRST_FEATURE_ID())->setValue(aFolderStartFeature); + aFoundFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(aFolderEndFeature); + + updateHistory(ModelAPI_Feature::group()); + return true; +} + +FolderPtr Model_Objects::findContainingFolder(const FeaturePtr& theFeature, int& theIndexInFolder) +{ + // search the label in the list of references + TDF_Label aFeaturesLab = featuresLabel(); + Handle(TDataStd_ReferenceArray) aRefs; + if (!aFeaturesLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) + return FolderPtr(); // no reference array (something is wrong) + + std::shared_ptr aData = + std::static_pointer_cast(theFeature->data()); + if (!aData || !aData->isValid()) + return FolderPtr(); + TDF_Label aLabelToFind = aData->label().Father(); + + theIndexInFolder = -1; + FolderPtr aFoundFolder; + TDF_Label aLastFeatureLabel; + + for (int aRefIndex = aRefs->Lower(); aRefIndex <= aRefs->Upper(); ++aRefIndex) { + TDF_Label aCurLabel = aRefs->Value(aRefIndex); + + if (aFoundFolder) + ++theIndexInFolder; + + if (aCurLabel == aLabelToFind) { // the feature is reached + if (aFoundFolder) { + if (isSkippedFeature(theFeature)) { + theIndexInFolder = -1; + return FolderPtr(); + } + // decrease the index of the feature in the folder by the number of skipped features + for (int anIndex = theIndexInFolder - 1; anIndex > 0; anIndex--) { + aCurLabel = aRefs->Value(aRefIndex - anIndex); + if (isSkippedFeature(feature(aCurLabel))) + theIndexInFolder--; + } + } + return aFoundFolder; + } + + if (!aFoundFolder) { + // if the current label refers to a folder, feel all necessary data + const ObjectPtr& aFolderObj = folder(aCurLabel); + if (aFolderObj.get()) { + aFoundFolder = std::dynamic_pointer_cast(aFolderObj); + theIndexInFolder = -1; + + AttributeReferencePtr aLastRef = + aFoundFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID()); + if (aLastRef->value()) { + aData = std::static_pointer_cast(aLastRef->value()->data()); + if (aData && aData->isValid()) + aLastFeatureLabel = aData->label().Father(); + } else // folder is empty + aFoundFolder = FolderPtr(); + } + } else if (aLastFeatureLabel == aCurLabel) { + // folder is finished, clear all stored data + theIndexInFolder = -1; + aFoundFolder = FolderPtr(); + } + } + + // folder is not found + theIndexInFolder = -1; + return FolderPtr(); +} + + std::shared_ptr Model_Objects::feature( const std::shared_ptr& theResult) { @@ -1247,23 +1919,38 @@ ResultPtr Model_Objects::findByName(const std::string theName) return aResult; } +TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, 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 + TDF_Label aCurLab = aRefs->Value(a); + if (aCurLab.IsEqual(theCurrent)) { + a += theReverse ? -1 : 1; + if (a >= aRefs->Lower() && a <= aRefs->Upper()) + return aRefs->Value(a); + break; // finish iiteration: it's last feature + } + } + } + return TDF_Label(); +} + FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, const bool theReverse) { std::shared_ptr aData = std::static_pointer_cast(theCurrent->data()); 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 - 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)); - break; // finish iiteration: it's last feature - } - } - } + do { + TDF_Label aNextLabel = nextLabel(aFeatureLabel, theReverse); + if (aNextLabel.IsNull()) + break; // last or something is wrong + FeaturePtr aFound = feature(aNextLabel); + if (aFound) + return aFound; // the feature is found + // if the next label is a folder, skip it + aFeatureLabel = folder(aNextLabel).get() ? aNextLabel : TDF_Label(); + } while (!aFeatureLabel.IsNull()); } return FeaturePtr(); // not found, last, or something is wrong } @@ -1281,6 +1968,11 @@ FeaturePtr Model_Objects::lastFeature() { Handle(TDataStd_ReferenceArray) aRefs; if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) { + 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 @@ -1311,6 +2003,22 @@ bool Model_Objects::isLater(FeaturePtr theLater, FeaturePtr theCurrent) const return false; // not found, or something is wrong } +std::list > Model_Objects::allObjects() +{ + std::list > aResult; + Handle(TDataStd_ReferenceArray) aRefs; + if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) { + for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { + ObjectPtr anObject = object(aRefs->Value(a)); + if (!anObject.get()) // is it a folder? + anObject = folder(aRefs->Value(a)); + if (anObject.get()) + aResult.push_back(anObject); + } + } + return aResult; +} + std::list > Model_Objects::allFeatures() { std::list > aResult;