X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_ResultCompSolid.cpp;h=c613cd29f3d88b13eb75a473781ff7e8dda03cd7;hb=41f9517e84ae934ce536718d4f48e26731c8430d;hp=5cb50556c6339dce0a8057f02c601b8804eaea31;hpb=7388be593836a09b38cb6ed2331b3aca0974432e;p=modules%2Fshaper.git diff --git a/src/Model/Model_ResultCompSolid.cpp b/src/Model/Model_ResultCompSolid.cpp index 5cb50556c..c613cd29f 100755 --- a/src/Model/Model_ResultCompSolid.cpp +++ b/src/Model/Model_ResultCompSolid.cpp @@ -6,96 +6,219 @@ #include -#include +#include +#include +#include +#include #include +#include +#include -#include +#include +#include -#include Model_ResultCompSolid::Model_ResultCompSolid() { myBuilder = new Model_BodyBuilder(this); + myLastConcealed = false; + updateSubs(shape()); // in case of open, etc. } Model_ResultCompSolid::~Model_ResultCompSolid() { + updateSubs(std::shared_ptr()); // erase sub-results } -void Model_ResultCompSolid::initAttributes() +void Model_ResultCompSolid::store(const std::shared_ptr& theShape, + const bool theIsStoreSameShapes) { - data()->addAttribute(Model_ResultCompSolid::BODIES_ID(), ModelAPI_AttributeRefList::typeId()); + ModelAPI_ResultCompSolid::store(theShape, theIsStoreSameShapes); + updateSubs(theShape); } -std::shared_ptr Model_ResultCompSolid::addResult(const int theIndex) +void Model_ResultCompSolid::storeGenerated(const std::shared_ptr& theFromShape, + const std::shared_ptr& theToShape) { - std::shared_ptr aBody = document()->createBody(data(), theIndex); - if (aBody.get()) { - data()->reflist(Model_ResultCompSolid::BODIES_ID())->append(aBody); - } - return aBody; + ModelAPI_ResultCompSolid::storeGenerated(theFromShape, theToShape); + updateSubs(theToShape); +} + +void Model_ResultCompSolid::storeModified(const std::shared_ptr& theOldShape, + const std::shared_ptr& theNewShape, const int theDecomposeSolidsTag) +{ + ModelAPI_ResultCompSolid::storeModified(theOldShape, theNewShape, theDecomposeSolidsTag); + updateSubs(theNewShape); } int Model_ResultCompSolid::numberOfSubs(bool forTree) const { - if (forTree) - return 0; - return data()->reflist(Model_ResultCompSolid::BODIES_ID())->size(); + return int(mySubs.size()); } std::shared_ptr Model_ResultCompSolid::subResult(const int theIndex, bool forTree) const { - if (forTree) { - std::shared_ptr aBody; - return aBody; + return mySubs.at(theIndex); +} + +bool Model_ResultCompSolid::isSub(ObjectPtr theObject) const +{ + std::vector >::const_iterator aSubIter = mySubs.cbegin(); + for(; aSubIter != mySubs.cend(); aSubIter++) + if (*aSubIter == theObject) + return true; + return false; +} + +void Model_ResultCompSolid::colorConfigInfo(std::string& theSection, std::string& theName, + std::string& theDefault) +{ + theSection = "Visualization"; + theName = "result_body_color"; + theDefault = DEFAULT_COLOR(); +} + +bool Model_ResultCompSolid::setDisabled(std::shared_ptr 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; +} - ObjectPtr anObj = data()->reflist(Model_ResultCompSolid::BODIES_ID())->object(theIndex); - return std::dynamic_pointer_cast(anObj); +bool Model_ResultCompSolid::isConcealed() +{ + bool aResult = false;; + if (ModelAPI_ResultCompSolid::isConcealed()) { + aResult = true; + } else { + std::vector >::const_iterator aSubIter = mySubs.cbegin(); + for(; aSubIter != mySubs.cend(); aSubIter++) { + if ((*aSubIter)->ModelAPI_ResultBody::isConcealed()) { + aResult = true; + break; + } + } + } + if (myLastConcealed != aResult) { + myLastConcealed = aResult; + //setIsConcealed(aResult); // set for all subs the same result + std::vector >::const_iterator aSubIter = mySubs.cbegin(); + for(; aSubIter != mySubs.cend(); aSubIter++) { // update the visualization status of each sub + if ((*aSubIter)->ModelAPI_ResultBody::isConcealed() != aResult) { + if (aResult) { // 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); + } + } + } + // update the display state of the subs: explicitly call Model_ResultBody::isConcealed + for(aSubIter = mySubs.cbegin(); aSubIter != mySubs.cend(); aSubIter++) { + (*aSubIter)->isConcealed(); + } + } + return aResult; } -/*int Model_ResultCompSolid::subResultId(const int theIndex) const +void Model_ResultCompSolid::setIsConcealed(const bool theValue) { - return subResult(theIndex)->data()->featureId(); -}*/ + if (theValue != ModelAPI_ResultCompSolid::isConcealed()) { + std::vector >::const_iterator aSubIter = mySubs.cbegin(); + for(; aSubIter != mySubs.cend(); aSubIter++) { + if ((*aSubIter)->ModelAPI_ResultBody::isConcealed() != 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); + } + } + } + ModelAPI_ResultCompSolid::setIsConcealed(theValue); + // to set correct myLastConcealed + isConcealed(); + } + //myLastConcealed = theValue; +} -bool Model_ResultCompSolid::isSub(ObjectPtr theObject) const +void Model_ResultCompSolid::updateSubs(const std::shared_ptr& theThisShape) { - // check is this feature of result - ResultBodyPtr aResult = std::dynamic_pointer_cast(theObject); - /*if (!aFeature) { - ResultPtr aRes = std::dynamic_pointer_cast(theObject); - if (aRes) - aFeature = document()->feature(aRes); - }*/ - if (aResult) { - return data()->reflist(Model_ResultCompSolid::BODIES_ID())->isInList(aResult); + 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(); + if (!aThisShape.IsNull() && (aThisShape.ShapeType() == TopAbs_COMPSOLID || + aThisShape.ShapeType() == TopAbs_COMPOUND)) { + bool aWasEmpty = mySubs.empty(); + Model_Objects* anObjects = std::dynamic_pointer_cast(document())->objects(); + unsigned int aSubIndex = 0; + TopoDS_Iterator aShapesIter(aThisShape); + for(; aShapesIter.More(); aShapesIter.Next(), aSubIndex++) { + std::shared_ptr aShape(new GeomAPI_Shape); + aShape->setImpl(new TopoDS_Shape(aShapesIter.Value())); + 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 (!aShape->isEqual(aSub->shape())) { + aSub->store(aShape, false); + 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); } - return false; } -void Model_ResultCompSolid::removeResult(std::shared_ptr theResult) +bool Model_ResultCompSolid::isLatestEqual(const std::shared_ptr& theShape) { - if (!data()->isValid()) // sketch is already removed (case on undo of sketch), sync is not needed - return; - - std::list aSubs = data()->reflist(Model_ResultCompSolid::BODIES_ID())->list(); - - std::list::iterator aSubIt = aSubs.begin(), aLastIt = aSubs.end(); - bool isRemoved = false; - bool aHasEmtpyResult = false; - for(; aSubIt != aLastIt && !isRemoved; aSubIt++) { - std::shared_ptr aResult = std::dynamic_pointer_cast(*aSubIt); - if (aResult.get() != NULL && aResult == theResult) { - data()->reflist(Model_ResultCompSolid::BODIES_ID())->remove(aResult); - isRemoved = true; + if (myBuilder->isLatestEqual(theShape)) + return true; + // also check that it is asked for sub-elements + std::vector >::const_iterator aSubIter = mySubs.cbegin(); + for(; aSubIter != mySubs.cend(); aSubIter++) { + if (aSubIter->get() && (*aSubIter)->isLatestEqual(theShape)) { + return true; } - else if (aResult.get() == NULL) - aHasEmtpyResult = true; } - // if the object is not found in the sketch sub-elements, that means that the object is removed already. - // Find the first empty element and remove it - if (!isRemoved && aHasEmtpyResult) - data()->reflist(Model_ResultCompSolid::BODIES_ID())->remove(ObjectPtr()); + return false; }