X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Data.cpp;h=fcccca5369263060fe270b22aa72c197716b4933;hb=ae3e12ab08ba2c98c74c9f4b93812faace2af798;hp=49bca1d2752823a715467acb473d742a254b4a2b;hpb=016814c4673909dcd7fd9591694cf599623dfbc7;p=modules%2Fshaper.git diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp index 49bca1d27..fcccca536 100644 --- a/src/Model/Model_Data.cpp +++ b/src/Model/Model_Data.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2020 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -12,10 +12,9 @@ // // 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 +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include @@ -36,32 +35,35 @@ #include #include #include +#include +#include + #include #include #include +#include #include #include #include -#include #include -#include #include #include +#include #include #include +#include #include #include #include +#include + #include #include -#include -#include -#include -#include -#include +#include +#include #include @@ -75,10 +77,20 @@ static const int kFlagInHistory = 0; static const int kFlagDisplayed = 1; // 2 - is deleted (for results) or not static const int kFlagDeleted = 2; +// TDataStd_Integer - 0 if the name of the object is generated automatically, +// otherwise the name is defined by user +static const Standard_GUID kUSER_DEFINED_NAME("9c694d18-a83c-4a56-bc9b-8020628a8244"); // invalid data const static std::shared_ptr kInvalid(new Model_Data()); +static const Standard_GUID kGroupAttributeGroupID("df64ea4c-fc42-4bf8-ad7e-08f7a54bf1b8"); +static const Standard_GUID kGroupAttributeID("ebdcb22a-e045-455b-9a7f-cfd38d68e185"); + +// id of attribute to store the version of the feature +static const Standard_GUID kVERSION_ID("61cdb78a-1ba7-4942-976f-63bea7f4a2b1"); + + Model_Data::Model_Data() : mySendAttributeUpdated(true), myWasChangedButBlocked(false) { } @@ -93,58 +105,87 @@ void Model_Data::setLabel(TDF_Label theLab) myFlags->SetValue(kFlagInHistory, Standard_True); // is in history by default is true myFlags->SetValue(kFlagDisplayed, Standard_True); // is displayed by default is true myFlags->SetValue(kFlagDeleted, Standard_False); // is deleted by default is false - } else if (myFlags->Length() != 3) { // for old formats support - Standard_Boolean aFlag0 = myFlags->Upper() >= 0 ? myFlags->Value(0) : Standard_True; - Standard_Boolean aFlag1 = myFlags->Upper() >= 1 ? myFlags->Value(1) : Standard_True; - Standard_Boolean aFlag2 = myFlags->Upper() >= 2 ? myFlags->Value(2) : Standard_True; - Handle(TColStd_HArray1OfByte) aNewArray = new TColStd_HArray1OfByte(0, 2); - myFlags->SetInternalArray(aNewArray); - myFlags->SetValue(0, aFlag0); - myFlags->SetValue(1, aFlag1); - myFlags->SetValue(2, aFlag2); } } -std::string Model_Data::name() +std::wstring Model_Data::name() { Handle(TDataStd_Name) aName; - if (myLab.FindAttribute(TDataStd_Name::GetID(), aName)) { + if (shapeLab().FindAttribute(TDataStd_Name::GetID(), aName)) { #ifdef DEBUG_NAMES - myObject->myName = TCollection_AsciiString(aName->Get()).ToCString(); + myObject->myName = Locale::Convert::toWString(aName->Get().ToExtString()); #endif - return std::string(TCollection_AsciiString(aName->Get()).ToCString()); + return Locale::Convert::toWString(aName->Get().ToExtString()); } - return ""; // not defined + return L""; // not defined } -void Model_Data::setName(const std::string& theName) +void Model_Data::setName(const std::wstring& theName) { bool isModified = false; - std::string anOldName = name(); + std::wstring anOldName = name(); Handle(TDataStd_Name) aName; - if (!myLab.FindAttribute(TDataStd_Name::GetID(), aName)) { - TDataStd_Name::Set(myLab, theName.c_str()); + if (!shapeLab().FindAttribute(TDataStd_Name::GetID(), aName)) { + TDataStd_Name::Set(shapeLab(), theName.c_str()); isModified = true; } else { isModified = !aName->Get().IsEqual(theName.c_str()); - if (isModified) + if (isModified) { aName->Set(theName.c_str()); + + // check the name of result is defined by user + // (name of result does not composed of the name of feature and the result index) + bool isUserDefined = true; + ResultPtr aResult = std::dynamic_pointer_cast(myObject); + if (aResult) { + std::wstring aDefaultName = ModelAPI_Tools::getDefaultName(aResult, false).first; + isUserDefined = aDefaultName != theName; + } + if (isUserDefined) { + // name is user-defined, thus special attribute is set + TDataStd_UAttribute::Set(shapeLab(), kUSER_DEFINED_NAME); + } + } } if (mySendAttributeUpdated && isModified) ModelAPI_ObjectRenamedMessage::send(myObject, anOldName, theName, this); if (isModified && myObject && myObject->document()) { std::dynamic_pointer_cast(myObject->document())-> - changeNamingName(anOldName, theName, myLab); + changeNamingName(anOldName, theName, shapeLab()); } #ifdef DEBUG_NAMES myObject->myName = theName; #endif } -AttributePtr Model_Data::addAttribute(const std::string& theID, const std::string theAttrType) +bool Model_Data::hasUserDefinedName() const +{ + return shapeLab().IsAttribute(kUSER_DEFINED_NAME); +} + +std::string Model_Data::version() +{ + Handle(TDataStd_Name) aVersionAttr; + std::string aVersion; + if (shapeLab().FindAttribute(kVERSION_ID, aVersionAttr)) + aVersion = TCollection_AsciiString(aVersionAttr->Get()).ToCString(); + return aVersion; +} + +void Model_Data::setVersion(const std::string& theVersion) +{ + Handle(TDataStd_Name) aVersionAttr; + std::string aVersion; + if (!shapeLab().FindAttribute(kVERSION_ID, aVersionAttr)) + aVersionAttr = TDataStd_Name::Set(shapeLab(), kVERSION_ID, TCollection_ExtendedString()); + aVersionAttr->Set(theVersion.c_str()); +} + +AttributePtr Model_Data::addAttribute( + const std::string& theID, const std::string theAttrType, const int theIndex) { AttributePtr aResult; - int anAttrIndex = int(myAttrs.size()) + 1; + int anAttrIndex = theIndex == -1 ? int(myAttrs.size()) + 1 : theIndex; TDF_Label anAttrLab = myLab.FindChild(anAttrIndex); ModelAPI_Attribute* anAttr = 0; if (theAttrType == ModelAPI_AttributeDocRef::typeId()) { @@ -201,7 +242,10 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin } anAttribute->myIsInitialized = anAllInitialized; anAttr = anAttribute; + } else if (theAttrType == GeomData_Point2DArray::typeId()) { + anAttr = new GeomData_Point2DArray(anAttrLab); } + if (anAttr) { aResult = std::shared_ptr(anAttr); myAttrs[theID] = std::pair(aResult, anAttrIndex); @@ -214,6 +258,97 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin return aResult; } +AttributePtr Model_Data::addFloatingAttribute( + const std::string& theID, const std::string theAttrType, const std::string& theGroup) +{ + // compute the index of the attribute placement + int anIndex; + TDF_Label aLab; + if (myLab.IsAttribute(TDF_TagSource::GetID())) { + // check this is re-init of attributes, so, check attribute with this name already there + TDF_ChildIDIterator anIter(myLab, kGroupAttributeID, false); + for(; anIter.More(); anIter.Next()) { + TCollection_AsciiString aThisName(Handle(TDataStd_Name)::DownCast(anIter.Value())->Get()); + if (theID == aThisName.ToCString()) { + TDF_Label aChildLab = anIter.Value()->Label(); + Handle(TDataStd_Name) aGName; + if (aChildLab.FindAttribute(kGroupAttributeGroupID, aGName)) { + TCollection_AsciiString aGroupName(aGName->Get()); + if (theGroup == aGroupName.ToCString()) { + return addAttribute(theGroup + "__" + theID, theAttrType, aChildLab.Tag()); + } + } + } + } + aLab = myLab.NewChild(); // already exists a floating attribute, create the next + anIndex = aLab.Tag(); + } else { // put the first floating attribute, quite far from other standard attributes + anIndex = int(myAttrs.size()) + 1000; + TDF_TagSource::Set(myLab)->Set(anIndex); + aLab = myLab.FindChild(anIndex, true); + } + // store the group ID and the attribute ID (to restore correctly) + TDataStd_Name::Set(aLab, kGroupAttributeGroupID, theGroup.c_str()); + TDataStd_Name::Set(aLab, kGroupAttributeID, theID.c_str()); + + return addAttribute(theGroup + "__" + theID, theAttrType, anIndex); +} + +void Model_Data::allGroups(std::list& theGroups) +{ + std::set alreadyThere; + for(TDF_ChildIDIterator aGroup(myLab, kGroupAttributeGroupID); aGroup.More(); aGroup.Next()) { + Handle(TDataStd_Name) aGroupAttr = Handle(TDataStd_Name)::DownCast(aGroup.Value()); + std::string aGroupID = TCollection_AsciiString(aGroupAttr->Get()).ToCString(); + if (alreadyThere.find(aGroupID) == alreadyThere.end()) { + theGroups.push_back(aGroupID); + alreadyThere.insert(aGroupID); + } + } +} + +void Model_Data::attributesOfGroup(const std::string& theGroup, + std::list >& theAttrs) +{ + for(TDF_ChildIDIterator aGroup(myLab, kGroupAttributeGroupID); aGroup.More(); aGroup.Next()) { + Handle(TDataStd_Name) aGroupID = Handle(TDataStd_Name)::DownCast(aGroup.Value()); + if (aGroupID->Get().IsEqual(theGroup.c_str())) { + Handle(TDataStd_Name) anID; + if (aGroup.Value()->Label().FindAttribute(kGroupAttributeID, anID)) { + TCollection_AsciiString anAsciiID(aGroupID->Get() + "__" + anID->Get()); + theAttrs.push_back(attribute(anAsciiID.ToCString())); + } + } + } +} + +void Model_Data::removeAttributes(const std::string& theGroup) +{ + TDF_LabelList aLabsToRemove; // collect labels that must be erased after the cycle + for(TDF_ChildIDIterator aGroup(myLab, kGroupAttributeGroupID); aGroup.More(); aGroup.Next()) { + Handle(TDataStd_Name) aGroupID = Handle(TDataStd_Name)::DownCast(aGroup.Value()); + if (aGroupID->Get().IsEqual(theGroup.c_str())) { + Handle(TDataStd_Name) anID; + if (!aGroup.Value()->Label().IsNull() && + aGroup.Value()->Label().FindAttribute(kGroupAttributeID, anID)) { + aLabsToRemove.Append(aGroup.Value()->Label()); + } + TCollection_AsciiString anAsciiID(aGroupID->Get() + "__" + anID->Get()); + myAttrs.erase(anAsciiID.ToCString()); + } + } + for(TDF_LabelList::Iterator aLab(aLabsToRemove); aLab.More(); aLab.Next()) { + aLab.ChangeValue().ForgetAllAttributes(true); + } +} + +void Model_Data::clearAttributes() +{ + myAttrs.clear(); +} + + + // macro for the generic returning of the attribute by the ID #define GET_ATTRIBUTE_BY_ID(ATTR_TYPE, METHOD_NAME) \ std::shared_ptr Model_Data::METHOD_NAME(const std::string& theID) { \ @@ -323,8 +458,10 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr) myWasChangedButBlocked.push_back(theAttr); } } else { - // trim: need to redisplay - if (myObject) { + // trim: need to redisplay or set color in the python script + if (myObject && (theAttr->attributeType() == "Point2D" || theAttr->id() == "Color" || + theAttr->id() == "Transparency" || theAttr->id() == "Deflection" || + theAttr->id() == "Iso_lines" || theAttr->id() == "Show_Iso_lines")) { static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY); ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); } @@ -395,7 +532,7 @@ enum StatesIndexes { STATE_INDEX_TRANSACTION = 2, // transaction ID }; -/// Returns the label array, initialises it by default values if not exists +/// Returns the label array, initializes it by default values if not exists static Handle(TDataStd_IntegerArray) stateArray(TDF_Label& theLab) { Handle(TDataStd_IntegerArray) aStateArray; @@ -459,15 +596,6 @@ int Model_Data::featureId() const return myLab.Father().Tag(); // tag of the feature label } -void Model_Data::eraseBackReferences() -{ - myRefsToMe.clear(); - std::shared_ptr aRes = - std::dynamic_pointer_cast(myObject); - if (aRes) - aRes->setIsConcealed(false); -} - void Model_Data::removeBackReference(ObjectPtr theObject, std::string theAttrID) { AttributePtr anAttribute = theObject->data()->attribute(theAttrID); @@ -481,7 +609,7 @@ void Model_Data::removeBackReference(AttributePtr theAttr) myRefsToMe.erase(theAttr); - // remove concealment immideately: on deselection it must be posible to reselect in GUI the same + // remove concealment immediately: on deselection it must be possible to reselect in GUI the same FeaturePtr aFeatureOwner = std::dynamic_pointer_cast(theAttr->owner()); if (aFeatureOwner.get() && ModelAPI_Session::get()->validators()->isConcealed(aFeatureOwner->getKind(), theAttr->id())) { @@ -496,13 +624,12 @@ void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, if (theApplyConcealment && theFeature->isStable() && ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) { - std::shared_ptr aRes = - std::dynamic_pointer_cast(myObject); + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); // the second condition is for history upper than concealment causer, so the feature result may // be displayed and previewed; also for avoiding of quick show/hide on history // moving deep down if (aRes && !theFeature->isDisabled()) { - aRes->setIsConcealed(true); + aRes->setIsConcealed(true, theFeature->getKind() == "RemoveResults"); } } } @@ -522,13 +649,20 @@ void Model_Data::updateConcealmentFlag() if (aRefsIter->get()) { FeaturePtr aFeature = std::dynamic_pointer_cast((*aRefsIter)->owner()); if (aFeature.get() && !aFeature->isDisabled() && aFeature->isStable()) { - if (ModelAPI_Session::get()->validators()->isConcealed( - aFeature->getKind(), (*aRefsIter)->id())) { + ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators(); + bool isCase = aValidators->isCase(aFeature, (*aRefsIter)->id()); + bool isConcealed = aValidators->isConcealed(aFeature->getKind(), (*aRefsIter)->id()); + if (isCase && isConcealed) { std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); if (aRes.get()) { - aRes->setIsConcealed(true); // set concealed - return; + if (aRes->groupName() != ModelAPI_ResultConstruction::group()) { + aRes->setIsConcealed(true); // set concealed + return; + } else if (aFeature->getKind() == "RemoveResults") { + aRes->setIsConcealed(true, true); + return; + } } } } @@ -541,42 +675,43 @@ void Model_Data::updateConcealmentFlag() } } -std::set set_union(const std::set& theLeft, - const std::set& theRight) +std::set set_union(const std::set& theLeft, + const std::set& theRight) { - std::set aResult; + std::set aResult; aResult.insert(theLeft.begin(), theLeft.end()); aResult.insert(theRight.begin(), theRight.end()); return aResult; } -std::set usedParameters(const AttributePointPtr& theAttribute) +std::set usedParameters(const AttributePointPtr& theAttribute) { - std::set anUsedParameters; + std::set anUsedParameters; for (int aComponent = 0; aComponent < 3; ++aComponent) anUsedParameters = set_union(anUsedParameters, theAttribute->usedParameters(aComponent)); return anUsedParameters; } -std::set usedParameters(const AttributePoint2DPtr& theAttribute) +std::set usedParameters(const AttributePoint2DPtr& theAttribute) { - std::set anUsedParameters; + std::set anUsedParameters; for (int aComponent = 0; aComponent < 2; ++aComponent) anUsedParameters = set_union(anUsedParameters, theAttribute->usedParameters(aComponent)); return anUsedParameters; } -std::list findVariables(const std::set& theParameters) +std::list findVariables(const std::set& theParameters, + const DocumentPtr& theDocument) { std::list aResult; - std::set::const_iterator aParamIt = theParameters.cbegin(); + std::set::const_iterator aParamIt = theParameters.cbegin(); for (; aParamIt != theParameters.cend(); ++aParamIt) { - const std::string& aName = *aParamIt; + const std::wstring& aName = *aParamIt; double aValue; ResultParameterPtr aParam; // theSearcher is not needed here: in expressions // of features the parameters history is not needed - if (ModelAPI_Tools::findVariable(FeaturePtr(), aName, aValue, aParam)) + if (ModelAPI_Tools::findVariable(FeaturePtr(), aName, aValue, aParam, theDocument)) aResult.push_back(aParam); } return aResult; @@ -608,21 +743,40 @@ void Model_Data::referencesToObjects( if (aRef->isObject()) { aReferenced.push_back(aRef->object()); } else { - AttributePtr anAttr = aRef->attr(); - if (anAttr.get()) - aReferenced.push_back(anAttr->owner()); + AttributePtr aReferredAttr = aRef->attr(); + if (aReferredAttr.get()) + aReferenced.push_back(aReferredAttr->owner()); } } else if (aType == ModelAPI_AttributeRefList::typeId()) { // list of references aReferenced = std::dynamic_pointer_cast(anAttr)->list(); - } else if (aType == ModelAPI_AttributeSelection::typeId()) { // selection attribute + } + else if (aType == ModelAPI_AttributeSelection::typeId()) { // selection attribute std::shared_ptr aRef = std::dynamic_pointer_cast< - ModelAPI_AttributeSelection>(anAttr); - aReferenced.push_back(aRef->context()); + ModelAPI_AttributeSelection>(anAttr); + FeaturePtr aRefFeat = aRef->contextFeature(); + if (aRefFeat.get()) { // reference to all results of the referenced feature + const std::list& allRes = aRefFeat->results(); + std::list::const_iterator aRefRes = allRes.cbegin(); + for(; aRefRes != allRes.cend(); aRefRes++) { + aReferenced.push_back(*aRefRes); + } + } else { + aReferenced.push_back(aRef->context()); + } } else if (aType == ModelAPI_AttributeSelectionList::typeId()) { // list of selection attributes std::shared_ptr aRef = std::dynamic_pointer_cast< ModelAPI_AttributeSelectionList>(anAttr); for(int a = 0, aSize = aRef->size(); a < aSize; ++a) { - aReferenced.push_back(aRef->value(a)->context()); + FeaturePtr aRefFeat = aRef->value(a)->contextFeature(); + if (aRefFeat.get()) { // reference to all results of the referenced feature + const std::list& allRes = aRefFeat->results(); + std::list::const_iterator aRefRes = allRes.cbegin(); + for (; aRefRes != allRes.cend(); aRefRes++) { + aReferenced.push_back(*aRefRes); + } + } else { + aReferenced.push_back(aRef->value(a)->context()); + } } } else if (aType == ModelAPI_AttributeRefAttrList::typeId()) { std::shared_ptr aRefAttr = std::dynamic_pointer_cast< @@ -636,26 +790,30 @@ void Model_Data::referencesToObjects( } else if (aType == ModelAPI_AttributeInteger::typeId()) { // integer attribute AttributeIntegerPtr anAttribute = std::dynamic_pointer_cast(anAttr); - std::set anUsedParameters = anAttribute->usedParameters(); - std::list aParameters = findVariables(anUsedParameters); + std::set anUsedParameters = anAttribute->usedParameters(); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == ModelAPI_AttributeDouble::typeId()) { // double attribute AttributeDoublePtr anAttribute = std::dynamic_pointer_cast(anAttr); - std::set anUsedParameters = anAttribute->usedParameters(); - std::list aParameters = findVariables(anUsedParameters); + std::set anUsedParameters = anAttribute->usedParameters(); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == GeomDataAPI_Point::typeId()) { // point attribute AttributePointPtr anAttribute = std::dynamic_pointer_cast(anAttr); - std::set anUsedParameters = usedParameters(anAttribute); - std::list aParameters = findVariables(anUsedParameters); + std::set anUsedParameters = usedParameters(anAttribute); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == GeomDataAPI_Point2D::typeId()) { // point attribute AttributePoint2DPtr anAttribute = std::dynamic_pointer_cast(anAttr); - std::set anUsedParameters = usedParameters(anAttribute); - std::list aParameters = findVariables(anUsedParameters); + std::set anUsedParameters = usedParameters(anAttribute); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else continue; // nothing to do, not reference @@ -668,35 +826,14 @@ void Model_Data::referencesToObjects( } } -/// makes copy of all attributes on the given label and all sub-labels -static void copyAttrs(TDF_Label theSource, TDF_Label theDestination) { - TDF_AttributeIterator anAttrIter(theSource); - for(; anAttrIter.More(); anAttrIter.Next()) { - Handle(TDF_Attribute) aTargetAttr; - if (!theDestination.FindAttribute(anAttrIter.Value()->ID(), aTargetAttr)) { - // create a new attribute if not yet exists in the destination - aTargetAttr = anAttrIter.Value()->NewEmpty(); - theDestination.AddAttribute(aTargetAttr); - } - // no special relocation, empty map, but self-relocation is on: copy references w/o changes - Handle(TDF_RelocationTable) aRelocTable = new TDF_RelocationTable(Standard_True); - anAttrIter.Value()->Paste(aTargetAttr, aRelocTable); - } - // copy the sub-labels content - TDF_ChildIterator aSubLabsIter(theSource); - for(; aSubLabsIter.More(); aSubLabsIter.Next()) { - copyAttrs(aSubLabsIter.Value(), theDestination.FindChild(aSubLabsIter.Value().Tag())); - } -} - void Model_Data::copyTo(std::shared_ptr theTarget) { TDF_Label aTargetRoot = std::dynamic_pointer_cast(theTarget)->label(); - copyAttrs(myLab, aTargetRoot); + Model_Tools::copyAttrs(myLab, aTargetRoot); // reinitialize Model_Attributes by TDF_Attributes set std::shared_ptr aTData = std::dynamic_pointer_cast(theTarget); aTData->myAttrs.clear(); - theTarget->owner()->initAttributes(); // reinit feature attributes + theTarget->owner()->initAttributes(); // reinitialize feature attributes } bool Model_Data::isInHistory()