X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Data.cpp;h=cbe96e2b3c043caf58214590311b078b170ec851;hb=10671023698288fff01b8717696d150419dc4475;hp=7f86b2116b0bc3c38fa6f24a681d3684c8f78b7e;hpb=47f93d1e56aff0b9c0515b0e767cbc46ef576ec4;p=modules%2Fshaper.git

diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp
index 7f86b2116..cbe96e2b3 100644
--- a/src/Model/Model_Data.cpp
+++ b/src/Model/Model_Data.cpp
@@ -15,9 +15,11 @@
 #include <Model_AttributeRefAttrList.h>
 #include <Model_AttributeBoolean.h>
 #include <Model_AttributeString.h>
+#include <Model_AttributeStringArray.h>
 #include <Model_AttributeSelection.h>
 #include <Model_AttributeSelectionList.h>
 #include <Model_AttributeIntArray.h>
+#include <Model_AttributeTables.h>
 #include <Model_Events.h>
 #include <Model_Expression.h>
 #include <ModelAPI_Feature.h>
@@ -83,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
 }
 
@@ -116,6 +122,9 @@ void Model_Data::setName(const std::string& theName)
     std::dynamic_pointer_cast<Model_Document>(myObject->document())->
       changeNamingName(anOldName, theName);
   }
+#ifdef DEBUG_NAMES
+  myObject->myName = theName;
+#endif
 }
 
 AttributePtr Model_Data::addAttribute(const std::string& theID, const std::string theAttrType)
@@ -126,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()) {
@@ -158,6 +160,8 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin
     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()) {
@@ -189,7 +193,8 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin
     anAttr->setObject(myObject);
     anAttr->setID(theID);
   } else {
-    Events_InfoMessage("Model_Data", "Can not create unknown type of attribute %1").arg(theAttrType).send();
+    Events_InfoMessage("Model_Data",
+      "Can not create unknown type of attribute %1").arg(theAttrType).send();
   }
   return aResult;
 }
@@ -211,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);
@@ -219,6 +225,7 @@ 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<ModelAPI_Attribute> Model_Data::attribute(const std::string& theID)
 {
@@ -230,7 +237,7 @@ std::shared_ptr<ModelAPI_Attribute> Model_Data::attribute(const std::string& the
 
 const std::string& Model_Data::id(const std::shared_ptr<ModelAPI_Attribute>& theAttr)
 {
-  std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = 
+  std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr =
     myAttrs.begin();
   for (; anAttr != myAttrs.end(); anAttr++) {
     if (anAttr->second == theAttr)
@@ -257,7 +264,7 @@ bool Model_Data::isValid()
 std::list<std::shared_ptr<ModelAPI_Attribute> > Model_Data::attributes(const std::string& theType)
 {
   std::list<std::shared_ptr<ModelAPI_Attribute> > aResult;
-  std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter = 
+  std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter =
     myAttrs.begin();
   for (; anAttrsIter != myAttrs.end(); anAttrsIter++) {
     if (theType.empty() || anAttrsIter->second->attributeType() == theType) {
@@ -267,10 +274,10 @@ std::list<std::shared_ptr<ModelAPI_Attribute> > Model_Data::attributes(const std
   return aResult;
 }
 
-std::list<std::string> Model_Data::attributesIDs(const std::string& theType) 
+std::list<std::string> Model_Data::attributesIDs(const std::string& theType)
 {
   std::list<std::string> aResult;
-  std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter = 
+  std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter =
     myAttrs.begin();
   for (; anAttrsIter != myAttrs.end(); anAttrsIter++) {
     if (theType.empty() || anAttrsIter->second->attributeType() == theType) {
@@ -295,16 +302,25 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr)
       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, const bool theSendMessage)
+bool Model_Data::blockSendAttributeUpdated(const bool theBlock, const bool theSendMessage)
 {
+  bool aWasBlocked = !mySendAttributeUpdated;
   if (mySendAttributeUpdated == theBlock) {
     mySendAttributeUpdated = !theBlock;
-    if (mySendAttributeUpdated && !myWasChangedButBlocked.empty()) { // so, now it is ok to send the update signal
+    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)
+        // make a copy to avoid iteration on modified list
+        // (may be cleared by attribute changed call)
         std::list<ModelAPI_Attribute*> aWasChangedButBlocked = myWasChangedButBlocked;
         myWasChangedButBlocked.clear();
         std::list<ModelAPI_Attribute*>::iterator aChangedIter = aWasChangedButBlocked.begin();
@@ -318,6 +334,7 @@ void Model_Data::blockSendAttributeUpdated(const bool theBlock, const bool theSe
       }
     }
   }
+  return aWasBlocked;
 }
 
 void Model_Data::erase()
@@ -327,12 +344,13 @@ void Model_Data::erase()
       // remove in order to clear back references in other objects
       std::list<std::pair<std::string, std::list<ObjectPtr> > > aRefs;
       referencesToObjects(aRefs);
-      std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator anAttrIter = aRefs.begin();
+      std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator
+        anAttrIter = aRefs.begin();
       for(; anAttrIter != aRefs.end(); anAttrIter++) {
         std::list<ObjectPtr>::iterator aReferenced = anAttrIter->second.begin();
         for(; aReferenced != anAttrIter->second.end(); aReferenced++) {
           if (aReferenced->get() && (*aReferenced)->data()->isValid()) {
-            std::shared_ptr<Model_Data> aData = 
+            std::shared_ptr<Model_Data> aData =
               std::dynamic_pointer_cast<Model_Data>((*aReferenced)->data());
             aData->removeBackReference(myAttrs[anAttrIter->first]);
           }
@@ -417,7 +435,7 @@ int Model_Data::featureId() const
 void Model_Data::eraseBackReferences()
 {
   myRefsToMe.clear();
-  std::shared_ptr<ModelAPI_Result> aRes = 
+  std::shared_ptr<ModelAPI_Result> aRes =
     std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
   if (aRes)
     aRes->setIsConcealed(false);
@@ -444,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...
@@ -452,15 +470,14 @@ 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<ModelAPI_Result> aRes = 
+    std::shared_ptr<ModelAPI_Result> aRes =
       std::dynamic_pointer_cast<ModelAPI_Result>(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() && 
-        !ModelAPI_Session::get()->validators()->isUnconcealed(aRes, theFeature)) {
+    if (aRes && !theFeature->isDisabled()) {
       aRes->setIsConcealed(true);
     }
   }
@@ -475,26 +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<ModelAPI_Result> aRes = 
+          std::shared_ptr<ModelAPI_Result> aRes =
             std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
           if (aRes.get()) {
-            if (!ModelAPI_Session::get()->validators()->isUnconcealed(aRes, aFeature)) {
-              aRes->setIsConcealed(true); // set concealed
-              return;
-            }
+            aRes->setIsConcealed(true); // set concealed
+            return;
           }
         }
       }
     }
   }
-  std::shared_ptr<ModelAPI_Result> aRes = 
+  std::shared_ptr<ModelAPI_Result> aRes =
     std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
   if (aRes.get()) {
     aRes->setIsConcealed(false);
   }
 }
 
-std::set<std::string> set_union(const std::set<std::string>& theLeft, 
+std::set<std::string> set_union(const std::set<std::string>& theLeft,
                                 const std::set<std::string>& theRight)
 {
   std::set<std::string> aResult;
@@ -527,7 +542,8 @@ std::list<ResultParameterPtr> findVariables(const std::set<std::string>& thePara
     const std::string& aName = *aParamIt;
     double aValue;
     ResultParameterPtr aParam;
-    // theSearcher is not needed here: in expressions of features the parameters history is not needed
+    // 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);
   }
@@ -537,7 +553,7 @@ std::list<ResultParameterPtr> findVariables(const std::set<std::string>& thePara
 void Model_Data::referencesToObjects(
   std::list<std::pair<std::string, std::list<ObjectPtr> > >& theRefs)
 {
-  static Model_ValidatorsFactory* aValidators = 
+  static Model_ValidatorsFactory* aValidators =
     static_cast<Model_ValidatorsFactory*>(ModelAPI_Session::get()->validators());
   FeaturePtr aMyFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(myObject);
 
@@ -628,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