X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FParametersPlugin%2FParametersPlugin_EvalListener.cpp;h=d63741c9fa606596f832c40bd95ddb6524d0b2ac;hb=471cc7b52168016a3b6fff7e64cdd800cd7d8f91;hp=03b4b11996a3d4d1d8830da95dfb2015a8126d97;hpb=9518d50a9b5dd14c20ffa04ee8dbf9995f96ee2c;p=modules%2Fshaper.git diff --git a/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp b/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp index 03b4b1199..d63741c9f 100644 --- a/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp +++ b/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp @@ -11,8 +11,10 @@ #include #include -#include +#include +#include +#include #include #include #include @@ -21,21 +23,48 @@ #include #include -#include #include #include +#include + #include #include #include +//------------------------------------------------------------------------------ +// Tools + +std::string toStdString(double theValue) +{ + std::ostringstream sstream; + sstream << theValue; + size_t aPos = sstream.str().find("."); + std::string aPnt = ""; + if (aPos == std::string::npos) + aPnt = "."; + return sstream.str() + aPnt; +} + +std::set toSet(const std::list& theContainer) +{ + return std::set(theContainer.begin(), theContainer.end()); +} + +//------------------------------------------------------------------------------ + ParametersPlugin_EvalListener::ParametersPlugin_EvalListener() { Events_Loop* aLoop = Events_Loop::loop(); - const Events_ID kEvaluationEvent = ModelAPI_AttributeEvalMessage::eventId(); - aLoop->registerListener(this, kEvaluationEvent, NULL, true); - const Events_ID kObjectRenamedEvent = ModelAPI_ObjectRenamedMessage::eventId(); - aLoop->registerListener(this, kObjectRenamedEvent, NULL, true); + + Events_ID anEvents_IDs[] = { + ModelAPI_AttributeEvalMessage::eventId(), + ModelAPI_ObjectRenamedMessage::eventId(), + ModelAPI_ReplaceParameterMessage::eventId() + }; + + for (int i = 0; i < sizeof(anEvents_IDs)/sizeof(anEvents_IDs[0]); ++i) + aLoop->registerListener(this, anEvents_IDs[i], NULL, true); myInterp = std::shared_ptr(new ParametersPlugin_PyInterp()); myInterp->initialize(); @@ -53,18 +82,23 @@ void ParametersPlugin_EvalListener::processEvent( const Events_ID kEvaluationEvent = ModelAPI_AttributeEvalMessage::eventId(); const Events_ID kObjectRenamedEvent = ModelAPI_ObjectRenamedMessage::eventId(); + const Events_ID kReplaceParameterEvent = ModelAPI_ReplaceParameterMessage::eventId(); + if (theMessage->eventID() == kEvaluationEvent) { processEvaluationEvent(theMessage); } else if (theMessage->eventID() == kObjectRenamedEvent) { processObjectRenamedEvent(theMessage); + } else if (theMessage->eventID() == kReplaceParameterEvent) { + processReplaceParameterEvent(theMessage); } else { - Events_Error::send(std::string("ParametersPlugin python interpreter, unhandled message caught: ") - + theMessage->eventID().eventText()); + Events_InfoMessage("ParametersPlugin_EvalListener", + "ParametersPlugin python interpreter, unhandled message caught: ") + .arg(theMessage->eventID().eventText()).send(); } } -double ParametersPlugin_EvalListener::evaluate(const std::string& theExpression, std::string& theError, - const std::shared_ptr& theDocument) +double ParametersPlugin_EvalListener::evaluate(FeaturePtr theParameter, + const std::string& theExpression, std::string& theError) { std::list anExprParams = myInterp->compile(theExpression); // find expression's params in the model @@ -73,12 +107,14 @@ double ParametersPlugin_EvalListener::evaluate(const std::string& theExpression, for ( ; it != anExprParams.end(); it++) { double aValue; ResultParameterPtr aParamRes; - if (!ModelAPI_Tools::findVariable(*it, aValue, aParamRes, theDocument)) continue; - - std::ostringstream sstream; - sstream << aValue; - std::string aParamValue = sstream.str(); - aContext.push_back(*it + "=" + aParamValue); + // If variable does not exist python interpreter will generate an error. It is OK. + // But due to the issue 1479 it should not check the history position of parameters relatively + // to feature that contains expression + if (!ModelAPI_Tools::findVariable(/*theParameter*/ FeaturePtr(), + *it, aValue, aParamRes, theParameter->document())) + continue; + + aContext.push_back(*it + "=" + toStdString(aValue)); } myInterp->extendLocalContext(aContext); double result = myInterp->evaluate(theExpression, theError); @@ -86,22 +122,31 @@ double ParametersPlugin_EvalListener::evaluate(const std::string& theExpression, return result; } -std::set toSet(const std::list& theContainer) -{ - return std::set(theContainer.begin(), theContainer.end()); -} - void ParametersPlugin_EvalListener::processEvaluationEvent( const std::shared_ptr& theMessage) { std::shared_ptr aMessage = std::dynamic_pointer_cast(theMessage); + FeaturePtr aParamFeature = + std::dynamic_pointer_cast(aMessage->attribute()->owner()); + if (aMessage->attribute()->attributeType() == ModelAPI_AttributeInteger::typeId()) { + AttributeIntegerPtr anAttribute = + std::dynamic_pointer_cast(aMessage->attribute()); + std::string anError; + int aValue = (int)evaluate(aParamFeature, anAttribute->text(), anError); + bool isValid = anError.empty(); + if (isValid) + anAttribute->setCalculatedValue(aValue); + anAttribute->setUsedParameters(isValid ? toSet(myInterp->compile(anAttribute->text())) : std::set()); + anAttribute->setExpressionInvalid(!isValid); + anAttribute->setExpressionError(anAttribute->text().empty() ? "" : anError); + } else if (aMessage->attribute()->attributeType() == ModelAPI_AttributeDouble::typeId()) { AttributeDoublePtr anAttribute = std::dynamic_pointer_cast(aMessage->attribute()); std::string anError; - double aValue = evaluate(anAttribute->text(), anError, anAttribute->owner()->document()); + double aValue = evaluate(aParamFeature, anAttribute->text(), anError); bool isValid = anError.empty(); if (isValid) anAttribute->setCalculatedValue(aValue); @@ -124,7 +169,7 @@ void ParametersPlugin_EvalListener::processEvaluationEvent( }; for (int i = 0; i < 3; ++i) { std::string anError; - double aValue = evaluate(aText[i], anError, anAttribute->owner()->document()); + double aValue = evaluate(aParamFeature, aText[i], anError); bool isValid = anError.empty(); if (isValid) aCalculatedValue[i] = aValue; anAttribute->setUsedParameters(i, isValid ? toSet(myInterp->compile(aText[i])) : std::set()); @@ -148,7 +193,7 @@ void ParametersPlugin_EvalListener::processEvaluationEvent( }; for (int i = 0; i < 2; ++i) { std::string anError; - double aValue = evaluate(aText[i], anError, anAttribute->owner()->document()); + double aValue = evaluate(aParamFeature, aText[i], anError); bool isValid = anError.empty(); if (isValid) aCalculatedValue[i] = aValue; anAttribute->setUsedParameters(i, isValid ? toSet(myInterp->compile(aText[i])) : std::set()); @@ -222,6 +267,14 @@ void ParametersPlugin_EvalListener::renameInAttribute( const std::string& theOldName, const std::string& theNewName) { + if (theAttribute->attributeType() == ModelAPI_AttributeInteger::typeId()) { + AttributeIntegerPtr anAttribute = + std::dynamic_pointer_cast(theAttribute); + std::string anExpressionString = anAttribute->text(); + anExpressionString = renameInPythonExpression(anExpressionString, + theOldName, theNewName); + anAttribute->setText(anExpressionString); + } else if (theAttribute->attributeType() == ModelAPI_AttributeDouble::typeId()) { AttributeDoublePtr anAttribute = std::dynamic_pointer_cast(theAttribute); @@ -260,9 +313,33 @@ void ParametersPlugin_EvalListener::renameInAttribute( } } +void ParametersPlugin_EvalListener::renameInDependents(std::shared_ptr theResultParameter, + const std::string& theOldName, + const std::string& theNewName) +{ + std::set > anAttributes = + theResultParameter->data()->refsToMe(); + std::set >::const_iterator anAttributeIt = + anAttributes.cbegin(); + for (; anAttributeIt != anAttributes.cend(); ++anAttributeIt) { + const AttributePtr& anAttribute = *anAttributeIt; + if (anAttribute->attributeType() == ModelAPI_AttributeRefList::typeId()) { + std::shared_ptr aParameter = + std::dynamic_pointer_cast( + anAttribute->owner()); + if (aParameter.get()) + // Rename + renameInParameter(aParameter, theOldName, theNewName); + } else + // Rename + renameInAttribute(anAttribute, theOldName, theNewName); + } +} + bool isValidAttribute(const AttributePtr& theAttribute) { - std::string aValidator, anError; + std::string aValidator; + Events_InfoMessage anError; return ModelAPI_Session::get()->validators()->validate(theAttribute, aValidator, anError); } @@ -270,7 +347,7 @@ void setParameterName(ResultParameterPtr theResultParameter, const std::string& { theResultParameter->data()->blockSendAttributeUpdated(true); theResultParameter->data()->setName(theName); - theResultParameter->data()->blockSendAttributeUpdated(false); + theResultParameter->data()->blockSendAttributeUpdated(false, false); std::shared_ptr aParameter = std::dynamic_pointer_cast( @@ -306,6 +383,18 @@ void ParametersPlugin_EvalListener::processObjectRenamedEvent( if (!aParameter.get()) return; + std::string aNotActivatedNames; + if (!ModelAPI_Tools::allDocumentsActivated(aNotActivatedNames)) { + QMessageBox::StandardButton aRes = QMessageBox::warning(0, QObject::tr("Warning"), + QObject::tr("Selected objects can be used in Part documents which are not loaded: \ +%1. Whould you like to continue?").arg(aNotActivatedNames.c_str()), + QMessageBox::No | QMessageBox::Yes, QMessageBox::No); + if (aRes != QMessageBox::Yes) { + setParameterName(aResultParameter, aMessage->oldName()); + return; + } + } + // try to update the parameter feature according the new name setParameterName(aResultParameter, aMessage->newName()); // TODO(spo): replace with ModelAPI_Session::get()->validators()->validate(aParameter, ParametersPlugin_Parameter::VARIABLE_ID()) @@ -316,24 +405,30 @@ void ParametersPlugin_EvalListener::processObjectRenamedEvent( return; } - std::set > anAttributes = - aResultParameter->data()->refsToMe(); - std::set >::const_iterator anAttributeIt = - anAttributes.cbegin(); - for (; anAttributeIt != anAttributes.cend(); ++anAttributeIt) { - const AttributePtr& anAttribute = *anAttributeIt; - AttributeRefListPtr anAttributeRefList = - std::dynamic_pointer_cast(anAttribute); - if (anAttributeRefList.get()) { - std::shared_ptr aParameter = - std::dynamic_pointer_cast( - anAttributeRefList->owner()); - if (aParameter.get()) - // Rename - renameInParameter(aParameter, aMessage->oldName(), aMessage->newName()); - } else - // Rename - renameInAttribute(anAttribute, aMessage->oldName(), aMessage->newName()); - } + renameInDependents(aResultParameter, aMessage->oldName(), aMessage->newName()); } +void ParametersPlugin_EvalListener::processReplaceParameterEvent( + const std::shared_ptr& theMessage) +{ + std::shared_ptr aMessage = + std::dynamic_pointer_cast(theMessage); + + // get parameter feature for the object + std::shared_ptr aParameter = + std::dynamic_pointer_cast( + ModelAPI_Feature::feature(aMessage->object())); + if (!aParameter.get()) + return; + + ResultParameterPtr aResultParameter = + std::dynamic_pointer_cast( + aParameter->firstResult()); + if (!aResultParameter.get()) + return; + + double aRealValue = aResultParameter->data()->real(ModelAPI_ResultParameter::VALUE())->value(); + std::string aValue = toStdString(aRealValue); + + renameInDependents(aResultParameter, aResultParameter->data()->name(), aValue); +}