diff --git a/src/Mod/TechDraw/App/CenterLinePy.xml b/src/Mod/TechDraw/App/CenterLinePy.xml
index fe3f099244a0..b3d1cca7d476 100644
--- a/src/Mod/TechDraw/App/CenterLinePy.xml
+++ b/src/Mod/TechDraw/App/CenterLinePy.xml
@@ -13,7 +13,7 @@
Delete="true">
- CenterLine specifies appearance parameters for TechDraw Geometry objects
+ CenterLine specifies additional mark up edges in a View
@@ -25,22 +25,77 @@
Create a copy of this centerline
-
-
- Change the appearance of this CenterLine. cl.setFormat(style, color, weight, visible)
-
-
-
-
-
- returns the appearance attributes of this CenterLine. returns tuple(style, color, weight, visible).
-
-
Gives the tag of the CenterLine as string.
+
+
+ 0 - face, 1 - 2 line, 2 - 2 point.
+
+
+
+
+
+ 0 - vert/ 1 - horiz/ 2 - aligned.
+
+
+
+
+
+ The appearance attributes (style, color, weight, visible) for this CenterLine.
+
+
+
+
+
+ The left/right offset for this CenterLine.
+
+
+
+
+
+ The up/down offset for this CenterLine.
+
+
+
+
+
+ The rotation of the Centerline in degrees.
+
+
+
+
+
+ The additional length to be added to this CenterLine.
+
+
+
+
+
+ Reverse the order of points for 2 point CenterLine.
+
+
+
+
+
+ The names of source edges for this CenterLine.
+
+
+
+
+
+ The names of source Faces for this CenterLine.
+
+
+
+
+
+ The names of source Points for this CenterLine.
+
+
+
diff --git a/src/Mod/TechDraw/App/CenterLinePyImp.cpp b/src/Mod/TechDraw/App/CenterLinePyImp.cpp
index 5b546d33b112..379ad69b0478 100644
--- a/src/Mod/TechDraw/App/CenterLinePyImp.cpp
+++ b/src/Mod/TechDraw/App/CenterLinePyImp.cpp
@@ -108,18 +108,94 @@ PyObject* CenterLinePy::copy(PyObject *args)
return cpy;
}
-PyObject* CenterLinePy::setFormat(PyObject* args)
+//PyObject* CenterLinePy::setFormat(PyObject* args)
+//{
+//// Base::Console().Message("CLPI::setFormat()\n");
+// PyObject* pTuple;
+// int style = 1;
+// double weight = 0.50;
+// double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
+// App::Color c(red, blue, green, alpha);
+// bool visible = 1;
+// if (!PyArg_ParseTuple(args, "O", &pTuple)) {
+// return NULL;
+// }
+//
+// TechDraw::CenterLine* cl = this->getCenterLinePtr();
+// if (PyTuple_Check(pTuple)) {
+// int tSize = (int) PyTuple_Size(pTuple);
+// if (tSize > 3) {
+// PyObject* pStyle = PyTuple_GetItem(pTuple,0);
+// style = (int) PyLong_AsLong(pStyle);
+// PyObject* pWeight = PyTuple_GetItem(pTuple,1);
+// weight = PyFloat_AsDouble(pWeight);
+// PyObject* pColor = PyTuple_GetItem(pTuple,2);
+// c = DrawUtil::pyTupleToColor(pColor);
+// PyObject* pVisible = PyTuple_GetItem(pTuple,3);
+// visible = (bool) PyLong_AsLong(pVisible);
+
+// cl->m_format.m_style = style;
+// cl->m_format.m_weight = weight;
+// cl->m_format.m_color = c;
+// cl->m_format.m_visible = visible;
+// }
+// } else {
+// Base::Console().Error("CLPI::setFormat - not a tuple!\n");
+// }
+//
+// return Py_None;
+//}
+
+//PyObject* CenterLinePy::getFormat(PyObject *args)
+//{
+// (void) args;
+//// Base::Console().Message("CLPI::getFormat()\n");
+// TechDraw::CenterLine* cl = this->getCenterLinePtr();
+
+// PyObject* pStyle = PyLong_FromLong((long) cl->m_format.m_style);
+// PyObject* pWeight = PyFloat_FromDouble(cl->m_format.m_weight);
+// PyObject* pColor = DrawUtil::colorToPyTuple(cl->m_format.m_color);
+// PyObject* pVisible = PyBool_FromLong((long) cl->m_format.m_visible);
+
+// PyObject* result = PyTuple_New(4);
+
+// PyTuple_SET_ITEM(result, 0, pStyle);
+// PyTuple_SET_ITEM(result, 1, pWeight);
+// PyTuple_SET_ITEM(result, 2, pColor);
+// PyTuple_SET_ITEM(result, 3, pVisible);
+
+// return result;
+//}
+
+Py::Object CenterLinePy::getFormat(void) const
+{
+// Base::Console().Message("CLP::getFormat()\n");
+ TechDraw::CenterLine* cl = this->getCenterLinePtr();
+
+ PyObject* pStyle = PyLong_FromLong((long) cl->m_format.m_style);
+ PyObject* pWeight = PyFloat_FromDouble(cl->m_format.m_weight);
+ PyObject* pColor = DrawUtil::colorToPyTuple(cl->m_format.m_color);
+ PyObject* pVisible = PyBool_FromLong((long) cl->m_format.m_visible);
+
+ PyObject* result = PyTuple_New(4);
+
+ PyTuple_SET_ITEM(result, 0, pStyle);
+ PyTuple_SET_ITEM(result, 1, pWeight);
+ PyTuple_SET_ITEM(result, 2, pColor);
+ PyTuple_SET_ITEM(result, 3, pVisible);
+
+ return Py::asObject(result);
+}
+
+void CenterLinePy::setFormat(Py::Object arg)
{
-// Base::Console().Message("CLPI::setFormat()\n");
- PyObject* pTuple;
+// Base::Console().Message("CLP::setFormat()\n");
+ PyObject* pTuple = arg.ptr();
int style = 1;
double weight = 0.50;
double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
App::Color c(red, blue, green, alpha);
bool visible = 1;
- if (!PyArg_ParseTuple(args, "O", &pTuple)) {
- return NULL;
- }
TechDraw::CenterLine* cl = this->getCenterLinePtr();
if (PyTuple_Check(pTuple)) {
@@ -142,35 +218,258 @@ PyObject* CenterLinePy::setFormat(PyObject* args)
} else {
Base::Console().Error("CLPI::setFormat - not a tuple!\n");
}
+}
+
+Py::String CenterLinePy::getTag(void) const
+{
+ std::string tmp = boost::uuids::to_string(getCenterLinePtr()->getTag());
+ return Py::String(tmp);
+}
+
+
+Py::Long CenterLinePy::getType(void) const
+{
+ int tmp = getCenterLinePtr()->m_type;
+ return Py::Long(tmp);
+}
+
+Py::Long CenterLinePy::getMode(void) const
+{
+ int tmp = getCenterLinePtr()->m_mode;
+ return Py::Long(tmp);
+}
+
+void CenterLinePy::setMode(Py::Long arg)
+{
+ PyObject* p = arg.ptr();
+ if (PyLong_Check(p)) {
+ long int temp = PyLong_AsLong(p);
+ getCenterLinePtr()->m_mode = (int) temp;
+ } else {
+ std::string error = std::string("type must be 'Integer', not ");
+ error += p->ob_type->tp_name;
+ throw Py::TypeError(error);
+ }
+}
+
+Py::Float CenterLinePy::getHorizShift(void) const
+{
+ double shift = getCenterLinePtr()->getHShift();
+ return Py::asObject(PyFloat_FromDouble(shift));
+}
+
+void CenterLinePy::setHorizShift(Py::Float arg)
+{
+ PyObject* p = arg.ptr();
+ if (PyFloat_Check(p)) {
+ double hshift = PyFloat_AsDouble(p);
+ double vshift = getCenterLinePtr()->getVShift();
+ getCenterLinePtr()->setShifts(hshift, vshift);
+ } else {
+ std::string error = std::string("type must be 'Float', not ");
+ error += p->ob_type->tp_name;
+ throw Py::TypeError(error);
+ }
+}
+
+Py::Float CenterLinePy::getVertShift(void) const
+{
+ double shift = getCenterLinePtr()->getVShift();
+ return Py::asObject(PyFloat_FromDouble(shift));
+}
+
+void CenterLinePy::setVertShift(Py::Float arg)
+{
+ PyObject* p = arg.ptr();
+ if (PyFloat_Check(p)) {
+ double vshift = PyFloat_AsDouble(p);
+ double hshift = getCenterLinePtr()->getHShift();
+ getCenterLinePtr()->setShifts(hshift, vshift);
+ } else {
+ std::string error = std::string("type must be 'Float', not ");
+ error += p->ob_type->tp_name;
+ throw Py::TypeError(error);
+ }
+}
+
+Py::Float CenterLinePy::getRotation(void) const
+{
+ double rot = getCenterLinePtr()->getRotate();
+ return Py::asObject(PyFloat_FromDouble(rot));
+}
+
+void CenterLinePy::setRotation(Py::Float arg)
+{
+ PyObject* p = arg.ptr();
+ if (PyFloat_Check(p)) {
+ double rot = PyFloat_AsDouble(p);
+ getCenterLinePtr()->setRotate(rot);
+ } else {
+ std::string error = std::string("type must be 'Float', not ");
+ error += p->ob_type->tp_name;
+ throw Py::TypeError(error);
+ }
+}
+
+Py::Float CenterLinePy::getExtension(void) const
+{
+ double rot = getCenterLinePtr()->getExtend();
+ return Py::asObject(PyFloat_FromDouble(rot));
+}
+
+void CenterLinePy::setExtension(Py::Float arg)
+{
+ PyObject* p = arg.ptr();
+ if (PyFloat_Check(p)) {
+ double ext = PyFloat_AsDouble(p);
+ getCenterLinePtr()->setExtend(ext);
+ } else {
+ std::string error = std::string("type must be 'Float', not ");
+ error += p->ob_type->tp_name;
+ throw Py::TypeError(error);
+ }
+}
+
+Py::Boolean CenterLinePy::getFlip(void) const
+{
+ bool flip = getCenterLinePtr()->getFlip();
+ if (flip) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+}
+
+void CenterLinePy::setFlip(Py::Boolean arg)
+{
+ PyObject* p = arg.ptr();
+ if (PyBool_Check(p)) {
+ if (p == Py_True) {
+ getCenterLinePtr()->setFlip(true);
+ } else {
+ getCenterLinePtr()->setFlip(false);
+ }
+ } else {
+ std::string error = std::string("type must be 'Boolean', not ");
+ error += p->ob_type->tp_name;
+ throw Py::TypeError(error);
+ }
+}
+
+Py::Object CenterLinePy::getEdges(void) const
+{
+// Base::Console().Message("CLP::getEdges()\n");
+ TechDraw::CenterLine* cl = this->getCenterLinePtr();
+
+ std::vector edges = cl->m_edges;
+ int size = edges.size();
+
+ PyObject* result = PyList_New(size);
+
+ for (auto& e: edges) {
+ PyList_Append(result, PyUnicode_FromString(e.c_str()));
+ }
+
+ return Py::asObject(result);
+}
+
+void CenterLinePy::setEdges(Py::Object arg)
+{
+// Base::Console().Message("CLP::setEdges()\n");
+ PyObject* pList = arg.ptr();
+
+ TechDraw::CenterLine* cl = this->getCenterLinePtr();
+ std::vector temp;
+ if (PyList_Check(pList)) {
+ int tSize = (int) PyList_Size(pList);
+ int i = 0;
+ for ( ; i < tSize; i++) {
+ PyObject* item = PyList_GetItem(pList, (Py_ssize_t) i);
+ const char* utf8 = PyUnicode_AsUTF8(item);
+ std::string ssTemp(utf8);
+ temp.push_back(ssTemp);
+ }
+ cl->m_edges = temp;
+ } else {
+ Base::Console().Error("CLPI::setEdges - input not a list!\n");
+ }
+}
+Py::Object CenterLinePy::getFaces(void) const
+{
+// Base::Console().Message("CLP::getFaces()\n");
+ TechDraw::CenterLine* cl = this->getCenterLinePtr();
+
+ std::vector faces = cl->m_faces;
+ int size = faces.size();
+
+ PyObject* result = PyList_New(size);
+
+ for (auto& f: faces) {
+ PyList_Append(result, PyUnicode_FromString(f.c_str()));
+ }
+
+ return Py::asObject(result);
+}
+
+void CenterLinePy::setFaces(Py::Object arg)
+{
+// Base::Console().Message("CLP::setFaces()\n");
+ PyObject* pList = arg.ptr();
- return Py_None;
+ TechDraw::CenterLine* cl = this->getCenterLinePtr();
+ std::vector temp;
+ if (PyList_Check(pList)) {
+ int tSize = (int) PyList_Size(pList);
+ int i = 0;
+ for ( ; i < tSize; i++) {
+ PyObject* item = PyList_GetItem(pList, (Py_ssize_t) i);
+ const char* utf8 = PyUnicode_AsUTF8(item);
+ std::string ssTemp(utf8);
+ temp.push_back(ssTemp);
+ }
+ cl->m_faces = temp;
+ } else {
+ Base::Console().Error("CLPI::setFaces - input not a list!\n");
+ }
}
-PyObject* CenterLinePy::getFormat(PyObject *args)
+Py::Object CenterLinePy::getPoints(void) const
{
- (void) args;
-// Base::Console().Message("CLPI::getFormat()\n");
+// Base::Console().Message("CLP::getPoints()\n");
TechDraw::CenterLine* cl = this->getCenterLinePtr();
- PyObject* pStyle = PyLong_FromLong((long) cl->m_format.m_style);
- PyObject* pWeight = PyFloat_FromDouble(cl->m_format.m_weight);
- PyObject* pColor = DrawUtil::colorToPyTuple(cl->m_format.m_color);
- PyObject* pVisible = PyBool_FromLong((long) cl->m_format.m_visible);
+ std::vector points = cl->m_verts;
+ int size = points.size();
- PyObject* result = PyTuple_New(4);
+ PyObject* result = PyList_New(size);
- PyTuple_SET_ITEM(result, 0, pStyle);
- PyTuple_SET_ITEM(result, 1, pWeight);
- PyTuple_SET_ITEM(result, 2, pColor);
- PyTuple_SET_ITEM(result, 3, pVisible);
+ for (auto& p: points) {
+ PyList_Append(result, PyUnicode_FromString(p.c_str()));
+ }
- return result;
+ return Py::asObject(result);
}
-Py::String CenterLinePy::getTag(void) const
+void CenterLinePy::setPoints(Py::Object arg)
{
- std::string tmp = boost::uuids::to_string(getCenterLinePtr()->getTag());
- return Py::String(tmp);
+// Base::Console().Message("CLP::setPoints()\n");
+ PyObject* pList = arg.ptr();
+
+ TechDraw::CenterLine* cl = this->getCenterLinePtr();
+ std::vector temp;
+ if (PyList_Check(pList)) {
+ int tSize = (int) PyList_Size(pList);
+ int i = 0;
+ for ( ; i < tSize; i++) {
+ PyObject* item = PyList_GetItem(pList, (Py_ssize_t) i);
+ const char* utf8 = PyUnicode_AsUTF8(item);
+ std::string ssTemp(utf8);
+ temp.push_back(ssTemp);
+ }
+ cl->m_verts = temp;
+ } else {
+ Base::Console().Error("CLPI::setPoints - input not a list!\n");
+ }
}
PyObject *CenterLinePy::getCustomAttributes(const char* /*attr*/) const
diff --git a/src/Mod/TechDraw/App/Cosmetic.cpp b/src/Mod/TechDraw/App/Cosmetic.cpp
index 03c47d6aa3e0..6b81cf6a2a39 100644
--- a/src/Mod/TechDraw/App/Cosmetic.cpp
+++ b/src/Mod/TechDraw/App/Cosmetic.cpp
@@ -324,7 +324,7 @@ CosmeticVertex* CosmeticVertex::clone(void) const
PyObject* CosmeticVertex::getPyObject(void)
{
// return new CosmeticVertexPy(new CosmeticVertex(this->copy())); //shouldn't this be clone?
- PyObject* result = new CosmeticVertexPy(this->clone()); //shouldn't this be clone?
+ PyObject* result = new CosmeticVertexPy(this->clone());
return result;
}
@@ -344,13 +344,15 @@ CosmeticEdge::CosmeticEdge()
// Base::Console().Message("CE::CE()\n");
m_geometry = new TechDraw::BaseGeom();
initialize();
-
}
+//TODO: set permaStart/permaEnd in ctors. Need scale.
CosmeticEdge::CosmeticEdge(CosmeticEdge* ce)
{
// Base::Console().Message("CE::CE(ce)\n");
TechDraw::BaseGeom* newGeom = ce->m_geometry->copy();
+ permaStart = ce->permaStart;
+ permaEnd = ce->permaEnd;
m_geometry = newGeom;
m_format = ce->m_format;
initialize();
@@ -365,6 +367,8 @@ CosmeticEdge::CosmeticEdge(Base::Vector3d pt1, Base::Vector3d pt2)
gp_Pnt gp2(p2.x,p2.y,p2.z);
TopoDS_Edge e = BRepBuilderAPI_MakeEdge(gp1, gp2);
m_geometry = TechDraw::BaseGeom::baseFactory(e);
+ permaStart = p1;
+ permaEnd = p2;
initialize();
}
@@ -372,6 +376,8 @@ CosmeticEdge::CosmeticEdge(TopoDS_Edge e)
{
// Base::Console().Message("CE::CE(TopoDS_Edge)\n");
m_geometry = TechDraw::BaseGeom::baseFactory(e);
+ permaStart = m_geometry->getStartPoint();
+ permaEnd = m_geometry->getEndPoint();
initialize();
}
@@ -379,6 +385,8 @@ CosmeticEdge::CosmeticEdge(TechDraw::BaseGeom* g)
{
// Base::Console().Message("CE::CE(bg)\n");
m_geometry = g;
+ permaStart = m_geometry->getStartPoint();
+ permaEnd = m_geometry->getEndPoint();
initialize();
}
@@ -400,6 +408,13 @@ void CosmeticEdge::initialize(void)
m_geometry->setCosmeticTag(getTagAsString());
}
+void CosmeticEdge::unscaleEnds(double scale)
+{
+ permaStart = permaStart / scale;
+ permaEnd = permaEnd / scale;
+ permaRadius = permaRadius / scale;
+}
+
TechDraw::BaseGeom* CosmeticEdge::scaledGeometry(double scale)
{
TechDraw::BaseGeom* newGeom = nullptr;
@@ -418,6 +433,7 @@ TechDraw::BaseGeom* CosmeticEdge::scaledGeometry(double scale)
std::string CosmeticEdge::toString(void) const
{
std::stringstream ss;
+ ss << getTagAsString() << ", $$$, ";
if (m_geometry != nullptr) {
ss << m_geometry->geomType <<
",$$$," <<
@@ -556,7 +572,7 @@ CosmeticEdge* CosmeticEdge::clone(void) const
PyObject* CosmeticEdge::getPyObject(void)
{
- return new CosmeticEdgePy(new CosmeticEdge(this->copy()));
+ return new CosmeticEdgePy(this->clone());
}
//*********************************************************
@@ -580,28 +596,38 @@ CenterLine::CenterLine(void)
initialize();
}
-CenterLine::CenterLine(CenterLine* cl)
+CenterLine::CenterLine(TechDraw::CenterLine* cl)
{
m_start = cl->m_start;
- m_end = cl->m_end;
+ m_end = cl->m_end;
m_mode = cl->m_mode;
m_hShift = cl->m_hShift;
m_vShift = cl->m_vShift;
m_rotate = cl->m_rotate;
m_extendBy = cl->m_extendBy;
- m_faces = cl->m_faces;
- m_format = cl->m_format;
m_type = cl->m_type;
- m_flip2Line = cl->m_flip2Line;
- m_edges = cl->m_edges;
- m_verts = cl->m_verts;
+ m_flip2Line = m_flip2Line;
- TechDraw::BaseGeom* newGeom = cl->m_geometry->copy();
- m_geometry = newGeom;
+ m_geometry = cl->m_geometry; //new BaseGeom(cl->m_geometry);??
+
+ initialize();
+}
+
+CenterLine::CenterLine(TechDraw::BaseGeom* bg)
+{
+ m_start = bg->getStartPoint();
+ m_end = bg->getEndPoint();
+ m_mode = CLMODE::VERTICAL;
+ m_hShift = 0.0;
+ m_vShift = 0.0;
+ m_rotate = 0.0;
+ m_extendBy = 0.0;
+ m_type = CLTYPE::FACE;
+ m_flip2Line = false;
+
+ m_geometry = bg;
initialize();
-
- m_format = cl->m_format;
}
CenterLine::CenterLine(Base::Vector3d pt1, Base::Vector3d pt2)
@@ -674,7 +700,7 @@ CenterLine* CenterLine::CenterLineBuilder(DrawViewPart* partFeat,
int mode,
bool flip)
{
-// Base::Console().Message("CL::CLBuilder()\n");
+// Base::Console().Message("CL::CLBuilder()\n - subNames: %d", subNames.size());
std::pair ends;
std::vector faces;
std::vector edges;
@@ -929,7 +955,7 @@ std::pair CenterLine::calcEndPoints2Lines(DrawVi
double rotate, bool flip)
{
-// Base::Console().Message("CL::calc2Lines() - mode: %d flip: %d\n", mode, flip);
+// Base::Console().Message("CL::calc2Lines() - mode: %d flip: %d edgeNames: %d\n", mode, flip, edgeNames.size());
std::pair result;
if (edgeNames.empty()) {
Base::Console().Warning("CL::calcEndPoints2Lines - no edges!\n");
@@ -937,6 +963,7 @@ std::pair CenterLine::calcEndPoints2Lines(DrawVi
}
double scale = partFeat->getScale();
+ const std::vector dbEdges = partFeat->getEdgeGeometry();
std::vector edges;
for (auto& en: edgeNames) {
@@ -947,10 +974,12 @@ std::pair CenterLine::calcEndPoints2Lines(DrawVi
TechDraw::BaseGeom* bg = partFeat->getGeomByIndex(idx);
if (bg != nullptr) {
edges.push_back(bg);
+ } else {
+ Base::Console().Message("CL::calcEndPoints2Lines - no geom for index: %d\n", idx);
}
}
if (edges.size() != 2) {
-// Base::Console().Message("CL::calcEndPoints2Lines - wrong number of edges!\n");
+ Base::Console().Message("CL::calcEndPoints2Lines - wrong number of edges: %d!\n", edges.size());
// return result;
throw Base::IndexError("CenterLine wrong number of edges.");
}
@@ -1085,8 +1114,8 @@ std::pair CenterLine::calcEndPoints2Points(DrawV
//extend
- p1 = p1 - (clDir * ext);
- p2 = p2 + (clDir * ext);
+ p1 = p1 + (clDir * ext);
+ p2 = p2 - (clDir * ext);
//rotate
if (!DrawUtil::fpCompare(rotate, 0.0)) {
@@ -1388,7 +1417,7 @@ CenterLine *CenterLine::clone(void) const
PyObject* CenterLine::getPyObject(void)
{
- return new CenterLinePy(new CenterLine(this->copy()));
+ return new CenterLinePy(this->clone());
}
void CenterLine::setShifts(double h, double v)
diff --git a/src/Mod/TechDraw/App/Cosmetic.h b/src/Mod/TechDraw/App/Cosmetic.h
index 7a8c41ba4881..1c3591723e6a 100644
--- a/src/Mod/TechDraw/App/Cosmetic.h
+++ b/src/Mod/TechDraw/App/Cosmetic.h
@@ -103,7 +103,6 @@ class TechDrawExport CosmeticVertex: public Base::Persistence, public TechDraw::
boost::uuids::uuid getTag() const;
virtual std::string getTagAsString(void) const;
-
protected:
//Uniqueness
void createNewTag();
@@ -142,8 +141,10 @@ class TechDrawExport CosmeticEdge : public Base::Persistence, public TechDraw::B
CosmeticEdge* copy(void) const;
CosmeticEdge* clone(void) const;
- //Base::Vector3d permaStart; //persistent unscaled start/end points in View coords
- //Base::Vector3d permaEnd;
+ Base::Vector3d permaStart; //persistent unscaled start/end points in View coords?
+ Base::Vector3d permaEnd;
+ double permaRadius;
+ void unscaleEnds(double scale);
TechDraw::BaseGeom* m_geometry;
LineFormat m_format;
@@ -167,7 +168,8 @@ class TechDrawExport CenterLine: public Base::Persistence
public:
CenterLine();
CenterLine(CenterLine* cl);
- //set m_faces after using next 2 ctors
+ //set m_faces after using next 3 ctors
+ CenterLine(TechDraw::BaseGeom* bg);
CenterLine(Base::Vector3d p1, Base::Vector3d p2);
CenterLine(Base::Vector3d p1, Base::Vector3d p2,
int m,
diff --git a/src/Mod/TechDraw/App/CosmeticEdgePy.xml b/src/Mod/TechDraw/App/CosmeticEdgePy.xml
index 39a8119d8cef..98d12e36bd42 100644
--- a/src/Mod/TechDraw/App/CosmeticEdgePy.xml
+++ b/src/Mod/TechDraw/App/CosmeticEdgePy.xml
@@ -25,22 +25,41 @@
Create a copy of this CosmeticEdge
-
-
- Change the appearance of this CometicEdge. edge.setFormat(style, color, weight, visible)
-
-
-
-
-
- returns the appearance attributes of this CometicEdge. returns tuple(style, color, weight, visible).
-
-
Gives the tag of the CosmeticEdge as string.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The appearance attributes (style, color, weight, visible) for this CosmeticEdge.
+
+
+
diff --git a/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp b/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
index 4ae3061bd3c0..507d39df187c 100644
--- a/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
+++ b/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
@@ -29,7 +29,13 @@
#include
+#include
+#include
+#include
+#include
+
#include "DrawUtil.h"
+#include "Geometry.h"
#include "Cosmetic.h"
#include "CosmeticEdgePy.h"
#include "CosmeticEdgePy.cpp"
@@ -111,18 +117,18 @@ PyObject* CosmeticEdgePy::copy(PyObject *args)
return cpy;
}
-PyObject* CosmeticEdgePy::setFormat(PyObject* args)
+void CosmeticEdgePy::setFormat(Py::Object arg)
{
// Base::Console().Message("CEP::setFormat()\n");
- PyObject* pTuple;
+ PyObject* pTuple = arg.ptr();
int style = 1;
double weight = 0.50;
double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
App::Color c(red, blue, green, alpha);
bool visible = 1;
- if (!PyArg_ParseTuple(args, "O", &pTuple)) {
- return NULL;
- }
+// if (!PyArg_ParseTuple(args, "O", &pTuple)) {
+// return NULL;
+// }
TechDraw::CosmeticEdge* ce = this->getCosmeticEdgePtr();
if (PyTuple_Check(pTuple)) {
@@ -145,13 +151,10 @@ PyObject* CosmeticEdgePy::setFormat(PyObject* args)
} else {
Base::Console().Error("CEPI::setFormat - not a tuple!\n");
}
-
- return Py_None;
}
-PyObject* CosmeticEdgePy::getFormat(PyObject *args)
+Py::Object CosmeticEdgePy::getFormat(void) const
{
- (void) args;
// Base::Console().Message("CEP::getFormat()\n");
TechDraw::CosmeticEdge* ce = this->getCosmeticEdgePtr();
@@ -167,7 +170,7 @@ PyObject* CosmeticEdgePy::getFormat(PyObject *args)
PyTuple_SET_ITEM(result, 2, pColor);
PyTuple_SET_ITEM(result, 3, pVisible);
- return result;
+ return Py::asObject(result);
}
Py::String CosmeticEdgePy::getTag(void) const
@@ -176,6 +179,89 @@ Py::String CosmeticEdgePy::getTag(void) const
return Py::String(tmp);
}
+//Py::String CosmeticEdgePy::getOwner(void) const
+//{
+//// std::string tmp = boost::uuids::to_string(getCosmeticEdgePtr()->getOwner());
+// std::string tmp = "not implemented yet";
+// return Py::String(tmp);
+//}
+
+//TODO: make BaseGeom py-aware or convert TD geometry to ??Part::Geometry2d?? or other
+// py-aware class.
+//Py::Object CosmeticEdgePy::getGeometry(void) const
+//{
+//// TechDraw::BaseGeom* bg = getCosmeticEdgePtr()->m_geometry;
+// Base::Console().Message("Not implemented yet");
+// return Py::asObject(Py_None);
+//}
+
+//void CosmeticEdgePy::setGeometry(Py::Object arg)
+//{
+// Base::Console().Message("Not implemented yet");
+// PyObject* p = arg.ptr();
+// if (PyObject_TypeCheck(p, &(TechDraw::BaseGeomPy::Type))) {
+// //TODO
+// } else {
+// std::string error = std::string("type must be 'BaseGeom', not ");
+// error += p->ob_type->tp_name;
+// throw Py::TypeError(error);
+// }
+//}
+
+//Py::Object CosmeticEdgePy::getStart(void) const
+//{
+// Base::Vector3d point = getCosmeticEdgePtr()->permaStart;
+// point = DrawUtil::invertY(point);
+// return Py::asObject(new Base::VectorPy(point));
+//}
+
+//void CosmeticEdgePy::setStart(Py::Object arg)
+//{
+// PyObject* p = arg.ptr();
+// if (PyObject_TypeCheck(p, &(Base::VectorPy::Type))) {
+// Base::Vector3d point = static_cast(p)->value();
+// getCosmeticEdgePtr()->permaStart =
+// DrawUtil::invertY(point);
+// }
+// else if (PyObject_TypeCheck(p, &PyTuple_Type)) {
+// Base::Vector3d point = Base::getVectorFromTuple(p);
+// getCosmeticEdgePtr()->permaStart =
+// DrawUtil::invertY(point);
+// }
+// else {
+// std::string error = std::string("type must be 'Vector', not ");
+// error += p->ob_type->tp_name;
+// throw Py::TypeError(error);
+// }
+//}
+
+//Py::Object CosmeticEdgePy::getEnd(void) const
+//{
+// Base::Vector3d point = getCosmeticEdgePtr()->permaEnd;
+// point = DrawUtil::invertY(point);
+// return Py::asObject(new Base::VectorPy(point));
+//}
+
+//void CosmeticEdgePy::setEnd(Py::Object arg)
+//{
+// PyObject* p = arg.ptr();
+// if (PyObject_TypeCheck(p, &(Base::VectorPy::Type))) {
+// Base::Vector3d point = static_cast(p)->value();
+// getCosmeticEdgePtr()->permaEnd =
+// DrawUtil::invertY(point);
+// }
+// else if (PyObject_TypeCheck(p, &PyTuple_Type)) {
+// Base::Vector3d point = Base::getVectorFromTuple(p);
+// getCosmeticEdgePtr()->permaEnd =
+// DrawUtil::invertY(point);
+// }
+// else {
+// std::string error = std::string("type must be 'Vector', not ");
+// error += p->ob_type->tp_name;
+// throw Py::TypeError(error);
+// }
+//}
+
PyObject *CosmeticEdgePy::getCustomAttributes(const char* /*attr*/) const
{
return 0;
diff --git a/src/Mod/TechDraw/App/CosmeticExtension.cpp b/src/Mod/TechDraw/App/CosmeticExtension.cpp
index 9ccb97fa599e..a59863ddbef8 100644
--- a/src/Mod/TechDraw/App/CosmeticExtension.cpp
+++ b/src/Mod/TechDraw/App/CosmeticExtension.cpp
@@ -49,6 +49,7 @@ CosmeticExtension::CosmeticExtension()
EXTENSION_ADD_PROPERTY_TYPE(CosmeticVertexes, (0), cgroup, App::Prop_Output, "CosmeticVertex Save/Restore");
EXTENSION_ADD_PROPERTY_TYPE(CosmeticEdges, (0), cgroup, App::Prop_Output, "CosmeticEdge Save/Restore");
+ EXTENSION_ADD_PROPERTY_TYPE(CenterLines ,(0),cgroup,App::Prop_Output,"Geometry format Save/Restore");
EXTENSION_ADD_PROPERTY_TYPE(GeomFormats ,(0),cgroup,App::Prop_Output,"Geometry format Save/Restore");
initExtensionType(CosmeticExtension::getExtensionClassTypeId());
@@ -180,8 +181,7 @@ bool CosmeticExtension::replaceCosmeticVertex(CosmeticVertex* newCV)
std::string CosmeticExtension::addCosmeticEdge(Base::Vector3d start,
Base::Vector3d end)
{
-// Base::Console().Message("CEx::addCosmeticEdge(%s)\n",
- // DrawUtil::formatVector(pos).c_str());
+// Base::Console().Message("CEx::addCosmeticEdge(s,e)\n");
std::vector edges = CosmeticEdges.getValues();
TechDraw::CosmeticEdge* ce = new TechDraw::CosmeticEdge(start, end);
edges.push_back(ce);
@@ -201,20 +201,24 @@ std::string CosmeticExtension::addCosmeticEdge(TechDraw::BaseGeom* bg)
return result;
}
-
//get CE by unique id
TechDraw::CosmeticEdge* CosmeticExtension::getCosmeticEdge(std::string tagString) const
{
// Base::Console().Message("CEx::getCosmeticEdge(%s)\n", tagString.c_str());
CosmeticEdge* result = nullptr;
+ bool found = false;
const std::vector edges = CosmeticEdges.getValues();
for (auto& ce: edges) {
std::string ceTag = ce->getTagAsString();
if (ceTag == tagString) {
result = ce;
+ found = true;
break;
}
}
+ if (!found) {
+ Base::Console().Message("CEx::getCosmeticEdge - CE for tag: %s not found.\n", tagString.c_str());
+ }
return result;
}
@@ -234,6 +238,7 @@ TechDraw::CosmeticEdge* CosmeticExtension::getCosmeticEdgeBySelection(std::strin
if (base == nullptr) {
return result;
}
+
if (!base->getCosmeticTag().empty()) {
result = getCosmeticEdge(base->getCosmeticTag());
}
@@ -272,7 +277,6 @@ void CosmeticExtension::removeCosmeticEdge(std::vector delTags)
bool CosmeticExtension::replaceCosmeticEdge(CosmeticEdge* newCE)
{
-// Base::Console().Message("DVP::replaceCE(%s)\n", newCE->getTagAsString().c_str());
bool result = false;
std::vector cEdges = CosmeticEdges.getValues();
std::vector newEdges;
@@ -291,6 +295,131 @@ bool CosmeticExtension::replaceCosmeticEdge(CosmeticEdge* newCE)
//********** Center Line *******************************************************
+//returns unique CL id
+//only adds cl to cllist property. does not add to display geometry until dvp executes.
+std::string CosmeticExtension::addCenterLine(Base::Vector3d start,
+ Base::Vector3d end)
+{
+// Base::Console().Message("CEx::addCenterLine(%s)\n",
+ // DrawUtil::formatVector(pos).c_str());
+ std::vector cLines = CenterLines.getValues();
+ TechDraw::CenterLine* cl = new TechDraw::CenterLine(start, end);
+ cLines.push_back(cl);
+ CenterLines.setValues(cLines);
+ std::string result = cl->getTagAsString();
+ return result;
+}
+
+std::string CosmeticExtension::addCenterLine(TechDraw::CenterLine* cl)
+{
+// Base::Console().Message("CEx::addCenterLine(cl: %X)\n", cl);
+ std::vector cLines = CenterLines.getValues();
+ cLines.push_back(cl);
+ CenterLines.setValues(cLines);
+ std::string result = cl->getTagAsString();
+ return result;
+}
+
+
+std::string CosmeticExtension::addCenterLine(TechDraw::BaseGeom* bg)
+{
+// Base::Console().Message("CEx::addCenterLine(bg: %X)\n", bg);
+ std::vector cLines = CenterLines.getValues();
+ TechDraw::CenterLine* cl = new TechDraw::CenterLine(bg);
+ cLines.push_back(cl);
+ CenterLines.setValues(cLines);
+ std::string result = cl->getTagAsString();
+ return result;
+}
+
+
+//get CL by unique id
+TechDraw::CenterLine* CosmeticExtension::getCenterLine(std::string tagString) const
+{
+// Base::Console().Message("CEx::getCenterLine(%s)\n", tagString.c_str());
+ CenterLine* result = nullptr;
+ const std::vector cLines = CenterLines.getValues();
+ for (auto& cl: cLines) {
+ std::string clTag = cl->getTagAsString();
+ if (clTag == tagString) {
+ result = cl;
+ break;
+ }
+ }
+ return result;
+}
+
+// find the center line corresponding to selection name (Edge5)
+// used when selecting
+TechDraw::CenterLine* CosmeticExtension::getCenterLineBySelection(std::string name) const
+{
+// Base::Console().Message("CEx::getCLBySelection(%s)\n",name.c_str());
+ CenterLine* result = nullptr;
+ App::DocumentObject* extObj = const_cast (getExtendedObject());
+ TechDraw::DrawViewPart* dvp = dynamic_cast(extObj);
+ if (dvp == nullptr) {
+ return result;
+ }
+ int idx = DrawUtil::getIndexFromName(name);
+ TechDraw::BaseGeom* base = dvp->getGeomByIndex(idx);
+ if (base == nullptr) {
+ return result;
+ }
+ if (!base->getCosmeticTag().empty()) {
+ result = getCenterLine(base->getCosmeticTag());
+ }
+ return result;
+}
+
+//overload for index only
+TechDraw::CenterLine* CosmeticExtension::getCenterLineBySelection(int i) const
+{
+// Base::Console().Message("CEx::getCLBySelection(%d)\n", i);
+ std::stringstream ss;
+ ss << "Edge" << i;
+ std::string eName = ss.str();
+ return getCenterLineBySelection(eName);
+}
+
+void CosmeticExtension::removeCenterLine(std::string delTag)
+{
+// Base::Console().Message("DVP::removeCL(%s)\n", delTag.c_str());
+ std::vector cLines = CenterLines.getValues();
+ std::vector newLines;
+ for (auto& cl: cLines) {
+ if (cl->getTagAsString() != delTag) {
+ newLines.push_back(cl);
+ }
+ }
+ CenterLines.setValues(newLines);
+}
+
+void CosmeticExtension::removeCenterLine(std::vector delTags)
+{
+ for (auto& t: delTags) {
+ removeCenterLine(t);
+ }
+}
+
+bool CosmeticExtension::replaceCenterLine(CenterLine* newCL)
+{
+// Base::Console().Message("DVP::replaceCL(%s)\n", newCL->getTagAsString().c_str());
+ bool result = false;
+ std::vector cLines = CenterLines.getValues();
+ std::vector newLines;
+ std::string tag = newCL->getTagAsString();
+ for (auto& cl: cLines) {
+ if (cl->getTagAsString() == tag) {
+ newLines.push_back(newCL);
+ result = true;
+ } else {
+ newLines.push_back(cl);
+ }
+ }
+ CenterLines.setValues(newLines);
+ return result;
+}
+
//********** Geometry Formats **************************************************
//returns unique GF id
diff --git a/src/Mod/TechDraw/App/CosmeticExtension.h b/src/Mod/TechDraw/App/CosmeticExtension.h
index 2a584445e7e1..17873d4fc10e 100644
--- a/src/Mod/TechDraw/App/CosmeticExtension.h
+++ b/src/Mod/TechDraw/App/CosmeticExtension.h
@@ -33,6 +33,7 @@
#include "PropertyCosmeticVertexList.h"
#include "PropertyCosmeticEdgeList.h"
+#include "PropertyCenterLineList.h"
#include "PropertyGeomFormatList.h"
@@ -49,7 +50,7 @@ class TechDrawExport CosmeticExtension : public App::DocumentObjectExtension {
TechDraw::PropertyCosmeticVertexList CosmeticVertexes;
TechDraw::PropertyCosmeticEdgeList CosmeticEdges;
-// TechDraw::PropertyCenterLineList CenterLines;
+ TechDraw::PropertyCenterLineList CenterLines;
TechDraw::PropertyGeomFormatList GeomFormats; //formats for geometric edges
virtual std::string addCosmeticVertex(Base::Vector3d pos);
@@ -69,6 +70,16 @@ class TechDrawExport CosmeticExtension : public App::DocumentObjectExtension {
virtual void removeCosmeticEdge(std::string tag);
virtual void removeCosmeticEdge(std::vector delTags);
+ virtual std::string addCenterLine(Base::Vector3d start, Base::Vector3d end);
+ virtual std::string addCenterLine(TechDraw::CenterLine* cl);
+ virtual std::string addCenterLine(TechDraw::BaseGeom* bg);
+ virtual CenterLine* getCenterLineBySelection(std::string name) const;
+ virtual CenterLine* getCenterLineBySelection(int i) const;
+ virtual CenterLine* getCenterLine(std::string tag) const;
+ virtual bool replaceCenterLine(CenterLine* newLine);
+ virtual void removeCenterLine(std::string tag);
+ virtual void removeCenterLine(std::vector delTags);
+
virtual std::string addGeomFormat(TechDraw::GeomFormat* gf);
virtual GeomFormat* getGeomFormatBySelection(std::string name) const;
virtual GeomFormat* getGeomFormatBySelection(int i) const;
diff --git a/src/Mod/TechDraw/App/DrawViewPart.cpp b/src/Mod/TechDraw/App/DrawViewPart.cpp
index 6511e34ad747..634f2c13095b 100644
--- a/src/Mod/TechDraw/App/DrawViewPart.cpp
+++ b/src/Mod/TechDraw/App/DrawViewPart.cpp
@@ -1080,16 +1080,15 @@ int DrawViewPart::add1CEToGE(std::string tag)
//update Edge geometry with current CE's
void DrawViewPart::refreshCEGeoms(void)
{
-// Base::Console().Message("CEx::refreshCEGeoms()\n");
-
+// Base::Console().Message("DVP::refreshCEGeoms()\n");
std::vector gEdges = getEdgeGeometry();
- std::vector newGEdges;
+ std::vector oldGEdges;
for (auto& ge :gEdges) {
- if (ge->getTagAsString().empty()) { //keep only non-ce edges
- newGEdges.push_back(ge);
+ if (ge->getCosmeticTag().empty()) { //keep only non-ce edges
+ oldGEdges.push_back(ge);
}
}
- getGeometryObject()->setEdgeGeometry(newGEdges);
+ getGeometryObject()->setEdgeGeometry(oldGEdges);
addCosmeticEdgesToGeom();
}
@@ -1101,129 +1100,50 @@ void DrawViewPart::clearCenterLines(void)
CenterLines.setValues(noLines);
}
-int DrawViewPart::addCenterLine(CenterLine* cl)
-{
-// Base::Console().Message("DVP::addCL(cl)\n");
- std::vector lines = CenterLines.getValues();
- int newIdx = (int) lines.size();
- lines.push_back(cl);
- CenterLines.setValues(lines);
- return newIdx;
-}
-
-void DrawViewPart::removeCenterLine(TechDraw::CenterLine* cl)
-{
- bool found = false;
- int i = 0;
- std::vector lines = CenterLines.getValues();
- int stop = lines.size();
- for ( ; i < stop; i++) {
- TechDraw::CenterLine* l = lines.at(i);
- if (cl == l) {
- found = true;
- break;
- }
- }
- if ( (cl != nullptr) &&
- (found) ) {
- removeCenterLine(i);
- }
-}
-
-void DrawViewPart::removeCenterLine(int idx)
+int DrawViewPart::add1CLToGE(std::string tag)
{
- std::vector lines = CenterLines.getValues();
- if (idx < (int) lines.size()) {
- lines.erase(lines.begin() + idx);
- CenterLines.setValues(lines);
- recomputeFeature();
- }
-}
-
-void DrawViewPart::removeCenterLine(std::string delTag)
-{
-// Base::Console().Message("DVP::removeCL(%s)\n", delTag.c_str());
- std::vector cLines = CenterLines.getValues();
- std::vector newLines;
- for (auto& cl: cLines) {
- if (cl->getTagAsString() != delTag) {
- newLines.push_back(cl);
- }
+// Base::Console().Message("CEx::add1CLToGE(%s) 2\n", tag.c_str());
+ TechDraw::CenterLine* cl = getCenterLine(tag);
+ if (cl == nullptr) {
+ Base::Console().Message("CEx::add1CLToGE 2 - cl %s not found\n", tag.c_str());
+ return -1;
}
- CenterLines.setValues(newLines);
+ TechDraw::BaseGeom* scaledGeom = cl->scaledGeometry(this);
+ int iGE = geometryObject->addCenterLine(scaledGeom,
+ tag);
+
+ return iGE;
}
-void DrawViewPart::removeCenterLine(std::vector delTags)
+//update Edge geometry with current CL's
+void DrawViewPart::refreshCLGeoms(void)
{
- std::vector cLines = CenterLines.getValues();
- std::vector newLines;
- for (auto& cl: cLines) {
- bool found = false;
- for (auto& dt: delTags) {
- if (cl->getTagAsString() == dt) {
- found = true; //this cl is in delete list
- break;
- }
- }
- if (!found) {
- newLines.push_back(cl);
+// Base::Console().Message("DVP::refreshCLGeoms()\n");
+ std::vector gEdges = getEdgeGeometry();
+ std::vector newGEdges;
+ for (auto& ge :gEdges) {
+ //TODO: this will keep CE & CL
+ if (ge->getCosmeticTag().empty()) { //keep only non-cl edges
+ newGEdges.push_back(ge);
}
}
- CenterLines.setValues(newLines);
-}
-
-void DrawViewPart::replaceCenterLine(int idx, TechDraw::CenterLine* cl)
-{
- std::vector lines = CenterLines.getValues();
- if (idx < (int) lines.size()) {
- lines.at(idx) = cl;
- recomputeFeature();
- }
-}
-
-void DrawViewPart::replaceCenterLineByGeom(int geomIndex, TechDraw::CenterLine* cl)
-{
- const std::vector &geoms = getEdgeGeometry();
- int sourceIndex = geoms.at(geomIndex)->sourceIndex();
- replaceCenterLine(sourceIndex, cl);
-}
-
-TechDraw::CenterLine* DrawViewPart::getCenterLineByIndex(int idx) const
-{
- CenterLine* result = nullptr;
- const std::vector lines = CenterLines.getValues();
- if (idx < (int) lines.size()) {
- result = lines.at(idx);
- }
- return result;
-}
-
-//find the cosmetic edge corresponding to geometry edge idx
-TechDraw::CenterLine* DrawViewPart::getCenterLineByGeom(int idx) const
-{
- const std::vector &geoms = getEdgeGeometry();
- int sourceIndex = geoms.at(idx)->sourceIndex();
- CenterLine* result = nullptr;
- const std::vector lines = CenterLines.getValues();
- result = lines.at(sourceIndex);
- return result;
+ getGeometryObject()->setEdgeGeometry(newGEdges);
+ addCenterLinesToGeom();
}
//add the center lines to geometry Edges list
void DrawViewPart::addCenterLinesToGeom(void)
{
// Base::Console().Message("DVP::addCenterLinesToGeom()\n");
- int i = 0;
const std::vector lines = CenterLines.getValues();
- int stop = (int) lines.size();
- for ( ; i < stop; i++) {
- TechDraw::BaseGeom* scaledGeom = lines.at(i)->scaledGeometry(this);
+ for (auto& cl: lines) {
+ TechDraw::BaseGeom* scaledGeom = cl->scaledGeometry(this);
if (scaledGeom == nullptr) {
Base::Console().Error("DVP::addCenterLinesToGeom - scaledGeometry is null\n");
continue;
}
// int idx =
- (void) geometryObject->addCenterLine(scaledGeom, 2, i);
+ (void) geometryObject->addCenterLine(scaledGeom, cl->getTagAsString());
}
}
@@ -1265,6 +1185,17 @@ void DrawViewPart::dumpCosVerts(std::string text)
}
}
+void DrawViewPart::dumpCosEdges(std::string text)
+{
+ std::vector cEdges = CosmeticEdges.getValues();
+ Base::Console().Message("%s - dumping %d CosmeticEdge\n",
+ text.c_str(), cEdges.size());
+ for (auto& ce: cEdges) {
+ ce->dump("a CE");
+ }
+}
+
+
void DrawViewPart::onDocumentRestored()
{
diff --git a/src/Mod/TechDraw/App/DrawViewPart.h b/src/Mod/TechDraw/App/DrawViewPart.h
index bfcbf35c2572..05397ee8186b 100644
--- a/src/Mod/TechDraw/App/DrawViewPart.h
+++ b/src/Mod/TechDraw/App/DrawViewPart.h
@@ -111,8 +111,6 @@ class TechDrawExport DrawViewPart : public DrawView, public CosmeticExtension
App::PropertyBool IsoHidden;
App::PropertyInteger IsoCount;
- TechDraw::PropertyCenterLineList CenterLines;
-
virtual short mustExecute() const override;
virtual void onDocumentRestored() override;
virtual App::DocumentObjectExecReturn *execute(void) override;
@@ -181,22 +179,16 @@ class TechDrawExport DrawViewPart : public DrawView, public CosmeticExtension
void addCosmeticEdgesToGeom(void);
int add1CEToGE(std::string tag);
- virtual int addCenterLine(TechDraw::CenterLine*);
- virtual void removeCenterLine(TechDraw::CenterLine* cl);
- virtual void removeCenterLine(int idx);
- void removeCenterLine(std::string delTag);
- void removeCenterLine(std::vector delTags);
- TechDraw::CenterLine* getCenterLineByIndex(int idx) const;
- TechDraw::CenterLine* getCenterLineByGeom(int idx) const;
- void replaceCenterLine(int idx, TechDraw::CenterLine* cl);
- void replaceCenterLineByGeom(int geomIndex, TechDraw::CenterLine* cl);
- void clearCenterLines(void);
+ void clearCenterLines(void);
+ void refreshCLGeoms(void);
void addCenterLinesToGeom(void);
+ int add1CLToGE(std::string tag);
void clearGeomFormats(void);
void dumpVerts(const std::string text);
void dumpCosVerts(const std::string text);
+ void dumpCosEdges(const std::string text);
protected:
bool checkXDirection(void) const;
diff --git a/src/Mod/TechDraw/App/DrawViewPartPy.xml b/src/Mod/TechDraw/App/DrawViewPartPy.xml
index 31f89feb49c5..fcf6bf9bf12a 100644
--- a/src/Mod/TechDraw/App/DrawViewPartPy.xml
+++ b/src/Mod/TechDraw/App/DrawViewPartPy.xml
@@ -35,17 +35,17 @@
- getCosmeticVertex(id) - returns CosmeticVertex with unique id.
+ cv = getCosmeticVertex(id) - returns CosmeticVertex with unique id.
- getCosmeticVertexBySelection(name) - returns CosmeticVertex with name (Vertex6). Used in selections.
+ cv = getCosmeticVertexBySelection(name) - returns CosmeticVertex with name (Vertex6). Used in selections.
- replaceCosmeticVertex(cv) - replaces CosmeticVertex in View. Returns True/False.
+ rc = replaceCosmeticVertex(cv) - replaces CosmeticVertex in View. Returns True/False.
@@ -60,17 +60,17 @@
- makeCosmeticLine(p1, p2) - add a CosmeticEdge from p1 to p2(View coordinates). Returns index of created edge.
+ tag = makeCosmeticLine(p1, p2) - add a CosmeticEdge from p1 to p2(View coordinates). Returns tag of new CosmeticEdge.
- makeCosmeticCircle(center, radius) - add a CosmeticEdge at center with radius radius(View coordinates). Returns index of created edge.
+ tag = makeCosmeticCircle(center, radius) - add a CosmeticEdge at center with radius radius(View coordinates). Returns tag of new CosmeticEdge.
- makeCosmeticCircleArc(center, radius, start, end) - add a CosmeticEdge at center with radius radius(View coordinates) from start angle to end angle. Returns index of created edge.
+ tag = makeCosmeticCircleArc(center, radius, start, end) - add a CosmeticEdge at center with radius radius(View coordinates) from start angle to end angle. Returns tag of new CosmeticEdge.
@@ -95,32 +95,42 @@
- makeCenterLine(subNames, mode) - draw a center line on this viewPart. SubNames is a list of n Faces, 2 Edges or 2 Vertices (ex [Face1,Face2,Face3]. Returns index of added CenterLine.
+ makeCenterLine(subNames, mode) - draw a center line on this viewPart. SubNames is a list of n Faces, 2 Edges or 2 Vertices (ex [Face1,Face2,Face3]. Returns unique tag of added CenterLine.
-
+
- clearCosmeticEdges() - remove all CosmeticLines from the View. Returns None.
+ cl = getCenterLine(id) - returns CenterLine with unique id.
-
+
- clearCenterLines() - remove all CenterLines from the View. Returns None.
+ cl = getCenterLineBySelection(name) - returns CenterLine by name (Edge25). Used in selections
-
+
- clearGeomFormats() - remove all GeomFormats from the View. Returns None.
+ replaceCenterLine(cl) - replacls CenterLine cl in View. Returns True/False.
+
+
+
+
+ removeCenterLine(cl) - remove CenterLine cl from View. Returns None.
-
+
- adjustCenterLine(index, hShift, vShift, rotate, extend [,flip]). Returns None.
+ clearCosmeticEdges() - remove all CosmeticLines from the View. Returns None.
-
+
- formatCenterLine(index, style, weight, color, visible). Returns None.
+ clearCenterLines() - remove all CenterLines from the View. Returns None.
+
+
+
+
+ clearGeomFormats() - remove all GeomFormats from the View. Returns None.
diff --git a/src/Mod/TechDraw/App/DrawViewPartPyImp.cpp b/src/Mod/TechDraw/App/DrawViewPartPyImp.cpp
index 30504fc8075d..08e42ec5d7ae 100644
--- a/src/Mod/TechDraw/App/DrawViewPartPyImp.cpp
+++ b/src/Mod/TechDraw/App/DrawViewPartPyImp.cpp
@@ -310,6 +310,8 @@ PyObject* DrawViewPartPy::makeCosmeticLine(PyObject *args)
std::string newTag = dvp->addCosmeticEdge(pnt1, pnt2);
TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdge(newTag);
if (ce != nullptr) {
+ ce->permaStart = pnt1;
+ ce->permaEnd = pnt2;
ce->m_format.m_style = style;
ce->m_format.m_weight = weight;
if (pColor == nullptr) {
@@ -322,8 +324,10 @@ PyObject* DrawViewPartPy::makeCosmeticLine(PyObject *args)
Base::Console().Message("%s\n",msg.c_str());
throw Py::RuntimeError(msg);
}
- PyObject* result = new CosmeticEdgePy(new CosmeticEdge(ce));
- return result;
+ //int link =
+ dvp->add1CEToGE(newTag);
+ dvp->requestPaint();
+ return PyUnicode_FromString(newTag.c_str()); //return tag for new CE
}
PyObject* DrawViewPartPy::makeCosmeticCircle(PyObject *args)
@@ -357,9 +361,11 @@ PyObject* DrawViewPartPy::makeCosmeticCircle(PyObject *args)
BRepBuilderAPI_MakeEdge aMakeEdge(hCircle, angle1*(M_PI/180), angle2*(M_PI/180));
TopoDS_Edge edge = aMakeEdge.Edge();
TechDraw::BaseGeom* bg = TechDraw::BaseGeom::baseFactory(edge);
- std::string tag = dvp->addCosmeticEdge(bg);
- TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdge(tag);
+ std::string newTag = dvp->addCosmeticEdge(bg);
+ TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdge(newTag);
if (ce != nullptr) {
+ ce->permaStart = pnt1;
+ ce->permaEnd = pnt1;
ce->m_format.m_style = style;
ce->m_format.m_weight = weight;
if (pColor == nullptr) {
@@ -372,8 +378,10 @@ PyObject* DrawViewPartPy::makeCosmeticCircle(PyObject *args)
Base::Console().Message("%s\n",msg.c_str());
throw Py::RuntimeError(msg);
}
- PyObject* result = new CosmeticEdgePy(new CosmeticEdge(ce));
- return result;
+ //int link =
+ dvp->add1CEToGE(newTag);
+ dvp->requestPaint();
+ return PyUnicode_FromString(newTag.c_str()); //return tag for new CE
}
PyObject* DrawViewPartPy::makeCosmeticCircleArc(PyObject *args)
@@ -410,9 +418,11 @@ PyObject* DrawViewPartPy::makeCosmeticCircleArc(PyObject *args)
TopoDS_Edge edge = aMakeEdge.Edge();
TechDraw::BaseGeom* bg = TechDraw::BaseGeom::baseFactory(edge);
- std::string tag = dvp->addCosmeticEdge(bg);
- TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdge(tag);
+ std::string newTag = dvp->addCosmeticEdge(bg);
+ TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdge(newTag);
if (ce != nullptr) {
+ ce->permaStart = pnt1;
+ ce->permaEnd = pnt1;
ce->m_format.m_style = style;
ce->m_format.m_weight = weight;
if (pColor == nullptr) {
@@ -426,8 +436,10 @@ PyObject* DrawViewPartPy::makeCosmeticCircleArc(PyObject *args)
throw Py::RuntimeError(msg);
}
- PyObject* result = new CosmeticEdgePy(new CosmeticEdge(ce));
- return result;
+ //int link =
+ dvp->add1CEToGE(newTag);
+ dvp->requestPaint();
+ return PyUnicode_FromString(newTag.c_str()); //return tag for new CE
}
//********** Cosmetic Edge *****************************************************
@@ -442,7 +454,9 @@ PyObject* DrawViewPartPy::getCosmeticEdge(PyObject *args)
DrawViewPart* dvp = getDrawViewPartPtr();
TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdge(tag);
if (ce != nullptr) {
- result = new CosmeticEdgePy(new CosmeticEdge(ce));
+// result = new CosmeticEdgePy(new CosmeticEdge(ce));
+ result = new CosmeticEdgePy(ce->clone());
+// result = ce->getPyObject();
} else {
Base::Console().Error("DVPPI::getCosmeticEdge - edge %s not found\n", tag);
}
@@ -453,18 +467,19 @@ PyObject* DrawViewPartPy::getCosmeticEdge(PyObject *args)
PyObject* DrawViewPartPy::getCosmeticEdgeBySelection(PyObject *args)
{
// Base::Console().Message("DVPPI::getCosmeticEdgeBySelection()\n");
- char* tag;
+ char* name;
PyObject* result = Py_None;
- if (!PyArg_ParseTuple(args, "s", &tag)) {
- throw Py::TypeError("expected (tag)");
+ if (!PyArg_ParseTuple(args, "s", &name)) {
+ throw Py::TypeError("expected (name)");
}
DrawViewPart* dvp = getDrawViewPartPtr();
- TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdgeBySelection(tag);
+ TechDraw::CosmeticEdge* ce = dvp->getCosmeticEdgeBySelection(name);
if (ce != nullptr) {
- result = new CosmeticEdgePy(new CosmeticEdge(ce));
+// result = ce->getPyObject();
+ result = new CosmeticEdgePy(ce->clone());
} else {
- Base::Console().Error("DVPPI::getCosmeticEdgebySelection - edge for tag %s not found\n", tag);
+ Base::Console().Error("DVPPI::getCosmeticEdgebySelection - edge for name %s not found\n", name);
}
return result;
}
@@ -530,87 +545,95 @@ PyObject* DrawViewPartPy::makeCenterLine(PyObject *args)
#endif
}
}
-
CenterLine* cl = nullptr;
- int idx = -1;
+ std::string tag;
if (!subs.empty()) {
cl = CenterLine::CenterLineBuilder(dvp,
subs,
mode); //vert,horiz,align
if (cl != nullptr) {
- idx = dvp->addCenterLine(cl);
+ tag = dvp->addCenterLine(cl);
} else {
std::string msg = "DVPPI:makeCenterLine - line creation failed";
Base::Console().Message("%s\n",msg.c_str());
throw Py::RuntimeError(msg);
}
}
- return PyLong_FromLong(idx);
+ //int link =
+ dvp->add1CLToGE(tag);
+ dvp->requestPaint();
+
+ return PyUnicode_FromString(tag.c_str()); //return tag for new CV
}
-PyObject* DrawViewPartPy::adjustCenterLine(PyObject *args)
+PyObject* DrawViewPartPy::getCenterLine(PyObject *args)
{
-// Base::Console().Message("DVPPI::adjustCenterLine()\n");
- int idx = -1;
- double hShift = 0.0;
- double vShift = 0.0;
- double rotate = 0.0;
- double extend = 0.0;
- bool flip = false;
-
- if (!PyArg_ParseTuple(args, "idddd|p",&idx, &hShift, &vShift, &rotate, &extend, &flip)) {
- throw Py::TypeError("expected (index, hShift, vShift, rotate, extend [,flip])");
+ char* tag;
+ PyObject* result = Py_None;
+ if (!PyArg_ParseTuple(args, "s", &tag)) {
+ throw Py::TypeError("expected (tag)");
}
-
DrawViewPart* dvp = getDrawViewPartPtr();
- CenterLine* cl = dvp->getCenterLineByIndex(idx);
+ TechDraw::CenterLine* cl = dvp->getCenterLine(tag);
if (cl != nullptr) {
- cl->m_hShift = hShift;
- cl->m_vShift = vShift;
- cl->m_rotate = rotate;
- cl->m_extendBy = extend;
- cl->m_flip2Line = flip;
+ result = new CenterLinePy(cl->clone());
} else {
- std::string msg = "DVPPI:adjustCenterLine - CenterLine not found";
- Base::Console().Message("%s\n",msg.c_str());
- throw Py::RuntimeError(msg);
+ Base::Console().Error("DVPPI::getCenterLine - centerLine %s not found\n", tag);
}
- return Py_None;
+
+ return result;
}
-PyObject* DrawViewPartPy::formatCenterLine(PyObject *args)
+PyObject* DrawViewPartPy::getCenterLineBySelection(PyObject *args)
{
-// Base::Console().Message("DVPPI::formatCenterLine()\n");
- int idx = -1;
- int style = Qt::SolidLine;
- App::Color defColor = LineFormat::getDefEdgeColor();
- double weight = 0.5;
- int visible = 1;
- PyObject* pColor;
-
- if (!PyArg_ParseTuple(args, "iidOi",&idx, &style, &weight, &pColor, &visible)) {
- throw Py::TypeError("expected (index, style, weight, color, visible)");
+// Base::Console().Message("DVPPI::getCenterLineBySelection()\n");
+ char* tag;
+ PyObject* result = Py_None;
+ if (!PyArg_ParseTuple(args, "s", &tag)) {
+ throw Py::TypeError("expected (name)");
}
-
DrawViewPart* dvp = getDrawViewPartPtr();
- CenterLine* cl = dvp->getCenterLineByIndex(idx);
+
+ TechDraw::CenterLine* cl = dvp->getCenterLineBySelection(tag);
if (cl != nullptr) {
- cl->m_format.m_style = style;
- cl->m_format.m_weight = weight;
- if (pColor == nullptr) {
- cl->m_format.m_color = defColor;
- } else {
- cl->m_format.m_color = DrawUtil::pyTupleToColor(pColor);
- }
- cl->m_format.m_visible = visible;
+ result = new CenterLinePy(cl->clone());
} else {
- std::string msg = "DVPPI:formatCenterLine - CenterLine not found";
- Base::Console().Message("%s\n",msg.c_str());
- throw Py::RuntimeError(msg);
+ Base::Console().Error("DVPPI::getCenterLinebySelection - centerLine for tag %s not found\n", tag);
+ }
+ return result;
+}
+
+PyObject* DrawViewPartPy::replaceCenterLine(PyObject *args)
+{
+// Base::Console().Message("DVPPI::replace CenterLine()\n");
+ PyObject* pNewCL;
+ if (!PyArg_ParseTuple(args, "O!", &(TechDraw::CenterLinePy::Type), &pNewCL)) {
+ throw Py::TypeError("expected (CenterLine)");
}
+ DrawViewPart* dvp = getDrawViewPartPtr();
+ TechDraw::CenterLinePy* clPy = static_cast(pNewCL);
+ TechDraw::CenterLine* cl = clPy->getCenterLinePtr();
+ bool result = dvp->replaceCenterLine(cl);
+ dvp->refreshCLGeoms();
+ dvp->requestPaint();
+ return PyBool_FromLong((long) result);
+}
+
+PyObject* DrawViewPartPy::removeCenterLine(PyObject *args)
+{
+// Base::Console().Message("DVPPI::removeCenterLine()\n");
+ char* tag;
+ if (!PyArg_ParseTuple(args, "s", &tag)) {
+ throw Py::TypeError("expected (tag)");
+ }
+ DrawViewPart* dvp = getDrawViewPartPtr();
+ dvp->removeCenterLine(tag);
+ Py_INCREF(Py_None);
return Py_None;
}
+//********** Geometry Edge *****************************************************
+
PyObject* DrawViewPartPy::formatGeometricEdge(PyObject *args)
{
// Base::Console().Message("DVPPI::formatGeometricEdge()\n");
diff --git a/src/Mod/TechDraw/App/Geometry.h b/src/Mod/TechDraw/App/Geometry.h
index a7d9ead6a0cb..14d4b8c83ea1 100644
--- a/src/Mod/TechDraw/App/Geometry.h
+++ b/src/Mod/TechDraw/App/Geometry.h
@@ -75,6 +75,7 @@ class TechDrawExport BaseGeom
{
public:
BaseGeom();
+ //BaseGeom(BaseGeom* bg); //do we need a copy constructor too?
virtual ~BaseGeom() = default;
public:
diff --git a/src/Mod/TechDraw/App/GeometryObject.cpp b/src/Mod/TechDraw/App/GeometryObject.cpp
index d759eaa41e5f..33660c24d9c9 100644
--- a/src/Mod/TechDraw/App/GeometryObject.cpp
+++ b/src/Mod/TechDraw/App/GeometryObject.cpp
@@ -667,6 +667,7 @@ int GeometryObject::addCosmeticEdge(Base::Vector3d start,
TechDraw::BaseGeom* base = BaseGeom::baseFactory(occEdge);
base->cosmetic = true;
base->setCosmeticTag(tagString);
+ base->source(1); //1-CosmeticEdge, 2-CenterLine
base->hlrVisible = true;
int idx = edgeGeom.size();
edgeGeom.push_back(base);
@@ -687,15 +688,16 @@ int GeometryObject::addCosmeticEdge(TechDraw::BaseGeom* base,
}
int GeometryObject::addCenterLine(TechDraw::BaseGeom* base,
- int s, int si)
+ std::string tag)
+// int s, int si)
{
// Base::Console().Message("GO::addCenterLine()\n");
base->cosmetic = true;
- base->source(s); //1-CosmeticEdge, 2-CenterLine
- base->sourceIndex(si); //index into source;
-
+ base->setCosmeticTag(tag);
+ base->source(2);
+// base->sourceIndex(si); //index into source;
+ int idx = edgeGeom.size();
edgeGeom.push_back(base);
- int idx = edgeGeom.size() - 1;
return idx;
}
diff --git a/src/Mod/TechDraw/App/GeometryObject.h b/src/Mod/TechDraw/App/GeometryObject.h
index 1834561d93f8..25f858cc95ad 100644
--- a/src/Mod/TechDraw/App/GeometryObject.h
+++ b/src/Mod/TechDraw/App/GeometryObject.h
@@ -158,7 +158,9 @@ class TechDrawExport GeometryObject
int addCosmeticEdge(TechDraw::BaseGeom* base,
std::string tagString);
- int addCenterLine(TechDraw::BaseGeom* bg, int s = 0, int si = -1);
+ int addCenterLine(TechDraw::BaseGeom* bg,
+ std::string tag);
+/* int s = 0, int si = -1);*/
protected:
//HLR output
diff --git a/src/Mod/TechDraw/App/PropertyCosmeticEdgeList.cpp b/src/Mod/TechDraw/App/PropertyCosmeticEdgeList.cpp
index 5029990c5083..40090eb2508f 100644
--- a/src/Mod/TechDraw/App/PropertyCosmeticEdgeList.cpp
+++ b/src/Mod/TechDraw/App/PropertyCosmeticEdgeList.cpp
@@ -116,7 +116,6 @@ PyObject *PropertyCosmeticEdgeList::getPyObject(void)
void PropertyCosmeticEdgeList::setPyObject(PyObject *value)
{
// check container of this property to notify about changes
-// Part2DObject* part2d = dynamic_cast(this->getContainer());
if (PySequence_Check(value)) {
Py_ssize_t nSize = PySequence_Size(value);
@@ -135,8 +134,6 @@ void PropertyCosmeticEdgeList::setPyObject(PyObject *value)
}
setValues(values);
-// if (part2d)
-// part2d->acceptCosmeticEdge();
}
else if (PyObject_TypeCheck(value, &(CosmeticEdgePy::Type))) {
CosmeticEdgePy *pcObject = static_cast(value);
diff --git a/src/Mod/TechDraw/Gui/CommandAnnotate.cpp b/src/Mod/TechDraw/Gui/CommandAnnotate.cpp
index 217c7b22426f..60162622a31c 100644
--- a/src/Mod/TechDraw/Gui/CommandAnnotate.cpp
+++ b/src/Mod/TechDraw/Gui/CommandAnnotate.cpp
@@ -753,8 +753,10 @@ void execCenterLine(Gui::Command* cmd)
int geomIdx = DrawUtil::getIndexFromName(edgeName);
const std::vector &geoms = baseFeat->getEdgeGeometry();
BaseGeom* bg = geoms.at(geomIdx);
- int clIdx = bg->sourceIndex();
- TechDraw::CenterLine* cl = baseFeat->getCenterLineByIndex(clIdx);
+// int clIdx = bg->sourceIndex();
+// TechDraw::CenterLine* cl = baseFeat->getCenterLineByIndex(clIdx);
+ std::string tag = bg->getCosmeticTag();
+ TechDraw::CenterLine* cl = baseFeat->getCenterLine(tag);
if (cl == nullptr) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong Selection"),
QObject::tr("No CenterLine in selection."));
@@ -829,8 +831,10 @@ void exec2LineCenterLine(Gui::Command* cmd)
int geomIdx = DrawUtil::getIndexFromName(edgeName);
const std::vector &geoms = dvp->getEdgeGeometry();
BaseGeom* bg = geoms.at(geomIdx);
- int clIdx = bg->sourceIndex();
- TechDraw::CenterLine* cl = dvp->getCenterLineByIndex(clIdx);
+// int clIdx = bg->sourceIndex();
+// TechDraw::CenterLine* cl = dvp->getCenterLineByIndex(clIdx);
+ std::string tag = bg->getCosmeticTag();
+ TechDraw::CenterLine* cl = dvp->getCenterLine(tag);
if (cl == nullptr) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong Selection"),
QObject::tr("No CenterLine in selection."));
diff --git a/src/Mod/TechDraw/Gui/QGIViewPart.cpp b/src/Mod/TechDraw/Gui/QGIViewPart.cpp
index a008b79b98d7..2555e23061e1 100644
--- a/src/Mod/TechDraw/Gui/QGIViewPart.cpp
+++ b/src/Mod/TechDraw/Gui/QGIViewPart.cpp
@@ -568,12 +568,12 @@ void QGIViewPart::drawViewPart()
item->setStyle(Qt::SolidLine);
if ((*itGeom)->cosmetic == true) {
int source = (*itGeom)->source();
- int sourceIndex = (*itGeom)->sourceIndex();
if (source == COSMETICEDGE) {
std::string cTag = (*itGeom)->getCosmeticTag();
showItem = formatGeomFromCosmetic(cTag, item);
} else if (source == CENTERLINE) {
- showItem = formatGeomFromCenterLine(sourceIndex, item);
+ std::string cTag = (*itGeom)->getCosmeticTag();
+ showItem = formatGeomFromCenterLine(cTag, item);
} else {
Base::Console().Message("QGIVP::drawVP - edge: %d is confused - source: %d\n",i,source);
}
@@ -702,12 +702,12 @@ bool QGIViewPart::formatGeomFromCosmetic(std::string cTag, QGIEdge* item)
}
-bool QGIViewPart::formatGeomFromCenterLine(int sourceIndex, QGIEdge* item)
+bool QGIViewPart::formatGeomFromCenterLine(std::string cTag, QGIEdge* item)
{
// Base::Console().Message("QGIVP::formatGeomFromCenterLine(%d)\n",sourceIndex);
bool result = true;
auto partFeat( dynamic_cast(getViewObject()) );
- TechDraw::CenterLine* cl = partFeat->getCenterLineByIndex(sourceIndex);
+ TechDraw::CenterLine* cl = partFeat->getCenterLine(cTag);
if (cl != nullptr) {
item->setNormalColor(cl->m_format.m_color.asValue());
item->setWidth(cl->m_format.m_weight * lineScaleFactor);
@@ -926,6 +926,7 @@ void QGIViewPart::drawSectionLine(TechDraw::DrawViewSection* viewSection, bool b
}
}
+//TODO: use Cosmetic::CenterLine object for this to make it usable for dims.
void QGIViewPart::drawCenterLines(bool b)
{
TechDraw::DrawViewPart *viewPart = dynamic_cast(getViewObject());
diff --git a/src/Mod/TechDraw/Gui/QGIViewPart.h b/src/Mod/TechDraw/Gui/QGIViewPart.h
index f6632d6ea1ed..6ec25fabb26f 100644
--- a/src/Mod/TechDraw/Gui/QGIViewPart.h
+++ b/src/Mod/TechDraw/Gui/QGIViewPart.h
@@ -107,7 +107,7 @@ class TechDrawGuiExport QGIViewPart : public QGIView
bool prefPrintCenters(void);
bool formatGeomFromCosmetic(std::string cTag, QGIEdge* item);
- bool formatGeomFromCenterLine(int sourceIndex, QGIEdge* item);
+ bool formatGeomFromCenterLine(std::string cTag, QGIEdge* item);
private:
QList deleteItems;
diff --git a/src/Mod/TechDraw/Gui/TaskCenterLine.cpp b/src/Mod/TechDraw/Gui/TaskCenterLine.cpp
index 8e15b781d6bb..694410171d5e 100644
--- a/src/Mod/TechDraw/Gui/TaskCenterLine.cpp
+++ b/src/Mod/TechDraw/Gui/TaskCenterLine.cpp
@@ -91,8 +91,8 @@ TaskCenterLine::TaskCenterLine(TechDraw::DrawViewPart* partFeat,
m_geomIndex = DrawUtil::getIndexFromName(m_edgeName);
const std::vector &geoms = partFeat->getEdgeGeometry();
BaseGeom* bg = geoms.at(m_geomIndex);
- m_clIdx = bg->sourceIndex();
- m_cl = partFeat->getCenterLineByIndex(m_clIdx);
+ std::string tag = bg->getCosmeticTag();
+ m_cl = partFeat->getCenterLine(tag);
if (m_cl == nullptr) { //checked by CommandAnnotate. Should never happen.
Base::Console().Message("TCL::TCL() - no centerline found\n");
}
@@ -291,7 +291,8 @@ void TaskCenterLine::updateCenterLine(void)
m_cl->m_extendBy = ui->qsbExtend->rawValue();
m_cl->m_type = m_type;
m_cl->m_flip2Line = m_flipped;
- m_partFeat->replaceCenterLine(m_clIdx, m_cl);
+ m_partFeat->replaceCenterLine(m_cl);
+ m_partFeat->refreshCLGeoms();
m_partFeat->requestPaint();
Gui::Command::updateActive();
diff --git a/src/Mod/TechDraw/Gui/TaskLineDecor.cpp b/src/Mod/TechDraw/Gui/TaskLineDecor.cpp
index c936885ee88f..63a748ea3b45 100644
--- a/src/Mod/TechDraw/Gui/TaskLineDecor.cpp
+++ b/src/Mod/TechDraw/Gui/TaskLineDecor.cpp
@@ -125,7 +125,8 @@ void TaskLineDecor::getDefaults(void)
m_weight = ce->m_format.m_weight;
m_visible = ce->m_format.m_visible;
} else if (bg->source() == 2) {
- TechDraw::CenterLine* cl = m_partFeat->getCenterLineByIndex(bg->sourceIndex());
+// TechDraw::CenterLine* cl = m_partFeat->getCenterLine(bg->getCosmeticTag);
+ TechDraw::CenterLine* cl = m_partFeat->getCenterLineBySelection(m_edges.front());
m_style = cl->m_format.m_style;
m_color = cl->m_format.m_color;
m_weight = cl->m_format.m_weight;
@@ -192,7 +193,8 @@ void TaskLineDecor::applyDecorations(void)
ce->m_format.m_weight = m_weight;
ce->m_format.m_visible = m_visible;
} else if (bg->source() == 2) {
- TechDraw::CenterLine* cl = m_partFeat->getCenterLineByIndex(bg->sourceIndex());
+// TechDraw::CenterLine* cl = m_partFeat->getCenterLine(bg->getCosmeticTag());
+ TechDraw::CenterLine* cl = m_partFeat->getCenterLineBySelection(e);
cl->m_format.m_style = m_style;
cl->m_format.m_color = m_color;
cl->m_format.m_weight = m_weight;