X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_ResultCompSolid.cpp;h=633e8cd08d920035e40ca45483629af46de0ff02;hb=69290817c24cb8b9d240129d8573b46807a007ef;hp=93f4331a034f48cd017e408b84ce70fec4cea07d;hpb=470905ace04b0b7345038bb2277050a6c8fcc585;p=modules%2Fshaper.git

diff --git a/src/Model/Model_ResultCompSolid.cpp b/src/Model/Model_ResultCompSolid.cpp
index 93f4331a0..633e8cd08 100755
--- a/src/Model/Model_ResultCompSolid.cpp
+++ b/src/Model/Model_ResultCompSolid.cpp
@@ -6,43 +6,187 @@
 
 #include <Model_ResultCompSolid.h>
 
+#include <Model_Document.h>
+#include <Model_Objects.h>
+#include <Model_BodyBuilder.h>
+#include <Model_Document.h>
+#include <ModelAPI_AttributeRefList.h>
+#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_Object.h>
+#include <ModelAPI_Events.h>
+#include <Events_Loop.h>
+
+#include <TopoDS_Shape.hxx>
+#include <TopExp_Explorer.hxx>
+
+
 Model_ResultCompSolid::Model_ResultCompSolid()
 {
+  myBuilder = new Model_BodyBuilder(this);
+  myLastConcealed = false;
+  setIsConcealed(myLastConcealed);
+  myIsDisabled = true; // by default it is not initialized and false to be after created
+  updateSubs(shape()); // in case of open, etc.
 }
 
 Model_ResultCompSolid::~Model_ResultCompSolid()
 {
+  updateSubs(std::shared_ptr<GeomAPI_Shape>()); // erase sub-results
 }
 
-std::shared_ptr<ModelAPI_ResultBody> Model_ResultCompSolid::addResult(std::string theID)
+void Model_ResultCompSolid::initAttributes()
 {
-  std::shared_ptr<ModelAPI_ResultBody> aResult;
-  return aResult;
+  DataPtr aData = data();
+  aData->addAttribute(COLOR_ID(), ModelAPI_AttributeIntArray::typeId());
+}
+
+void Model_ResultCompSolid::store(const std::shared_ptr<GeomAPI_Shape>& theShape)
+{
+  ModelAPI_ResultCompSolid::store(theShape);
+  updateSubs(theShape);
+}
+
+void Model_ResultCompSolid::storeGenerated(const std::shared_ptr<GeomAPI_Shape>& theFromShape,
+    const std::shared_ptr<GeomAPI_Shape>& theToShape)
+{
+  ModelAPI_ResultCompSolid::storeGenerated(theFromShape, theToShape);
+  updateSubs(theToShape);
+}
+
+void Model_ResultCompSolid::storeModified(const std::shared_ptr<GeomAPI_Shape>& theOldShape,
+    const std::shared_ptr<GeomAPI_Shape>& theNewShape, const int theDecomposeSolidsTag)
+{
+  ModelAPI_ResultCompSolid::storeModified(theOldShape, theNewShape, theDecomposeSolidsTag);
+  updateSubs(theNewShape);
 }
 
 int Model_ResultCompSolid::numberOfSubs(bool forTree) const
 {
-  return 0;
+  return mySubs.size();
 }
 
 std::shared_ptr<ModelAPI_ResultBody> Model_ResultCompSolid::subResult(const int theIndex,
                                                                       bool forTree) const
 {
-  std::shared_ptr<ModelAPI_ResultBody> aBody;
+  return mySubs.at(theIndex);
+}
 
-  return aBody;
+bool Model_ResultCompSolid::isSub(ObjectPtr theObject) const
+{
+  std::vector<std::shared_ptr<ModelAPI_ResultBody> >::const_iterator aSubIter = mySubs.cbegin();
+  for(; aSubIter != mySubs.cend(); aSubIter++)
+    if (*aSubIter == theObject)
+      return true;
+  return false;
 }
 
-int Model_ResultCompSolid::subResultId(const int theIndex) const
+void Model_ResultCompSolid::colorConfigInfo(std::string& theSection, std::string& theName,
+  std::string& theDefault)
 {
-  return 0;
+  theSection = "Visualization";
+  theName = "result_body_color";
+  theDefault = DEFAULT_COLOR();
 }
 
-bool Model_ResultCompSolid::isSub(ObjectPtr theObject) const
+bool Model_ResultCompSolid::setDisabled(std::shared_ptr<ModelAPI_Result> theThis, const bool theFlag)
+{
+  bool aChanged = ModelAPI_ResultBody::setDisabled(theThis, theFlag);
+  if (aChanged) { // state is changed, so modifications are needed
+    myBuilder->evolutionToSelection(theFlag);
+    updateSubs(shape()); // to set disabled/enabled 
+  }
+  return aChanged;
+}
+
+bool Model_ResultCompSolid::isConcealed()
+{
+  bool aResult = false;;
+  if (ModelAPI_ResultCompSolid::isConcealed()) {
+    aResult = true;
+  } else {
+    std::vector<std::shared_ptr<ModelAPI_ResultBody> >::const_iterator aSubIter = mySubs.cbegin();
+    for(; aSubIter != mySubs.cend(); aSubIter++)
+      if ((*aSubIter)->isConcealed())
+        aResult = true;
+  }
+  if (myLastConcealed != aResult) {
+    myLastConcealed = aResult;
+    setIsConcealed(aResult); // set for all subs the same result
+  }
+  return aResult;
+}
+
+void Model_ResultCompSolid::setIsConcealed(const bool theValue)
 {
-  return true;
+  ModelAPI_ResultCompSolid::setIsConcealed(theValue);
+  std::vector<std::shared_ptr<ModelAPI_ResultBody> >::const_iterator aSubIter = mySubs.cbegin();
+  for(; aSubIter != mySubs.cend(); aSubIter++) {
+    if ((*aSubIter)->isConcealed() != theValue) {
+      (*aSubIter)->setIsConcealed(theValue);
+      if (theValue) { // hidden unit must be redisplayed (hidden)
+        ModelAPI_EventCreator::get()->sendDeleted(document(), (*aSubIter)->groupName());
+        // redisplay for the viewer (it must be disappeared also)
+        static Events_ID EVENT_DISP = 
+          Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+        ModelAPI_EventCreator::get()->sendUpdated(*aSubIter, EVENT_DISP);
+      } else { // was not concealed become concealed => delete event
+        static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
+        ModelAPI_EventCreator::get()->sendUpdated(*aSubIter, anEvent);
+      }
+    }
+  }
 }
 
-void Model_ResultCompSolid::removeResult(std::shared_ptr<ModelAPI_ResultBody> theResult)
+void Model_ResultCompSolid::updateSubs(const std::shared_ptr<GeomAPI_Shape>& theThisShape)
 {
+  static Events_Loop* aLoop = Events_Loop::loop();
+  static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+  static Events_ID EVENT_UPD = aLoop->eventByName(EVENT_OBJECT_UPDATED);
+  static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
+  // iterate all sub-solids of compsolid to make sub-results synchronized with them
+  TopoDS_Shape aThisShape;
+  if (theThisShape.get()) aThisShape = theThisShape->impl<TopoDS_Shape>();
+  if (!aThisShape.IsNull() && (aThisShape.ShapeType() == TopAbs_COMPSOLID ||
+       aThisShape.ShapeType() == TopAbs_COMPOUND)) {
+    bool aWasEmpty = mySubs.empty();
+    Model_Objects* anObjects = std::dynamic_pointer_cast<Model_Document>(document())->objects();
+    unsigned int aSubIndex = 0;
+    TopExp_Explorer aSolids(aThisShape, TopAbs_SOLID);
+    for(; aSolids.More(); aSolids.Next(), aSubIndex++) {
+      std::shared_ptr<GeomAPI_Shape> aSolidShape(new GeomAPI_Shape);
+      aSolidShape->setImpl(new TopoDS_Shape(aSolids.Current()));
+      ResultBodyPtr aSub;
+      if (mySubs.size() <= aSubIndex) { // it is needed to create a new sub-result
+        aSub = anObjects->createBody(this->data(), aSubIndex);
+        mySubs.push_back(aSub);
+      } else { // just update shape of this result
+        aSub = mySubs[aSubIndex];
+      }
+      if (!aSolidShape->isEqual(aSub->shape())) {
+        aSub->store(aSolidShape);
+        aECreator->sendUpdated(aSub, EVENT_DISP);
+        aECreator->sendUpdated(aSub, EVENT_UPD);
+      }
+      aSub->setDisabled(aSub, isDisabled());
+      aSub->setIsConcealed(myLastConcealed);
+    }
+    // erase left, unused results
+    while(mySubs.size() > aSubIndex) {
+      ResultBodyPtr anErased = *(mySubs.rbegin());
+      anErased->setDisabled(anErased, true);
+      mySubs.pop_back();
+    }
+    if (aWasEmpty) { // erase all subs
+      // redisplay this because result with and without subs are displayed differently
+      aECreator->sendUpdated(data()->owner(), EVENT_DISP);
+    }
+  } else if (!mySubs.empty()) { // erase all subs
+    while(!mySubs.empty()) {
+      ResultBodyPtr anErased = *(mySubs.rbegin());
+      anErased->setDisabled(anErased, true);
+      mySubs.pop_back();
+    }
+    // redisplay this because result with and without subs are displayed differently
+    aECreator->sendUpdated(data()->owner(), EVENT_DISP);
+  }
 }