X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FGeomData%2FGeomData_Point.cpp;h=0d1ff198f41dec8874ff0705fb052862a75c88a0;hb=ea593bc59e7e9461f6c4e2afd3f24d621edb1011;hp=9fbb5f4243fad2d51ce217dd5f32a76b6661eed6;hpb=e0599afe13a8f2be4fe593e6d50b23a23b0a6c81;p=modules%2Fshaper.git diff --git a/src/GeomData/GeomData_Point.cpp b/src/GeomData/GeomData_Point.cpp index 9fbb5f424..0d1ff198f 100644 --- a/src/GeomData/GeomData_Point.cpp +++ b/src/GeomData/GeomData_Point.cpp @@ -1,38 +1,229 @@ -// File: ModelAPI_AttributeDouble.cxx -// Created: 2 Apr 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "GeomData_Point.h" -using namespace std; +#include + +#include +#include +#include +#include + +#include + +GeomData_Point::GeomData_Point() +{ + myIsInitialized = false; +} + +void GeomData_Point::reinit() +{ + myIsInitialized = true; + for (int aComponent = 0; aComponent < NUM_COMPONENTS; ++aComponent) { + myExpression[aComponent]->reinit(); + myIsInitialized = myIsInitialized && myExpression[aComponent]->isInitialized(); + } +} + +void GeomData_Point::setCalculatedValue(const double theX, const double theY, const double theZ) +{ + if (!myIsInitialized || x() != theX || y() != theY || z() != theZ) { + myExpression[0]->setValue(theX); + myExpression[1]->setValue(theY); + myExpression[2]->setValue(theZ); + owner()->data()->sendAttributeUpdated(this); + } +} void GeomData_Point::setValue(const double theX, const double theY, const double theZ) { - myCoords->SetValue(0, theX); - myCoords->SetValue(1, theY); - myCoords->SetValue(2, theZ); + setCalculatedValue(textX().empty() ? theX : x(), + textY().empty() ? theY : y(), + textZ().empty() ? theZ : z()); +} + +void GeomData_Point::setValue(const std::shared_ptr& thePoint) +{ + setValue(thePoint->x(), thePoint->y(), thePoint->z()); } double GeomData_Point::x() const { - return myCoords->Value(0); + return myExpression[0]->value(); } double GeomData_Point::y() const { - return myCoords->Value(1); + return myExpression[1]->value(); } double GeomData_Point::z() const { - return myCoords->Value(2); + return myExpression[2]->value(); +} + +void GeomData_Point::setX(const double theX) +{ + if (!myIsInitialized) { + setCalculatedValue(theX, 0, 0); + } else if (x() != theX) { + myExpression[0]->setValue(theX); + myExpression[0]->setText(""); // uninitialize the text + owner()->data()->sendAttributeUpdated(this); + } +} + +void GeomData_Point::setY(const double theY) +{ + if (!myIsInitialized) { + setCalculatedValue(0, theY, 0); + } else if (y() != theY) { + myExpression[1]->setValue(theY); + myExpression[1]->setText(""); // uninitialize the text + owner()->data()->sendAttributeUpdated(this); + } +} + +void GeomData_Point::setZ(const double theZ) +{ + if (!myIsInitialized) { + setCalculatedValue(0, 0, theZ); + } + else if (z() != theZ) { + myExpression[2]->setValue(theZ); + myExpression[2]->setText(""); // uninitialize the text + owner()->data()->sendAttributeUpdated(this); + } +} + + +std::shared_ptr GeomData_Point::pnt() +{ + std::shared_ptr aResult(new GeomAPI_Pnt(x(), y(), z())); + return aResult; +} + +void GeomData_Point::setText(const std::string& theX, + const std::string& theY, + const std::string& theZ) +{ + if (!myIsInitialized || textX() != theX || textY() != theY || textZ() != theZ) { + myExpression[0]->setText(theX); + myExpression[1]->setText(theY); + myExpression[2]->setText(theZ); + // Send it to evaluator to convert into the double and store in the attribute + ModelAPI_AttributeEvalMessage::send(owner()->data()->attribute(id()), this); + owner()->data()->sendAttributeUpdated(this); + } } -GeomData_Point::GeomData_Point(TDF_Label& theLabel) +void GeomData_Point::setTextX(const std::string& theX) { - // check the attribute could be already presented in this doc (after load document) - if (!theLabel.FindAttribute(TDataStd_RealArray::GetID(), myCoords)) { - // create attribute: not initialized by value yet, just zero - myCoords = TDataStd_RealArray::Set(theLabel, 0, 2); + if (!myIsInitialized) { + static const std::string aDefaultText = "0"; + setText(theX, aDefaultText, aDefaultText); } + else if (textX() != theX) { + myExpression[0]->setText(theX); + // Send it to evaluator to convert into the double and store in the attribute + ModelAPI_AttributeEvalMessage::send(owner()->data()->attribute(id()), this); + owner()->data()->sendAttributeUpdated(this); + } +} + +void GeomData_Point::setTextY(const std::string& theY) +{ + if (!myIsInitialized) { + static const std::string aDefaultText = "0"; + setText(aDefaultText, theY, aDefaultText); + } + else if (textY() != theY) { + myExpression[1]->setText(theY); + // Send it to evaluator to convert into the double and store in the attribute + ModelAPI_AttributeEvalMessage::send(owner()->data()->attribute(id()), this); + owner()->data()->sendAttributeUpdated(this); + } +} + +void GeomData_Point::setTextZ(const std::string& theZ) +{ + if (!myIsInitialized) { + static const std::string aDefaultText = "0"; + setText(aDefaultText, aDefaultText, theZ); + } + else if (textZ() != theZ) { + myExpression[2]->setText(theZ); + // Send it to evaluator to convert into the double and store in the attribute + ModelAPI_AttributeEvalMessage::send(owner()->data()->attribute(id()), this); + owner()->data()->sendAttributeUpdated(this); + } +} + +std::string GeomData_Point::textX() +{ + return myExpression[0]->text(); +} +std::string GeomData_Point::textY() +{ + return myExpression[1]->text(); +} +std::string GeomData_Point::textZ() +{ + return myExpression[2]->text(); +} + +void GeomData_Point::setExpressionInvalid(int theComponent, bool theFlag) +{ + assert(theComponent >= 0 && theComponent < NUM_COMPONENTS); + if (!myIsInitialized || expressionInvalid(theComponent) != theFlag) + myExpression[theComponent]->setInvalid(theFlag); +} + +bool GeomData_Point::expressionInvalid(int theComponent) +{ + assert(theComponent >= 0 && theComponent < NUM_COMPONENTS); + return myExpression[theComponent]->isInvalid(); +} + +void GeomData_Point::setExpressionError(int theComponent, const std::string& theError) +{ + assert(theComponent >= 0 && theComponent < NUM_COMPONENTS); + if (expressionError(theComponent) != theError) + myExpression[theComponent]->setError(theError); +} + +std::string GeomData_Point::expressionError(int theComponent) +{ + assert(theComponent >= 0 && theComponent < NUM_COMPONENTS); + return myExpression[theComponent]->error(); +} + +void GeomData_Point::setUsedParameters(int theComponent, + const std::set& theUsedParameters) +{ + assert(theComponent >= 0 && theComponent < NUM_COMPONENTS); + myExpression[theComponent]->setUsedParameters(theUsedParameters); +} + +std::set GeomData_Point::usedParameters(int theComponent) const +{ + assert(theComponent >= 0 && theComponent < NUM_COMPONENTS); + return myExpression[theComponent]->usedParameters(); }