// Created: 12 Aug 2014
// Author: Vitaly SMETANNIKOV
-#ifndef Config_Prop_H
-#define Config_Prop_H
+#ifndef CONFIG_PROP_H
+#define CONFIG_PROP_H
#include "Config_def.h"
{
Disabled,
Space,
- Bool,
+ Boolean,
Color,
String,
Selector,
for(int aFaceIndex = 0; aFaceIndex < aFacesNum || aFacesNum == -1; aFaceIndex++) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- std::shared_ptr<GeomAPI_Shape> aFace =
- aFacesNum == -1 ? aValueFace : aConstruction->face(aFaceIndex);
+ std::shared_ptr<GeomAPI_Shape> aFace;
+ if (aFacesNum == -1) {
+ aFace = aValueFace;
+ } else {
+ aFace = std::dynamic_pointer_cast<GeomAPI_Shape>(aConstruction->face(aFaceIndex));
+ }
GeomAlgoAPI_Extrusion aFeature(aFace, aSize);
if(!aFeature.isDone()) {
static const std::string aFeatureError = "Extrusion algorithm failed";
return aPath;
}
+bool Model_Document::isRoot() const
+{
+ return this == Model_Session::get()->moduleDocument().get();
+}
+
bool Model_Document::load(const char* theFileName)
{
Handle(Model_Application) anApp = Model_Application::getApplication();
- if (this == Model_Session::get()->moduleDocument().get()) {
+ if (isRoot()) {
anApp->setLoadPath(theFileName);
}
TCollection_ExtendedString aPath(DocFileName(theFileName, myID));
std::dynamic_pointer_cast<Model_Session>(Model_Session::get());
aSession->setActiveDocument(anApp->getDocument(myID), false);
aSession->setCheckTransactions(false);
- synchronizeFeatures(false, true);
+ synchronizeFeatures(false, true, true);
aSession->setCheckTransactions(true);
aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false);
aSession->setActiveDocument(anApp->getDocument(myID), true);
{
// create a directory in the root document if it is not yet exist
Handle(Model_Application) anApp = Model_Application::getApplication();
- if (this == Model_Session::get()->moduleDocument().get()) {
+ if (isRoot()) {
#ifdef WIN32
CreateDirectory(theFileName, NULL);
#else
void Model_Document::close(const bool theForever)
{
std::shared_ptr<ModelAPI_Session> aPM = Model_Session::get();
- if (this != aPM->moduleDocument().get() && this == aPM->activeDocument().get()) {
+ if (!isRoot() && this == aPM->activeDocument().get()) {
aPM->setActiveDocument(aPM->moduleDocument());
- } else if (this == aPM->moduleDocument().get()) {
+ } else if (isRoot()) {
// erase the active document if root is closed
aPM->setActiveDocument(DocumentPtr());
}
// this must be here just after everything is finished but before real transaction stop
// to avoid messages about modifications outside of the transaction
// and to rebuild everything after all updates and creates
- if (Model_Session::get()->moduleDocument().get() == this) { // once for root document
+ if (isRoot()) { // once for root document
Events_Loop::loop()->autoFlush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
static std::shared_ptr<Events_Message> aFinishMsg
(new Events_Message(Events_Loop::eventByName("FinishOperation")));
if (!aResult && !myTransactions.empty() /* it can be for just created part document */)
aResult = myTransactions.rbegin()->myOCAFNum != 0;
- if (!aResult && Model_Session::get()->moduleDocument().get() == this) {
+ if (!aResult && isRoot()) {
// nothing inside in all documents, so remove this transaction from the transactions list
undoInternal(true, false);
myDoc->ClearRedos();
myDoc->Undo();
myDoc->ClearRedos();
}
- synchronizeFeatures(true, false); // references were not changed since transaction start
+ // references were not changed since transaction start
+ synchronizeFeatures(true, false, isRoot());
// abort for all subs
const std::set<std::string> aSubs = subDocuments(true);
std::set<std::string>::iterator aSubIter = aSubs.begin();
for(int a = 0; a < aNumTransactions; a++)
myDoc->Undo();
- if (theSynchronize)
- synchronizeFeatures(true, true);
if (theWithSubs) {
// undo for all subs
const std::set<std::string> aSubs = subDocuments(true);
for (; aSubIter != aSubs.end(); aSubIter++)
subDoc(*aSubIter)->undoInternal(theWithSubs, theSynchronize);
}
+ // after redo of all sub-documents to avoid updates on not-modified data (issue 370)
+ if (theSynchronize)
+ synchronizeFeatures(true, true, isRoot());
}
void Model_Document::undo()
for(int a = 0; a < aNumRedos; a++)
myDoc->Redo();
- synchronizeFeatures(true, true);
// redo for all subs
const std::set<std::string> aSubs = subDocuments(true);
std::set<std::string>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++)
subDoc(*aSubIter)->redo();
+
+ // after redo of all sub-documents to avoid updates on not-modified data (issue 370)
+ synchronizeFeatures(true, true, isRoot());
}
std::list<std::string> Model_Document::undoList() const
theObj->initAttributes();
}
-void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool theUpdateReferences)
+void Model_Document::synchronizeFeatures(
+ const bool theMarkUpdated, const bool theUpdateReferences, const bool theFlush)
{
std::shared_ptr<ModelAPI_Document> aThis =
Model_Application::getApplication()->getDocument(myID);
myExecuteFeatures = false;
aLoop->activateFlushes(true);
- aLoop->flush(aCreateEvent);
- aLoop->flush(aDeleteEvent);
- aLoop->flush(anUpdateEvent);
- aLoop->flush(aRedispEvent);
- aLoop->flush(aToHideEvent);
+ if (theFlush) {
+ aLoop->flush(aCreateEvent);
+ aLoop->flush(aDeleteEvent);
+ aLoop->flush(anUpdateEvent);
+ aLoop->flush(aRedispEvent);
+ aLoop->flush(aToHideEvent);
+ }
myExecuteFeatures = true;
}
//! Synchronizes myFeatures list with the updated document
//! \param theMarkUpdated causes the "update" event for all features
//! \param theUpdateReferences causes the update of back-references
- void synchronizeFeatures(const bool theMarkUpdated, const bool theUpdateReferences);
+ //! \param theFlush makes flush all events in the end of all modifications of this method
+ void synchronizeFeatures(const bool theMarkUpdated, const bool theUpdateReferences,
+ const bool theFlush);
//! Synchronizes the BackReferences list in Data of Features and Results
void synchronizeBackRefs();
/// Internally makes document know that feature was removed or added in history after creation
MODEL_EXPORT virtual void addToHistory(const std::shared_ptr<ModelAPI_Object> theObject);
+ /// Returns true if the document is root module document
+ bool isRoot() const;
+
friend class Model_Application;
friend class Model_Session;
friend class Model_Update;
if (aDoc.get()) {
bool aWasChecked = myCheckTransactions;
setCheckTransactions(false);
- aDoc->synchronizeFeatures(false, true);
+ aDoc->synchronizeFeatures(false, true, true);
if (aWasChecked)
setCheckTransactions(true);
}
aRT->SetRelocation(aSourceRoot, aTargetRoot);
TDF_CopyTool::Copy(aDS, aRT);
- aNew->synchronizeFeatures(false, true);
+ aNew->synchronizeFeatures(false, true, true);
return aNew;
}
aLoop->registerListener(this, kOpStartEvent);
Config_PropManager::registerProp("Model update", "automatic_rebuild", "Rebuild immediately",
- Config_Prop::Bool, "false");
+ Config_Prop::Boolean, "false");
myIsAutomatic =
Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true";
}
\r
#include <QString>\r
#include <QObject>\r
+#include <QMap>\r
\r
#include <string>\r
#include <map>\r
\r
/// Add menu atems for viewer into the given menu\r
/// \param theMenu a popup menu to be shown in the viewer\r
- virtual void addViewerItems(QMenu* theMenu) const {}\r
+ /// \param theStdActions a map of standard actions\r
+ /// \return true if items are added and there is no necessity to provide standard menu\r
+ virtual bool addViewerItems(QMenu* theMenu, const QMap<QString, QAction*>& theStdActions) const { return false; }\r
\r
/// Add menu atems for object browser into the given menu\r
/// \param theMenu a popup menu to be shown in the object browser\r
#include <ModelAPI_AttributeString.h>
#include <QWidget>
-#include <Qlist>
+#include <QList>
#include <QVBoxLayout>
AttributeSelectionListPtr aSelectionListAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(aData->attribute(attributeID()));
if (aShape->isEqual(aResult->shape()))
- aSelectionListAttr->append(aResult, NULL);
+ aSelectionListAttr->append(aResult, GeomShapePtr());
else
aSelectionListAttr->append(aResult, aShape);
myObject = GeomValidators_Tools::getObject(anAttribute);
myShape = getShape();
- myRefAttribute = NULL;
+ myRefAttribute = AttributePtr();
myIsObject = false;
AttributeRefAttrPtr aRefAttr = aData->refattr(attributeID());
if (aRefAttr) {
return aCanDisplay;
}
-void PartSet_Module::addViewerItems(QMenu* theMenu) const
+bool PartSet_Module::addViewerItems(QMenu* theMenu, const QMap<QString, QAction*>& theStdActions) const
{
ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
if (!PartSet_SketcherMgr::isSketchOperation(anOperation) &&
!PartSet_SketcherMgr::isNestedSketchOperation(anOperation))
- return;
+ return false;
ModuleBase_ISelection* aSelection = myWorkshop->selection();
QObjectPtrList aObjects = aSelection->selectedPresentations();
}
}
if (hasFeature) {
- XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
- XGUI_Workshop* aWorkshop = aConnector->workshop();
- QAction* anAction = aWorkshop->contextMenuMgr()->action("DELETE_CMD");
- theMenu->addAction(anAction);
+ theMenu->addAction(theStdActions["DELETE_CMD"]);
}
}
bool isAuxiliary;
theMenu->addAction(anAction);
anAction->setChecked(isAuxiliary);
}
+ return true;
}
void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation)
/// Add menu atems for viewer into the given menu
/// \param theMenu a popup menu to be shown in the viewer
- virtual void addViewerItems(QMenu* theMenu) const;
+ /// \param theStdActions a map of standard actions
+ /// \return true if items are added and there is no necessity to provide standard menu
+ virtual bool addViewerItems(QMenu* theMenu, const QMap<QString, QAction*>& theStdActions) const;
public slots:
/// SLOT, that is called by no more widget signal emitted by property panel
anIgnoredFeatures.insert(sketch());
XGUI_Workshop::deleteFeatures(anObjects, anIgnoredFeatures);
}
- myExternalObject = NULL;
+ myExternalObject = ObjectPtr();
}
}
ResultConstructionPtr aRC =
std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aMirrorIter);
DocumentPtr aDoc = aRC ? aRC->document() : DocumentPtr();
- FeaturePtr aFeature = aDoc ? std::dynamic_pointer_cast<SketchPlugin_Feature>(
- aDoc->feature(aRC)) : FeaturePtr();
+ FeaturePtr aFeature = aDoc ? aDoc->feature(aRC) : FeaturePtr();
if (aFeature)
aDoc->removeFeature(aFeature);
}
new SketchPlugin_ExternalValidator);
aFactory->registerValidator("SketchPlugin_TangentAttr",
new SketchPlugin_TangentAttrValidator);
+ aFactory->registerValidator("SketchPlugin_NotFixed",
+ new SketchPlugin_NotFixedValidator);
+ aFactory->registerValidator("SketchPlugin_EqualAttr",
+ new SketchPlugin_EqualAttrValidator);
// register this plugin
ModelAPI_Session::get()->registerPlugin(this);
#include "SketchPlugin_Validators.h"
#include "SketchPlugin_ConstraintDistance.h"
#include "SketchPlugin_ConstraintCoincidence.h"
+#include "SketchPlugin_ConstraintRigid.h"
#include "SketchPlugin_Line.h"
#include "SketchPlugin_Arc.h"
+#include "SketchPlugin_Circle.h"
#include "SketcherPrs_Tools.h"
if (aOtherFea->getKind() != SketchPlugin_Arc::ID())
return false;
} else if (aRefFea->getKind() == SketchPlugin_Arc::ID()) {
- if (aOtherFea->getKind() != SketchPlugin_Line::ID())
+ if (aOtherFea->getKind() != SketchPlugin_Line::ID() &&
+ aOtherFea->getKind() != SketchPlugin_Arc::ID())
return false;
} else
return false;
return false;
}
+bool SketchPlugin_NotFixedValidator::isValid(
+ const AttributePtr& theAttribute, const std::list<std::string>& theArguments) const
+{
+ std::shared_ptr<SketchPlugin_Feature> aFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(theAttribute->owner());
+ if (!aFeature)
+ return true;
+
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
+ if (!aRefAttr)
+ return false;
+
+ SketchPlugin_Sketch* aSketch = aFeature->sketch();
+ int aNbFeatures = aSketch->numberOfSubs();
+ for (int anInd = 0; anInd < aNbFeatures; anInd++) {
+ FeaturePtr aSubFeature = aSketch->subFeature(anInd);
+ if (aSubFeature->getKind() != SketchPlugin_ConstraintRigid::ID() || aSubFeature == aFeature)
+ continue;
+ AttributeRefAttrPtr aRAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aSubFeature->attribute(SketchPlugin_ConstraintRigid::ENTITY_A()));
+ if (aRefAttr->isObject()) {
+ if (aRefAttr->object() == aRAttr->object())
+ return false;
+ } else if (aRefAttr->attr() == aRAttr->attr())
+ return false;
+ }
+ return true;
+}
+
+bool SketchPlugin_EqualAttrValidator::isValid(
+ const AttributePtr& theAttribute, const std::list<std::string>& theArguments ) const
+{
+ std::string aParamA = theArguments.front();
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
+ AttributeRefAttrPtr aRefAttr[2];
+ aRefAttr[0] = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
+ if (!aRefAttr)
+ return false;
+ aRefAttr[1] = aFeature->data()->refattr(aParamA);
+
+ if (!aRefAttr[0]->isObject() || !aRefAttr[1]->isObject())
+ return false;
+
+ int aType[2] = {0, 0}; // types of attributes: 0 - incorrect, 1 - line, 2 - circle, 3 - arc
+ std::list<std::string> anArguments;
+ for (int i = 0; i < 2; i++) {
+ ObjectPtr anObject = aRefAttr[i]->object();
+ aFeature = ModelAPI_Feature::feature(anObject);
+ if (!aFeature)
+ return false;
+
+ if (aFeature->getKind() == SketchPlugin_Line::ID()) {
+ aType[i] = 1;
+ continue;
+ }
+ if (aFeature->getKind() == SketchPlugin_Circle::ID()) {
+ aType[i] = 2;
+ continue;
+ }
+ if (aFeature->getKind() == SketchPlugin_Arc::ID()) {
+ aType[i] = 3;
+ continue;
+ }
+ // wrong type of attribute
+ return false;
+ }
+
+ if ((aType[0] == 1 && aType[1] == 2) ||
+ (aType[0] == 2 && aType[1] == 1))
+ return false;
+ return true;
+}
};
+/**\class SketchPlugin_NotFixed
+ * \ingroup Validators
+ * \brief Validator for the rigid constraint input.
+ *
+ * It just checks there is no rigid constraint for the current feature.
+ */
+class SketchPlugin_NotFixedValidator : public ModelAPI_AttributeValidator
+{
+ public:
+ //! returns true if attribute is not used in another rigid constraint
+ //! \param theAttribute the checked attribute
+ //! \param theArguments arguments of the attribute
+ virtual bool isValid(const AttributePtr& theAttribute,
+ const std::list<std::string>& theArguments) const;
+};
+
+/**\class SketchPlugin_EqualAttrValidator
+ * \ingroup Validators
+ * \brief Validator for the equal constraint input.
+ *
+ * It checks that attributes of the Equal constraint are correct.
+ */
+class SketchPlugin_EqualAttrValidator : public ModelAPI_AttributeValidator
+{
+ public:
+ //! returns true if attribute is valid
+ //! \param theAttribute the checked attribute
+ //! \param theArguments arguments of the attribute
+ virtual bool isValid(const AttributePtr& theAttribute,
+ const std::list<std::string>& theArguments) const;
+};
+
+
#endif
<shape_selector id="ConstraintEntityA" label="Object" tooltip="Select an object"
shape_types="edge vertex">
<validator id="PartSet_SketchEntityValidator" parameters="SketchPoint,SketchLine,SketchCircle,SketchArc"/>
+ <validator id="SketchPlugin_NotFixed"/>
</shape_selector>
<validator id="PartSet_RigidValidator"/>
</feature>
<sketch_constraint_shape_selector id="ConstraintEntityB"
label="Last object" tooltip="Select line, circle or arc" shape_types="edge">
- <validator id="PartSet_SameTypeAttr" parameters="ConstraintEntityA"/>
+ <validator id="SketchPlugin_EqualAttr" parameters="ConstraintEntityA"/>
<validator id="PartSet_DifferentObjects"/>
</sketch_constraint_shape_selector>
</feature>
for ( ; aBaseIter != aBaseList.end(); aBaseIter++, aMirIter++) {
aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aBaseIter);
aBaseFeature = aRC ? aRC->document()->feature(aRC) :
- std::dynamic_pointer_cast<SketchPlugin_Feature>(*aBaseIter);
+ std::dynamic_pointer_cast<ModelAPI_Feature>(*aBaseIter);
aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aMirIter);
aMirrorFeature = aRC ? aRC->document()->feature(aRC) :
- std::dynamic_pointer_cast<SketchPlugin_Feature>(*aMirIter);
+ std::dynamic_pointer_cast<ModelAPI_Feature>(*aMirIter);
if (!aBaseFeature || !aMirrorFeature ||
aBaseFeature->getKind() != aMirrorFeature->getKind())
Slvs_hParam v = changeParameter(y, aParamIter);
Slvs_Entity aPoint = Slvs_MakePoint2d(++myEntityMaxID, myID, myWorkplane.h, u, v);
myEntities.push_back(aPoint);
+ myEntOfConstr.push_back(true);
aBothMiddlePoints[i] = aPoint.h;
// additional constraint point-on-curve
Slvs_Constraint aPonCircConstr = Slvs_MakeConstraint(
aPoint.h, SLVS_E_UNKNOWN, aBothArcs[i], SLVS_E_UNKNOWN);
myConstraints.push_back(aPonCircConstr);
myConstraintMap[theConstraint].push_back(aPonCircConstr.h);
+ aNewConstraints.push_back(aPonCircConstr.h);
}
aBaseArcPoints[2] = aBothMiddlePoints[0];
for (aBaseIter = aBaseList.begin(); aBaseIter != aBaseList.end(); aBaseIter++) {
aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aBaseIter);
aBaseFeature = aRC ? aRC->document()->feature(aRC) :
- std::dynamic_pointer_cast<SketchPlugin_Feature>(*aBaseIter);
+ std::dynamic_pointer_cast<ModelAPI_Feature>(*aBaseIter);
if (!aBaseFeature) continue;
std::list<AttributePtr> aPoints = aBaseFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
- std::list<AttributePtr>::iterator anIt = aPoints.begin();
- for ( ; anIt != aPoints.end(); anIt++) {
+ if (aBaseFeature->getKind() != SketchPlugin_Arc::ID()) {
+ std::list<AttributePtr>::iterator anIt = aPoints.begin();
+ for ( ; anIt != aPoints.end(); anIt++) {
+ addTemporaryConstraintWhereDragged(*anIt);
+ }
+ } else {
// Arcs are fixed by center and start points only (to avoid solving errors in SolveSpace)
- if (aBaseFeature->getKind() == SketchPlugin_Arc::ID() &&
- (*anIt)->id() == SketchPlugin_Arc::END_ID())
- continue;
- addTemporaryConstraintWhereDragged(*anIt);
+ AttributePtr aCenterAttr = aBaseFeature->attribute(SketchPlugin_Arc::CENTER_ID());
+ std::map<AttributePtr, Slvs_hEntity>::iterator aFound = myEntityAttrMap.find(aCenterAttr);
+ Slvs_hEntity anArcPoints[3] = {aFound->second, 0, 0};
+ AttributePtr aStartAttr = aBaseFeature->attribute(SketchPlugin_Arc::START_ID());
+ aFound = myEntityAttrMap.find(aStartAttr);
+ anArcPoints[1] = aFound->second;
+ AttributePtr aEndAttr = aBaseFeature->attribute(SketchPlugin_Arc::END_ID());
+ aFound = myEntityAttrMap.find(aEndAttr);
+ anArcPoints[2] = aFound->second;
+
+ bool isFixed[3] = {false, false, false};
+ int aNbFixed = 0; // number of already fixed points on the arc
+ for (int i = 0; i < 3; i++) {
+ std::vector<std::set<Slvs_hEntity> >::iterator aCoPtIter = myCoincidentPoints.begin();
+ for (; aCoPtIter != myCoincidentPoints.end() && !isFixed[i]; aCoPtIter++) {
+ if (aCoPtIter->find(anArcPoints[i]) == aCoPtIter->end())
+ continue; // the entity was not found in current set
+
+ // Find one of already created SLVS_C_WHERE_DRAGGED constraints in current set of coincident points
+ std::vector<Slvs_Constraint>::iterator aConstrIter = myConstraints.begin();
+ for (; aConstrIter != myConstraints.end(); aConstrIter++)
+ if (aConstrIter->type == SLVS_C_WHERE_DRAGGED &&
+ aCoPtIter->find(aConstrIter->ptA) != aCoPtIter->end()) {
+ isFixed[i] = true;
+ aNbFixed++;
+ break; // the SLVS_C_WHERE_DRAGGED constraint already exists
+ }
+ }
+ }
+ if (aNbFixed < 2) { // append constraints
+ if (!isFixed[0])
+ addTemporaryConstraintWhereDragged(aCenterAttr);
+ if (!isFixed[1] && (isFixed[0] || aNbFixed == 0))
+ addTemporaryConstraintWhereDragged(aStartAttr);
+ }
}
}
}
for (int indEnt = 0; aFilIter != aFilletList.end(); aFilIter++, indEnt++) {
aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aFilIter);
aFilletFeature = aRC ? aRC->document()->feature(aRC) :
- std::dynamic_pointer_cast<SketchPlugin_Feature>(*aFilIter);
+ std::dynamic_pointer_cast<ModelAPI_Feature>(*aFilIter);
if (!aFilletFeature)
return false;
aFilletEnt[indEnt] = changeEntityFeature(aFilletFeature);
std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator aEntIter =
myEntityAttrMap.find(theEntity);
int aEntPos;
- std::vector<Slvs_Param>::const_iterator aParamIter; // looks at first parameter of already existent entity or at the end of vector otherwise
+ std::vector<Slvs_Param>::iterator aParamIter; // looks at first parameter of already existent entity or at the end of vector otherwise
if (aEntIter == myEntityAttrMap.end()) // no such entity => should be created
aParamIter = myParams.end();
else { // the entity already exists
// Try to find existent normal
std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator aEntIter =
myEntityAttrMap.find(theNorm);
- std::vector<Slvs_Param>::const_iterator aParamIter; // looks to the first parameter of already existent entity or to the end of vector otherwise
+ std::vector<Slvs_Param>::iterator aParamIter; // looks to the first parameter of already existent entity or to the end of vector otherwise
if (aEntIter == myEntityAttrMap.end()) // no such entity => should be created
aParamIter = myParams.end();
else { // the entity already exists, update it
// Purpose: create/update value of parameter
// ============================================================================
Slvs_hParam SketchSolver_ConstraintGroup::changeParameter(
- const double& theParam, std::vector<Slvs_Param>::const_iterator& thePrmIter)
+ double theParam, std::vector<Slvs_Param>::iterator& thePrmIter)
{
if (thePrmIter != myParams.end()) { // Parameter should be updated
int aParamPos = thePrmIter - myParams.begin();
Slvs_Entity aBase = myEntities[Search(theBase, myEntities)];
Slvs_Entity aMirror = myEntities[Search(theMirror, myEntities)];
int i = 0;
- while (aBase.point[i] != 0 && aMirror.point[i] != 0) {
- makeMirrorEntity(aBase.point[i], aMirror.point[i], theMirrorLine);
- i++;
+ if (aBase.type != SLVS_E_ARC_OF_CIRCLE) {
+ while (aBase.point[i] != 0 && aMirror.point[i] != 0) {
+ makeMirrorEntity(aBase.point[i], aMirror.point[i], theMirrorLine);
+ i++;
+ }
+ } else {
+ // swap mirroring first and last points of an arc
+ makeMirrorEntity(aBase.point[0], aMirror.point[0], theMirrorLine);
+ makeMirrorEntity(aBase.point[1], aMirror.point[2], theMirrorLine);
+ makeMirrorEntity(aBase.point[2], aMirror.point[1], theMirrorLine);
}
if (aBase.param[0] != 0 && aMirror.param[0] != 0) { // this is a point, copy it
Slvs_Entity aMirrorLine = myEntities[Search(theMirrorLine, myEntities)];
std::map<Slvs_hEntity, Slvs_hEntity>::iterator aMapIter = thePrevMirror.find(theBasePoint);
if (aMapIter != thePrevMirror.end()) {
thePrevMirror.erase(aMapIter);
- std::vector<Slvs_Constraint>::const_iterator anIter = thePrevConstr.begin();
+ std::vector<Slvs_Constraint>::iterator anIter = thePrevConstr.begin();
for (; anIter != thePrevConstr.end(); anIter++)
if (anIter->ptA == theBasePoint) {
if (anIter->ptB != theMirrorPoint) {
* (the iterator will be increased if it does not reach the end of the list)
* \return identifier of changed parameter; when the parameter cannot be created, returned ID is 0
*/
- Slvs_hParam changeParameter(const double& theParam,
- std::vector<Slvs_Param>::const_iterator& thePrmIter);
+ Slvs_hParam changeParameter(double theParam,
+ std::vector<Slvs_Param>::iterator& thePrmIter);
/** \brief Removes specified entities and their parameters
* \param[in] theEntities list of IDs of the entities to be removed
for (aFeatIter = aFeatures.begin(); aFeatIter != aFeatures.end(); aFeatIter++) {
std::shared_ptr<SketchPlugin_Feature> aFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(*aFeatIter);
- if (!aFeature || aFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID())
+ if (!aFeature /*|| aFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()*/)
continue;
changeConstraintOrEntity(aFeature);
}
#include <Graphic3d_ArrayOfPoints.hxx>
#include <Prs3d_PointAspect.hxx>
#include <Prs3d_Root.hxx>
+#include <SelectMgr_EntityOwner.hxx>
+#include <SelectMgr_Selection.hxx>
+#include <Select3D_SensitivePoint.hxx>
IMPLEMENT_STANDARD_HANDLE(SketcherPrs_Coincident, AIS_InteractiveObject);
const std::shared_ptr<GeomAPI_Ax3>& thePlane)
: AIS_InteractiveObject(), myConstraint(theConstraint), myPlane(thePlane)
{
+
}
return;
std::shared_ptr<GeomAPI_Pnt> aPoint = myPlane->to3D(aPnt->x(), aPnt->y());
-
- static Handle(Graphic3d_AspectMarker3d) aPtA = new Graphic3d_AspectMarker3d ();
- aPtA->SetType(Aspect_TOM_RING1);
- aPtA->SetScale(2.);
- aPtA->SetColor(myOwnColor);
+ myPoint = aPoint->impl<gp_Pnt>();
+
+ static Handle(Graphic3d_AspectMarker3d) aPtA;
+ if (aPtA.IsNull()) {
+ aPtA = new Graphic3d_AspectMarker3d ();
+ aPtA->SetType(Aspect_TOM_RING1);
+ aPtA->SetScale(2.);
+ aPtA->SetColor(myOwnColor);
+ }
Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(thePresentation);
aGroup->SetPrimitivesAspect(aPtA);
Handle(Graphic3d_ArrayOfPoints) aPntArray = new Graphic3d_ArrayOfPoints(1);
void SketcherPrs_Coincident::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
const Standard_Integer aMode)
{
+ Handle(SelectMgr_EntityOwner) aOwn = new SelectMgr_EntityOwner(this, 10);
+ Handle(Select3D_SensitivePoint) aSp = new Select3D_SensitivePoint(aOwn, myPoint);
+ aSelection->Add(aSp);
}
void SketcherPrs_Coincident::SetColor(const Quantity_NameOfColor aCol)
private:
SketchPlugin_Constraint* myConstraint;
std::shared_ptr<GeomAPI_Ax3> myPlane;
+ gp_Pnt myPoint;
};
#include <SketchPlugin_Arc.h>
#include <GeomDataAPI_Point2D.h>
-#include <GeomAPI_Pnt2D.h>
+#include <GeomAPI_Pnt2d.h>
#include <GeomAPI_Circ.h>
#include <GeomAPI_XYZ.h>
#include <ModelAPI_AttributeDouble.h>
void XGUI_ContextMenuMgr::addViewerItems(QMenu* theMenu) const
{
- XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
- QObjectPtrList aObjects = aSelMgr->selection()->selectedObjects();
- if (aObjects.size() > 0) {
- //if (aObjects.size() == 1)
- // theMenu->addAction(action("EDIT_CMD"));
- bool isVisible = false;
- bool isShading = false;
- bool canBeShaded = false;
- foreach(ObjectPtr aObject, aObjects)
- {
- ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObject);
- if (aRes && myWorkshop->displayer()->isVisible(aRes)) {
- isVisible = true;
- canBeShaded = myWorkshop->displayer()->canBeShaded(aObject);
- isShading = (myWorkshop->displayer()->displayMode(aObject) == XGUI_Displayer::Shading);
- break;
+ bool aIsDone = false;
+ ModuleBase_IModule* aModule = myWorkshop->module();
+ if (aModule)
+ aIsDone = aModule->addViewerItems(theMenu, myActions);
+
+ if (!aIsDone) {
+ XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
+ QObjectPtrList aObjects = aSelMgr->selection()->selectedObjects();
+ if (aObjects.size() > 0) {
+ //if (aObjects.size() == 1)
+ // theMenu->addAction(action("EDIT_CMD"));
+ bool isVisible = false;
+ bool isShading = false;
+ bool canBeShaded = false;
+ foreach(ObjectPtr aObject, aObjects)
+ {
+ ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObject);
+ if (aRes && myWorkshop->displayer()->isVisible(aRes)) {
+ isVisible = true;
+ canBeShaded = myWorkshop->displayer()->canBeShaded(aObject);
+ isShading = (myWorkshop->displayer()->displayMode(aObject) == XGUI_Displayer::Shading);
+ break;
+ }
}
+ if (isVisible) {
+ if (canBeShaded) {
+ if (isShading)
+ theMenu->addAction(action("WIREFRAME_CMD"));
+ else
+ theMenu->addAction(action("SHADING_CMD"));
+ }
+ theMenu->addSeparator();
+ theMenu->addAction(action("SHOW_ONLY_CMD"));
+ theMenu->addAction(action("HIDE_CMD"));
+ } else
+ theMenu->addAction(action("SHOW_CMD"));
+ //theMenu->addAction(action("DELETE_CMD"));
}
- if (isVisible) {
- if (canBeShaded) {
- if (isShading)
- theMenu->addAction(action("WIREFRAME_CMD"));
- else
- theMenu->addAction(action("SHADING_CMD"));
- }
- theMenu->addSeparator();
- theMenu->addAction(action("SHOW_ONLY_CMD"));
- theMenu->addAction(action("HIDE_CMD"));
- } else
- theMenu->addAction(action("SHOW_CMD"));
- //theMenu->addAction(action("DELETE_CMD"));
+ if (myWorkshop->canChangeColor())
+ theMenu->addAction(action("COLOR_CMD"));
+ if (myWorkshop->displayer()->objectsCount() > 0)
+ theMenu->addAction(action("HIDEALL_CMD"));
}
- if (myWorkshop->displayer()->objectsCount() > 0)
- theMenu->addAction(action("HIDEALL_CMD"));
if (!myWorkshop->isSalomeMode()) {
theMenu->addSeparator();
QMdiArea* aMDI = myWorkshop->mainWindow()->mdiArea();
aSubMenu->addActions(aMDI->actions());
}
}
- if (myWorkshop->canChangeColor())
- theMenu->addAction(action("COLOR_CMD"));
- ModuleBase_IModule* aModule = myWorkshop->module();
- if (aModule)
- aModule->addViewerItems(theMenu);
}
void XGUI_ContextMenuMgr::connectObjectBrowser() const