#include <Events_Error.h>
#include <TDataStd_Name.hxx>
+#include <TDataStd_AsciiString.hxx>
#include <TDF_AttributeIterator.hxx>
#include <TDF_ChildIterator.hxx>
#include <TDF_RelocationTable.hxx>
// myLab contains:
// TDataStd_Name - name of the object
// TDataStd_Integer - state of the object execution
+// TDataStd_BooleanArray - array of flags of this data:
+// 0 - is in history or not
+static const int kFlagInHistory = 0;
+// 1 - is displayed or not
+static const int kFlagDisplayed = 1;
+
+// invalid data
+const static std::shared_ptr<ModelAPI_Data> kInvalid(new Model_Data());
Model_Data::Model_Data() : mySendAttributeUpdated(true)
{
void Model_Data::setLabel(TDF_Label theLab)
{
myLab = theLab;
+ // set or get the default flags
+ if (!myLab.FindAttribute(TDataStd_BooleanArray::GetID(), myFlags)) {
+ // set default values if not found
+ myFlags = TDataStd_BooleanArray::Set(myLab, 0, 1);
+ myFlags->SetValue(kFlagInHistory, Standard_True); // is in history by default is true
+ myFlags->SetValue(kFlagDisplayed, Standard_True); // is displayed by default is true
+ }
}
std::string Model_Data::name()
AttributePtr aResult;
TDF_Label anAttrLab = myLab.FindChild(myAttrs.size() + 1);
ModelAPI_Attribute* anAttr = 0;
- if (theAttrType == ModelAPI_AttributeDocRef::type()) {
+ if (theAttrType == ModelAPI_AttributeDocRef::typeId()) {
anAttr = new Model_AttributeDocRef(anAttrLab);
- } else if (theAttrType == Model_AttributeInteger::type()) {
+ } else if (theAttrType == Model_AttributeInteger::typeId()) {
anAttr = new Model_AttributeInteger(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeDouble::type()) {
+ } else if (theAttrType == ModelAPI_AttributeDouble::typeId()) {
anAttr = new Model_AttributeDouble(anAttrLab);
- } else if (theAttrType == Model_AttributeBoolean::type()) {
+ } else if (theAttrType == Model_AttributeBoolean::typeId()) {
anAttr = new Model_AttributeBoolean(anAttrLab);
- } else if (theAttrType == Model_AttributeString::type()) {
+ } else if (theAttrType == Model_AttributeString::typeId()) {
anAttr = new Model_AttributeString(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeReference::type()) {
+ } else if (theAttrType == ModelAPI_AttributeReference::typeId()) {
anAttr = new Model_AttributeReference(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeSelection::type()) {
+ } else if (theAttrType == ModelAPI_AttributeSelection::typeId()) {
anAttr = new Model_AttributeSelection(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeSelectionList::type()) {
+ } else if (theAttrType == ModelAPI_AttributeSelectionList::typeId()) {
anAttr = new Model_AttributeSelectionList(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeRefAttr::type()) {
+ } else if (theAttrType == ModelAPI_AttributeRefAttr::typeId()) {
anAttr = new Model_AttributeRefAttr(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeRefList::type()) {
+ } else if (theAttrType == ModelAPI_AttributeRefList::typeId()) {
anAttr = new Model_AttributeRefList(anAttrLab);
- } else if (theAttrType == ModelAPI_AttributeIntArray::type()) {
+ } else if (theAttrType == ModelAPI_AttributeIntArray::typeId()) {
anAttr = new Model_AttributeIntArray(anAttrLab);
}
// create also GeomData attributes here because only here the OCAF strucure is known
- else if (theAttrType == GeomData_Point::type()) {
+ else if (theAttrType == GeomData_Point::typeId()) {
anAttr = new GeomData_Point(anAttrLab);
- } else if (theAttrType == GeomData_Dir::type()) {
+ } else if (theAttrType == GeomData_Dir::typeId()) {
anAttr = new GeomData_Dir(anAttrLab);
- } else if (theAttrType == GeomData_Point2D::type()) {
+ } else if (theAttrType == GeomData_Point2D::typeId()) {
anAttr = new GeomData_Point2D(anAttrLab);
}
if (anAttr) {
return ModelAPI_StateMustBeUpdated; // default value
}
-void Model_Data::setError(const std::string& theError)
+void Model_Data::setError(const std::string& theError, bool theSend)
{
execState(ModelAPI_StateExecFailed);
- Events_Error::send(theError);
+ if (theSend) {
+ Events_Error::send(theError);
+ }
+ TDataStd_AsciiString::Set(myLab, theError.c_str());
+}
+
+std::string Model_Data::error() const
+{
+ Handle(TDataStd_AsciiString) anErrorAttr;
+ if (myLab.FindAttribute(TDataStd_AsciiString::GetID(), anErrorAttr)) {
+ return std::string(anErrorAttr->Get().ToCString());
+ }
+ return std::string();
}
int Model_Data::featureId() const
aRes->setIsConcealed(false);
}
-void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID)
+void Model_Data::removeBackReference(FeaturePtr theFeature, std::string theAttrID)
{
+ AttributePtr anAttribute = theFeature->data()->attribute(theAttrID);
+ if (myRefsToMe.find(anAttribute) == myRefsToMe.end())
+ return;
+
+ myRefsToMe.erase(anAttribute);
+}
+
+void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID,
+ const bool theApplyConcealment)
+{
+ // do not add the same attribute twice
+ AttributePtr anAttribute = theFeature->data()->attribute(theAttrID);
+ if (myRefsToMe.find(anAttribute) != myRefsToMe.end())
+ return;
+
myRefsToMe.insert(theFeature->data()->attribute(theAttrID));
- if (ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) {
+ if (theApplyConcealment &&
+ ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) {
std::shared_ptr<ModelAPI_Result> aRes =
std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
if (aRes) {
std::list<ObjectPtr> aReferenced; // not inside of cycle to avoid excess memory menagement
for(; anAttr != myAttrs.end(); anAttr++) {
std::string aType = anAttr->second->attributeType();
- if (aType == ModelAPI_AttributeReference::type()) { // reference to object
+ if (aType == ModelAPI_AttributeReference::typeId()) { // reference to object
std::shared_ptr<ModelAPI_AttributeReference> aRef = std::dynamic_pointer_cast<
ModelAPI_AttributeReference>(anAttr->second);
aReferenced.push_back(aRef->value());
- } else if (aType == ModelAPI_AttributeRefAttr::type()) { // reference to attribute or object
+ } else if (aType == ModelAPI_AttributeRefAttr::typeId()) { // reference to attribute or object
std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
ModelAPI_AttributeRefAttr>(anAttr->second);
aReferenced.push_back(aRef->isObject() ? aRef->object() : aRef->attr()->owner());
- } else if (aType == ModelAPI_AttributeRefList::type()) { // list of references
+ } else if (aType == ModelAPI_AttributeRefList::typeId()) { // list of references
aReferenced = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(anAttr->second)->list();
- } else if (aType == ModelAPI_AttributeSelection::type()) { // selection attribute
+ } else if (aType == ModelAPI_AttributeSelection::typeId()) { // selection attribute
std::shared_ptr<ModelAPI_AttributeSelection> aRef = std::dynamic_pointer_cast<
ModelAPI_AttributeSelection>(anAttr->second);
aReferenced.push_back(aRef->context());
- } else if (aType == ModelAPI_AttributeSelectionList::type()) { // list of selection attributes
+ } else if (aType == ModelAPI_AttributeSelectionList::typeId()) { // list of selection attributes
std::shared_ptr<ModelAPI_AttributeSelectionList> aRef = std::dynamic_pointer_cast<
ModelAPI_AttributeSelectionList>(anAttr->second);
for(int a = aRef->size() - 1; a >= 0; a--) {
}
}
}
+
+bool Model_Data::isInHistory()
+{
+ return myFlags->Value(kFlagInHistory) == Standard_True;
+}
+
+void Model_Data::setIsInHistory(const bool theFlag)
+{
+ return myFlags->SetValue(kFlagInHistory, theFlag);
+}
+
+bool Model_Data::isDisplayed()
+{
+ return myFlags->Value(kFlagDisplayed) == Standard_True;
+}
+
+void Model_Data::setDisplayed(const bool theDisplay)
+{
+ if (theDisplay != isDisplayed()) {
+ myFlags->SetValue(kFlagDisplayed, theDisplay);
+ static Events_Loop* aLoop = Events_Loop::loop();
+ static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+ static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
+ aECreator->sendUpdated(myObject, EVENT_DISP);
+ }
+}
+
+std::shared_ptr<ModelAPI_Data> Model_Data::invalidPtr()
+{
+ return kInvalid;
+}
