+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
// File: Model_Document.cxx
// Created: 28 Feb 2014
// Author: Mikhail PONIKAROV
#include <TDF_Reference.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_LabelMapHasher.hxx>
+#include <OSD_File.hxx>
+#include <OSD_Path.hxx>
#include <climits>
#ifndef WIN32
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),
myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format
{
myDoc->SetUndoLimit(UNDO_LIMIT);
- myTransactionsAfterSave = 0;
+ myTransactionsCounter = 0;
+ myTransactionSave = 0;
myNestedNum = -1;
myExecuteFeatures = true;
// to have something in the document and avoid empty doc open/save problem
bool Model_Document::save(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();
if (this == Model_Session::get()->moduleDocument().get()) {
#ifdef WIN32
CreateDirectory(theFileName, NULL);
TCollection_ExtendedString aPath(DocFileName(theFileName, myID));
PCDM_StoreStatus aStatus;
try {
- aStatus = Model_Application::getApplication()->SaveAs(myDoc, aPath);
+ aStatus = anApp->SaveAs(myDoc, aPath);
} catch (Standard_Failure) {
Handle(Standard_Failure) aFail = Standard_Failure::Caught();
Events_Error::send(
break;
}
}
- myTransactionsAfterSave = 0;
+ myTransactionSave = myTransactionsCounter;
if (isDone) { // save also sub-documents if any
theResults.push_back(TCollection_AsciiString(aPath).ToCString());
std::set<std::string>::iterator aSubIter = mySubs.begin();
for (; aSubIter != mySubs.end() && isDone; aSubIter++) {
isDone = subDoc(*aSubIter)->save(theFileName, theResults);
}
+ if (isDone) { // also try to copy the not-activated sub-documents
+ // they are not in mySubs but as ResultParts
+ int aPartsNum = size(ModelAPI_ResultPart::group());
+ for(int aPart = 0; aPart < aPartsNum; aPart++) {
+ ResultPartPtr aPartRes = std::dynamic_pointer_cast<ModelAPI_ResultPart>
+ (object(ModelAPI_ResultPart::group(), aPart));
+ if (aPartRes) {
+ std::string aDocName = aPartRes->data()->name();
+ if (!aDocName.empty() && mySubs.find(aDocName) == mySubs.end()) {
+ // 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));
+ OSD_Path aDestination(aDestinationDir);
+ aFile.Copy(aDestination);
+ theResults.push_back(aDestinationDir.ToCString());
+ } else {
+ Events_Error::send(
+ std::string("Can not open file ") + aSubPath.ToCString() + " for saving");
+ }
+ }
+ }
+ }
+ }
}
return isDone;
}
myNestedNum = 0;
myDoc->InitDeltaCompaction();
}
- myIsEmptyTr[myTransactionsAfterSave] = !myDoc->CommitCommand();
- myTransactionsAfterSave++;
+ myIsEmptyTr[myTransactionsCounter] = !myDoc->CommitCommand();
+ myTransactionsCounter++;
myDoc->OpenCommand();
} else { // start the simple command
myDoc->NewCommand();
{
bool allWasEmpty = true;
while (myNestedNum != -1) {
- myTransactionsAfterSave--;
- if (!myIsEmptyTr[myTransactionsAfterSave]) {
+ myTransactionsCounter--;
+ if (!myIsEmptyTr[myTransactionsCounter]) {
allWasEmpty = false;
}
- myIsEmptyTr.erase(myTransactionsAfterSave);
+ myIsEmptyTr.erase(myTransactionsCounter);
myNestedNum--;
}
- myIsEmptyTr[myTransactionsAfterSave] = allWasEmpty;
- myTransactionsAfterSave++;
+ myIsEmptyTr[myTransactionsCounter] = allWasEmpty;
+ myTransactionsCounter++;
if (allWasEmpty) {
// Issue 151: if everything is empty, it is a problem for OCCT to work with it,
// just commit the empty that returns nothing
}
} else {
// returns false if delta is empty and no transaction was made
- myIsEmptyTr[myTransactionsAfterSave] = !myDoc->CommitCommand(); // && (myNestedNum == -1);
- myTransactionsAfterSave++;
+ myIsEmptyTr[myTransactionsCounter] = !myDoc->CommitCommand(); // && (myNestedNum == -1);
+ myTransactionsCounter++;
}
}
{
if (myNestedNum > 0 && !myDoc->HasOpenCommand()) { // abort all what was done in nested
// first compact all nested
- compactNested();
- myDoc->Undo();
+ if (compactNested()) {
+ myDoc->Undo(); // undo only compacted, if not: do not undo the empty transaction
+ }
myDoc->ClearRedos();
- myTransactionsAfterSave--;
- myIsEmptyTr.erase(myTransactionsAfterSave);
+ myTransactionsCounter--;
+ myIsEmptyTr.erase(myTransactionsCounter);
} else {
if (myNestedNum == 0) // abort only high-level
myNestedNum = -1;
bool Model_Document::isModified()
{
// is modified if at least one operation was commited and not undoed
- return myTransactionsAfterSave > 0 || isOperation();
+ return myTransactionsCounter != myTransactionSave || isOperation();
}
bool Model_Document::canUndo()
{
if (myDoc->GetAvailableUndos() > 0 && myNestedNum != 0
- && myTransactionsAfterSave != 0 /* for omitting the first useless transaction */)
+ && myTransactionsCounter != 0 /* for omitting the first useless transaction */)
return true;
// check other subs contains operation that can be undoed
std::set<std::string>::iterator aSubIter = mySubs.begin();
void Model_Document::undo()
{
- myTransactionsAfterSave--;
+ myTransactionsCounter--;
if (myNestedNum > 0)
myNestedNum--;
- if (!myIsEmptyTr[myTransactionsAfterSave])
+ if (!myIsEmptyTr[myTransactionsCounter])
myDoc->Undo();
synchronizeFeatures(true, true);
// undo for all subs
{
if (myNestedNum != -1)
myNestedNum++;
- if (!myIsEmptyTr[myTransactionsAfterSave])
+ if (!myIsEmptyTr[myTransactionsCounter])
myDoc->Redo();
- myTransactionsAfterSave++;
+ myTransactionsCounter++;
synchronizeFeatures(true, true);
// redo for all subs
std::set<std::string>::iterator aSubIter = mySubs.begin();
}
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());
{
return TDF_LabelMapHasher::IsEqual(theLab1, theLab2);
}
+
+void Model_Document::addNamingName(const TDF_Label theLabel, std::string theName)
+{
+ myNamingNames[theName] = theLabel;
+}
+
+TDF_Label Model_Document::findNamingName(std::string theName)
+{
+ std::map<std::string, TDF_Label>::iterator aFind = myNamingNames.find(theName);
+ if (aFind == myNamingNames.end())
+ return TDF_Label(); // not found
+ return aFind->second;
+}
