X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Document.cpp;h=4ff65b48c699da6b4d07e62764f267cd22fdebf1;hb=77b93142eb8ba33bfb9a42040c2fd8926ffea5c8;hp=3f1ae6a4d2da036ba6fbc0bab291a725b8fdfcfb;hpb=a3ee4e38876c359fdf737179605db194bca4ecbb;p=modules%2Fshaper.git diff --git a/src/Model/Model_Document.cpp b/src/Model/Model_Document.cpp index 3f1ae6a4d..4ff65b48c 100644 --- a/src/Model/Model_Document.cpp +++ b/src/Model/Model_Document.cpp @@ -13,6 +13,8 @@ #include #include #include +#include +#include #include #include @@ -26,8 +28,13 @@ #include #include #include +#include #include #include +#include +#include +#include +#include #include #ifndef WIN32 @@ -46,9 +53,11 @@ static const int TAG_GENERAL = 1; // general properties tag // general sub-labels static const int TAG_CURRENT_FEATURE = 1; ///< where the reference to the current feature label is located (or no attribute if null feature) +static const int TAG_CURRENT_TRANSACTION = 2; ///< integer, index of the cransaction +static const int TAG_SELECTION_FEATURE = 3; ///< integer, tag of the selection feature label Model_Document::Model_Document(const std::string theID, const std::string theKind) - : myID(theID), myKind(theKind), + : myID(theID), myKind(theKind), myIsActive(false), myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format { myObjs = new Model_Objects(myDoc->Main()); @@ -59,6 +68,8 @@ Model_Document::Model_Document(const std::string theID, const std::string theKin // in transaction for nesting correct working myDoc->NewCommand(); TDataStd_Integer::Set(myDoc->Main().Father(), 0); + // this to avoid creation of integer attribute outside the transaction after undo + transactionID(); myDoc->CommitCommand(); } @@ -94,8 +105,9 @@ bool Model_Document::load(const char* theFileName, DocumentPtr theThis) } TCollection_ExtendedString aPath(DocFileName(theFileName, myID)); PCDM_ReaderStatus aStatus = (PCDM_ReaderStatus) -1; + Handle(TDocStd_Document) aLoaded; try { - aStatus = anApp->Open(aPath, myDoc); + aStatus = anApp->Open(aPath, aLoaded); } catch (Standard_Failure) { Handle(Standard_Failure) aFail = Standard_Failure::Caught(); Events_Error::send( @@ -157,6 +169,7 @@ bool Model_Document::load(const char* theFileName, DocumentPtr theThis) } } if (!isError) { + myDoc = aLoaded; myDoc->SetUndoLimit(UNDO_LIMIT); // to avoid the problem that feature is created in the current, not this, document std::shared_ptr aSession = @@ -171,8 +184,15 @@ bool Model_Document::load(const char* theFileName, DocumentPtr theThis) setCurrentFeature(currentFeature(false), false); aSession->setCheckTransactions(true); aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); - aSession->setActiveDocument(anApp->getDocument(myID), true); - } + // this is done in Part result "activate", so no needed here. Causes not-blue active part. + // aSession->setActiveDocument(anApp->getDocument(myID), true); + } else { // open failed, but new documnet was created to work with it: inform the model + static std::shared_ptr aMsg( + new Events_Message(Events_Loop::eventByName(EVENT_DOCUMENT_CHANGED))); + Events_Loop::loop()->send(aMsg); + TDF_LabelList anEmpty; + myObjs->synchronizeFeatures(anEmpty, true, true); + } return !isError; } @@ -257,18 +277,23 @@ void Model_Document::close(const bool theForever) // close all subs const std::set aSubs = subDocuments(true); std::set::iterator aSubIter = aSubs.begin(); - for (; aSubIter != aSubs.end(); aSubIter++) - subDoc(*aSubIter)->close(theForever); + for (; aSubIter != aSubs.end(); aSubIter++) { + std::shared_ptr aSub = subDoc(*aSubIter); + if (aSub->myObjs) // if it was not closed before + aSub->close(theForever); + } // close for thid document needs no transaction in this document std::static_pointer_cast(Model_Session::get())->setCheckTransactions(false); // close all only if it is really asked, otherwise it can be undoed/redoed if (theForever) { + // flush everything to avoid messages with bad objects delete myObjs; myObjs = 0; if (myDoc->CanClose() == CDM_CCS_OK) myDoc->Close(); + mySelectionFeature.reset(); } else { setCurrentFeature(FeaturePtr(), false); // disables all features } @@ -288,6 +313,7 @@ void Model_Document::startOperation() myDoc->NewCommand(); } // starts a new operation + incrementTransactionID(); myTransactions.push_back(Transaction()); if (!myNestedNum.empty()) (*myNestedNum.rbegin())++; @@ -324,7 +350,6 @@ bool Model_Document::finishOperation() aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY)); - aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TOHIDE)); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED)); // this must be here just after everything is finished but before real transaction stop // to avoid messages about modifications outside of the transaction @@ -374,10 +399,41 @@ bool Model_Document::finishOperation() return aResult; } +/// Returns in theDelta labels that has been modified in the latest transaction of theDoc +static void modifiedLabels(const Handle(TDocStd_Document)& theDoc, TDF_LabelList& theDelta, + const bool isRedo = false) { + Handle(TDF_Delta) aDelta; + if (isRedo) + aDelta = theDoc->GetRedos().First(); + else + aDelta = theDoc->GetUndos().Last(); + TDF_LabelList aDeltaList; + aDelta->Labels(aDeltaList); // it clears list, so, use new one and then append to the result + for(TDF_ListIteratorOfLabelList aListIter(aDeltaList); aListIter.More(); aListIter.Next()) { + theDelta.Append(aListIter.Value()); + } + // add also label of the modified attributes + const TDF_AttributeDeltaList& anAttrs = aDelta->AttributeDeltas(); + for (TDF_ListIteratorOfAttributeDeltaList anAttr(anAttrs); anAttr.More(); anAttr.Next()) { + theDelta.Append(anAttr.Value()->Label()); + } +} + void Model_Document::abortOperation() { + TDF_LabelList aDeltaLabels; // labels that are updated during "abort" if (!myNestedNum.empty() && !myDoc->HasOpenCommand()) { // abort all what was done in nested compactNested(); + // store undo-delta here as undo actually does in the method later + int a, aNumTransactions = myTransactions.rbegin()->myOCAFNum; + for(a = 0; a < aNumTransactions; a++) { + modifiedLabels(myDoc, aDeltaLabels); + myDoc->Undo(); + } + for(a = 0; a < aNumTransactions; a++) { + myDoc->Redo(); + } + undoInternal(false, false); myDoc->ClearRedos(); myRedos.clear(); @@ -387,9 +443,16 @@ void Model_Document::abortOperation() if (!myNestedNum.empty()) (*myNestedNum.rbegin())--; // roll back the needed number of transactions - myDoc->AbortCommand(); - for(int a = 0; a < aNumTransactions; a++) + // make commit/undo to get the modification delta + //myDoc->AbortCommand(); + if (myDoc->CommitCommand()) { + modifiedLabels(myDoc, aDeltaLabels); myDoc->Undo(); + } + for(int a = 0; a < aNumTransactions; a++) { + modifiedLabels(myDoc, aDeltaLabels); + myDoc->Undo(); + } myDoc->ClearRedos(); } // abort for all subs, flushes will be later, in the end of root abort @@ -398,7 +461,7 @@ void Model_Document::abortOperation() for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->abortOperation(); // references may be changed because they are set in attributes on the fly - myObjs->synchronizeFeatures(true, true, isRoot()); + myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot()); } bool Model_Document::isOperation() const @@ -424,9 +487,14 @@ bool Model_Document::canUndo() // check other subs contains operation that can be undoed const std::set aSubs = subDocuments(true); std::set::iterator aSubIter = aSubs.begin(); - for (; aSubIter != aSubs.end(); aSubIter++) - if (subDoc(*aSubIter)->canUndo()) - return true; + for (; aSubIter != aSubs.end(); aSubIter++) { + std::shared_ptr aSub = subDoc(*aSubIter); + if (aSub->myObjs) {// if it was not closed before + if (aSub->canUndo()) + return true; + } + } + return false; } @@ -438,21 +506,28 @@ void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchron if (!myNestedNum.empty()) (*myNestedNum.rbegin())--; // roll back the needed number of transactions - for(int a = 0; a < aNumTransactions; a++) + TDF_LabelList aDeltaLabels; + for(int a = 0; a < aNumTransactions; a++) { + if (theSynchronize) + modifiedLabels(myDoc, aDeltaLabels); myDoc->Undo(); + } if (theWithSubs) { // undo for all subs const std::set aSubs = subDocuments(true); std::set::iterator aSubIter = aSubs.begin(); - for (; aSubIter != aSubs.end(); aSubIter++) + for (; aSubIter != aSubs.end(); aSubIter++) { + if (!subDoc(*aSubIter)->myObjs) + continue; subDoc(*aSubIter)->undoInternal(theWithSubs, theSynchronize); + } } - // after redo of all sub-documents to avoid updates on not-modified data (issue 370) + // after undo of all sub-documents to avoid updates on not-modified data (issue 370) if (theSynchronize) { + myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot()); // update the current features status setCurrentFeature(currentFeature(false), false); - myObjs->synchronizeFeatures(true, true, isRoot()); } } @@ -468,9 +543,12 @@ bool Model_Document::canRedo() // check other subs contains operation that can be redoed const std::set aSubs = subDocuments(true); std::set::iterator aSubIter = aSubs.begin(); - for (; aSubIter != aSubs.end(); aSubIter++) + for (; aSubIter != aSubs.end(); aSubIter++) { + if (!subDoc(*aSubIter)->myObjs) + continue; if (subDoc(*aSubIter)->canRedo()) return true; + } return false; } @@ -481,8 +559,11 @@ void Model_Document::redo() int aNumRedos = myRedos.rbegin()->myOCAFNum; myTransactions.push_back(*myRedos.rbegin()); myRedos.pop_back(); - for(int a = 0; a < aNumRedos; a++) + TDF_LabelList aDeltaLabels; + for(int a = 0; a < aNumRedos; a++) { + modifiedLabels(myDoc, aDeltaLabels, true); myDoc->Redo(); + } // redo for all subs const std::set aSubs = subDocuments(true); @@ -490,10 +571,10 @@ void Model_Document::redo() for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->redo(); + // after redo of all sub-documents to avoid updates on not-modified data (issue 370) + myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot()); // update the current features status setCurrentFeature(currentFeature(false), false); - // after redo of all sub-documents to avoid updates on not-modified data (issue 370) - myObjs->synchronizeFeatures(true, true, isRoot()); } std::list Model_Document::undoList() const @@ -527,13 +608,14 @@ void Model_Document::operationId(const std::string& theId) myTransactions.rbegin()->myId = theId; } -FeaturePtr Model_Document::addFeature(std::string theID) +FeaturePtr Model_Document::addFeature(std::string theID, const bool theMakeCurrent) { std::shared_ptr aSession = std::dynamic_pointer_cast(ModelAPI_Session::get()); FeaturePtr aFeature = aSession->createFeature(theID, this); if (!aFeature) return aFeature; + aFeature->init(); Model_Document* aDocToAdd; if (!aFeature->documentToAdd().empty()) { // use the customized document to add if (aFeature->documentToAdd() != kind()) { // the root document by default @@ -545,9 +627,27 @@ FeaturePtr Model_Document::addFeature(std::string theID) aDocToAdd = this; } if (aFeature) { - aDocToAdd->myObjs->addFeature(aFeature, currentFeature(false)); + // searching for feature after which must be added the next feature: this is the current feature + // but also all sub-features of this feature + FeaturePtr aCurrent = aDocToAdd->currentFeature(false); + bool isModified = true; + for(CompositeFeaturePtr aComp = std::dynamic_pointer_cast(aCurrent); + aComp.get() && isModified; + aComp = std::dynamic_pointer_cast(aCurrent)) { + isModified = false; + int aSubs = aComp->numberOfSubs(false); + for(int a = 0; a < aSubs; a++) { + FeaturePtr aSub = aComp->subFeature(a, false); + if (myObjs->isLater(aSub, aCurrent)) { + isModified = true; + aCurrent = aSub; + } + } + } + aDocToAdd->myObjs->addFeature(aFeature, aCurrent); if (!aFeature->isAction()) { // do not add action to the data model - setCurrentFeature(aFeature, false); // after all this feature stays in the document, so make it current + if (theMakeCurrent) // after all this feature stays in the document, so make it current + aDocToAdd->setCurrentFeature(aFeature, false); } else { // feature must be executed // no creation event => updater not working, problem with remove part aFeature->execute(); @@ -565,17 +665,16 @@ void Model_Document::refsToFeature(FeaturePtr theFeature, void Model_Document::removeFeature(FeaturePtr theFeature) { - // if this feature is current, make the current the previous feature - if (theFeature == currentFeature(false)) { - int aCurrentIndex = index(theFeature); - if (aCurrentIndex != -1) { - setCurrentFeature(std::dynamic_pointer_cast( - object(ModelAPI_Feature::group(), aCurrentIndex - 1)), false); - } - } myObjs->removeFeature(theFeature); } +void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) +{ + myObjs->moveFeature(theMoved, theAfterThis); + if (theAfterThis == currentFeature(true)) + setCurrentFeature(theMoved, true); +} + void Model_Document::updateHistory(const std::shared_ptr theObject) { myObjs->updateHistory(theObject); @@ -599,8 +698,9 @@ const std::set Model_Document::subDocuments(const bool theActivated std::list::iterator aPartRes = aPartResults.begin(); for(; aPartRes != aPartResults.end(); aPartRes++) { ResultPartPtr aPart = std::dynamic_pointer_cast(*aPartRes); - if (aPart && (!theActivatedOnly || aPart->isActivated())) - aResult.insert(aPart->data()->name()); + if (aPart && (!theActivatedOnly || aPart->isActivated())) { + aResult.insert(aPart->original()->data()->name()); + } } return aResult; } @@ -635,13 +735,16 @@ int Model_Document::size(const std::string& theGroupID) std::shared_ptr Model_Document::currentFeature(const bool theVisible) { + if (!myObjs) // on close document feature destruction it may call this method + return std::shared_ptr(); TDF_Label aRefLab = generalLabel().FindChild(TAG_CURRENT_FEATURE); Handle(TDF_Reference) aRef; if (aRefLab.FindAttribute(TDF_Reference::GetID(), aRef)) { TDF_Label aLab = aRef->Get(); FeaturePtr aResult = myObjs->feature(aLab); if (theVisible) { // get nearest visible (in history) going up - while(aResult.get() && !aResult->isInHistory()) { + while(aResult.get() && // sub-composites are never in history + (!aResult->isInHistory() || ModelAPI_Tools::compositeOwner(aResult).get())) { aResult = myObjs->nextFeature(aResult, true); } } @@ -651,34 +754,49 @@ std::shared_ptr Model_Document::currentFeature(const bool theV } void Model_Document::setCurrentFeature(std::shared_ptr theCurrent, - const bool theVisible) + const bool theVisible, const bool theFlushUpdates) { + // blocks the flush signals to avoid each objects visualization in the viewer + // they should not be shown once after all modifications are performed + Events_Loop* aLoop = Events_Loop::loop(); + bool isActive = aLoop->activateFlushes(false); + TDF_Label aRefLab = generalLabel().FindChild(TAG_CURRENT_FEATURE); + CompositeFeaturePtr aMain; // main feature that may nest the new current if (theCurrent.get()) { - /* - if (theVisible) { // make features below which are not in history also enabled: sketch subs - FeaturePtr aNext = myObjs->nextFeature(theCurrent); - for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent)) { - if (aNext->isInHistory()) { - break; // next in history is not needed - } else { // next not in history is good for making current - theCurrent = aNext; + aMain = std::dynamic_pointer_cast(theCurrent); + if (!aMain.get()) { + // if feature nests into compisite feature, make the composite feature as current + const std::set& aRefsToMe = theCurrent->data()->refsToMe(); + std::set::const_iterator aRefToMe = aRefsToMe.begin(); + for(; aRefToMe != aRefsToMe.end(); aRefToMe++) { + CompositeFeaturePtr aComposite = + std::dynamic_pointer_cast((*aRefToMe)->owner()); + if (aComposite.get() && aComposite->isSub(theCurrent)) { + aMain = aComposite; + break; } } - }*/ - // if feature nests into compisite feature, make the composite feature as current - const std::set& aRefsToMe = theCurrent->data()->refsToMe(); - std::set::const_iterator aRefToMe = aRefsToMe.begin(); - for(; aRefToMe != aRefsToMe.end(); aRefToMe++) { - CompositeFeaturePtr aComposite = - std::dynamic_pointer_cast((*aRefToMe)->owner()); - if (aComposite.get() && aComposite->isSub(theCurrent)) { - theCurrent = aComposite; - } } + } + if (theVisible) { // make features below which are not in history also enabled: sketch subs + FeaturePtr aNext = + theCurrent.get() ? myObjs->nextFeature(theCurrent) : myObjs->firstFeature(); + for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent)) { + if (aNext->isInHistory()) { + break; // next in history is not needed + } else { // next not in history is good for making current + theCurrent = aNext; + } + } + } + if (theCurrent.get()) { std::shared_ptr aData = std::static_pointer_cast(theCurrent->data()); - if (!aData.get()) return; // unknown case + if (!aData.get() || !aData->isValid()) { + aLoop->activateFlushes(isActive); + return; + } TDF_Label aFeatureLabel = aData->label().Father(); Handle(TDF_Reference) aRef; @@ -691,31 +809,63 @@ void Model_Document::setCurrentFeature(std::shared_ptr theCurr aRefLab.ForgetAttribute(TDF_Reference::GetID()); } // make all features after this feature disabled in reversed order (to remove results without deps) - static Events_Loop* aLoop = Events_Loop::loop(); static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - - // if the current feature is composite features, all sub-features also must be enabled - CompositeFeaturePtr aCurComp = std::dynamic_pointer_cast(theCurrent); - + static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); + static Events_ID aDeleteEvent = aLoop->eventByName(EVENT_OBJECT_DELETED); bool aPassed = false; // flag that the current object is already passed in cycle FeaturePtr anIter = myObjs->lastFeature(); + bool aWasChanged = false; for(; anIter.get(); anIter = myObjs->nextFeature(anIter, true)) { // check this before passed become enabled: the current feature is enabled! if (anIter == theCurrent) aPassed = true; bool aDisabledFlag = !aPassed; - if (aCurComp.get() && aCurComp->isSub(anIter)) + if (aMain.get() && aMain->isSub(anIter)) // sub-elements of not-disabled feature are not disabled aDisabledFlag = false; + if (anIter->getKind() == "Parameter") {// parameters are always out of the history of features, but not parameters + if (theCurrent.get() && theCurrent->getKind() != "Parameter") + aDisabledFlag = false; + } if (anIter->setDisabled(aDisabledFlag)) { // state of feature is changed => so feature become updated static Events_ID anUpdateEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED); ModelAPI_EventCreator::get()->sendUpdated(anIter, anUpdateEvent); // flush is in the end of this method ModelAPI_EventCreator::get()->sendUpdated(anIter, aRedispEvent /*, false*/); + aWasChanged = true; + } + // update for everyone the concealment flag immideately: on edit feature in the midle of history + if (aWasChanged) { + const std::list >& aResList = anIter->results(); + std::list >::const_iterator aRes = aResList.begin(); + for(; aRes != aResList.end(); aRes++) { + if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled()) + std::dynamic_pointer_cast((*aRes)->data())->updateConcealmentFlag(); + } + } } - aLoop->flush(aRedispEvent); + // unblock the flush signals and up them after this + aLoop->activateFlushes(isActive); + + if (theFlushUpdates) { + aLoop->flush(aCreateEvent); + aLoop->flush(aRedispEvent); + aLoop->flush(aDeleteEvent); + } +} + +void Model_Document::setCurrentFeatureUp() +{ + // on remove just go up for minimum step: highlight external objects in sketch causes + // problems if it is true: here and in "setCurrentFeature" + FeaturePtr aCurrent = currentFeature(false); + if (aCurrent.get()) { // if not, do nothing because null is the upper + FeaturePtr aPrev = myObjs->nextFeature(aCurrent, true); + // do not flush: it is called only on remove, it will be flushed in the end of transaction + setCurrentFeature(aPrev, false, false); + } } TDF_Label Model_Document::generalLabel() const @@ -741,6 +891,13 @@ std::shared_ptr Model_Document::createPart( return myObjs->createPart(theFeatureData, theIndex); } +std::shared_ptr Model_Document::copyPart( + const std::shared_ptr& theOrigin, + const std::shared_ptr& theFeatureData, const int theIndex) +{ + return myObjs->copyPart(theOrigin, theFeatureData, theIndex); +} + std::shared_ptr Model_Document::createGroup( const std::shared_ptr& theFeatureData, const int theIndex) { @@ -756,12 +913,7 @@ std::shared_ptr Model_Document::createParameter( std::shared_ptr Model_Document::feature( const std::shared_ptr& theResult) { - std::shared_ptr aData = std::dynamic_pointer_cast(theResult->data()); - if (aData) { - TDF_Label aFeatureLab = aData->label().Father().Father().Father(); - return myObjs->feature(aFeatureLab); - } - return FeaturePtr(); + return myObjs->feature(theResult); } Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper) @@ -791,3 +943,140 @@ ResultPtr Model_Document::findByName(const std::string theName) { return myObjs->findByName(theName); } + +std::list > Model_Document::allFeatures() +{ + return myObjs->allFeatures(); +} + +void Model_Document::setActive(const bool theFlag) +{ + if (theFlag != myIsActive) { + myIsActive = theFlag; + // redisplay all the objects of this part + static Events_Loop* aLoop = Events_Loop::loop(); + static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + + for(int a = size(ModelAPI_Feature::group()) - 1; a >= 0; a--) { + FeaturePtr aFeature = std::dynamic_pointer_cast( + object(ModelAPI_Feature::group(), a)); + if (aFeature.get() && aFeature->data()->isValid()) { + const std::list >& aResList = aFeature->results(); + std::list >::const_iterator aRes = aResList.begin(); + for(; aRes != aResList.end(); aRes++) { + ModelAPI_EventCreator::get()->sendUpdated(*aRes, aRedispEvent); + } + } + } + } +} + +bool Model_Document::isActive() const +{ + return myIsActive; +} + +int Model_Document::transactionID() +{ + Handle(TDataStd_Integer) anIndex; + if (!generalLabel().FindChild(TAG_CURRENT_TRANSACTION). + FindAttribute(TDataStd_Integer::GetID(), anIndex)) { + anIndex = TDataStd_Integer::Set(generalLabel().FindChild(TAG_CURRENT_TRANSACTION), 1); + } + return anIndex->Get(); +} + +void Model_Document::incrementTransactionID() +{ + int aNewVal = transactionID() + 1; + TDataStd_Integer::Set(generalLabel().FindChild(TAG_CURRENT_TRANSACTION), aNewVal); +} +void Model_Document::decrementTransactionID() +{ + int aNewVal = transactionID() - 1; + TDataStd_Integer::Set(generalLabel().FindChild(TAG_CURRENT_TRANSACTION), aNewVal); +} + +bool Model_Document::isOpened() +{ + return myObjs && !myDoc.IsNull(); +} + +int Model_Document::numInternalFeatures() +{ + return myObjs->numInternalFeatures(); +} + +std::shared_ptr Model_Document::internalFeature(const int theIndex) +{ + return myObjs->internalFeature(theIndex); +} + +void Model_Document::synchronizeTransactions() +{ + Model_Document* aRoot = + std::dynamic_pointer_cast(ModelAPI_Session::get()->moduleDocument()).get(); + if (aRoot == this) + return; // don't need to synchronise root with root + + std::shared_ptr aSession = + std::dynamic_pointer_cast(Model_Session::get()); + while(myRedos.size() > aRoot->myRedos.size()) { // remove redos in this + aSession->setCheckTransactions(false); + redo(); + aSession->setCheckTransactions(true); + } + /* this case can not be reproduced in any known case for the current moment, so, just comment + while(myRedos.size() < aRoot->myRedos.size()) { // add more redos in this + undoInternal(false, true); + }*/ +} + +/// Feature that is used for selection in the Part document by the external request +class Model_SelectionInPartFeature : public ModelAPI_Feature { +public: + /// Nothing to do in constructor + Model_SelectionInPartFeature() : ModelAPI_Feature() {} + + /// Returns the unique kind of a feature + virtual const std::string& getKind() { + static std::string MY_KIND("InternalSelectionInPartFeature"); + return MY_KIND; + } + /// Request for initialization of data model of the object: adding all attributes + virtual void initAttributes() { + data()->addAttribute("selection", ModelAPI_AttributeSelectionList::typeId()); + } + /// Nothing to do in the execution function + virtual void execute() {} + +}; + +//! Returns the feature that is used for calculation of selection externally from the document +AttributeSelectionListPtr Model_Document::selectionInPartFeature() +{ + // return already created, otherwise create + if (!mySelectionFeature.get() || !mySelectionFeature->data()->isValid()) { + // create a new one + mySelectionFeature = FeaturePtr(new Model_SelectionInPartFeature); + + TDF_Label aFeatureLab = generalLabel().FindChild(TAG_SELECTION_FEATURE); + std::shared_ptr aData(new Model_Data); + aData->setLabel(aFeatureLab.FindChild(1)); + aData->setObject(mySelectionFeature); + mySelectionFeature->setDoc(myObjs->owner()); + mySelectionFeature->setData(aData); + std::string aName = id() + "_Part"; + mySelectionFeature->data()->setName(aName); + mySelectionFeature->setDoc(myObjs->owner()); + mySelectionFeature->initAttributes(); + } + return mySelectionFeature->selectionList("selection"); +} + +FeaturePtr Model_Document::lastFeature() +{ + if (myObjs) + return myObjs->lastFeature(); + return FeaturePtr(); +}