X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchPlugin%2FSketchPlugin_Plugin.cpp;h=635583b0c14011a42a5f6d631431eb8442655f2f;hb=80429c27dc32991ddac430f18d7a1bbe947061d1;hp=7035cff11d3a5098070b1ae52bce6ff4dd0d7ac0;hpb=3874b57fe5aba25ff5aee2a07654fc23c1ee8eb0;p=modules%2Fshaper.git diff --git a/src/SketchPlugin/SketchPlugin_Plugin.cpp b/src/SketchPlugin/SketchPlugin_Plugin.cpp index 7035cff11..635583b0c 100644 --- a/src/SketchPlugin/SketchPlugin_Plugin.cpp +++ b/src/SketchPlugin/SketchPlugin_Plugin.cpp @@ -1,26 +1,52 @@ // Copyright (C) 2014-20xx CEA/DEN, EDF R&D --> -#include "SketchPlugin_Plugin.h" -#include "SketchPlugin_Sketch.h" -#include "SketchPlugin_Line.h" -#include "SketchPlugin_Point.h" -#include "SketchPlugin_Circle.h" -#include "SketchPlugin_Arc.h" -#include "SketchPlugin_ConstraintCoincidence.h" -#include "SketchPlugin_ConstraintDistance.h" -#include "SketchPlugin_ConstraintLength.h" -#include "SketchPlugin_ConstraintParallel.h" -#include "SketchPlugin_ConstraintPerpendicular.h" -#include "SketchPlugin_ConstraintRadius.h" -#include "SketchPlugin_ConstraintRigid.h" -#include "SketchPlugin_Validators.h" -#include "SketchPlugin_ResultValidators.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + #include #include #include +#include #include +#include + +#ifdef _DEBUG +#include +#endif + +//#define SET_PLANES_COLOR_IN_PREFERENCES + using namespace std; // the only created instance of this plugin @@ -32,36 +58,61 @@ SketchPlugin_Plugin::SketchPlugin_Plugin() ModelAPI_ValidatorsFactory* aFactory = aMgr->validators(); aFactory->registerValidator("SketchPlugin_DistanceAttr", new SketchPlugin_DistanceAttrValidator); - aFactory->registerValidator("SketchPlugin_DifferentObjects", - new SketchPlugin_DifferentObjectsValidator); - aFactory->registerValidator("SketchPlugin_ResultPoint", new SketchPlugin_ResultPointValidator); - aFactory->registerValidator("SketchPlugin_ResultLine", new SketchPlugin_ResultLineValidator); - aFactory->registerValidator("SketchPlugin_ResultArc", new SketchPlugin_ResultArcValidator); + aFactory->registerValidator("SketchPlugin_ExternalValidator", + new SketchPlugin_ExternalValidator); + aFactory->registerValidator("SketchPlugin_TangentAttr", + new SketchPlugin_TangentAttrValidator); + aFactory->registerValidator("SketchPlugin_NotFixed", + new SketchPlugin_NotFixedValidator); + aFactory->registerValidator("SketchPlugin_EqualAttr", + new SketchPlugin_EqualAttrValidator); + aFactory->registerValidator("SketchPlugin_MirrorAttr", + new SketchPlugin_MirrorAttrValidator); + aFactory->registerValidator("SketchPlugin_CoincidenceAttr", + new SketchPlugin_CoincidenceAttrValidator); + aFactory->registerValidator("SketchPlugin_CopyValidator", + new SketchPlugin_CopyValidator); + aFactory->registerValidator("SketchPlugin_SolverErrorValidator", + new SketchPlugin_SolverErrorValidator); + aFactory->registerValidator("SketchPlugin_FilletVertexValidator", + new SketchPlugin_FilletVertexValidator); + aFactory->registerValidator("SketchPlugin_MiddlePointAttr", + new SketchPlugin_MiddlePointAttrValidator); + aFactory->registerValidator("SketchPlugin_ArcTangentPoint", + new SketchPlugin_ArcTangentPointValidator); + aFactory->registerValidator("SketchPlugin_IntersectionValidator", + new SketchPlugin_IntersectionValidator); + aFactory->registerValidator("SketchPlugin_ProjectionValidator", + new SketchPlugin_ProjectionValidator); // register this plugin ModelAPI_Session::get()->registerPlugin(this); + + Config_PropManager::registerProp("Visualization", "sketch_entity_color", "Sketch entity color", + Config_Prop::Color, SKETCH_ENTITY_COLOR); + + Config_PropManager::registerProp("Visualization", "sketch_external_color", "Sketch external entity color", + Config_Prop::Color, SKETCH_EXTERNAL_COLOR); + + Config_PropManager::registerProp("Visualization", "sketch_auxiliary_color", "Sketch auxiliary entity color", + Config_Prop::Color, SKETCH_AUXILIARY_COLOR); + + Config_PropManager::registerProp("Visualization", "sketch_dimension_color", "Sketch dimension color", + Config_Prop::Color, SKETCH_DIMENSION_COLOR); + + Config_PropManager::registerProp("Visualization", "sketch_overconstraint_color", + "Sketch overconstraint color", + Config_Prop::Color, SKETCH_OVERCONSTRAINT_COLOR); // register sketcher properties - Config_PropManager::registerProp("Sketch planes", "planes_color", "Color", Config_Prop::Color, - SKETCH_PLANE_COLOR); - Config_PropManager::registerProp("Sketch planes", "planes_size", "Size", Config_Prop::Double, - PLANE_SIZE); - Config_PropManager::registerProp("Sketch planes", "planes_thickness", "Thickness", - Config_Prop::Integer, SKETCH_WIDTH); - - Config_PropManager::registerProp("Visualization", "parallel_color", "Parallel constraint color", - Config_Prop::Color, PARALLEL_COLOR); - Config_PropManager::registerProp("Visualization", "perpendicular_color", - "Perpendicular constraint color", Config_Prop::Color, - PERPENDICULAR_COLOR); - Config_PropManager::registerProp("Visualization", "distance_color", "Distance color", - Config_Prop::Color, DISTANCE_COLOR); - Config_PropManager::registerProp("Visualization", "length_color", "Length color", - Config_Prop::Color, LENGTH_COLOR); - Config_PropManager::registerProp("Visualization", "radius_color", "Radius color", - Config_Prop::Color, RADIUS_COLOR); - Config_PropManager::registerProp("Visualization", "fixing_color", "Fixing color", - Config_Prop::Color, FIXING_COLOR); +#ifdef SET_PLANES_COLOR_IN_PREFERENCES + Config_PropManager::registerProp("Visualization", "yz_plane_color", "YZ plane color", + Config_Prop::Color, YZ_PLANE_COLOR); + Config_PropManager::registerProp("Visualization", "xz_plane_color", "XZ plane color", + Config_Prop::Color, XZ_PLANE_COLOR); + Config_PropManager::registerProp("Visualization", "xy_plane_color", "XY plane color", + Config_Prop::Color, XY_PLANE_COLOR); +#endif } FeaturePtr SketchPlugin_Plugin::createFeature(string theFeatureID) @@ -70,14 +121,20 @@ FeaturePtr SketchPlugin_Plugin::createFeature(string theFeatureID) return FeaturePtr(new SketchPlugin_Sketch); } else if (theFeatureID == SketchPlugin_Point::ID()) { return FeaturePtr(new SketchPlugin_Point); + } else if (theFeatureID == SketchPlugin_IntersectionPoint::ID()) { + return FeaturePtr(new SketchPlugin_IntersectionPoint); } else if (theFeatureID == SketchPlugin_Line::ID()) { return FeaturePtr(new SketchPlugin_Line); } else if (theFeatureID == SketchPlugin_Circle::ID()) { return FeaturePtr(new SketchPlugin_Circle); } else if (theFeatureID == SketchPlugin_Arc::ID()) { return FeaturePtr(new SketchPlugin_Arc); + } else if (theFeatureID == SketchPlugin_Projection::ID()) { + return FeaturePtr(new SketchPlugin_Projection); } else if (theFeatureID == SketchPlugin_ConstraintCoincidence::ID()) { return FeaturePtr(new SketchPlugin_ConstraintCoincidence); + } else if (theFeatureID == SketchPlugin_ConstraintCollinear::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintCollinear); } else if (theFeatureID == SketchPlugin_ConstraintDistance::ID()) { return FeaturePtr(new SketchPlugin_ConstraintDistance); } else if (theFeatureID == SketchPlugin_ConstraintLength::ID()) { @@ -90,7 +147,89 @@ FeaturePtr SketchPlugin_Plugin::createFeature(string theFeatureID) return FeaturePtr(new SketchPlugin_ConstraintRadius); } else if (theFeatureID == SketchPlugin_ConstraintRigid::ID()) { return FeaturePtr(new SketchPlugin_ConstraintRigid); + } else if (theFeatureID == SketchPlugin_ConstraintHorizontal::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintHorizontal); + } else if (theFeatureID == SketchPlugin_ConstraintVertical::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintVertical); + } else if (theFeatureID == SketchPlugin_ConstraintEqual::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintEqual); + } else if (theFeatureID == SketchPlugin_ConstraintTangent::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintTangent); + } else if (theFeatureID == SketchPlugin_ConstraintMiddle::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintMiddle); + } else if (theFeatureID == SketchPlugin_ConstraintMirror::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintMirror); + } else if (theFeatureID == SketchPlugin_ConstraintFillet::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintFillet); + } else if (theFeatureID == SketchPlugin_MultiTranslation::ID()) { + return FeaturePtr(new SketchPlugin_MultiTranslation); + } else if (theFeatureID == SketchPlugin_MultiRotation::ID()) { + return FeaturePtr(new SketchPlugin_MultiRotation); + } else if (theFeatureID == SketchPlugin_ConstraintAngle::ID()) { + return FeaturePtr(new SketchPlugin_ConstraintAngle); } // feature of such kind is not found return FeaturePtr(); } + +void SketchPlugin_Plugin::processEvent(const std::shared_ptr& theMessage) +{ + const Events_ID kRequestEvent = + Events_Loop::loop()->eventByName(EVENT_FEATURE_STATE_REQUEST); + if (theMessage->eventID() == kRequestEvent) { + std::shared_ptr aStateMessage = + std::dynamic_pointer_cast(theMessage); + Events_Loop::loop()->send(getFeaturesState(aStateMessage->feature()), false); + } +} + +std::shared_ptr SketchPlugin_Plugin +::getFeaturesState(const std::shared_ptr& theFeature) const +{ + const Events_ID kResponseEvent = Events_Loop::loop()->eventByName(EVENT_FEATURE_STATE_RESPONSE); + std::shared_ptr aMsg( + new ModelAPI_FeatureStateMessage(kResponseEvent, this)); + + bool aHasSketchPlane = false; + std::shared_ptr aSketchFeature = + std::dynamic_pointer_cast(theFeature); + if (aSketchFeature.get()) { + std::shared_ptr aData = aSketchFeature->data(); + if (aData) { + std::shared_ptr aNormal = + std::dynamic_pointer_cast(aData->attribute(SketchPlugin_Sketch::NORM_ID())); + // it is important to check whether the normal attribute is initialized + // because it is possible that normal values are filled when the plane is checked on validity + aHasSketchPlane = aNormal && aNormal->isInitialized() && + !(aNormal->x() == 0 && aNormal->y() == 0 && aNormal->z() == 0); + + aMsg->setState(SketchPlugin_Point::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_IntersectionPoint::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_Line::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_Circle::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_Arc::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_Projection::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintCoincidence::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintCollinear::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintDistance::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintLength::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintParallel::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintPerpendicular::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintRadius::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintRigid::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintHorizontal::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintVertical::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintEqual::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintTangent::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintMiddle::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintMirror::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintFillet::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_ConstraintAngle::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_MultiRotation::ID(), aHasSketchPlane); + aMsg->setState(SketchPlugin_MultiTranslation::ID(), aHasSketchPlane); + // SketchRectangle is a python feature, so its ID is passed just as a string + aMsg->setState("SketchRectangle", aHasSketchPlane); + } + } + return aMsg; +}