-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2023 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
#include <SketchPlugin_ConstraintVertical.h>
#include <SketchPlugin_MacroBSpline.h>
#include <SketchPlugin_SketchCopy.h>
+#include <SketchPlugin_Offset.h>
#include <SketcherPrs_Tools.h>
//--------------------------------------------------------------------------------------
#include <ModelAPI_Events.h>
#include "SketchAPI_MacroEllipse.h"
#include "SketchAPI_MacroEllipticArc.h"
#include "SketchAPI_Mirror.h"
+#include "SketchAPI_Offset.h"
#include "SketchAPI_Point.h"
#include "SketchAPI_Projection.h"
#include "SketchAPI_Rectangle.h"
}
SketchPtr addSketch(const std::shared_ptr<ModelAPI_Document> & thePart,
- const std::string & theExternalName)
+ const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(SketchAPI_Sketch::ID());
return SketchPtr(
compositeFeature()->addFeature(SketchPlugin_Point::ID());
return PointPtr(new SketchAPI_Point(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Point::ID());
return anIntersection;
}
std::shared_ptr<SketchAPI_IntersectionPoint> SketchAPI_Sketch::addIntersectionPoint(
- const std::string & theExternalName,
+ const std::wstring & theExternalName,
bool theKeepResult)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Line::ID());
return LinePtr(new SketchAPI_Line(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Line::ID());
return RectanglePtr(new SketchAPI_Rectangle(aFeature, theStartPoint, theEndPoint));
}
+static std::shared_ptr<GeomAPI_Pnt2d> pointCoordinates(
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & thePoint)
+{
+ if (thePoint.first)
+ return thePoint.first;
+
+ AttributePtr anAttr = thePoint.second.attr();
+ if (thePoint.second.object()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(thePoint.second.object());
+ if (aFeature)
+ anAttr = aFeature->attribute(SketchPlugin_Point::COORD_ID());
+ }
+
+ std::shared_ptr<GeomDataAPI_Point2D> aPntAttr =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr);
+ if (aPntAttr)
+ return aPntAttr->pnt();
+ return std::shared_ptr<GeomAPI_Pnt2d>();
+}
+
+std::shared_ptr<SketchAPI_Rectangle> SketchAPI_Sketch::addRectangleCentered(
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & theCenter,
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & theCorner)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
+ RectanglePtr aRect(new SketchAPI_Rectangle(aFeature));
+ fillAttribute("RectangleTypeCentered", aRect->type());
+ if (!theCenter.second.isEmpty())
+ fillAttribute(theCenter.second, aRect->centerPointRef());
+ fillAttribute(pointCoordinates(theCenter), aRect->centerPoint());
+ fillAttribute(pointCoordinates(theCorner), aRect->cornerPoint());
+ aRect->execute();
+
+ if (!theCorner.second.isEmpty() && aRect->linesList()->size() > 1) {
+ // get start point of the last line in rectangle and apply coindidence constraint
+ FeaturePtr aLine = ModelAPI_Feature::feature(aRect->linesList()->object(3));
+ AttributePtr aEndPnt = aLine->attribute(SketchPlugin_Line::START_ID());
+ setCoincident(ModelHighAPI_RefAttr(aEndPnt), theCorner.second);
+ }
+ return aRect;
+}
+
//--------------------------------------------------------------------------------------
std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(double theCenterX,
double theCenterY,
return CirclePtr(new SketchAPI_Circle(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Circle::ID());
return ArcPtr(new SketchAPI_Arc(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Arc::ID());
}
std::shared_ptr<SketchAPI_Ellipse> SketchAPI_Sketch::addEllipse(
- const std::string & theExternalName)
+ const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Ellipse::ID());
}
std::shared_ptr<SketchAPI_EllipticArc> SketchAPI_Sketch::addEllipticArc(
- const std::string & theExternalName)
+ const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_EllipticArc::ID());
//--------------------------------------------------------------------------------------
std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
const ModelHighAPI_Selection & theExternalFeature,
- bool theKeepResult)
-{
- std::shared_ptr<ModelAPI_Feature> aFeature =
- compositeFeature()->addFeature(SketchPlugin_Projection::ID());
- ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalFeature));
- aProjection->setIncludeToResult(theKeepResult);
- return aProjection;
-}
-
-std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
- const std::string & theExternalName,
- bool theKeepResult)
+ bool keepResult,
+ bool keepRefToOriginal)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Projection::ID());
- ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalName));
- aProjection->setIncludeToResult(theKeepResult);
+ ProjectionPtr aProjection(new SketchAPI_Projection(aFeature));
+ aProjection->setIncludeToResult(keepResult);
+ aProjection->setKeepReferenceToOriginal(keepRefToOriginal);
+ aProjection->setExternalFeature(theExternalFeature);
return aProjection;
}
return MirrorPtr(new SketchAPI_Mirror(aFeature, theMirrorLine, theObjects));
}
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_Offset> SketchAPI_Sketch::addOffset(
+ const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
+ const ModelHighAPI_Double & theValue,
+ const bool theReversed,
+ const std::string & theJointType)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Offset::ID());
+ return OffsetPtr(new SketchAPI_Offset(aFeature, theObjects, theValue, theReversed, theJointType));
+}
+
//--------------------------------------------------------------------------------------
std::shared_ptr<SketchAPI_Translation> SketchAPI_Sketch::addTranslation(
const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
if (aVersion == SketchPlugin_ConstraintAngle::THE_VERSION_1) {
std::string aTypeLC = theType;
- std::transform(aTypeLC.begin(), aTypeLC.end(), aTypeLC.begin(), ::tolower);
+ std::transform(aTypeLC.begin(), aTypeLC.end(), aTypeLC.begin(),
+ [](char c) { return static_cast<char>(::tolower(c)); });
if (aTypeLC == "supplementary")
aType = (int)SketcherPrs_Tools::ANGLE_COMPLEMENTARY;
else if (aTypeLC == "backward")
aBase->attribute(SketchPlugin_Sketch::DIRX_ID()))->dir();
// Check the plane is coordinate plane
- std::string aPlaneName = defaultPlane(anOrigin, aNormal, aDirX);
+ std::wstring aPlaneName = defaultPlane(anOrigin, aNormal, aDirX);
if(anExternal->context()) { // checking for selected planes
if (!aPlaneName.empty()
&& anExternal->context()->data()