-// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2022 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
//
// 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
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or
-// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "ModuleBase_Tools.h"
#include <ModuleBase_ParamIntSpinBox.h>
#include <ModuleBase_ParamSpinBox.h>
+#include <ModuleBase_Preferences.h>
#include <ModuleBase_WidgetFactory.h>
#include <ModuleBase_IWorkshop.h>
#include <ModuleBase_IModule.h>
+#include <ModuleBase_IViewer.h>
#include <ModuleBase_IconFactory.h>
#include <ModuleBase_ResultPrs.h>
+#include <ModuleBase_ViewerPrs.h>
#include <ModelAPI_Attribute.h>
#include <ModelAPI_AttributeRefAttr.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeRefList.h>
#include <ModelAPI_AttributeRefAttrList.h>
+#include <ModelAPI_ResultGroup.h>
#include <ModelAPI_ResultPart.h>
#include <ModelAPI_ResultConstruction.h>
+#include <ModelAPI_AttributeString.h>
+#include <ModelAPI_Expression.h>
+#include <ModelAPI_ResultField.h>
#include <Events_Loop.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Result.h>
-#include <ModelAPI_ResultCompSolid.h>
#include <ModelAPI_ResultParameter.h>
#include <ModelAPI_Tools.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Folder.h>
#include <ModelGeomAlgo_Point2D.h>
+#include <SUIT_ResourceMgr.h>
+#ifdef HAVE_SALOME
+#include <SUIT_Application.h>
+#include <SUIT_Session.h>
+#endif
+
+#include <StdSelect_BRepOwner.hxx>
#include <TopoDS_Iterator.hxx>
+#include <AIS_InteractiveContext.hxx>
+#include <Prs3d_LineAspect.hxx>
+#include <Prs3d_PlaneAspect.hxx>
#include <GeomDataAPI_Point2D.h>
#include <Events_InfoMessage.h>
#include <QMessageBox>
#include <QAction>
#include <QTextCodec>
+#include <QWindow>
+#include <QScreen>
+#include <QCheckBox>
#include <sstream>
#include <string>
//******************************************************************
+ //! Waits for REDISPLAY message and set the Visible flag to the entities
+ //! according to Preferences choice.
+ class ModuleBase_RedisplayListener : public Events_Listener
+ {
+ public:
+ static std::shared_ptr<ModuleBase_RedisplayListener> instance()
+ {
+ static std::shared_ptr<ModuleBase_RedisplayListener>
+ anInstance(new ModuleBase_RedisplayListener);
+ return anInstance;
+ }
+
+ void processEvent(const std::shared_ptr<Events_Message>& theMessage)
+ {
+ if (theMessage->eventID() == Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY))
+ {
+#if HAVE_SALOME
+ // If the python script is being loaded now, the preferences should be used
+ // to display the required object
+ SUIT_Session* aSession = SUIT_Session::session();
+ if (!aSession)
+ return;
+ SUIT_Application * anApp = aSession->activeApplication();
+ if (!anApp)
+ return;
+ QVariant aVar = anApp->property("IsLoadedScript");
+ if (!aVar.isNull() && aVar.toBool()) {
+ DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
+ int aSize = aRootDoc->size(ModelAPI_ResultPart::group());
+ if (aSize > 0) {
+ ObjectPtr anPartObject = aRootDoc->object(ModelAPI_ResultPart::group(), aSize - 1);
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(anPartObject);
+ ModuleBase_Tools::setDisplaying(aPart, true);
+ }
+ }
+#endif
+ }
+ }
+
+ private:
+ ModuleBase_RedisplayListener()
+ {
+ Events_Loop::loop()->registerListener(this,
+ Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ }
+ };
+
+ static std::shared_ptr<ModuleBase_RedisplayListener>
+ RL = ModuleBase_RedisplayListener::instance();
+
//******************************************************************
void adjustMargins(QWidget* theWidget)
activateWindow(theWidget);
theWidget->setFocus();
// rectangle of focus is not visible on tool button widgets
- theWidget->repaint();
+ theWidget->update();
#ifdef DEBUG_SET_FOCUS
qDebug(QString("setFocus: %1").arg(theInfo).toStdString().c_str());
#endif
{
QImage anIcon = ModuleBase_IconFactory::loadImage(theIcon);
QImage anAditional(theAdditionalIcon);
+ return composite(anAditional, anIcon);
+}
- if (anIcon.isNull())
+QPixmap composite(const QImage& theAdditionalIcon, QImage& theIcon)
+{
+ if (theIcon.isNull())
return QPixmap();
- int anAddWidth = anAditional.width();
- int anAddHeight = anAditional.height();
+ int anAddWidth = theAdditionalIcon.width();
+ int anAddHeight = theAdditionalIcon.height();
- int aWidth = anIcon.width();
- int aHeight = anIcon.height();
+ int aWidth = theIcon.width();
+ int aHeight = theIcon.height();
- int aStartWidthPos = aWidth - anAddWidth - 1;
- int aStartHeightPos = aHeight - anAddHeight - 1;
+ int aStartWidthPos = aWidth - anAddWidth;
+ int aStartHeightPos = aHeight - anAddHeight;
for (int i = 0; i < anAddWidth && i + aStartWidthPos < aWidth; i++)
{
for (int j = 0; j < anAddHeight && j + aStartHeightPos < aHeight; j++)
{
- if (qAlpha(anAditional.pixel(i, j)) > 0)
- anIcon.setPixel(i + aStartWidthPos, j + aStartHeightPos, anAditional.pixel(i, j));
+ if (qAlpha(theAdditionalIcon.pixel(i, j)) > 0)
+ theIcon.setPixel(i + aStartWidthPos, j + aStartHeightPos, theAdditionalIcon.pixel(i, j));
}
}
- return QPixmap::fromImage(anIcon);
+ return QPixmap::fromImage(theIcon);
}
QPixmap lighter(const QString& theIcon, const int theLighterValue)
void setSpinValue(ModuleBase_ParamSpinBox* theSpin, double theValue)
{
- if (fabs(theSpin->value() - theValue) < tolerance)
+ if (!theSpin->text().isEmpty() && fabs(theSpin->value() - theValue) < tolerance)
return;
bool isBlocked = theSpin->blockSignals(true);
theSpin->setValue(theValue);
if (!theObj.get())
return "";
- return theObj->data()->name().c_str();
+ return QString::fromStdWString(theObj->data()->name());
}
QString objectInfo(const ObjectPtr& theObj, const bool isUseAttributesInfo)
if (aFeature.get()) {
aFeatureStr.append(QString(": %1").arg(aFeature->getKind().c_str()).toStdString().c_str());
if (aFeature->data()->isValid()) {
- aFeatureStr.append(QString(", name=%1").arg(theObj->data()->name().c_str()).toStdString()
- .c_str());
+ aFeatureStr.append(QString(", name=%1")
+ .arg(QString::fromStdWString(theObj->data()->name())).toStdString().c_str());
}
if (isUseAttributesInfo) {
std::set<std::shared_ptr<ModelAPI_Attribute> > anAttributes;
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(aObj);
ResultParameterPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aResult);
+ FieldStepPtr aStep = std::dynamic_pointer_cast<ModelAPI_ResultField::ModelAPI_FieldStep>(aObj);
- hasResult |= (aResult.get() != NULL);
+ hasResult |= ((aResult.get() != NULL) || (aStep.get() != NULL));
hasFeature |= (aFeature.get() != NULL);
hasFolder |= (aFolder.get() != NULL);
hasParameter |= (aConstruction.get() != NULL);
if (hasFeature)
hasCompositeOwner |= (ModelAPI_Tools::compositeOwner(aFeature) != NULL);
+ else if (aResult.get())
+ hasCompositeOwner |= (ModelAPI_Tools::bodyOwner(aResult) != NULL);
if (!hasResultInHistory && aResult.get()) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(aResult);
+ aFeature = ModelAPI_Feature::feature(aResult);
hasResultInHistory = aFeature.get() && aFeature->isInHistory();
}
- if (hasFeature && hasResult && hasParameter && hasCompositeOwner && hasFeature)
+ if (hasFeature && hasResult && hasParameter && hasCompositeOwner)
break;
}
}
-/*bool setDefaultDeviationCoefficient(std::shared_ptr<GeomAPI_Shape> theGeomShape)
-{
- if (!theGeomShape.get())
- return false;
- // if the shape could not be exploded on faces, it contains only wires, edges, and vertices
- // correction of deviation for them should not influence to the application performance
- GeomAPI_ShapeExplorer anExp(theGeomShape, GeomAPI_Shape::FACE);
- bool anEmpty = anExp.empty();
- return !anExp.more();
-}*/
-
-/*void setDefaultDeviationCoefficient(const std::shared_ptr<ModelAPI_Result>& theResult,
- const Handle(Prs3d_Drawer)& theDrawer)
-{
- if (!theResult.get())
- return;
- bool aUseDeviation = false;
-
- std::string aResultGroup = theResult->groupName();
- if (aResultGroup == ModelAPI_ResultConstruction::group())
- aUseDeviation = true;
- else if (aResultGroup == ModelAPI_ResultBody::group()) {
- GeomShapePtr aGeomShape = theResult->shape();
- if (aGeomShape.get())
- aUseDeviation = setDefaultDeviationCoefficient(aGeomShape);
- }
- if (aUseDeviation)
- theDrawer->SetDeviationCoefficient(DEFAULT_DEVIATION_COEFFICIENT);
-}
-*/
void setDefaultDeviationCoefficient(const TopoDS_Shape& theShape,
const Handle(Prs3d_Drawer)& theDrawer)
{
if (theShape.IsNull())
return;
+ if (theDrawer.IsNull())
+ return;
std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape());
aGeomShape->setImpl(new TopoDS_Shape(theShape));
return aShapeType;
}
+TopoDS_Shape getSelectedShape(const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs)
+{
+ if (thePrs->shape().get())
+ return thePrs->shape()->impl<TopoDS_Shape>();
+
+ Handle(StdSelect_BRepOwner) anOwner = Handle(StdSelect_BRepOwner)::DownCast(thePrs->owner());
+ if (!anOwner.IsNull())
+ return anOwner->Shape();
+
+ return TopoDS_Shape();
+}
+
void getParameters(QStringList& theParameters)
{
theParameters.clear();
int aSize = aDocument->size(aGroupId);
for (int i = 0; i < aSize; i++) {
ObjectPtr anObject = aDocument->object(aGroupId, i);
- std::string aParameterName = anObject->data()->name();
- theParameters.append(aParameterName.c_str());
+ std::wstring aParameterName = anObject->data()->name();
+ theParameters.append(QString::fromStdWString(aParameterName));
}
}
}
if (aType == ModelAPI_AttributeSelectionList::typeId()) {
AttributeSelectionListPtr aSelectionListAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
- ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
- aHasObject = aSelectionListAttr->isInList(aResult, theShape, theTemporarily);
+ aHasObject = aSelectionListAttr->isInList(theObject, theShape, theTemporarily);
}
else if (aType == ModelAPI_AttributeRefList::typeId()) {
AttributeRefListPtr aRefListAttr =
} else if (aType == ModelAPI_AttributeSelection::typeId()) {
AttributeSelectionPtr aSelectAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
- ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
if (aSelectAttr.get() != NULL) {
- aSelectAttr->setValue(aResult, theShape, theTemporarily);
+ aSelectAttr->setValue(theObject, theShape, theTemporarily);
}
}
if (aType == ModelAPI_AttributeSelectionList::typeId()) {
AttributeSelectionListPtr aSelectionListAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
- ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
if (!theCheckIfAttributeHasObject ||
- !aSelectionListAttr->isInList(aResult, theShape, theTemporarily))
- aSelectionListAttr->append(aResult, theShape, theTemporarily);
+ !aSelectionListAttr->isInList(theObject, theShape, theTemporarily))
+ aSelectionListAttr->append(theObject, theShape, theTemporarily);
}
else if (aType == ModelAPI_AttributeRefList::typeId()) {
AttributeRefListPtr aRefListAttr =
// (for the sketch result) to start processing of the sketch in the solver.
// TODO: these flushes should be moved in a separate method provided by Model
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_VISUAL_ATTRIBUTES));
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_UPDATE_SELECTION));
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
blockUpdateViewer(false);
int n = aWords.count();
QString aLine;
for (int i = 0; i < n; i++) {
- QString aLineExt = aLine + " " + aWords[i];
+ QString aLineExt = i == 0 ? aWords[i] : aLine + " " + aWords[i];
qreal anWidthNonExt = tfm.boundingRect(aLine).width();
qreal anWidthExt = tfm.boundingRect(aLineExt).width();
qreal aDeltaNonExt = fabs(anWidthNonExt-aGoldWidth);
const std::string& thePrefixInfo)
{
QString aNotActivatedDocWrn;
- std::string aNotActivatedNames;
+ std::wstring aNotActivatedNames;
if (!ModelAPI_Tools::allDocumentsActivated(aNotActivatedNames)) {
if (ModuleBase_Tools::hasModuleDocumentFeature(theFeatures))
aNotActivatedDocWrn =
- QObject::tr("Selected objects can be used in Part documents which are not loaded:%1.\n")
- .arg(aNotActivatedNames.c_str());
+ QObject::tr("Selected objects can be used in Part documents which are not loaded: %1.\n")
+ .arg(QString::fromStdWString(aNotActivatedNames));
}
std::set<FeaturePtr> aFeaturesRefsTo;
continue;
if (isFeatureOfResult(aFeature, ModelAPI_ResultPart::group()))
- aPartFeatureNames.append(aFeature->name().c_str());
+ aPartFeatureNames.append(QString::fromStdWString(aFeature->name()));
std::set<FeaturePtr> aRefFeatures;
std::set<FeaturePtr> aRefList = theReferences.at(aFeature);
FeaturePtr aFeature = *anIt;
if (theReferencesToDelete.find(aFeature) == theReferencesToDelete.end()) {
aFeaturesRefsToParameterOnly.insert(aFeature);
- aParamFeatureNames.append(aFeature->name().c_str());
+ aParamFeatureNames.append(QString::fromStdWString(aFeature->name()));
}
}
aParamFeatureNames.sort();
aLast = theReferencesToDelete.end();
for (; anIt != aLast; anIt++) {
FeaturePtr aFeature = *anIt;
+ if (aFeature->getKind() == "RemoveResults")
+ continue; // skip the remove results feature mentioning: result will be removed anyway
if (isFeatureOfResult(aFeature, ModelAPI_ResultPart::group()))
- aPartFeatureNames.append(aFeature->name().c_str());
+ aPartFeatureNames.append(QString::fromStdWString(aFeature->name()));
else
- anOtherFeatureNames.append(aFeature->name().c_str());
+ anOtherFeatureNames.append(QString::fromStdWString(aFeature->name()));
}
aPartFeatureNames.sort();
anOtherFeatureNames.sort();
- bool aCanReplaceParameters = !aFeaturesRefsToParameterOnly.empty();
-
QMessageBox aMessageBox(theParent);
aMessageBox.setWindowTitle(QObject::tr("Delete features"));
aMessageBox.setIcon(QMessageBox::Warning);
aMessageBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
aMessageBox.setDefaultButton(QMessageBox::No);
- QString aText;
+ QString aText, aDetailedText;
if (!thePrefixInfo.empty())
aText = thePrefixInfo.c_str();
QString aSep = ", ";
if (!aNotActivatedDocWrn.isEmpty())
aText += aNotActivatedDocWrn;
if (!anOtherFeatureNames.empty()) {
- const char* aMsg = "Features are used in the following features: %1.\nThese "
- "features will be deleted.\n";
- aText += QString(QObject::tr(aMsg))
+ const char* aMsg = "The selected features are used in some\n"
+ "other features, which will also be deleted.\n";
+ const char* aMsgDetails = "The selected features are used"
+ " in the following features: %1.\n";
+ aText += QString(QObject::tr(aMsg));
+ aDetailedText += QString(QObject::tr(aMsgDetails))
.arg(anOtherFeatureNames.join(aSep));
}
if (!aParamFeatureNames.empty()) {
- const char* aMsg = "Parameters are used in the following features: %1.\nThese features will "
- "be deleted.\nOr parameters could be replaced by their values.\n";
- aText += QString(QObject::tr(aMsg))
+ const char* aMsg = "The selected parameters are used directly or through\n"
+ "a sequence of dependencies in some features.\n"
+ "These features will be deleted.\n"
+ "Or parameters could be replaced by their values.\n";
+ const char* aMsgDetails = "Parameters are used in the following features: %1.\n";
+ aText += QString(QObject::tr(aMsg));
+ aDetailedText += QString(QObject::tr(aMsgDetails))
.arg(aParamFeatureNames.join(aSep));
- QPushButton *aReplaceButton =
- aMessageBox.addButton(QObject::tr("Replace"), QMessageBox::ActionRole);
+ aMessageBox.addButton(QObject::tr("Replace"), QMessageBox::ActionRole);
}
if (!aText.isEmpty()) {
- aText += "Would you like to continue?";
aMessageBox.setText(aText);
+ aMessageBox.setInformativeText(QObject::tr("Would you like to continue?"));
+ if (!aDetailedText.isEmpty())
+ aMessageBox.setDetailedText(aDetailedText);
aMessageBox.exec();
QMessageBox::ButtonRole aButtonRole = aMessageBox.buttonRole(aMessageBox.clickedButton());
return true;
}
+//**************************************************************
+bool warningAboutConflict(QWidget* theParent, const std::string& theWarningText)
+{
+ QMessageBox aMessageBox(theParent);
+ aMessageBox.setWindowTitle(QObject::tr("Conflicts in constraint"));
+ aMessageBox.setIcon(QMessageBox::Warning);
+ aMessageBox.setText((theWarningText + "\nConstraints will be removed or substituted").c_str());
+
+ QCheckBox* aCheckBox = new QCheckBox;
+
+ aCheckBox->setTristate(false);
+ aCheckBox->setText("switch off the notifications.");
+
+ aMessageBox.setCheckBox(aCheckBox);
+ aMessageBox.setStandardButtons(QMessageBox::Ok);
+
+ aMessageBox.exec();
+
+ if (aCheckBox->isChecked())
+ {
+ ModuleBase_Preferences::resourceMgr()->setValue(SKETCH_TAB_NAME,
+ "notify_change_constraint", false);
+ }
+
+ return true;
+}
+
//**************************************************************
void convertToFeatures(const QObjectPtrList& theObjects, std::set<FeaturePtr>& theFeatures)
{
if (!aFeature.get() && anObject->groupName() == ModelAPI_ResultParameter::group()) {
aFeature = ModelAPI_Feature::feature(anObject);
}
- theFeatures.insert(aFeature);
+ if (aFeature.get())
+ theFeatures.insert(aFeature);
+ }
+}
+
+//**************************************************************
+void convertToFolders(const QObjectPtrList& theObjects,
+ std::set<FolderPtr>& theFolders)
+{
+ QObjectPtrList::const_iterator anIt = theObjects.begin(), aLast = theObjects.end();
+ for(; anIt != aLast; anIt++) {
+ ObjectPtr anObject = *anIt;
+ FolderPtr aFeature = std::dynamic_pointer_cast<ModelAPI_Folder>(anObject);
+ if (aFeature.get())
+ theFolders.insert(aFeature);
}
}
+
+//**************************************************************
QString translate(const Events_InfoMessage& theMessage)
{
QString aMessage;
return aMessage;
}
-void setPointBallHighlighting(AIS_Shape* theAIS)
+void setPointBallHighlighting(AIS_InteractiveObject* theAIS)
{
static Handle(Image_AlienPixMap) aPixMap;
if(aPixMap.IsNull()) {
aFile = std::string(anEnv) +
FSEP + "share" + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper";
} else {
- anEnv = getenv("OPENPARTS_ROOT_DIR");
+ anEnv = getenv("CADBUILDER_ROOT_DIR");
if (anEnv)
aFile = std::string(anEnv) + FSEP + "resources";
}
}
Handle(Graphic3d_AspectMarker3d) anAspect;
- Handle(Prs3d_Drawer) aDrawer = theAIS->HilightAttributes();
-#ifdef USE_OCCT_720
- // to do: implement ball highlighting, in 7.2.0 this drawer is NULL
-#else
+ Handle(Prs3d_Drawer) aDrawer = theAIS->DynamicHilightAttributes();
+ if (aDrawer.IsNull()) {
+ if (ModuleBase_IViewer::DefaultHighlightDrawer.IsNull())
+ return;
+ aDrawer = new Prs3d_Drawer(*ModuleBase_IViewer::DefaultHighlightDrawer);
+ if (!aDrawer->HasOwnPointAspect()) {
+ aDrawer->SetPointAspect(new Prs3d_PointAspect(Aspect_TOM_BALL, Quantity_NOC_BLACK, 2.0));
+ }
+ }
if(aDrawer->HasOwnPointAspect()) {
Handle(Prs3d_PointAspect) aPntAspect = aDrawer->PointAspect();
if(aPixMap->IsEmpty()) {
aPntAspect->SetAspect(anAspect);
}
aDrawer->SetPointAspect(aPntAspect);
- theAIS->SetHilightAttributes(aDrawer);
+ theAIS->SetDynamicHilightAttributes(aDrawer);
}
-#endif
+}
+
+FeaturePtr createParameter(const QString& theText)
+{
+ FeaturePtr aParameter;
+ QStringList aList = theText.split("=");
+ if (aList.count() != 2) {
+ return aParameter;
+ }
+ QString aParamName = aList.at(0).trimmed();
+
+ if (isNameExist(aParamName, FeaturePtr())) {
+ return aParameter;
+ }
+
+ if (!ModelAPI_Expression::isVariable(aParamName.toStdString())) {
+ return aParameter;
+ }
+
+ QString aExpression = aList.at(1).trimmed();
+ if (aExpression.isEmpty()) {
+ return aParameter;
+ }
+
+ SessionPtr aMgr = ModelAPI_Session::get();
+ std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
+
+ aParameter = aDoc->addFeature("Parameter", false);
+ if (aParameter.get()) {
+ AttributeStringPtr aNameAttr = aParameter->string("variable");
+ aNameAttr->setValue(aParamName.toStdString());
+
+ AttributeStringPtr aExprAttr = aParameter->string("expression");
+ aExprAttr->setValue(aExpression.toStdString());
+ aParameter->execute();
+
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+ }
+ return aParameter;
+}
+
+void editParameter(FeaturePtr theParam, const QString& theText)
+{
+ QStringList aList = theText.split("=");
+ QString aParamName = aList.at(0).trimmed();
+
+ QString aExpression = aList.at(1).trimmed();
+ if (aExpression.isEmpty()) {
+ return;
+ }
+
+ if (isNameExist(aParamName, theParam)) {
+ return;
+ }
+ AttributeStringPtr aNameAttr = theParam->string("variable");
+ aNameAttr->setValue(aParamName.toStdString());
+
+ AttributeStringPtr aExprAttr = theParam->string("expression");
+ aExprAttr->setValue(aExpression.toStdString());
+ theParam->execute();
+
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+}
+
+bool isNameExist(const QString& theName, FeaturePtr theIgnoreParameter)
+{
+ SessionPtr aMgr = ModelAPI_Session::get();
+ std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
+ FeaturePtr aParamFeature;
+ int aNbFeatures = aDoc->numInternalFeatures();
+ std::wstring aName = theName.toStdWString();
+ for (int i = 0; i < aNbFeatures; i++) {
+ aParamFeature = aDoc->internalFeature(i);
+ if (aParamFeature && aParamFeature->getKind() == "Parameter") {
+ if ((theIgnoreParameter != aParamFeature) && (aParamFeature->name() == aName))
+ return true;
+ }
+ }
+ return false;
+}
+
+FeaturePtr findParameter(const QString& theName)
+{
+ SessionPtr aMgr = ModelAPI_Session::get();
+ std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
+ FeaturePtr aParamFeature;
+ int aNbFeatures = aDoc->numInternalFeatures();
+ std::wstring aName = theName.toStdWString();
+ for (int i = 0; i < aNbFeatures; i++) {
+ aParamFeature = aDoc->internalFeature(i);
+ if (aParamFeature && aParamFeature->getKind() == "Parameter") {
+ if (aParamFeature->name() == aName)
+ return aParamFeature;
+ }
+ }
+ return FeaturePtr();
+}
+
+
+//********************************************************************
+std::wstring generateName(const AttributePtr& theAttribute,
+ ModuleBase_IWorkshop* theWorkshop)
+{
+ std::wstring aName;
+ if (theAttribute.get() != NULL) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
+ if (aFeature.get()) {
+ std::string aXmlCfg, aDescription;
+ theWorkshop->module()->getXMLRepresentation(aFeature->getKind(), aXmlCfg, aDescription);
+
+ ModuleBase_WidgetFactory aFactory(aXmlCfg, theWorkshop);
+ std::string anAttributeTitle;
+ aFactory.getAttributeTitle(theAttribute->id(), anAttributeTitle);
+
+ std::wstringstream aStreamName;
+ aStreamName << theAttribute->owner()->data()->name() << "/" << anAttributeTitle.c_str();
+ aName = aStreamName.str();
+ }
+ }
+ return aName;
+}
+
+bool isSameShape(const TopoDS_Shape& theShape1, const TopoDS_Shape& theShape2)
+{
+ // In case of compound we cannot rely on simple comparison method.
+ // If the compound is generated by Group feature then this compound is alwais new.
+ // So, we have to compare content of these compounds
+ if (theShape1.ShapeType() != theShape2.ShapeType())
+ return false;
+
+ if (theShape1.ShapeType() != TopAbs_COMPOUND)
+ return theShape1.IsSame(theShape2);
+
+ TopoDS_Iterator aIt1(theShape1);
+ TopoDS_Iterator aIt2(theShape2);
+
+ for (; aIt1.More() && aIt2.More(); aIt1.Next(), aIt2.Next()) {
+ if (!(aIt1.Value()).IsSame(aIt2.Value()))
+ return false;
+ }
+ return true;
+}
+
+qreal currentPixelRatio()
+{
+ QWindowList aWnds = qApp->topLevelWindows();
+ if (aWnds.size() > 0)
+ return aWnds.first()->devicePixelRatio();
+ return qApp->primaryScreen()->devicePixelRatio();
+}
+
+
+// Set displaying status to every element on group
+static void setDisplayingByLoop(DocumentPtr theDoc, int theSize,
+ std::string theGroup, bool theDisplayFromScript, int theDisplayingId)
+{
+ for (int anIndex = theSize - 1; anIndex >= 0; --anIndex) {
+ ObjectPtr anObject = theDoc->object(theGroup, anIndex);
+ anObject->setDisplayed((theDisplayingId == 1 && anIndex == theSize - 1) ||
+ theDisplayingId == 2);
+ }
+}
+
+void setDisplaying(ResultPartPtr thePart, bool theDisplayFromScript)
+{
+ static bool isDoingDisplay = false;
+
+ if (isDoingDisplay)
+ return;
+
+ isDoingDisplay = true;
+ DocumentPtr aDoc = thePart->partDoc();
+ int aConstructionSize = aDoc->size(ModelAPI_ResultConstruction::group());
+ int aGroupSize = aDoc->size(ModelAPI_ResultGroup::group());
+ int aFieldSize = aDoc->size(ModelAPI_ResultField::group());
+ int aResultSize = aDoc->size(ModelAPI_ResultBody::group());
+
+ int aDisplayingId = -1;
+ if (theDisplayFromScript) {
+ aDisplayingId = ModuleBase_Preferences::resourceMgr()->integerValue("General",
+ "part_visualization_script", -1);
+ // Increase ID to prevert using "As stored in HDF"
+ ++aDisplayingId;
+ }
+ else {
+ aDisplayingId = ModuleBase_Preferences::resourceMgr()->integerValue("General",
+ "part_visualization_study", -1);
+
+ // if chosen "As stored in HDF" then don't change displaying
+ if (aDisplayingId == 0)
+ return;
+ }
+
+ setDisplayingByLoop(aDoc, aConstructionSize, ModelAPI_ResultConstruction::group(),
+ theDisplayFromScript, aDisplayingId);
+ setDisplayingByLoop(aDoc, aGroupSize, ModelAPI_ResultGroup::group(),
+ theDisplayFromScript, aDisplayingId);
+ setDisplayingByLoop(aDoc, aFieldSize, ModelAPI_ResultField::group(),
+ theDisplayFromScript, aDisplayingId);
+ setDisplayingByLoop(aDoc, aResultSize, ModelAPI_ResultBody::group(),
+ theDisplayFromScript, aDisplayingId);
+ isDoingDisplay = false;
}
} // namespace ModuleBase_Tools