-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2024 CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include <ModelAPI_Tools.h>
#include <ModelAPI_AttributeString.h>
+// Attention: keep the next include here,
+// otherwise it causes compilation errors at least on Debian 8
+#include <ModuleBase_Preferences.h>
+
#include "PartSet_OverconstraintListener.h"
#include <PartSet_Module.h>
#include <PartSet_SketcherMgr.h>
#include "SketchPlugin_SketchEntity.h"
#include "SketchPlugin_MacroArcReentrantMessage.h"
#include "SketchPlugin_Sketch.h"
+#include "SketchPlugin_ConstraintHorizontal.h"
+#include "SketchPlugin_ConstraintVertical.h"
+
+#include <SUIT_ResourceMgr.h>
#include "Events_Loop.h"
#include <ModuleBase_Tools.h>
#include <QString>
+#include <QTimer>
//#define DEBUG_FEATURE_OVERCONSTRAINT_LISTENER
aLoop->registerListener(this, ModelAPI_EventReentrantMessage::eventId());
aLoop->registerListener(this, SketchPlugin_MacroArcReentrantMessage::eventId());
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_REMOVE_CONSTRAINTS));
}
void PartSet_OverconstraintListener::setActive(const bool& theActive)
return;
FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
- std::string aFeatureName = aFeature->data()->name();
if (myConflictingObjects.find(theObject) != myConflictingObjects.end()) {
theColor = Config_PropManager::color("Visualization", "sketch_overconstraint_color");
}
if (myIsFullyConstrained) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
// only entity features has custom color when sketch is fully constrained
if (aFeature.get() && PartSet_SketcherMgr::isEntity(aFeature->getKind()) &&
!PartSet_SketcherMgr::isExternalFeature(aFeature)) {
}
}
-void PartSet_OverconstraintListener::processEvent(
- const std::shared_ptr<Events_Message>& theMessage)
+void PartSet_OverconstraintListener::processEvent(const std::shared_ptr<Events_Message>& theMessage)
{
// #2271 open document: if sketch has confilcting elements, solver sends message with the
// elements by opening the document. Sketch is not active, but an internal container should
anEventID == Events_Loop::eventByName(EVENT_SOLVER_REPAIRED)) {
std::shared_ptr<ModelAPI_SolverFailedMessage> anErrorMsg =
std::dynamic_pointer_cast<ModelAPI_SolverFailedMessage>(theMessage);
- bool anUpdated = false;
if (anErrorMsg.get()) {
const std::set<ObjectPtr>& aConflictingObjects = anErrorMsg->objects();
if (anEventID == Events_Loop::eventByName(EVENT_SOLVER_FAILED))
- anUpdated = appendConflictingObjects(aConflictingObjects);
+ appendConflictingObjects(aConflictingObjects);
else
- anUpdated = repairConflictingObjects(aConflictingObjects);
+ repairConflictingObjects(aConflictingObjects);
}
}
else if (anEventID == Events_Loop::eventByName(EVENT_SKETCH_UNDER_CONSTRAINED) ||
// This Line's message should not be processed, as the reentrant operation is not for Line
// It is not enoght of kind, the name should be used, e.g. restarted Lines on auxiliary
// cirlce sometimes causes previous line change, kind the same, but feature line is different
- std::string aCurrentFeatureName;
+ std::wstring aCurrentFeatureName;
ModuleBase_Operation* anOperation =
XGUI_Tools::workshop(myWorkshop)->operationMgr()->currentOperation();
if (anOperation) {
}
}
}
+ else if (anEventID == Events_Loop::eventByName(EVENT_REMOVE_CONSTRAINTS)) {
+ std::shared_ptr<ModelAPI_CheckConstraintsMessage> aConstraintsMsg =
+ std::dynamic_pointer_cast<ModelAPI_CheckConstraintsMessage>(theMessage);
+ if (aConstraintsMsg.get()) {
+ myObjectsToRemove = aConstraintsMsg->constraints();
+
+ std::set<ObjectPtr>::const_iterator anIt = myObjectsToRemove.begin();
+
+ PartSet_Module* aModule = dynamic_cast<PartSet_Module*>(myWorkshop->module());
+
+ for (; anIt != myObjectsToRemove.end(); )
+ {
+ ObjectPtr anObject = *anIt;
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
+ std::string aType = aFeature->getKind();
+ if ((aType == SketchPlugin_ConstraintHorizontal::ID() ||
+ aType == SketchPlugin_ConstraintVertical::ID()) &&
+ !aModule->sketchReentranceMgr()->isLastAutoConstraint(*anIt))
+ anIt = myObjectsToRemove.erase(anIt);
+ else
+ anIt++;
+ }
+
+ if (myObjectsToRemove.empty())
+ return;
+ QTimer::singleShot(5, aModule, SLOT(onRemoveConflictingConstraints()));
+ }
+ }
#ifdef DEBUG_FEATURE_OVERCONSTRAINT_LISTENER
aCurrentInfoStr = getObjectsInfo(myConflictingObjects);
qDebug(QString("RESULT: current objects count = %1:%2\n")
bool PartSet_OverconstraintListener::appendConflictingObjects(
const std::set<ObjectPtr>& theConflictingObjects)
{
- std::set<ObjectPtr> aModifiedObjects;
-
- // set error state for new objects and append them in the internal map of objects
- std::set<ObjectPtr>::const_iterator
- anIt = theConflictingObjects.begin(), aLast = theConflictingObjects.end();
- for (; anIt != aLast; anIt++) {
- ObjectPtr anObject = *anIt;
- if (myConflictingObjects.find(anObject) == myConflictingObjects.end()) { // it is not found
- aModifiedObjects.insert(anObject);
- myConflictingObjects.insert(anObject);
+ bool isAllowToChange = ModuleBase_Preferences::resourceMgr()->booleanValue(SKETCH_TAB_NAME,
+ "allow_change_constraint");
+ if (isAllowToChange) {
+ std::set<ObjectPtr> aModifiedObjects;
+
+ // set error state for new objects and append them in the internal map of objects
+ std::set<ObjectPtr>::const_iterator
+ anIt = theConflictingObjects.begin(), aLast = theConflictingObjects.end();
+
+ int aCountOfSimilarConstraints = 0;
+ for (; anIt != aLast; anIt++) {
+ ObjectPtr anObject = *anIt;
+ if (myConflictingObjects.find(anObject) == myConflictingObjects.end()) { // it is not found
+ aModifiedObjects.insert(anObject);
+ myConflictingObjects.insert(anObject);
+ }
+ else
+ ++aCountOfSimilarConstraints;
}
- }
- bool isUpdated = !aModifiedObjects.empty();
- if (isUpdated)
- redisplayObjects(aModifiedObjects);
- return isUpdated;
+ if (theConflictingObjects.size() == aCountOfSimilarConstraints)
+ return false;
+
+ std::shared_ptr<ModelAPI_CheckConstraintsMessage> aMessage =
+ std::shared_ptr<ModelAPI_CheckConstraintsMessage>(
+ new ModelAPI_CheckConstraintsMessage(
+ Events_Loop::eventByName(EVENT_CHECK_CONSTRAINTS)));
+ aMessage->setConstraints(theConflictingObjects);
+ Events_Loop::loop()->send(aMessage);
+
+ bool isUpdated = !aModifiedObjects.empty();
+ if (isUpdated)
+ redisplayObjects(aModifiedObjects);
+ return isUpdated;
+ }
+ else
+ return false;
}
bool PartSet_OverconstraintListener::repairConflictingObjects(
ObjectPtr anObject = *anIt;
if (theConflictingObjects.find(anObject) != theConflictingObjects.end()) { // it is found
myConflictingObjects.erase(anObject);
-
aModifiedObjects.insert(anObject);
}
}
static Events_Loop* aLoop = Events_Loop::loop();
static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_VISUAL_ATTRIBUTES);
+ static Events_ID EVENT_REDISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
std::set<ObjectPtr>::const_iterator anIt = theObjects.begin(), aLast = theObjects.end();
- for (; anIt != aLast; anIt++)
- aECreator->sendUpdated(*anIt, EVENT_DISP);
-
+ for (; anIt != aLast; anIt++) {
+ ObjectPtr aObj = *anIt;
+ aECreator->sendUpdated(aObj, EVENT_DISP);
+ aECreator->sendUpdated(aObj, EVENT_REDISP);
+ }
aLoop->flush(EVENT_DISP);
+ aLoop->flush(EVENT_REDISP);
}
PartSet_Module* PartSet_OverconstraintListener::module() const
