X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Data.cpp;h=cbe96e2b3c043caf58214590311b078b170ec851;hb=10671023698288fff01b8717696d150419dc4475;hp=e9d808ade039cee5c7f934664bdfa7817b73b81e;hpb=353cb0b3156491b5985a504f65a6953af2c151b0;p=modules%2Fshaper.git diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp index e9d808ade..cbe96e2b3 100644 --- a/src/Model/Model_Data.cpp +++ b/src/Model/Model_Data.cpp @@ -8,15 +8,18 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include #include #include +#include #include #include #include @@ -36,7 +39,7 @@ #include #include #include -#include +#include #include #include @@ -82,17 +85,21 @@ void Model_Data::setLabel(TDF_Label theLab) 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); + myFlags->SetValue(0, aFlag0); + myFlags->SetValue(1, aFlag1); + myFlags->SetValue(2, aFlag2); } } std::string Model_Data::name() { Handle(TDataStd_Name) aName; - if (myLab.FindAttribute(TDataStd_Name::GetID(), aName)) + if (myLab.FindAttribute(TDataStd_Name::GetID(), aName)) { +#ifdef DEBUG_NAMES + myObject->myName = TCollection_AsciiString(aName->Get()).ToCString(); +#endif return std::string(TCollection_AsciiString(aName->Get()).ToCString()); + } return ""; // not defined } @@ -111,6 +118,13 @@ void Model_Data::setName(const std::string& theName) } if (mySendAttributeUpdated && isModified) ModelAPI_ObjectRenamedMessage::send(myObject, anOldName, theName, this); + if (isModified && myObject && myObject->document()) { + std::dynamic_pointer_cast(myObject->document())-> + changeNamingName(anOldName, theName); + } +#ifdef DEBUG_NAMES + myObject->myName = theName; +#endif } AttributePtr Model_Data::addAttribute(const std::string& theID, const std::string theAttrType) @@ -121,22 +135,15 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin if (theAttrType == ModelAPI_AttributeDocRef::typeId()) { anAttr = new Model_AttributeDocRef(anAttrLab); } else if (theAttrType == Model_AttributeInteger::typeId()) { - Model_AttributeInteger* anAttribute = new Model_AttributeInteger(); - // Expression should use the same label to support backward compatibility - TDF_Label anExpressionLab = anAttrLab; - anAttribute->myExpression.reset(new Model_ExpressionInteger(anExpressionLab)); - anAttribute->myIsInitialized = anAttribute->myExpression->isInitialized(); - anAttr = anAttribute; + anAttr = new Model_AttributeInteger(anAttrLab); } else if (theAttrType == ModelAPI_AttributeDouble::typeId()) { - Model_AttributeDouble* anAttribute = new Model_AttributeDouble(); - TDF_Label anExpressionLab = anAttrLab.FindChild(1); - anAttribute->myExpression.reset(new Model_ExpressionDouble(anExpressionLab)); - anAttribute->myIsInitialized = anAttribute->myExpression->isInitialized(); - anAttr = anAttribute; + anAttr = new Model_AttributeDouble(anAttrLab); } else if (theAttrType == Model_AttributeBoolean::typeId()) { anAttr = new Model_AttributeBoolean(anAttrLab); } else if (theAttrType == Model_AttributeString::typeId()) { anAttr = new Model_AttributeString(anAttrLab); + } else if (theAttrType == Model_AttributeStringArray::typeId()) { + anAttr = new Model_AttributeStringArray(anAttrLab); } else if (theAttrType == ModelAPI_AttributeReference::typeId()) { anAttr = new Model_AttributeReference(anAttrLab); } else if (theAttrType == ModelAPI_AttributeSelection::typeId()) { @@ -151,7 +158,11 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin anAttr = new Model_AttributeRefAttrList(anAttrLab); } else if (theAttrType == ModelAPI_AttributeIntArray::typeId()) { anAttr = new Model_AttributeIntArray(anAttrLab); - } + } else if (theAttrType == ModelAPI_AttributeDoubleArray::typeId()) { + anAttr = new Model_AttributeDoubleArray(anAttrLab); + } else if (theAttrType == ModelAPI_AttributeTables::typeId()) { + anAttr = new Model_AttributeTables(anAttrLab); + } // create also GeomData attributes here because only here the OCAF structure is known else if (theAttrType == GeomData_Point::typeId()) { GeomData_Point* anAttribute = new GeomData_Point(); @@ -182,12 +193,13 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin anAttr->setObject(myObject); anAttr->setID(theID); } else { - Events_Error::send("Can not create unknown type of attribute " + theAttrType); + Events_InfoMessage("Model_Data", + "Can not create unknown type of attribute %1").arg(theAttrType).send(); } return aResult; } -// macro for gthe generic returning of the attribute by the ID +// 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) { \ std::shared_ptr aRes; \ @@ -204,6 +216,7 @@ GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeDouble, real); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeInteger, integer); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeBoolean, boolean); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeString, string); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeStringArray, stringArray); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeReference, reference); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeSelection, selection); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeSelectionList, selectionList); @@ -211,6 +224,8 @@ GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeRefAttr, refattr); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeRefList, reflist); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeRefAttrList, refattrlist); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeIntArray, intArray); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeDoubleArray, realArray); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeTables, tables); std::shared_ptr Model_Data::attribute(const std::string& theID) { @@ -222,7 +237,7 @@ std::shared_ptr Model_Data::attribute(const std::string& the const std::string& Model_Data::id(const std::shared_ptr& theAttr) { - std::map >::iterator anAttr = + std::map >::iterator anAttr = myAttrs.begin(); for (; anAttr != myAttrs.end(); anAttr++) { if (anAttr->second == theAttr) @@ -249,7 +264,7 @@ bool Model_Data::isValid() std::list > Model_Data::attributes(const std::string& theType) { std::list > aResult; - std::map >::iterator anAttrsIter = + std::map >::iterator anAttrsIter = myAttrs.begin(); for (; anAttrsIter != myAttrs.end(); anAttrsIter++) { if (theType.empty() || anAttrsIter->second->attributeType() == theType) { @@ -259,10 +274,10 @@ std::list > Model_Data::attributes(const std return aResult; } -std::list Model_Data::attributesIDs(const std::string& theType) +std::list Model_Data::attributesIDs(const std::string& theType) { std::list aResult; - std::map >::iterator anAttrsIter = + std::map >::iterator anAttrsIter = myAttrs.begin(); for (; anAttrsIter != myAttrs.end(); anAttrsIter++) { if (theType.empty() || anAttrsIter->second->attributeType() == theType) { @@ -283,27 +298,68 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr) ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); } } else { - myWasChangedButBlocked = true; + // to avoid too many duplications do not add the same like the last + if (myWasChangedButBlocked.empty() || *(myWasChangedButBlocked.rbegin()) != theAttr) + myWasChangedButBlocked.push_back(theAttr); + } + } else { + // trim: need to redisplay + if (myObject) { + static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); } } } -void Model_Data::blockSendAttributeUpdated(const bool theBlock) +bool Model_Data::blockSendAttributeUpdated(const bool theBlock, const bool theSendMessage) { + bool aWasBlocked = !mySendAttributeUpdated; if (mySendAttributeUpdated == theBlock) { mySendAttributeUpdated = !theBlock; - if (mySendAttributeUpdated && myWasChangedButBlocked) { // so, now it is ok to send the update signal - static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); - ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); - myWasChangedButBlocked = false; + if (mySendAttributeUpdated && !myWasChangedButBlocked.empty()) { + // so, now it is ok to send the update signal + if (theSendMessage) { + // make a copy to avoid iteration on modified list + // (may be cleared by attribute changed call) + std::list aWasChangedButBlocked = myWasChangedButBlocked; + myWasChangedButBlocked.clear(); + std::list::iterator aChangedIter = aWasChangedButBlocked.begin(); + for(; aChangedIter != aWasChangedButBlocked.end(); aChangedIter++) { + myObject->attributeChanged((*aChangedIter)->id()); + } + static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); + ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); + } else { + myWasChangedButBlocked.clear(); + } } } + return aWasBlocked; } void Model_Data::erase() { - if (!myLab.IsNull()) + if (!myLab.IsNull()) { + if (myLab.HasAttribute()) { + // remove in order to clear back references in other objects + std::list > > aRefs; + referencesToObjects(aRefs); + std::list > >::iterator + anAttrIter = aRefs.begin(); + for(; anAttrIter != aRefs.end(); anAttrIter++) { + std::list::iterator aReferenced = anAttrIter->second.begin(); + for(; aReferenced != anAttrIter->second.end(); aReferenced++) { + if (aReferenced->get() && (*aReferenced)->data()->isValid()) { + std::shared_ptr aData = + std::dynamic_pointer_cast((*aReferenced)->data()); + aData->removeBackReference(myAttrs[anAttrIter->first]); + } + } + } + } + myAttrs.clear(); myLab.ForgetAllAttributes(); + } } // indexes in the state array @@ -330,9 +386,6 @@ void Model_Data::execState(const ModelAPI_ExecState theState) if (stateArray(myLab)->Value(STATE_INDEX_STATE) != (int)theState) { stateArray(myLab)->SetValue(STATE_INDEX_STATE, (int)theState); } - // send signal even if the new value corresponds to the one in data model: undo issue 980 - static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_ERROR_CHANGED); - ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent, false); } } @@ -355,11 +408,9 @@ void Model_Data::setError(const std::string& theError, bool theSend) { execState(ModelAPI_StateExecFailed); if (theSend) { - Events_Error::send(theError); + Events_InfoMessage("Model_Data", theError).send(); } TDataStd_AsciiString::Set(myLab, theError.c_str()); - static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_ERROR_CHANGED); - ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent, false); } void Model_Data::eraseErrorString() @@ -384,7 +435,7 @@ int Model_Data::featureId() const void Model_Data::eraseBackReferences() { myRefsToMe.clear(); - std::shared_ptr aRes = + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); if (aRes) aRes->setIsConcealed(false); @@ -411,7 +462,7 @@ void Model_Data::removeBackReference(AttributePtr theAttr) } } -void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, +void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, const bool theApplyConcealment) { // it is possible to add the same attribute twice: may be last time the owner was not Stable... @@ -419,9 +470,9 @@ void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, if (myRefsToMe.find(anAttribute) == myRefsToMe.end()) myRefsToMe.insert(theFeature->data()->attribute(theAttrID)); - if (theApplyConcealment && theFeature->isStable() && + if (theApplyConcealment && theFeature->isStable() && ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) { - std::shared_ptr aRes = + 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 @@ -441,24 +492,24 @@ void Model_Data::updateConcealmentFlag() if (aFeature.get() && !aFeature->isDisabled() && aFeature->isStable()) { if (ModelAPI_Session::get()->validators()->isConcealed( aFeature->getKind(), (*aRefsIter)->id())) { - std::shared_ptr aRes = + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); if (aRes.get()) { aRes->setIsConcealed(true); // set concealed + return; } - return; } } } } - std::shared_ptr aRes = + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); if (aRes.get()) { aRes->setIsConcealed(false); } } -std::set set_union(const std::set& theLeft, +std::set set_union(const std::set& theLeft, const std::set& theRight) { std::set aResult; @@ -483,8 +534,7 @@ std::set usedParameters(const AttributePoint2DPtr& theAttribute) return anUsedParameters; } -std::list findVariables(const std::set& theParameters, - const DocumentPtr& theDocument) +std::list findVariables(const std::set& theParameters) { std::list aResult; std::set::const_iterator aParamIt = theParameters.cbegin(); @@ -492,7 +542,9 @@ std::list findVariables(const std::set& thePara const std::string& aName = *aParamIt; double aValue; ResultParameterPtr aParam; - if (ModelAPI_Tools::findVariable(aName, aValue, aParam, theDocument)) + // theSearcher is not needed here: in expressions + // of features the parameters history is not needed + if (ModelAPI_Tools::findVariable(FeaturePtr(), aName, aValue, aParam)) aResult.push_back(aParam); } return aResult; @@ -501,7 +553,7 @@ std::list findVariables(const std::set& thePara void Model_Data::referencesToObjects( std::list > >& theRefs) { - static Model_ValidatorsFactory* aValidators = + static Model_ValidatorsFactory* aValidators = static_cast(ModelAPI_Session::get()->validators()); FeaturePtr aMyFeature = std::dynamic_pointer_cast(myObject); @@ -520,7 +572,13 @@ void Model_Data::referencesToObjects( } else if (aType == ModelAPI_AttributeRefAttr::typeId()) { // reference to attribute or object std::shared_ptr aRef = std::dynamic_pointer_cast< ModelAPI_AttributeRefAttr>(anAttr->second); - aReferenced.push_back(aRef->isObject() ? aRef->object() : aRef->attr()->owner()); + if (aRef->isObject()) { + aReferenced.push_back(aRef->object()); + } else { + AttributePtr anAttr = aRef->attr(); + if (anAttr.get()) + aReferenced.push_back(anAttr->owner()); + } } else if (aType == ModelAPI_AttributeRefList::typeId()) { // list of references aReferenced = std::dynamic_pointer_cast(anAttr->second)->list(); } else if (aType == ModelAPI_AttributeSelection::typeId()) { // selection attribute @@ -546,25 +604,25 @@ void Model_Data::referencesToObjects( AttributeIntegerPtr anAttribute = std::dynamic_pointer_cast(anAttr->second); std::set anUsedParameters = anAttribute->usedParameters(); - std::list aParameters = findVariables(anUsedParameters, aMyFeature->document()); + std::list aParameters = findVariables(anUsedParameters); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == ModelAPI_AttributeDouble::typeId()) { // double attribute AttributeDoublePtr anAttribute = std::dynamic_pointer_cast(anAttr->second); std::set anUsedParameters = anAttribute->usedParameters(); - std::list aParameters = findVariables(anUsedParameters, aMyFeature->document()); + std::list aParameters = findVariables(anUsedParameters); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == GeomDataAPI_Point::typeId()) { // point attribute AttributePointPtr anAttribute = std::dynamic_pointer_cast(anAttr->second); std::set anUsedParameters = usedParameters(anAttribute); - std::list aParameters = findVariables(anUsedParameters, aMyFeature->document()); + std::list aParameters = findVariables(anUsedParameters); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == GeomDataAPI_Point2D::typeId()) { // point attribute AttributePoint2DPtr anAttribute = std::dynamic_pointer_cast(anAttr->second); std::set anUsedParameters = usedParameters(anAttribute); - std::list aParameters = findVariables(anUsedParameters, aMyFeature->document()); + std::list aParameters = findVariables(anUsedParameters); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else continue; // nothing to do, not reference @@ -586,7 +644,8 @@ static void copyAttrs(TDF_Label theSource, TDF_Label theDestination) { aTargetAttr = anAttrIter.Value()->NewEmpty(); theDestination.AddAttribute(aTargetAttr); } - Handle(TDF_RelocationTable) aRelocTable = new TDF_RelocationTable(); // no relocation, empty map + // 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 @@ -600,15 +659,10 @@ void Model_Data::copyTo(std::shared_ptr theTarget) { TDF_Label aTargetRoot = std::dynamic_pointer_cast(theTarget)->label(); copyAttrs(myLab, aTargetRoot); - // make initialized the initialized attributes - std::map >::iterator aMyIter = myAttrs.begin(); - for(; aMyIter != myAttrs.end(); aMyIter++) { - if (aMyIter->second->isInitialized()) { - AttributePtr aTargetAttr = theTarget->attribute(aMyIter->first); - if (aTargetAttr) - aTargetAttr->setInitialized(); - } - } + // 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 } bool Model_Data::isInHistory()