#include <Model_Document.h>
#include <Model_Data.h>
+#include <Model_Objects.h>
#include <Model_Application.h>
#include <Model_Session.h>
#include <Model_Events.h>
-#include <Model_ResultPart.h>
-#include <Model_ResultConstruction.h>
-#include <Model_ResultBody.h>
-#include <Model_ResultGroup.h>
-#include <Model_ResultParameter.h>
+#include <ModelAPI_ResultPart.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_CompositeFeature.h>
+#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_Tools.h>
#include <Events_Loop.h>
#include <Events_Error.h>
#include <TDataStd_Comment.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDataStd_ReferenceArray.hxx>
+#include <TDataStd_ReferenceList.hxx>
+#include <TDataStd_IntegerArray.hxx>
#include <TDataStd_HLabelArray1.hxx>
#include <TDataStd_Name.hxx>
+#include <TDataStd_AsciiString.hxx>
#include <TDF_Reference.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_LabelMapHasher.hxx>
+#include <TDF_Delta.hxx>
#include <OSD_File.hxx>
#include <OSD_Path.hxx>
+#include <TDF_AttributeDelta.hxx>
+#include <TDF_AttributeDeltaList.hxx>
+#include <TDF_ListIteratorOfAttributeDeltaList.hxx>
+#include <TDF_ListIteratorOfLabelList.hxx>
#include <climits>
#ifndef WIN32
static const int UNDO_LIMIT = 1000; // number of possible undo operations (big for sketcher)
static const int TAG_GENERAL = 1; // general properties tag
-static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features, results)
-static const int TAG_HISTORY = 3; // tag of the history sub-tree (python dump)
// 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 transaction
+static const int TAG_SELECTION_FEATURE = 3; ///< integer, tag of the selection feature label
-// feature sub-labels
-static const int TAG_FEATURE_ARGUMENTS = 1; ///< where the arguments are located
-static const int TAG_FEATURE_RESULTS = 2; ///< where the results are located
-
-///
-/// 0:1:2 - where features are located
-/// 0:1:2:N:1 - data of the feature N
-/// 0:1:2:N:2:K:1 - data of the K result of the feature N
-
-Model_Document::Model_Document(const std::string theID, const std::string theKind)
- : myID(theID), myKind(theKind),
+Model_Document::Model_Document(const int theID, const std::string theKind)
+ : myID(theID), myKind(theKind), myIsActive(false),
myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format
{
+ myObjs = new Model_Objects(myDoc->Main());
myDoc->SetUndoLimit(UNDO_LIMIT);
myTransactionSave = 0;
myExecuteFeatures = true;
// 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();
}
-/// Returns the file name of this document by the nameof directory and identifuer of a document
-static TCollection_ExtendedString DocFileName(const char* theFileName, const std::string& theID)
+void Model_Document::setThis(DocumentPtr theDoc)
+{
+ myObjs->setOwner(theDoc);
+}
+
+/// Returns the file name of this document by the name of directory and identifier of a document
+static TCollection_ExtendedString DocFileName(const char* theDirName, const std::string& theID)
{
- TCollection_ExtendedString aPath((const Standard_CString) theFileName);
+ TCollection_ExtendedString aPath((const Standard_CString) theDirName);
// remove end-separators
while(aPath.Length() &&
(aPath.Value(aPath.Length()) == '\\' || aPath.Value(aPath.Length()) == '/'))
return this == Model_Session::get()->moduleDocument().get();
}
-bool Model_Document::load(const char* theFileName)
+bool Model_Document::load(const char* theDirName, const char* theFileName, DocumentPtr theThis)
{
Handle(Model_Application) anApp = Model_Application::getApplication();
if (isRoot()) {
- anApp->setLoadPath(theFileName);
+ anApp->setLoadPath(theDirName);
}
- TCollection_ExtendedString aPath(DocFileName(theFileName, myID));
+ TCollection_ExtendedString aPath(DocFileName(theDirName, theFileName));
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(
break;
}
}
+ std::shared_ptr<Model_Session> aSession =
+ std::dynamic_pointer_cast<Model_Session>(Model_Session::get());
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<Model_Session> aSession =
- std::dynamic_pointer_cast<Model_Session>(Model_Session::get());
- aSession->setActiveDocument(anApp->getDocument(myID), false);
+ aSession->setActiveDocument(anApp->document(myID), false);
aSession->setCheckTransactions(false);
- synchronizeFeatures(false, true, true);
+ if (myObjs)
+ delete myObjs;
+ myObjs = new Model_Objects(myDoc->Main()); // synchronisation is inside
+ myObjs->setOwner(theThis);
+ // update the current features status
+ 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);
+
+ // make sub-parts as loaded by demand
+ std::list<ResultPtr> aPartResults;
+ myObjs->allResults(ModelAPI_ResultPart::group(), aPartResults);
+ std::list<ResultPtr>::iterator aPartRes = aPartResults.begin();
+ for(; aPartRes != aPartResults.end(); aPartRes++) {
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aPartRes);
+ if (aPart.get())
+ anApp->setLoadByDemand(aPart->data()->name());
+ }
+
+ } else { // open failed, but new documnet was created to work with it: inform the model
+ aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false);
+ }
return !isError;
}
-bool Model_Document::save(const char* theFileName, std::list<std::string>& theResults)
+bool Model_Document::save(
+ const char* theDirName, const char* theFileName, std::list<std::string>& theResults)
{
// create a directory in the root document if it is not yet exist
Handle(Model_Application) anApp = Model_Application::getApplication();
#endif
}
// filename in the dir is id of document inside of the given directory
- TCollection_ExtendedString aPath(DocFileName(theFileName, myID));
+ TCollection_ExtendedString aPath(DocFileName(theDirName, theFileName));
PCDM_StoreStatus aStatus;
try {
aStatus = anApp->SaveAs(myDoc, aPath);
break;
}
}
- myTransactionSave = myTransactions.size();
+ myTransactionSave = int(myTransactions.size());
if (isDone) { // save also sub-documents if any
theResults.push_back(TCollection_AsciiString(aPath).ToCString());
- const std::set<std::string> aSubs = subDocuments(false);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
- for (; aSubIter != aSubs.end() && isDone; aSubIter++) {
- if (anApp->isLoadByDemand(*aSubIter)) {
+ // iterate all result parts to find all loaded or not yet loaded documents
+ std::list<ResultPtr> aPartResults;
+ myObjs->allResults(ModelAPI_ResultPart::group(), aPartResults);
+ std::list<ResultPtr>::iterator aPartRes = aPartResults.begin();
+ for(; aPartRes != aPartResults.end(); aPartRes++) {
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aPartRes);
+ if (!aPart->isActivated()) {
// copy not-activated document that is not in the memory
- std::string aDocName = *aSubIter;
+ std::string aDocName = aPart->data()->name();
if (!aDocName.empty()) {
// just copy file
TCollection_AsciiString aSubPath(DocFileName(anApp->loadPath().c_str(), aDocName));
OSD_Path aPath(aSubPath);
OSD_File aFile(aPath);
if (aFile.Exists()) {
- TCollection_AsciiString aDestinationDir(DocFileName(theFileName, aDocName));
+ TCollection_AsciiString aDestinationDir(DocFileName(theDirName, aDocName));
OSD_Path aDestination(aDestinationDir);
aFile.Copy(aDestination);
theResults.push_back(aDestinationDir.ToCString());
}
}
} else { // simply save opened document
- isDone = subDoc(*aSubIter)->save(theFileName, theResults);
+ isDone = std::dynamic_pointer_cast<Model_Document>(aPart->partDoc())->
+ save(theDirName, aPart->data()->name().c_str(), theResults);
}
}
}
aPM->setActiveDocument(DocumentPtr());
}
// close all subs
- const std::set<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
- for (; aSubIter != aSubs.end(); aSubIter++)
- subDoc(*aSubIter)->close(theForever);
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
+ for (; aSubIter != aSubs.end(); aSubIter++) {
+ std::shared_ptr<Model_Document> 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>(Model_Session::get())->setCheckTransactions(false);
- // delete all features of this document
- std::shared_ptr<ModelAPI_Document> aThis =
- Model_Application::getApplication()->getDocument(myID);
- Events_Loop* aLoop = Events_Loop::loop();
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeaturesIter(myObjs);
- for(; aFeaturesIter.More(); aFeaturesIter.Next()) {
- FeaturePtr aFeature = aFeaturesIter.Value();
- static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- ModelAPI_EventCreator::get()->sendDeleted(aThis, ModelAPI_Feature::group());
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, EVENT_DISP);
- aFeature->eraseResults();
- if (theForever) { // issue #294: do not delete content of the document until it can be redone
- aFeature->erase();
- } else {
- aFeature->data()->execState(ModelAPI_StateMustBeUpdated);
- }
- }
- if (theForever) {
- myObjs.Clear();
- }
- aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
- aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
-
// 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
+ // update the OB: features are disabled (on remove of Part)
+ Events_Loop* aLoop = Events_Loop::loop();
+ static Events_ID aDeleteEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED);
+ aLoop->flush(aDeleteEvent);
}
std::static_pointer_cast<Model_Session>(Model_Session::get())->setCheckTransactions(true);
void Model_Document::startOperation()
{
+ incrementTransactionID(); // outside of transaction in order to avoid empty transactions keeping
if (myDoc->HasOpenCommand()) { // start of nested command
if (myDoc->CommitCommand()) { // commit the current: it will contain all nested after compactification
myTransactions.rbegin()->myOCAFNum++; // if has open command, the list is not empty
(*myNestedNum.rbegin())++;
myRedos.clear();
// new command for all subs
- const std::set<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++)
subDoc(*aSubIter)->startOperation();
}
}
}
+/// Compares the content ofthe given attributes, returns true if equal.
+/// This method is used to avoid empty transactions when only "current" is changed
+/// to some value and then comes back in this transaction, so, it compares only
+/// references and Boolean and Integer Arrays for the current moment.
+static bool isEqualContent(Handle(TDF_Attribute) theAttr1, Handle(TDF_Attribute) theAttr2)
+{
+ if (Standard_GUID::IsEqual(theAttr1->ID(), TDF_Reference::GetID())) { // reference
+ Handle(TDF_Reference) aRef1 = Handle(TDF_Reference)::DownCast(theAttr1);
+ Handle(TDF_Reference) aRef2 = Handle(TDF_Reference)::DownCast(theAttr2);
+ if (aRef1.IsNull() && aRef2.IsNull())
+ return true;
+ if (aRef1.IsNull() || aRef2.IsNull())
+ return false;
+ return aRef1->Get().IsEqual(aRef2->Get()) == Standard_True;
+ } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_BooleanArray::GetID())) {
+ Handle(TDataStd_BooleanArray) anArr1 = Handle(TDataStd_BooleanArray)::DownCast(theAttr1);
+ Handle(TDataStd_BooleanArray) anArr2 = Handle(TDataStd_BooleanArray)::DownCast(theAttr2);
+ if (anArr1.IsNull() && anArr2.IsNull())
+ return true;
+ if (anArr1.IsNull() || anArr2.IsNull())
+ return false;
+ if (anArr1->Lower() == anArr2->Lower() && anArr1->Upper() == anArr2->Upper()) {
+ for(int a = anArr1->Lower(); a <= anArr1->Upper(); a++)
+ if (a != 1 && anArr1->Value(a) != anArr2->Value(a)) // second is for display
+ return false;
+ return true;
+ }
+ } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_IntegerArray::GetID())) {
+ Handle(TDataStd_IntegerArray) anArr1 = Handle(TDataStd_IntegerArray)::DownCast(theAttr1);
+ Handle(TDataStd_IntegerArray) anArr2 = Handle(TDataStd_IntegerArray)::DownCast(theAttr2);
+ if (anArr1.IsNull() && anArr2.IsNull())
+ return true;
+ if (anArr1.IsNull() || anArr2.IsNull())
+ return false;
+ if (anArr1->Lower() == anArr2->Lower() && anArr1->Upper() == anArr2->Upper()) {
+ for(int a = anArr1->Lower(); a <= anArr1->Upper(); a++)
+ if (anArr1->Value(a) != anArr2->Value(a)) {
+ // avoid the transaction ID checking
+ if (a == 2 && anArr1->Upper() == 2 && anArr2->Label().Tag() == 1 &&
+ (anArr2->Label().Depth() == 4 || anArr2->Label().Depth() == 6))
+ continue;
+ return false;
+ }
+ return true;
+ }
+ } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_ReferenceArray::GetID())) {
+ Handle(TDataStd_ReferenceArray) anArr1 = Handle(TDataStd_ReferenceArray)::DownCast(theAttr1);
+ Handle(TDataStd_ReferenceArray) anArr2 = Handle(TDataStd_ReferenceArray)::DownCast(theAttr2);
+ if (anArr1.IsNull() && anArr2.IsNull())
+ return true;
+ if (anArr1.IsNull() || anArr2.IsNull())
+ return false;
+ if (anArr1->Lower() == anArr2->Lower() && anArr1->Upper() == anArr2->Upper()) {
+ for(int a = anArr1->Lower(); a <= anArr1->Upper(); a++)
+ if (anArr1->Value(a) != anArr2->Value(a)) {
+ // avoid the transaction ID checking
+ if (a == 2 && anArr1->Upper() == 2 && anArr2->Label().Tag() == 1 &&
+ (anArr2->Label().Depth() == 4 || anArr2->Label().Depth() == 6))
+ continue;
+ return false;
+ }
+ return true;
+ }
+ } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_ReferenceList::GetID())) {
+ Handle(TDataStd_ReferenceList) aList1 = Handle(TDataStd_ReferenceList)::DownCast(theAttr1);
+ Handle(TDataStd_ReferenceList) aList2= Handle(TDataStd_ReferenceList)::DownCast(theAttr2);
+ if (aList1.IsNull() && aList2.IsNull())
+ return true;
+ if (aList1.IsNull() || aList2.IsNull())
+ return false;
+ const TDF_LabelList& aLList1 = aList1->List();
+ const TDF_LabelList& aLList2 = aList2->List();
+ TDF_ListIteratorOfLabelList aLIter1(aLList1);
+ TDF_ListIteratorOfLabelList aLIter2(aLList2);
+ for(; aLIter1.More() && aLIter2.More(); aLIter1.Next(), aLIter2.Next()) {
+ if (aLIter1.Value() != aLIter2.Value())
+ return false;
+ }
+ return !aLIter1.More() && !aLIter2.More(); // both lists are with the same size
+ } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDF_TagSource::GetID())) {
+ return true; // it just for created and removed feature: nothing is changed
+ }
+ return false;
+}
+
+/// Returns true if the last transaction is actually empty: modification to te same values
+/// were performed only
+static bool isEmptyTransaction(const Handle(TDocStd_Document)& theDoc) {
+ Handle(TDF_Delta) aDelta;
+ 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()) {
+ return false;
+ }
+ // add also label of the modified attributes
+ const TDF_AttributeDeltaList& anAttrs = aDelta->AttributeDeltas();
+ for (TDF_ListIteratorOfAttributeDeltaList anAttr(anAttrs); anAttr.More(); anAttr.Next()) {
+ Handle(TDF_AttributeDelta)& anADelta = anAttr.Value();
+ Handle(TDF_DeltaOnAddition) anAddition = Handle(TDF_DeltaOnAddition)::DownCast(anADelta);
+ if (anAddition.IsNull()) { // if the attribute was added, transaction is not empty
+ if (!anADelta->Label().IsNull() && !anADelta->Attribute().IsNull()) {
+ Handle(TDF_Attribute) aCurrentAttr;
+ if (anADelta->Label().FindAttribute(anADelta->Attribute()->ID(), aCurrentAttr)) {
+ if (isEqualContent(anADelta->Attribute(), aCurrentAttr)) {
+ continue; // attribute is not changed actually
+ }
+ } else if (Standard_GUID::IsEqual(anADelta->Attribute()->ID(), TDataStd_AsciiString::GetID())) {
+ continue; // error message is disappeared
+ }
+ }
+ }
+ return false;
+ }
+ return true;
+}
+
bool Model_Document::finishOperation()
{
bool isNestedClosed = !myDoc->HasOpenCommand() && !myNestedNum.empty();
static std::shared_ptr<Model_Session> aSession =
std::static_pointer_cast<Model_Session>(Model_Session::get());
- synchronizeBackRefs();
+ // do it before flashes to enable and recompute nesting features correctly
+ if (myNestedNum.empty() || (isNestedClosed && myNestedNum.size() == 1)) {
+ // if all nested operations are closed, make current the higher level objects (to perform
+ // it in the python scripts correctly): sketch become current after creation ofsub-elements
+ FeaturePtr aCurrent = currentFeature(false);
+ CompositeFeaturePtr aMain, aNext = ModelAPI_Tools::compositeOwner(aCurrent);
+ while(aNext.get()) {
+ aMain = aNext;
+ aNext = ModelAPI_Tools::compositeOwner(aMain);
+ }
+ if (aMain.get() && aMain != aCurrent)
+ setCurrentFeature(aMain, false);
+ }
+ myObjs->synchronizeBackRefs();
Events_Loop* aLoop = Events_Loop::loop();
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
// finish for all subs first: to avoid nested finishing and "isOperation" calls problems inside
bool aResult = false;
- const std::set<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++)
if (subDoc(*aSubIter)->finishOperation())
aResult = true;
// transaction may be empty if this document was created during this transaction (create part)
if (!myTransactions.empty() && myDoc->CommitCommand()) { // if commit is successfull, just increment counters
- myTransactions.rbegin()->myOCAFNum++;
- aResult = true;
+ if (isEmptyTransaction(myDoc)) { // erase this transaction
+ myDoc->Undo();
+ myDoc->ClearRedos();
+ } else {
+ myTransactions.rbegin()->myOCAFNum++;
+ aResult = true;
+ }
}
if (isNestedClosed) {
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();
if (!myNestedNum.empty())
(*myNestedNum.rbegin())--;
// roll back the needed number of transactions
- myDoc->AbortCommand();
- for(int a = 0; a < aNumTransactions; a++)
+ //myDoc->AbortCommand();
+ // instead of abort, do commit and undo: to get the delta of modifications
+ 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
- const std::set<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++)
subDoc(*aSubIter)->abortOperation();
// references may be changed because they are set in attributes on the fly
- synchronizeFeatures(true, true, isRoot());
+ myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot());
}
bool Model_Document::isOperation() const
myTransactions.size() - aCurrentNum > 0 /* for omitting the first useless transaction */)
return true;
// check other subs contains operation that can be undoed
- const std::set<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
- for (; aSubIter != aSubs.end(); aSubIter++)
- if (subDoc(*aSubIter)->canUndo())
- return true;
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
+ for (; aSubIter != aSubs.end(); aSubIter++) {
+ std::shared_ptr<Model_Document> aSub = subDoc(*aSubIter);
+ if (aSub->myObjs) {// if it was not closed before
+ if (aSub->canUndo())
+ return true;
+ }
+ }
+
return false;
}
void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchronize)
{
+ if (myTransactions.empty())
+ return;
int aNumTransactions = myTransactions.rbegin()->myOCAFNum;
myRedos.push_back(*myTransactions.rbegin());
myTransactions.pop_back();
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<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
- for (; aSubIter != aSubs.end(); aSubIter++)
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
+ for (; aSubIter != aSubs.end(); aSubIter++) {
+ if (!subDoc(*aSubIter)->myObjs)
+ continue;
subDoc(*aSubIter)->undoInternal(theWithSubs, theSynchronize);
+ }
+ }
+ // 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);
}
- // after redo of all sub-documents to avoid updates on not-modified data (issue 370)
- if (theSynchronize)
- synchronizeFeatures(true, true, isRoot());
}
void Model_Document::undo()
if (!myRedos.empty())
return true;
// check other subs contains operation that can be redoed
- const std::set<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
- for (; aSubIter != aSubs.end(); aSubIter++)
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
+ for (; aSubIter != aSubs.end(); aSubIter++) {
+ if (!subDoc(*aSubIter)->myObjs)
+ continue;
if (subDoc(*aSubIter)->canRedo())
return true;
+ }
return false;
}
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<std::string> aSubs = subDocuments(true);
- std::set<std::string>::iterator aSubIter = aSubs.begin();
+ const std::set<int> aSubs = subDocuments();
+ std::set<int>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++)
subDoc(*aSubIter)->redo();
// after redo of all sub-documents to avoid updates on not-modified data (issue 370)
- synchronizeFeatures(true, true, isRoot());
+ myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot());
+ // update the current features status
+ setCurrentFeature(currentFeature(false), false);
}
std::list<std::string> Model_Document::undoList() const
// the number of skipped current operations (on undo they will be aborted)
int aSkipCurrent = isOperation() ? 1 : 0;
std::list<Transaction>::const_reverse_iterator aTrIter = myTransactions.crbegin();
- int aNumUndo = myTransactions.size();
+ int aNumUndo = int(myTransactions.size());
if (!myNestedNum.empty())
aNumUndo = *myNestedNum.rbegin();
for( ; aNumUndo > 0; aTrIter++, aNumUndo--) {
myTransactions.rbegin()->myId = theId;
}
-/// Append to the array of references a new referenced label
-static void AddToRefArray(TDF_Label& theArrayLab, TDF_Label& theReferenced)
-{
- Handle(TDataStd_ReferenceArray) aRefs;
- if (!theArrayLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
- aRefs = TDataStd_ReferenceArray::Set(theArrayLab, 0, 0);
- aRefs->SetValue(0, theReferenced);
- } else { // extend array by one more element
- Handle(TDataStd_HLabelArray1) aNewArray = new TDataStd_HLabelArray1(aRefs->Lower(),
- aRefs->Upper() + 1);
- for (int a = aRefs->Lower(); a <= aRefs->Upper(); a++) {
- aNewArray->SetValue(a, aRefs->Value(a));
- }
- aNewArray->SetValue(aRefs->Upper() + 1, theReferenced);
- aRefs->SetInternalArray(aNewArray);
- }
-}
-
-FeaturePtr Model_Document::addFeature(std::string theID)
+FeaturePtr Model_Document::addFeature(std::string theID, const bool theMakeCurrent)
{
- TDF_Label anEmptyLab;
- FeaturePtr anEmptyFeature;
std::shared_ptr<Model_Session> aSession =
std::dynamic_pointer_cast<Model_Session>(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
aDocToAdd = this;
}
if (aFeature) {
- TDF_Label aFeatureLab;
- if (!aFeature->isAction()) { // do not add action to the data model
- TDF_Label aFeaturesLab = aDocToAdd->featuresLabel();
- aFeatureLab = aFeaturesLab.NewChild();
- aDocToAdd->initData(aFeature, aFeatureLab, TAG_FEATURE_ARGUMENTS);
- // keep the feature ID to restore document later correctly
- TDataStd_Comment::Set(aFeatureLab, aFeature->getKind().c_str());
- aDocToAdd->myObjs.Bind(aFeatureLab, aFeature);
- // store feature in the history of features array
- if (aFeature->isInHistory()) {
- AddToRefArray(aFeaturesLab, aFeatureLab);
+ // 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<ModelAPI_CompositeFeature>(aCurrent);
+ aComp.get() && isModified;
+ aComp = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(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
- // event: feature is added
- static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, anEvent);
- aFeature->setDisabled(false); // by default created feature is enabled
- 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();
return aFeature;
}
-/// Appenad to the array of references a new referenced label.
-/// If theIndex is not -1, removes element at this index, not theReferenced.
-/// \returns the index of removed element
-static int RemoveFromRefArray(TDF_Label theArrayLab, TDF_Label theReferenced,
- const int theIndex = -1)
-{
- int aResult = -1; // no returned
- Handle(TDataStd_ReferenceArray) aRefs;
- if (theArrayLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
- if (aRefs->Length() == 1) { // just erase an array
- if ((theIndex == -1 && aRefs->Value(0) == theReferenced) || theIndex == 0) {
- theArrayLab.ForgetAttribute(TDataStd_ReferenceArray::GetID());
- }
- aResult = 0;
- } else { // reduce the array
- Handle(TDataStd_HLabelArray1) aNewArray = new TDataStd_HLabelArray1(aRefs->Lower(),
- aRefs->Upper() - 1);
- int aCount = aRefs->Lower();
- for (int a = aCount; a <= aRefs->Upper(); a++, aCount++) {
- if ((theIndex == -1 && aRefs->Value(a) == theReferenced) || theIndex == a) {
- aCount--;
- aResult = a;
- } else {
- aNewArray->SetValue(aCount, aRefs->Value(a));
- }
- }
- aRefs->SetInternalArray(aNewArray);
- }
- }
- return aResult;
-}
void Model_Document::refsToFeature(FeaturePtr theFeature,
- std::set<std::shared_ptr<ModelAPI_Feature> >& theRefs,
- const bool isSendError)
+ std::set<std::shared_ptr<ModelAPI_Feature> >& theRefs, const bool isSendError)
{
- // check the feature: it must have no depended objects on it
- // the dependencies can be in the feature results
- std::list<ResultPtr>::const_iterator aResIter = theFeature->results().cbegin();
- for(; aResIter != theFeature->results().cend(); aResIter++) {
- ResultPtr aResult = (*aResIter);
- std::shared_ptr<Model_Data> aData =
- std::dynamic_pointer_cast<Model_Data>(aResult->data());
- if (aData.get() != NULL) {
- const std::set<AttributePtr>& aRefs = aData->refsToMe();
- std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin(), aRefLast = aRefs.end();
- for(; aRefIt != aRefLast; aRefIt++) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRefIt)->owner());
- if (aFeature.get() != NULL)
- theRefs.insert(aFeature);
- }
- }
- }
- // the dependencies can be in the feature itself
- std::shared_ptr<Model_Data> aData =
- std::dynamic_pointer_cast<Model_Data>(theFeature->data());
- if (aData && !aData->refsToMe().empty()) {
- const std::set<AttributePtr>& aRefs = aData->refsToMe();
- std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin(), aRefLast = aRefs.end();
- for(; aRefIt != aRefLast; aRefIt++) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRefIt)->owner());
- if (aFeature.get() != NULL)
- theRefs.insert(aFeature);
- }
- }
-
- if (!theRefs.empty() && isSendError) {
- Events_Error::send(
- "Feature '" + theFeature->data()->name() + "' is used and can not be deleted");
- }
-}
-
-void Model_Document::removeFeature(FeaturePtr theFeature/*, const bool theCheck*/)
-{
- std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theFeature->data());
- if (aData) {
- TDF_Label aFeatureLabel = aData->label().Father();
- if (myObjs.IsBound(aFeatureLabel))
- myObjs.UnBind(aFeatureLabel);
- else
- return; // not found feature => do not remove
-
- // checking that the sub-element of composite feature is removed: if yes, inform the owner
- std::set<std::shared_ptr<ModelAPI_Feature> > aRefs;
- refsToFeature(theFeature, aRefs, false);
- std::set<std::shared_ptr<ModelAPI_Feature> >::iterator aRefIter = aRefs.begin();
- for(; aRefIter != aRefs.end(); aRefIter++) {
- std::shared_ptr<ModelAPI_CompositeFeature> aComposite =
- std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aRefIter);
- if (aComposite.get()) {
- aComposite->removeFeature(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<ModelAPI_Feature>(
- object(ModelAPI_Feature::group(), aCurrentIndex - 1)), false);
- }
- }
-
- // erase fields
- theFeature->erase();
- static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- ModelAPI_EventCreator::get()->sendUpdated(theFeature, EVENT_DISP);
- // erase all attributes under the label of feature
- aFeatureLabel.ForgetAllAttributes();
- // remove it from the references array
- if (theFeature->isInHistory()) {
- RemoveFromRefArray(featuresLabel(), aFeatureLabel);
- }
- // event: feature is deleted
- ModelAPI_EventCreator::get()->sendDeleted(theFeature->document(), ModelAPI_Feature::group());
- // the redisplay signal should be flushed in order to erase the feature presentation in the viewer
- Events_Loop::loop()->flush(EVENT_DISP);
- }
+ myObjs->refsToFeature(theFeature, theRefs, isSendError);
}
-void Model_Document::addToHistory(const std::shared_ptr<ModelAPI_Object> theObject)
+void Model_Document::removeFeature(FeaturePtr theFeature)
{
- TDF_Label aFeaturesLab = featuresLabel();
- std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theObject->data());
- if (!aData) {
- return; // not found feature => do not remove
- }
- TDF_Label aFeatureLabel = aData->label().Father();
- // store feature in the history of features array
- if (theObject->isInHistory()) {
- AddToRefArray(aFeaturesLab, aFeatureLabel);
- } else {
- RemoveFromRefArray(aFeaturesLab, aFeatureLabel);
- }
+ myObjs->removeFeature(theFeature);
}
-FeaturePtr Model_Document::feature(TDF_Label& theLabel) const
+void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis)
{
- if (myObjs.IsBound(theLabel))
- return myObjs.Find(theLabel);
- return FeaturePtr(); // not found
+ myObjs->moveFeature(theMoved, theAfterThis);
+ if (theAfterThis == currentFeature(true))
+ setCurrentFeature(theMoved, true);
}
-ObjectPtr Model_Document::object(TDF_Label theLabel)
+void Model_Document::updateHistory(const std::shared_ptr<ModelAPI_Object> theObject)
{
- // try feature by label
- FeaturePtr aFeature = feature(theLabel);
- if (aFeature)
- return feature(theLabel);
- TDF_Label aFeatureLabel = theLabel.Father().Father(); // let's suppose it is result
- aFeature = feature(aFeatureLabel);
- if (aFeature) {
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.cbegin();
- for (; aRIter != aResults.cend(); aRIter++) {
- std::shared_ptr<Model_Data> aResData = std::dynamic_pointer_cast<Model_Data>(
- (*aRIter)->data());
- if (aResData->label().Father().IsEqual(theLabel))
- return *aRIter;
- }
- }
- return FeaturePtr(); // not found
+ myObjs->updateHistory(theObject);
}
-std::shared_ptr<ModelAPI_Document> Model_Document::subDocument(std::string theDocID)
+void Model_Document::updateHistory(const std::string theGroup)
{
- return Model_Application::getApplication()->getDocument(theDocID);
+ myObjs->updateHistory(theGroup);
}
-const std::set<std::string> Model_Document::subDocuments(const bool theActivatedOnly) const
+const std::set<int> Model_Document::subDocuments() const
{
- std::set<std::string> aResult;
- // comment must be in any feature: it is kind
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- if (aFeature.get()) { // if document is closed the feature may be not in myObjs map
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if ((*aRIter)->groupName() != ModelAPI_ResultPart::group()) continue;
- if ((*aRIter)->isInHistory()) {
- ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aRIter);
- if (aPart && (!theActivatedOnly || aPart->isActivated()))
- aResult.insert(aPart->data()->name());
- }
- }
+ std::set<int> aResult;
+ std::list<ResultPtr> aPartResults;
+ myObjs->allResults(ModelAPI_ResultPart::group(), aPartResults);
+ std::list<ResultPtr>::iterator aPartRes = aPartResults.begin();
+ for(; aPartRes != aPartResults.end(); aPartRes++) {
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aPartRes);
+ if (aPart && aPart->isActivated()) {
+ aResult.insert(aPart->original()->partDoc()->id());
}
}
return aResult;
}
-std::shared_ptr<Model_Document> Model_Document::subDoc(std::string theDocID)
+std::shared_ptr<Model_Document> Model_Document::subDoc(int theDocID)
{
// just store sub-document identifier here to manage it later
return std::dynamic_pointer_cast<Model_Document>(
- Model_Application::getApplication()->getDocument(theDocID));
+ Model_Application::getApplication()->document(theDocID));
}
-ObjectPtr Model_Document::object(const std::string& theGroupID, const int theIndex,
- const bool theHidden)
+ObjectPtr Model_Document::object(const std::string& theGroupID, const int theIndex)
{
- if (theGroupID == ModelAPI_Feature::group()) {
- if (theHidden) {
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- if (theIndex == anIndex) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- return feature(aFLabel);
- }
- anIndex++;
- }
- } else {
- Handle(TDataStd_ReferenceArray) aRefs;
- if (!featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs))
- return ObjectPtr();
- if (aRefs->Lower() > theIndex || aRefs->Upper() < theIndex)
- return ObjectPtr();
- TDF_Label aFeatureLabel = aRefs->Value(theIndex);
- return feature(aFeatureLabel);
- }
- } else {
- // comment must be in any feature: it is kind
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if ((*aRIter)->groupName() != theGroupID) continue;
- bool isIn = theHidden && (*aRIter)->isInHistory();
- if (!isIn && (*aRIter)->isInHistory()) { // check that there is nobody references this result
- isIn = !(*aRIter)->isConcealed();
- }
- if (isIn) {
- if (anIndex == theIndex)
- return *aRIter;
- anIndex++;
- }
- }
- }
- }
- // not found
- return ObjectPtr();
+ return myObjs->object(theGroupID, theIndex);
}
std::shared_ptr<ModelAPI_Object> Model_Document::objectByName(
const std::string& theGroupID, const std::string& theName)
{
- if (theGroupID == ModelAPI_Feature::group()) {
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- if (aFeature && aFeature->name() == theName)
- return aFeature;
- }
- } else {
- // comment must be in any feature: it is kind
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if ((*aRIter)->groupName() == theGroupID && (*aRIter)->data()->name() == theName)
- return *aRIter;
- }
- }
- }
- // not found
- return ObjectPtr();
+ return myObjs->objectByName(theGroupID, theName);
}
const int Model_Document::index(std::shared_ptr<ModelAPI_Object> theObject)
{
- const std::string aGroupName = theObject->groupName();
- if (aGroupName == ModelAPI_Feature::group()) {
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- if (aFeature == theObject)
- return anIndex;
- if (aFeature->isInHistory())
- anIndex++;
- }
- } else {
- // comment must be in any feature: it is kind
- int anIndex = 0;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if (*aRIter == theObject)
- return anIndex;
- if ((*aRIter)->groupName() == aGroupName) {
- bool isIn = (*aRIter)->isInHistory() && !(*aRIter)->isConcealed();
- if (isIn) {
- anIndex++;
- }
- }
- }
- }
- }
- // not found
- return -1;
+ return myObjs->index(theObject);
}
-int Model_Document::size(const std::string& theGroupID, const bool theHidden)
+int Model_Document::size(const std::string& theGroupID)
{
- int aResult = 0;
- if (theGroupID == ModelAPI_Feature::group()) {
- if (theHidden) {
- return myObjs.Size();
- } else {
- Handle(TDataStd_ReferenceArray) aRefs;
- if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs))
- return aRefs->Length();
- }
- } else {
- // comment must be in any feature: it is kind
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature = feature(aFLabel);
- if (!aFeature) // may be on close
- continue;
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if ((*aRIter)->groupName() != theGroupID) continue;
- bool isIn = theHidden;
- if (!isIn && (*aRIter)->isInHistory()) { // check that there is nobody references this result
- isIn = !(*aRIter)->isConcealed();
- }
- if (isIn)
- aResult++;
- }
- }
- }
- // group is not found
- return aResult;
+ if (myObjs == 0) // may be on close
+ return 0;
+ return myObjs->size(theGroupID);
}
std::shared_ptr<ModelAPI_Feature> Model_Document::currentFeature(const bool theVisible)
{
+ if (!myObjs) // on close document feature destruction it may call this method
+ return std::shared_ptr<ModelAPI_Feature>();
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 = feature(aLab);
+ FeaturePtr aResult = myObjs->feature(aLab);
if (theVisible) { // get nearest visible (in history) going up
- int aTag = aLab.Tag();
- while(aTag > 1 && (!aResult.get() || !aResult->isInHistory())) {
- aTag--;
- aLab = aLab.Father().FindChild(aTag);
- aResult = feature(aLab);
+ while(aResult.get() && !aResult->isInHistory()) {
+ aResult = myObjs->nextFeature(aResult, true);
}
- if (aTag <= 1)
- aResult.reset();
}
return aResult;
}
return std::shared_ptr<ModelAPI_Feature>(); // null feature means the higher than first
}
-void Model_Document::setCurrentFeature(std::shared_ptr<ModelAPI_Feature> theCurrent,
- const bool theVisible)
-{
- TDF_Label aRefLab = generalLabel().FindChild(TAG_CURRENT_FEATURE);
- if (theCurrent.get()) {
- std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
- if (aData.get()) {
- TDF_Label aFeatureLabel = aData->label().Father();
- if (theVisible) { // make features below which are not in history also enabled: sketch subs
- int aTag = aFeatureLabel.Tag();
- FeaturePtr aNextFeature;
- TDF_Label aNextLabel;
- for(aTag++; true; aTag++) {
- TDF_Label aLabel = aFeatureLabel.Father().FindChild(aTag, 0);
- if (aLabel.IsNull())
- break;
- FeaturePtr aFeature = feature(aLabel);
- if (aFeature.get()) {
- if (aFeature->isInHistory())
- break;
- aNextFeature = aFeature;
- aNextLabel = aLabel;
- }
- }
- if (aNextFeature.get()) {
- theCurrent = aNextFeature;
- aFeatureLabel = aNextLabel;
- }
- }
- Handle(TDF_Reference) aRef;
- if (aRefLab.FindAttribute(TDF_Reference::GetID(), aRef)) {
- aRef->Set(aFeatureLabel);
- } else {
- aRef = TDF_Reference::Set(aRefLab, aFeatureLabel);
- }
- }
- } else { // remove reference for the null feature
- aRefLab.ForgetAttribute(TDF_Reference::GetID());
- }
- // make all features after this feature disabled in reversed order (to remove results without deps)
- bool aPassed = false; // flag that the current object is already passed in cycle
- int aSize = size(ModelAPI_Feature::group(), true);
- for(int a = aSize - 1; a >= 0; a--) {
- FeaturePtr aFeature =
- std::dynamic_pointer_cast<ModelAPI_Feature>(object(ModelAPI_Feature::group(), a, true));
-
- // check this before passed become enabled: the current feature is enabled!
- if (aFeature == theCurrent) aPassed = true;
-
- if (aFeature->setDisabled(!aPassed)) {
- // state of feature is changed => so feature become updated
- static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent);
-
- }
- }
-}
-
-TDF_Label Model_Document::featuresLabel() const
-{
- return myDoc->Main().FindChild(TAG_OBJECTS);
+// recursive function to check if theSub is a child of theMain composite feature
+// through all the hierarchy of parents
+static bool isSub(const CompositeFeaturePtr theMain, const FeaturePtr theSub) {
+ CompositeFeaturePtr aParent = ModelAPI_Tools::compositeOwner(theSub);
+ if (!aParent.get())
+ return false;
+ if (aParent == theMain)
+ return true;
+ return isSub(theMain, aParent);
}
-TDF_Label Model_Document::generalLabel() const
+void Model_Document::setCurrentFeature(
+ std::shared_ptr<ModelAPI_Feature> theCurrent, const bool theVisible)
{
- return myDoc->Main().FindChild(TAG_GENERAL);
-}
+ // 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);
-void Model_Document::setUniqueName(FeaturePtr theFeature)
-{
- if (!theFeature->data()->name().empty())
- return; // not needed, name is already defined
- std::string aName; // result
- // first count all objects of such kind to start with index = count + 1
- int aNumObjects = 0;
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFIter(myObjs);
- for (; aFIter.More(); aFIter.Next()) {
- if (aFIter.Value()->getKind() == theFeature->getKind())
- aNumObjects++;
- }
- // generate candidate name
- std::stringstream aNameStream;
- aNameStream << theFeature->getKind() << "_" << aNumObjects + 1;
- aName = aNameStream.str();
- // check this is unique, if not, increase index by 1
- for (aFIter.Initialize(myObjs); aFIter.More();) {
- FeaturePtr aFeature = aFIter.Value();
- bool isSameName = aFeature->data()->name() == aName;
- if (!isSameName) { // check also results to avoid same results names (actual for Parts)
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- isSameName = (*aRIter)->data()->name() == aName;
+ TDF_Label aRefLab = generalLabel().FindChild(TAG_CURRENT_FEATURE);
+ CompositeFeaturePtr aMain; // main feature that may nest the new current
+ std::set<FeaturePtr> anOwners; // composites that contain theCurrent (with any level of nesting)
+ if (theCurrent.get()) {
+ aMain = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(theCurrent);
+ CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theCurrent);
+ while(anOwner.get()) {
+ if (!aMain.get()) {
+ aMain = anOwner;
}
+ anOwners.insert(anOwner);
+ anOwner = ModelAPI_Tools::compositeOwner(anOwner);
}
- if (isSameName) {
- aNumObjects++;
- std::stringstream aNameStream;
- aNameStream << theFeature->getKind() << "_" << aNumObjects + 1;
- aName = aNameStream.str();
- // reinitialize iterator to make sure a new name is unique
- aFIter.Initialize(myObjs);
- } else
- aFIter.Next();
- }
- theFeature->data()->setName(aName);
-}
-
-void Model_Document::initData(ObjectPtr theObj, TDF_Label theLab, const int theTag)
-{
- std::shared_ptr<ModelAPI_Document> aThis = Model_Application::getApplication()->getDocument(
- myID);
- std::shared_ptr<Model_Data> aData(new Model_Data);
- aData->setLabel(theLab.FindChild(theTag));
- aData->setObject(theObj);
- theObj->setDoc(aThis);
- theObj->setData(aData);
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
- if (aFeature) {
- setUniqueName(aFeature); // must be before "initAttributes" because duplicate part uses name
}
- theObj->initAttributes();
-}
-void Model_Document::synchronizeFeatures(
- const bool theMarkUpdated, const bool theUpdateReferences, const bool theFlush)
-{
- std::shared_ptr<ModelAPI_Document> aThis =
- Model_Application::getApplication()->getDocument(myID);
- // after all updates, sends a message that groups of features were created or updated
- Events_Loop* aLoop = Events_Loop::loop();
- static Events_ID aDispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
- static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
- static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- static Events_ID aDeleteEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED);
- static Events_ID aToHideEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- aLoop->activateFlushes(false);
-
- // update all objects by checking are they on labels or not
- std::set<FeaturePtr> aNewFeatures, aKeptFeatures;
- TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter.More(); aLabIter.Next()) {
- TDF_Label aFeatureLabel = aLabIter.Value()->Label();
- FeaturePtr aFeature;
- if (!myObjs.IsBound(aFeatureLabel)) { // a new feature is inserted
- // create a feature
- aFeature = std::dynamic_pointer_cast<Model_Session>(ModelAPI_Session::get())->createFeature(
- TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(aLabIter.Value())->Get())
- .ToCString(), this);
- if (!aFeature) { // somethig is wrong, most probably, the opened document has invalid structure
- Events_Error::send("Invalid type of object in the document");
- aLabIter.Value()->Label().ForgetAllAttributes();
- continue;
- }
- // this must be before "setData" to redo the sketch line correctly
- myObjs.Bind(aFeatureLabel, aFeature);
- aNewFeatures.insert(aFeature);
- initData(aFeature, aFeatureLabel, TAG_FEATURE_ARGUMENTS);
-
- // event: model is updated
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, aCreateEvent);
- } else { // nothing is changed, both iterators are incremented
- aFeature = myObjs.Find(aFeatureLabel);
- aKeptFeatures.insert(aFeature);
- if (theMarkUpdated) {
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent);
+ 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;
}
}
}
- // update results of the features (after features created because they may be connected, like sketch and sub elements)
- std::list<FeaturePtr> aComposites; // composites must be updated after their subs (issue 360)
- TDF_ChildIDIterator aLabIter2(featuresLabel(), TDataStd_Comment::GetID());
- for (; aLabIter2.More(); aLabIter2.Next()) {
- TDF_Label aFeatureLabel = aLabIter2.Value()->Label();
- if (myObjs.IsBound(aFeatureLabel)) { // a new feature is inserted
- FeaturePtr aFeature = myObjs.Find(aFeatureLabel);
- if (std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature).get())
- aComposites.push_back(aFeature);
- updateResults(aFeature);
+ if (theCurrent.get()) {
+ std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
+ if (!aData.get() || !aData->isValid()) {
+ aLoop->activateFlushes(isActive);
+ return;
}
- }
- std::list<FeaturePtr>::iterator aComposite = aComposites.begin();
- for(; aComposite != aComposites.end(); aComposite++) {
- updateResults(*aComposite);
- }
-
- // check all features are checked: if not => it was removed
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFIter(myObjs);
- while (aFIter.More()) {
- if (aKeptFeatures.find(aFIter.Value()) == aKeptFeatures.end()
- && aNewFeatures.find(aFIter.Value()) == aNewFeatures.end()) {
- FeaturePtr aFeature = aFIter.Value();
- // event: model is updated
- //if (aFeature->isInHistory()) {
- ModelAPI_EventCreator::get()->sendDeleted(aThis, ModelAPI_Feature::group());
- //}
- // results of this feature must be redisplayed (hided)
- // redisplay also removed feature (used for sketch and AISObject)
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, aRedispEvent);
- aFeature->erase();
- // unbind after the "erase" call: on abort sketch is removes sub-objects that corrupts aFIter
- myObjs.UnBind(aFIter.Key());
- // reinitialize iterator because unbind may corrupt the previous order in the map
- aFIter.Initialize(myObjs);
- } else
- aFIter.Next();
- }
+ TDF_Label aFeatureLabel = aData->label().Father();
- if (theUpdateReferences) {
- synchronizeBackRefs();
+ Handle(TDF_Reference) aRef;
+ if (aRefLab.FindAttribute(TDF_Reference::GetID(), aRef)) {
+ aRef->Set(aFeatureLabel);
+ } else {
+ aRef = TDF_Reference::Set(aRefLab, aFeatureLabel);
+ }
+ } else { // remove reference for the null feature
+ aRefLab.ForgetAttribute(TDF_Reference::GetID());
}
+ // make all features after this feature disabled in reversed order (to remove results without deps)
+ static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+ static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
+ static Events_ID aDeleteEvent = aLoop->eventByName(EVENT_OBJECT_DELETED);
- myExecuteFeatures = false;
- aLoop->activateFlushes(true);
-
- if (theFlush) {
- aLoop->flush(aCreateEvent);
- aLoop->flush(aDeleteEvent);
- aLoop->flush(anUpdateEvent);
- aLoop->flush(aRedispEvent);
- aLoop->flush(aToHideEvent);
- }
- myExecuteFeatures = true;
-}
+ 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 (aMain.get()) {
+ if (isSub(aMain, anIter)) // sub-elements of not-disabled feature are not disabled
+ aDisabledFlag = false;
+ else if (anOwners.find(anIter) != anOwners.end()) // disable the higher-level feature is the nested is the current
+ aDisabledFlag = true;
+ }
-void Model_Document::synchronizeBackRefs()
-{
- std::shared_ptr<ModelAPI_Document> aThis =
- Model_Application::getApplication()->getDocument(myID);
- // keeps the concealed flags of result to catch the change and create created/deleted events
- std::list<std::pair<ResultPtr, bool> > aConcealed;
- // first cycle: erase all data about back-references
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeatures(myObjs);
- for(; aFeatures.More(); aFeatures.Next()) {
- FeaturePtr aFeature = aFeatures.Value();
- std::shared_ptr<Model_Data> aFData =
- std::dynamic_pointer_cast<Model_Data>(aFeature->data());
- if (aFData) {
- aFData->eraseBackReferences();
+ if (anIter->getKind() == "Parameter") {// parameters are always out of the history of features, but not parameters
+ if (theCurrent.get() && theCurrent->getKind() != "Parameter")
+ aDisabledFlag = false;
}
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- std::shared_ptr<Model_Data> aResData =
- std::dynamic_pointer_cast<Model_Data>((*aRIter)->data());
- if (aResData) {
- aConcealed.push_back(std::pair<ResultPtr, bool>(*aRIter, (*aRIter)->isConcealed()));
- aResData->eraseBackReferences();
- }
+ 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;
}
- }
-
- // second cycle: set new back-references: only features may have reference, iterate only them
- ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
- for(aFeatures.Initialize(myObjs); aFeatures.More(); aFeatures.Next()) {
- FeaturePtr aFeature = aFeatures.Value();
- std::shared_ptr<Model_Data> aFData =
- std::dynamic_pointer_cast<Model_Data>(aFeature->data());
- if (aFData) {
- std::list<std::pair<std::string, std::list<ObjectPtr> > > aRefs;
- aFData->referencesToObjects(aRefs);
- std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator
- aRefsIter = aRefs.begin();
- for(; aRefsIter != aRefs.end(); aRefsIter++) {
- std::list<ObjectPtr>::iterator aRefTo = aRefsIter->second.begin();
- for(; aRefTo != aRefsIter->second.end(); aRefTo++) {
- if (*aRefTo) {
- std::shared_ptr<Model_Data> aRefData =
- std::dynamic_pointer_cast<Model_Data>((*aRefTo)->data());
- aRefData->addBackReference(aFeature, aRefsIter->first); // here the Concealed flag is updated
- }
- }
+ // update for everyone the concealment flag immideately: on edit feature in the midle of history
+ if (aWasChanged) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(anIter, aResults);
+ std::list<ResultPtr>::const_iterator aRes = aResults.begin();
+ for(; aRes != aResults.end(); aRes++) {
+ if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled())
+ std::dynamic_pointer_cast<Model_Data>((*aRes)->data())->updateConcealmentFlag();
}
- }
- }
- std::list<std::pair<ResultPtr, bool> >::iterator aCIter = aConcealed.begin();
- for(; aCIter != aConcealed.end(); aCIter++) {
- if (aCIter->first->isConcealed() != aCIter->second) { // somethign is changed => produce event
- if (aCIter->second) { // was concealed become not => creation event
- static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
- ModelAPI_EventCreator::get()->sendUpdated(aCIter->first, anEvent);
- } else { // was not concealed become concealed => delete event
- ModelAPI_EventCreator::get()->sendDeleted(aThis, aCIter->first->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(aCIter->first, EVENT_DISP);
+ // update the concealment status for disply in isConcealed of ResultBody
+ for(aRes = aResults.begin(); aRes != aResults.end(); aRes++) {
+ if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled())
+ (*aRes)->isConcealed();
}
}
}
+ // unblock the flush signals and up them after this
+ aLoop->activateFlushes(isActive);
}
-TDF_Label Model_Document::resultLabel(
- const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theResultIndex)
+void Model_Document::setCurrentFeatureUp()
{
- const std::shared_ptr<Model_Data>& aData =
- std::dynamic_pointer_cast<Model_Data>(theFeatureData);
- return aData->label().Father().FindChild(TAG_FEATURE_RESULTS).FindChild(theResultIndex + 1);
+ // 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);
+ }
}
-void Model_Document::storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
- std::shared_ptr<ModelAPI_Result> theResult,
- const int theResultIndex)
+TDF_Label Model_Document::generalLabel() const
{
- std::shared_ptr<ModelAPI_Document> aThis =
- Model_Application::getApplication()->getDocument(myID);
- theResult->setDoc(aThis);
- initData(theResult, resultLabel(theFeatureData, theResultIndex), TAG_FEATURE_ARGUMENTS);
- if (theResult->data()->name().empty()) { // if was not initialized, generate event and set a name
- std::stringstream aNewName;
- aNewName<<theFeatureData->name();
- if (theResultIndex > 0) // if there are several results, add unique prefix starting from second
- aNewName<<"_"<<theResultIndex + 1;
- theResult->data()->setName(aNewName.str());
- }
+ return myDoc->Main().FindChild(TAG_GENERAL);
}
std::shared_ptr<ModelAPI_ResultConstruction> Model_Document::createConstruction(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
- TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultConstruction::group().c_str());
- ObjectPtr anOldObject = object(aLab);
- std::shared_ptr<ModelAPI_ResultConstruction> aResult;
- if (anOldObject) {
- aResult = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(anOldObject);
- }
- if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultConstruction>(new Model_ResultConstruction);
- storeResult(theFeatureData, aResult, theIndex);
- }
- return aResult;
+ return myObjs->createConstruction(theFeatureData, theIndex);
}
std::shared_ptr<ModelAPI_ResultBody> Model_Document::createBody(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
- TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
- ObjectPtr anOldObject = object(aLab);
- std::shared_ptr<ModelAPI_ResultBody> aResult;
- if (anOldObject) {
- aResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anOldObject);
- }
- if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
- storeResult(theFeatureData, aResult, theIndex);
- }
- return aResult;
+ return myObjs->createBody(theFeatureData, theIndex);
}
std::shared_ptr<ModelAPI_ResultPart> Model_Document::createPart(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
- TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultPart::group().c_str());
- ObjectPtr anOldObject = object(aLab);
- std::shared_ptr<ModelAPI_ResultPart> aResult;
- if (anOldObject) {
- aResult = std::dynamic_pointer_cast<ModelAPI_ResultPart>(anOldObject);
- }
- if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultPart>(new Model_ResultPart);
- storeResult(theFeatureData, aResult, theIndex);
- }
- return aResult;
+ return myObjs->createPart(theFeatureData, theIndex);
+}
+
+std::shared_ptr<ModelAPI_ResultPart> Model_Document::copyPart(
+ const std::shared_ptr<ModelAPI_ResultPart>& theOrigin,
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
+{
+ return myObjs->copyPart(theOrigin, theFeatureData, theIndex);
}
std::shared_ptr<ModelAPI_ResultGroup> Model_Document::createGroup(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
- TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultGroup::group().c_str());
- ObjectPtr anOldObject = object(aLab);
- std::shared_ptr<ModelAPI_ResultGroup> aResult;
- if (anOldObject) {
- aResult = std::dynamic_pointer_cast<ModelAPI_ResultGroup>(anOldObject);
- }
- if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultGroup>(new Model_ResultGroup(theFeatureData));
- storeResult(theFeatureData, aResult, theIndex);
- }
- return aResult;
+ return myObjs->createGroup(theFeatureData, theIndex);
}
std::shared_ptr<ModelAPI_ResultParameter> Model_Document::createParameter(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
- TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- TDataStd_Comment::Set(aLab, ModelAPI_ResultParameter::group().c_str());
- ObjectPtr anOldObject = object(aLab);
- std::shared_ptr<ModelAPI_ResultParameter> aResult;
- if (anOldObject) {
- aResult = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(anOldObject);
- }
- if (!aResult) {
- aResult = std::shared_ptr<ModelAPI_ResultParameter>(new Model_ResultParameter);
- storeResult(theFeatureData, aResult, theIndex);
- }
- return aResult;
+ return myObjs->createParameter(theFeatureData, theIndex);
}
std::shared_ptr<ModelAPI_Feature> Model_Document::feature(
const std::shared_ptr<ModelAPI_Result>& theResult)
{
- std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theResult->data());
- if (aData) {
- TDF_Label aFeatureLab = aData->label().Father().Father().Father();
- return feature(aFeatureLab);
- }
- return FeaturePtr();
-}
-
-void Model_Document::updateResults(FeaturePtr theFeature)
-{
- // for not persistent is will be done by parametric updater automatically
- //if (!theFeature->isPersistentResult()) return;
- // check the existing results and remove them if there is nothing on the label
- std::list<ResultPtr>::const_iterator aResIter = theFeature->results().cbegin();
- while(aResIter != theFeature->results().cend()) {
- ResultPtr aBody = std::dynamic_pointer_cast<ModelAPI_Result>(*aResIter);
- if (aBody) {
- if (!aBody->data()->isValid()) {
- // found a disappeared result => remove it
- theFeature->removeResult(aBody);
- // start iterate from beginning because iterator is corrupted by removing
- aResIter = theFeature->results().cbegin();
- continue;
- }
- }
- aResIter++;
- }
- // it may be on undo
- if (!theFeature->data() || !theFeature->data()->isValid())
- return;
- // check that results are presented on all labels
- int aResSize = theFeature->results().size();
- TDF_ChildIterator aLabIter(resultLabel(theFeature->data(), 0).Father());
- for(; aLabIter.More(); aLabIter.Next()) {
- // here must be GUID of the feature
- int aResIndex = aLabIter.Value().Tag() - 1;
- ResultPtr aNewBody;
- if (aResSize <= aResIndex) {
- TDF_Label anArgLab = aLabIter.Value();
- Handle(TDataStd_Comment) aGroup;
- if (anArgLab.FindAttribute(TDataStd_Comment::GetID(), aGroup)) {
- if (aGroup->Get() == ModelAPI_ResultBody::group().c_str()) {
- aNewBody = createBody(theFeature->data(), aResIndex);
- } else if (aGroup->Get() == ModelAPI_ResultPart::group().c_str()) {
- aNewBody = createPart(theFeature->data(), aResIndex);
- } else if (aGroup->Get() == ModelAPI_ResultConstruction::group().c_str()) {
- theFeature->execute(); // construction shapes are needed for sketch solver
- break;
- } else if (aGroup->Get() == ModelAPI_ResultGroup::group().c_str()) {
- aNewBody = createGroup(theFeature->data(), aResIndex);
- } else if (aGroup->Get() == ModelAPI_ResultParameter::group().c_str()) {
- theFeature->attributeChanged("expression"); // just produce a value
- break;
- } else {
- Events_Error::send(std::string("Unknown type of result is found in the document:") +
- TCollection_AsciiString(aGroup->Get()).ToCString());
- }
- }
- if (aNewBody) {
- theFeature->setResult(aNewBody, aResIndex);
- }
- }
- }
+ return myObjs->feature(theResult);
}
Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper)
ResultPtr Model_Document::findByName(const std::string theName)
{
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator anObjIter(myObjs);
- for(; anObjIter.More(); anObjIter.Next()) {
- FeaturePtr& aFeature = anObjIter.ChangeValue();
- if (!aFeature) // may be on close
- continue;
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if (aRIter->get() && (*aRIter)->data() && (*aRIter)->data()->isValid() &&
- (*aRIter)->data()->name() == theName) {
- return *aRIter;
+ return myObjs->findByName(theName);
+}
+
+std::list<std::shared_ptr<ModelAPI_Feature> > 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<ModelAPI_Feature>(
+ object(ModelAPI_Feature::group(), a));
+ if (aFeature.get() && aFeature->data()->isValid()) {
+ const std::list<std::shared_ptr<ModelAPI_Result> >& aResList = aFeature->results();
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResList.begin();
+ for(; aRes != aResList.end(); aRes++) {
+ ModelAPI_EventCreator::get()->sendUpdated(*aRes, aRedispEvent);
+ // #issue 1048: sub-compsolids also
+ ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRes);
+ if (aCompRes.get()) {
+ int aNumSubs = aCompRes->numberOfSubs();
+ for(int a = 0; a < aNumSubs; a++) {
+ ResultPtr aSub = aCompRes->subResult(a);
+ if (aSub.get()) {
+ ModelAPI_EventCreator::get()->sendUpdated(aSub, aRedispEvent);
+ }
+ }
+ }
+ }
}
}
}
- // not found
- return ResultPtr();
+}
+
+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<ModelAPI_Feature> Model_Document::internalFeature(const int theIndex)
+{
+ return myObjs->internalFeature(theIndex);
+}
+
+std::shared_ptr<ModelAPI_Feature> Model_Document::featureById(const int theId)
+{
+ return myObjs->featureById(theId);
+}
+
+void Model_Document::synchronizeTransactions()
+{
+ Model_Document* aRoot =
+ std::dynamic_pointer_cast<Model_Document>(ModelAPI_Session::get()->moduleDocument()).get();
+ if (aRoot == this)
+ return; // don't need to synchronise root with root
+
+ std::shared_ptr<Model_Session> aSession =
+ std::dynamic_pointer_cast<Model_Session>(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<Model_Data> 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();
+ mySelectionFeature->init(); // to make it enabled and Update correctly
+ // this update may cause recomputation of the part after selection on it, that is not needed
+ mySelectionFeature->data()->blockSendAttributeUpdated(true);
+ }
+ return mySelectionFeature->selectionList("selection");
+}
+
+FeaturePtr Model_Document::lastFeature()
+{
+ if (myObjs)
+ return myObjs->lastFeature();
+ return FeaturePtr();
}
