# ***************************************************************************
# *   Copyright (c) 2010 Yorik van Havre <yorik@uncreated.net>              *
# *   Copyright (c) 2010 Ken Cline <cline@frii.com>                         *
# *   Copyright (c) 2020 Carlo Pavan <carlopav@gmail.com>                   *
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
# *   as published by the Free Software Foundation; either version 2 of     *
# *   the License, or (at your option) any later version.                   *
# *   for detail see the LICENCE text file.                                 *
# *                                                                         *
# *   This program is distributed in the hope that it will be useful,       *
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
# *   GNU Library General Public License for more details.                  *
# *                                                                         *
# *   You should have received a copy of the GNU Library General Public     *
# *   License along with this program; if not, write to the Free Software   *
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
# *   USA                                                                   *
# *                                                                         *
# ***************************************************************************
"""Provides support functions to edit Draft objects.

All functions in this module work with Object coordinate space.
No conversion to global coordinate system is needed.

To support an new Object, Draft_Edit needs at least two functions:
getObjectPts(obj): returns a list of points on which Draft_Edit will display
    edit trackers
updateObject(obj, nodeIndex, v): update the give object according to the
    index of a moved edit tracker and the vector of the displacement
TODO: Abstract the code that handles the preview and move the object specific
    code to this module from main Draft_Edit module
"""
## @package gui_edit_draft_objects
# \ingroup draftguitools
# \brief Provides support functions to edit Draft objects.

__title__ = "FreeCAD Draft Edit Tool"
__author__ = ("Yorik van Havre, Werner Mayer, Martin Burbaum, Ken Cline, "
              "Dmitry Chigrin, Carlo Pavan")
__url__ = "https://www.freecadweb.org"

## \addtogroup draftguitools
# @{
import math
import FreeCAD as App
import DraftVecUtils

from draftutils.translate import translate
import draftutils.utils as utils

import draftguitools.gui_trackers as trackers

from draftguitools.gui_edit_base_object import GuiTools



class DraftWireGuiTools(GuiTools):

    def __init__(self):
        pass

    def get_edit_points(self, obj):
        editpoints = []
        for p in obj.Points:
            editpoints.append(p)
        return editpoints

    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        pts = obj.Points
        tol = 0.001 # TODO : Use default precision
        if (node_idx == 0 and (v - pts[-1]).Length < tol ):
            # DNC: user moved first point over last point -> Close curve
            obj.Closed = True
            pts[0] = v
            del pts[-1]
            obj.Points = pts
            return
        elif node_idx == len(pts) - 1 and (v - pts[0]).Length < tol:
            # DNC: user moved last point over first point -> Close curve
            obj.Closed = True
            del pts[-1]
            obj.Points = pts
            return
        elif v in pts:
            # DNC: checks if point enter is equal to other, this could cause a OCC problem
            _err = translate("draft", "This object does not support possible "
                                    "coincident points, please try again.")
            App.Console.PrintMessage(_err + "\n")
            return

        if obj.Closed:
            # DNC: project the new point to the plane of the face if present
            if hasattr(obj.Shape, "normalAt"):
                normal = obj.Shape.normalAt(0,0)
                point_on_plane = obj.Shape.Vertexes[0].Point
                v.projectToPlane(point_on_plane, normal)

        pts[node_idx] = v
        obj.Points = pts


    def get_edit_point_context_menu(self, obj, node_idx):
        actions = ["delete point"]
        return actions
    
    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        if action == "delete point":
            self.delete_point(obj, node_idx)
            edit_command.resetTrackers(obj)

    def init_preview_object(self, obj):
        return trackers.wireTracker(obj.Shape)

    def update_preview_object(self, edit_command, obj, node_idx, v):
        if utils.get_type(obj) in ["Wire"]:
            pointList = edit_command.globalize_vectors(obj, obj.Points)
            pointList[node_idx] = v
            if obj.Closed:
                pointList.append(pointList[0])
            edit_command.ghost.updateFromPointlist(pointList)
        
    def delete_point(self, obj, node_idx):
        if len(obj.Points) <= 2:
            _msg = translate("draft", "Active object must have more than two points/nodes") 
            App.Console.PrintWarning(_msg + "\n")
            return

        pts = obj.Points
        pts.pop(node_idx)
        obj.Points = pts

        obj.recompute()


class DraftBSplineGuiTools(DraftWireGuiTools):

    def init_preview_object(self, obj):
        return trackers.bsplineTracker()

    def update_preview_object(self, edit_command, obj, node_idx, v):
        pointList = edit_command.globalize_vectors(obj, obj.Points)
        pointList[node_idx] = v
        if obj.Closed:
            pointList.append(pointList[0])
        edit_command.ghost.update(pointList)


class DraftRectangleGuiTools(GuiTools):

    def __init__(self):
        pass

    def get_edit_points(self, obj):
        """Return the list of edipoints for the given Draft Rectangle.

        0 : Placement.Base
        1 : Length
        2 : Height
        """
        editpoints = []
        editpoints.append(App.Vector(0, 0, 0))
        editpoints.append(App.Vector(obj.Length, 0, 0))
        editpoints.append(App.Vector(0, obj.Height, 0))
        return editpoints

    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        if node_idx == 0:
            obj.Placement.Base = obj.Placement.multVec(v)
        elif node_idx == 1:
            obj.Length = DraftVecUtils.project(v, App.Vector(1,0,0)).Length
        elif node_idx == 2:
            obj.Height = DraftVecUtils.project(v, App.Vector(0,1,0)).Length

    def get_edit_point_context_menu(self, obj, node_idx):
        pass

    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        pass


class DraftCircleGuiTools(GuiTools):

    def __init__(self):
        pass

    def get_edit_points(self, obj):
        """Return the list of edipoints for the given Draft Arc or Circle.

        circle:
        0 : Placement.Base or center
        1 : radius

        arc:
        0 : Placement.Base or center
        1 : first endpoint
        2 : second endpoint
        3 : midpoint
        """
        editpoints = []
        editpoints.append(App.Vector(0, 0, 0))
        if obj.FirstAngle == obj.LastAngle:
            # obj is a circle
            editpoints.append(App.Vector(obj.Radius,0,0))
        else:
            # obj is an arc
            editpoints.append(self.getArcStart(obj))#First endpoint
            editpoints.append(self.getArcEnd(obj))#Second endpoint
            editpoints.append(self.getArcMid(obj))#Midpoint
        return editpoints

    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        if obj.FirstAngle == obj.LastAngle:
            # object is a circle
            if node_idx == 0:
                obj.Placement.Base = obj.Placement.multVec(v)
            elif node_idx == 1:
                obj.Radius = v.Length

        else:
            # obj is an arc
            if alt_edit_mode == 0:
                import Part
                if node_idx == 0:
                    # center point
                    p1 = self.getArcStart(obj)
                    p2 = self.getArcEnd(obj)
                    p0 = DraftVecUtils.project(v, self.getArcMid(obj))
                    obj.Radius = p1.sub(p0).Length
                    obj.FirstAngle = -math.degrees(DraftVecUtils.angle(p1.sub(p0)))
                    obj.LastAngle = -math.degrees(DraftVecUtils.angle(p2.sub(p0)))
                    obj.Placement.Base = obj.Placement.multVec(p0)

                else:
                    """ Edit arc by 3 points.
                    """
                    v= obj.Placement.multVec(v)
                    p1 = obj.Placement.multVec(self.getArcStart(obj))
                    p2 = obj.Placement.multVec(self.getArcMid(obj))
                    p3 = obj.Placement.multVec(self.getArcEnd(obj))
                    
                    if node_idx == 1:  # first point
                        p1 = v
                    elif node_idx == 3:  # midpoint
                        p2 = v
                    elif node_idx == 2:  # second point
                        p3 = v

                    arc=Part.ArcOfCircle(p1, p2, p3)
                    import Part
                    s = arc.toShape()
                    # Part.show(s) DEBUG
                    p0 = arc.Location
                    obj.Placement.Base = p0
                    obj.Radius = arc.Radius
                    
                    delta = s.Vertexes[0].Point
                    obj.FirstAngle = -math.degrees(DraftVecUtils.angle(p1.sub(p0)))
                    delta = s.Vertexes[1].Point
                    obj.LastAngle = -math.degrees(DraftVecUtils.angle(p3.sub(p0)))

            elif alt_edit_mode == 1:
                # edit arc by center radius FirstAngle LastAngle
                if node_idx == 0:
                    obj.Placement.Base = obj.Placement.multVec(v)
                else:
                    dangle = math.degrees(math.atan2(v[1],v[0]))
                    if node_idx == 1:
                        obj.FirstAngle = dangle
                    elif node_idx == 2:
                        obj.LastAngle = dangle
                    elif node_idx == 3:
                        obj.Radius = v.Length


    def get_edit_point_context_menu(self, obj, node_idx):
        actions = None
        if obj.FirstAngle != obj.LastAngle:
            if node_idx == 0:  # user is over arc start point
                actions = ["move arc"]
            elif node_idx == 1:  # user is over arc start point
                actions = ["set first angle"]
            elif node_idx == 2:  # user is over arc end point
                actions = ["set last angle"]
            elif node_idx == 3:  # user is over arc mid point
                actions = ["set radius"]
        if actions:
            return actions


    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        if action in ("move arc", "set radius",
                "set first angle", "set last angle"):
            edit_command.alt_edit_mode = 1
            edit_command.startEditing(edit_command.event)

    def init_preview_object(self, obj):
        return trackers.arcTracker()

    def update_preview_object(self, edit_command, obj, node_idx, v):
        edit_command.ghost.setCenter(obj.getGlobalPlacement().Base)
        edit_command.ghost.setRadius(obj.Radius)
        if obj.FirstAngle == obj.LastAngle:
            # obj is a circle
            edit_command.ghost.circle = True
            if node_idx == 0:
                edit_command.ghost.setCenter(v)
            elif node_idx == 1:
                radius = v.sub(obj.getGlobalPlacement().Base).Length
                edit_command.ghost.setRadius(radius)
        else:
            if edit_command.alt_edit_mode == 0:
                # edit by 3 points
                if node_idx == 0:
                    # center point
                    p1 = edit_command.localize_vectors(obj, obj.Shape.Vertexes[0].Point)
                    p2 = edit_command.localize_vectors(obj, obj.Shape.Vertexes[1].Point)
                    p0 = DraftVecUtils.project(edit_command.localize_vectors(obj, v),
                                                edit_command.localize_vectors(obj, (self.getArcMid(obj, global_placement=True))))
                    edit_command.ghost.autoinvert=False
                    edit_command.ghost.setRadius(p1.sub(p0).Length)
                    edit_command.ghost.setStartPoint(obj.Shape.Vertexes[1].Point)
                    edit_command.ghost.setEndPoint(obj.Shape.Vertexes[0].Point)
                    edit_command.ghost.setCenter(edit_command.globalize_vector(obj, p0))
                    return
                else:
                    p1 = self.getArcStart(obj, global_placement=True)
                    p2 = self.getArcMid(obj, global_placement=True)
                    p3 = self.getArcEnd(obj, global_placement=True)
                    if node_idx == 1:
                        p1=v
                    elif node_idx == 3:
                        p2=v
                    elif node_idx == 2:
                        p3=v
                    edit_command.ghost.setBy3Points(p1,p2,p3)
            elif edit_command.alt_edit_mode == 1:
                # edit by center radius angles
                edit_command.ghost.setStartAngle(math.radians(obj.FirstAngle))
                edit_command.ghost.setEndAngle(math.radians(obj.LastAngle))
                if node_idx == 0:
                    edit_command.ghost.setCenter(v)
                elif node_idx == 1:
                    edit_command.ghost.setStartPoint(v)
                elif node_idx == 2:
                    edit_command.ghost.setEndPoint(v)
                elif node_idx == 3:
                    edit_command.ghost.setRadius(edit_command.localize_vectors(obj, v).Length)


    def getArcStart(self, obj, global_placement=False):#Returns object midpoint
        if utils.get_type(obj) == "Circle":
            return self.pointOnCircle(obj, obj.FirstAngle, global_placement)


    def getArcEnd(self, obj, global_placement=False):#Returns object midpoint
        if utils.get_type(obj) == "Circle":
            return self.pointOnCircle(obj, obj.LastAngle, global_placement)


    def getArcMid(self, obj, global_placement=False):#Returns object midpoint
        if utils.get_type(obj) == "Circle":
            if obj.LastAngle > obj.FirstAngle:
                midAngle = obj.FirstAngle + (obj.LastAngle - obj.FirstAngle) / 2.0
            else:
                midAngle = obj.FirstAngle + (obj.LastAngle - obj.FirstAngle) / 2.0
                midAngle += App.Units.Quantity(180,App.Units.Angle)
            return self.pointOnCircle(obj, midAngle, global_placement)


    def pointOnCircle(self, obj, angle, global_placement=False):
        if utils.get_type(obj) == "Circle":
            px = obj.Radius * math.cos(math.radians(angle))
            py = obj.Radius * math.sin(math.radians(angle))
            p = App.Vector(px, py, 0.0)
            if global_placement == True:
                p = obj.getGlobalPlacement().multVec(p)
            return p
        return None


    def arcInvert(self, obj):
        obj.FirstAngle, obj.LastAngle = obj.LastAngle, obj.FirstAngle
        obj.recompute()


class DraftEllipseGuiTools(GuiTools):

    def __init__(self):
        pass

    def get_edit_points(self, obj):
        editpoints = []
        editpoints.append(App.Vector(0, 0, 0))
        editpoints.append(App.Vector(obj.MajorRadius, 0, 0))
        editpoints.append(App.Vector(0, obj.MinorRadius, 0))
        return editpoints

    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        if node_idx == 0:
            obj.Placement.Base = obj.Placement.multVec(v)
        elif node_idx == 1:
            if v.Length >= obj.MinorRadius:
                obj.MajorRadius = v.Length
            else:
                obj.MajorRadius = obj.MinorRadius
        elif node_idx == 2:
            if v.Length <= obj.MajorRadius:
                obj.MinorRadius = v.Length
            else:
                obj.MinorRadius = obj.MajorRadius

    def get_edit_point_context_menu(self, obj, node_idx):
        pass

    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        pass


class DraftPolygonGuiTools(GuiTools):

    def __init__(self):
        pass

    def get_edit_points(self, obj):
        editpoints = []
        editpoints.append(App.Vector(0, 0, 0))
        if obj.DrawMode == 'inscribed':
            editpoints.append(obj.Placement.inverse().multVec(obj.Shape.Vertexes[0].Point))
        else:
            editpoints.append(obj.Placement.inverse().multVec((obj.Shape.Vertexes[0].Point + 
                                                            obj.Shape.Vertexes[1].Point) / 2
                                                            ))
        return editpoints

    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        if node_idx == 0:
            obj.Placement.Base = obj.Placement.multVec(v)
        elif node_idx == 1:
            obj.Radius = v.Length
        obj.recompute()

    def get_edit_point_context_menu(self, obj, node_idx):
        pass

    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        pass


class DraftDimensionGuiTools(GuiTools):

    def __init__(self):
        pass

    def get_edit_points(self, obj):
        editpoints = []
        p = obj.ViewObject.Proxy.textpos.translation.getValue()
        editpoints.append(obj.Start)
        editpoints.append(obj.End)
        editpoints.append(obj.Dimline)
        editpoints.append(App.Vector(p[0], p[1], p[2]))
        return editpoints

    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        if node_idx == 0:
            obj.Start = v
        elif node_idx == 1:
            obj.End = v
        elif node_idx == 2:
            obj.Dimline = v
        elif node_idx == 3:
            obj.ViewObject.TextPosition = v

    def get_edit_point_context_menu(self, obj, node_idx):
        pass

    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        pass


class DraftBezCurveGuiTools(GuiTools):

    def __init__(self):
        pass


    def get_edit_points(self, obj):
        editpoints = []
        for p in obj.Points:
            editpoints.append(p)
        return editpoints


    def update_object_from_edit_points(self, obj, node_idx, v, alt_edit_mode=0):
        pts = obj.Points
        # DNC: check for coincident startpoint/endpoint to auto close the curve
        tol = 0.001
        if ( ( node_idx == 0 ) and ( (v - pts[-1]).Length < tol) ) or ( 
                node_idx == len(pts) - 1 ) and ( (v - pts[0]).Length < tol):
            obj.Closed = True
        # DNC: checks if point enter is equal to other, this could cause a OCC problem
        if v in pts:
            _err = translate("draft", "This object does not support possible "
                                    "coincident points, please try again.")
            App.Console.PrintMessage(_err + "\n")
            return
        
        pts = self.recomputePointsBezier(obj, pts, node_idx, v, obj.Degree, moveTrackers=False)

        if obj.Closed:
            # check that the new point lies on the plane of the wire
            if hasattr(obj.Shape,"normalAt"):
                normal = obj.Shape.normalAt(0,0)
                point_on_plane = obj.Shape.Vertexes[0].Point
                v.projectToPlane(point_on_plane, normal)
        pts[node_idx] = v
        obj.Points = pts


    def get_edit_point_context_menu(self, obj, node_idx):
        if utils.get_type(obj) in ["Line", "Wire", "BSpline"]:
            actions = ["delete point"]
        elif utils.get_type(obj) in ["BezCurve"]:
            actions = ["make sharp", "make tangent",
                        "make symmetric", "delete point"]
        return actions
    

    def evaluate_context_menu_action(self, edit_command, obj, node_idx, action):
        if action == "delete point":
            self.delete_point(obj, node_idx)
            edit_command.resetTrackers(obj)
        # Bezier curve menu
        elif action in ["make sharp", "make tangent", "make symmetric"]:
            if action == "make sharp":
                self.smoothBezPoint(obj, node_idx, 'Sharp')
            elif action == "make tangent":
                self.smoothBezPoint(obj, node_idx, 'Tangent')
            elif action == "make symmetric":
                self.smoothBezPoint(obj, node_idx, 'Symmetric')
            edit_command.resetTrackers(obj)


    def init_preview_object(self, obj):
        return trackers.bezcurveTracker()

    def update_preview_object(self, edit_command, obj, node_idx, v):
        plist = edit_command.globalize_vectors(obj, obj.Points)
        pointList = self.recomputePointsBezier(obj,plist,node_idx,v,obj.Degree,moveTrackers=False)
        edit_command.ghost.update(pointList, obj.Degree)
       
    def delete_point(self, obj, node_idx):
        if len(obj.Points) <= 2:
            _msg = translate("draft", "Active object must have more than two points/nodes") 
            App.Console.PrintWarning(_msg + "\n")
            return

        pts = obj.Points
        pts.pop(node_idx)
        obj.Points = pts
        obj.Proxy.resetcontinuity(obj)
        obj.recompute()

    def recomputePointsBezier(self, obj, pts, idx, v,
                                degree, moveTrackers=False):
        """
        (object, Points as list, nodeIndex as Int, App.Vector of new point, moveTrackers as Bool)
        return the new point list, applying the App.Vector to the given index point
        """
        # DNC: allows to close the curve by placing ends close to each other
        tol = 0.001
        if ( ( idx == 0 ) and ( (v - pts[-1]).Length < tol) ) or (
                idx == len(pts) - 1 ) and ( (v - pts[0]).Length < tol):
            obj.Closed = True
        # DNC: fix error message if edited point coincides with one of the existing points
        #if ( v in pts ) == False:
        knot = None
        ispole = idx % degree

        if ispole == 0: #knot
            if degree >= 3:
                if idx >= 1: #move left pole
                    knotidx = idx if idx < len(pts) else 0
                    pts[idx-1] = pts[idx-1] + v - pts[knotidx]
                    #if moveTrackers: # trackers are reset after editing
                    #    self.trackers[obj.Name][idx-1].set(pts[idx-1])
                if idx < len(pts)-1: #move right pole
                    pts[idx+1] = pts[idx+1] + v - pts[idx]
                    #if moveTrackers:
                    #    self.trackers[obj.Name][idx+1].set(pts[idx+1])
                if idx == 0 and obj.Closed: # move last pole
                    pts[-1] = pts [-1] + v -pts[idx]
                    #if moveTrackers:
                    #    self.trackers[obj.Name][-1].set(pts[-1])

        elif ispole == 1 and (idx >=2 or obj.Closed): #right pole
            knot = idx -1
            changep = idx - 2  # -1 in case of closed curve

        elif ispole == degree-1 and idx <= len(pts)-3:  # left pole
            knot = idx + 1
            changep = idx + 2

        elif ispole == degree-1 and obj.Closed and idx == len(pts)-1: #last pole
            knot = 0
            changep = 1

        if knot is not None:  # we need to modify the opposite pole
            segment = int(knot / degree) - 1
            cont = obj.Continuity[segment] if len(obj.Continuity) > segment else 0
            if cont == 1: #tangent
                pts[changep] = obj.Proxy.modifytangentpole(pts[knot],
                    v,pts[changep])
                #if moveTrackers:
                #    self.trackers[obj.Name][changep].set(pts[changep])
            elif cont == 2: #symmetric
                pts[changep] = obj.Proxy.modifysymmetricpole(pts[knot],v)
                #if moveTrackers:
                #    self.trackers[obj.Name][changep].set(pts[changep])
        pts[idx] = v

        return pts  # returns the list of new points, taking into account knot continuity


    def smoothBezPoint(self, obj, point, style='Symmetric'):
        "called when changing the continuity of a knot"
        style2cont = {'Sharp':0,'Tangent':1,'Symmetric':2}
        if point is None:
            return
        if not (utils.get_type(obj) == "BezCurve"):
            return
        pts = obj.Points
        deg = obj.Degree
        if deg < 2:
            return
        if point % deg != 0:  # point is a pole
            if deg >=3:  # allow to select poles
                if (point % deg == 1) and (point > 2 or obj.Closed): #right pole
                    knot = point -1
                    keepp = point
                    changep = point -2
                elif point < len(pts) -3 and point % deg == deg -1: #left pole
                    knot = point +1
                    keepp = point
                    changep = point +2
                elif point == len(pts)-1 and obj.Closed: #last pole
                    # if the curve is closed the last pole has the last
                    # index in the points lists
                    knot = 0
                    keepp = point
                    changep = 1
                else:
                    App.Console.PrintWarning(translate("draft",
                                                        "Can't change Knot belonging to pole %d"%point)
                                                        + "\n")
                    return
                if knot:
                    if style == 'Tangent':
                        pts[changep] = obj.Proxy.modifytangentpole(pts[knot],
                            pts[keepp],pts[changep])
                    elif style == 'Symmetric':
                        pts[changep] = obj.Proxy.modifysymmetricpole(pts[knot],
                            pts[keepp])
                    else: #sharp
                        pass #
            else:
                App.Console.PrintWarning(translate("draft",
                                                    "Selection is not a Knot")
                                                    + "\n")
                return
        else: #point is a knot
            if style == 'Sharp':
                if obj.Closed and point == len(pts)-1:
                    knot = 0
                else:
                    knot = point
            elif style == 'Tangent' and point > 0 and point < len(pts)-1:
                prev, next = obj.Proxy.tangentpoles(pts[point], pts[point-1], pts[point+1])
                pts[point-1] = prev
                pts[point+1] = next
                knot = point  # index for continuity
            elif style == 'Symmetric' and point > 0 and point < len(pts)-1:
                prev, next = obj.Proxy.symmetricpoles(pts[point], pts[point-1], pts[point+1])
                pts[point-1] = prev
                pts[point+1] = next
                knot = point  # index for continuity
            elif obj.Closed and (style == 'Symmetric' or style == 'Tangent'):
                if style == 'Tangent':
                    pts[1], pts[-1] = obj.Proxy.tangentpoles(pts[0], pts[1], pts[-1])
                elif style == 'Symmetric':
                    pts[1], pts[-1] = obj.Proxy.symmetricpoles(pts[0], pts[1], pts[-1])
                knot = 0
            else:
                App.Console.PrintWarning(translate("draft",
                                                        "Endpoint of BezCurve can't be smoothed")
                                                        + "\n")
                return
        segment = knot // deg  # segment index
        newcont = obj.Continuity[:]  # don't edit a property inplace !!!
        if not obj.Closed and (len(obj.Continuity) == segment -1 or
            segment == 0) :
            pass # open curve
        elif (len(obj.Continuity) >= segment or obj.Closed and segment == 0 and
                len(obj.Continuity) >1):
            newcont[segment-1] = style2cont.get(style)
        else: #should not happen
            App.Console.PrintWarning('Continuity indexing error:'
                                        + 'point:%d deg:%d len(cont):%d' % (knot,deg,
                                            len(obj.Continuity)))
        obj.Points = pts
        obj.Continuity = newcont

## @}
