# ##########################################################
# FlatCAM: 2D Post-processing for Manufacturing            #
# File Author: Marius Adrian Stanciu (c)                   #
# Date: 09/29/2019                                         #
# MIT Licence                                              #
# ##########################################################

from appTool import *

fcTranslate.apply_language('strings')
if '_' not in builtins.__dict__:
    _ = gettext.gettext

log = logging.getLogger('base')


class ObjectDistance(AppTool):

    def __init__(self, app):
        AppTool.__init__(self, app)

        self.app = app
        self.canvas = self.app.plotcanvas
        self.units = self.app.app_units.lower()
        self.decimals = self.app.decimals

        self.active = False
        self.original_call_source = None

        # #############################################################################
        # ######################### Tool GUI ##########################################
        # #############################################################################
        self.ui = ObjectDistanceUI(layout=self.layout, app=self.app)
        self.pluginName = self.ui.pluginName
        self.connect_signals_at_init()

        self.h_point = (0, 0)

    def run(self, toggle=False):
        # if the plugin was already launched do not do it again
        if self.active is True:
            return

        if self.app.plugin_tab_locked is True:
            return

        # if the splitter is hidden, display it
        if self.app.ui.splitter.sizes()[0] == 0:
            self.app.ui.splitter.setSizes([1, 1])

        if toggle:
            pass

        # if the Tool Tab is hidden display it, else hide it but only if the objectName is the same
        found_idx = None
        for idx in range(self.app.ui.notebook.count()):
            if self.app.ui.notebook.widget(idx).objectName() == "plugin_tab":
                found_idx = idx
                break
        # show the Tab
        if not found_idx:
            try:
                self.app.ui.notebook.addTab(self.app.ui.plugin_tab, _("Plugin"))
            except RuntimeError:
                self.app.ui.plugin_tab = QtWidgets.QWidget()
                self.app.ui.plugin_tab.setObjectName("plugin_tab")
                self.app.ui.plugin_tab_layout = QtWidgets.QVBoxLayout(self.app.ui.plugin_tab)
                self.app.ui.plugin_tab_layout.setContentsMargins(2, 2, 2, 2)

                self.app.ui.plugin_scroll_area = VerticalScrollArea()
                self.app.ui.plugin_tab_layout.addWidget(self.app.ui.plugin_scroll_area)
                self.app.ui.notebook.addTab(self.app.ui.plugin_tab, _("Plugin"))
            # focus on Tool Tab
            self.app.ui.notebook.setCurrentWidget(self.app.ui.plugin_tab)

        # Remove anything else in the appGUI
        self.app.ui.plugin_scroll_area.takeWidget()

        # Put oneself in the appGUI
        self.app.ui.plugin_scroll_area.setWidget(self)

        # Switch notebook to tool page
        self.app.ui.notebook.setCurrentWidget(self.app.ui.plugin_tab)

        self.set_tool_ui()
        self.app.ui.notebook.setTabText(2, _("Object Distance"))

        # activate the plugin
        self.activate_measure_tool()

    def install(self, icon=None, separator=None, **kwargs):
        AppTool.install(self, icon, separator, shortcut='Shift+M', **kwargs)

    def connect_signals_at_init(self):
        self.ui.measure_btn.clicked.connect(self.activate_measure_tool)
        self.ui.jump_hp_btn.clicked.connect(self.on_jump_to_half_point)
        self.ui.reset_button.clicked.connect(self.set_tool_ui)
        self.ui.distance_type_combo.currentIndexChanged.connect(self.on_didstance_type_changed)

    def set_tool_ui(self):
        self.units = self.app.app_units.lower()

        # initial view of the layout
        self.init_plugin()

    def init_plugin(self):
        self.ui.start_entry.set_value('(0, 0)')
        self.ui.stop_entry.set_value('(0, 0)')

        self.ui.distance_x_entry.set_value('0.0')
        self.ui.distance_y_entry.set_value('0.0')
        self.ui.angle_entry.set_value('0.0')
        self.ui.total_distance_entry.set_value('0.0')
        self.ui.half_point_entry.set_value('(0, 0)')

        self.ui.jump_hp_btn.setDisabled(True)

        self.active = True

    def on_didstance_type_changed(self):
        self.init_plugin()

    def activate_measure_tool(self):
        # ENABLE the Measuring TOOL
        self.ui.jump_hp_btn.setDisabled(False)

        self.units = self.app.app_units.lower()
        self.original_call_source = deepcopy(self.app.call_source)

        measuring_type = self.ui.distance_type_combo.get_value()

        if measuring_type == 0:      # 0 is "nearest points"
            if self.app.call_source == 'app':
                first_pos, last_pos = self.measure_nearest_in_app()
            elif self.app.call_source == 'geo_editor':
                first_pos, last_pos = self.measure_nearest_in_geo_editor()
            elif self.app.call_source == 'exc_editor':
                first_pos, last_pos = self.measure_nearest_in_exc_editor()
            elif self.app.call_source == 'grb_editor':
                first_pos, last_pos = self.measure_nearest_in_grb_editor()
            else:
                first_pos, last_pos = Point((0, 0)), Point((0, 0))
        else:
            if self.app.call_source == 'app':
                first_pos, last_pos = self.measure_center_in_app()
            elif self.app.call_source == 'geo_editor':
                first_pos, last_pos = self.measure_center_in_geo_editor()
            elif self.app.call_source == 'exc_editor':
                first_pos, last_pos = self.measure_center_in_exc_editor()
            elif self.app.call_source == 'grb_editor':
                first_pos, last_pos = self.measure_center_in_grb_editor()
            else:
                first_pos, last_pos = Point((0, 0)), Point((0, 0))

        if first_pos == "fail":
            return

        # self.ui.start_entry.set_value("(%.*f, %.*f)" % (self.decimals, first_pos.x, self.decimals, first_pos.y))
        # self.ui.stop_entry.set_value("(%.*f, %.*f)" % (self.decimals, last_pos.x, self.decimals, last_pos.y))

        # update start point
        val_start = self.update_start(first_pos)
        self.display_start(val_start)

        # update end point
        val_stop = self.update_end_point(last_pos)
        self.display_end(val_stop)

        # update deltas
        dx, dy = self.update_deltas(first_pt=first_pos, second_pt=last_pos)
        self.display_deltas(dx, dy)

        # update angle
        angle_val = self.update_angle(dx=dx, dy=dy)
        self.display_angle(angle_val)

        # update the total distance
        d = self.update_distance(dx, dy)
        self.display_distance(d)

        self.h_point = self.update_half_distance(first_pos, last_pos, dx, dy)
        if measuring_type == 0:  # 0 is "nearest points"
            if d != 0:
                self.display_half_distance(self.h_point)
            else:
                self.display_half_distance((0.0, 0.0))
                intersect_loc = "(%.*f, %.*f)" % (self.decimals, self.h_point[0], self.decimals, self.h_point[1])
                msg = '[WARNING_NOTCL] %s: %s' % (_("Objects intersects or touch at"), intersect_loc)
                self.app.inform.emit(msg)
        else:
            self.display_half_distance(self.h_point)

        self.active = False

    def measure_nearest_in_app(self):
        selected_objs = self.app.collection.get_selected()
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"

        geo_first = selected_objs[0].solid_geometry
        geo_second = selected_objs[1].solid_geometry
        if isinstance(selected_objs[0].solid_geometry, list):
            try:
                geo_first = MultiPolygon(geo_first)
            except Exception:
                geo_first = unary_union(geo_first)
        if isinstance(selected_objs[1].solid_geometry, list):
            try:
                geo_second = MultiPolygon(geo_second)
            except Exception:
                geo_second = unary_union(geo_second)

        first_pos, last_pos = nearest_points(geo_first, geo_second)
        return first_pos, last_pos

    def measure_nearest_in_geo_editor(self):
        selected_objs = self.app.geo_editor.selected
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"
        first_pos, last_pos = nearest_points(selected_objs[0].geo, selected_objs[1].geo)
        return first_pos, last_pos

    def measure_nearest_in_grb_editor(self):
        selected_objs = self.app.grb_editor.selected
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"

        first_pos, last_pos = nearest_points(selected_objs[0].geo['solid'], selected_objs[1].geo['solid'])
        return first_pos, last_pos

    def measure_nearest_in_exc_editor(self):
        selected_objs = self.app.exc_editor.selected
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"

        # the objects are really MultiLinesStrings made out of 2 lines in cross shape
        xmin, ymin, xmax, ymax = selected_objs[0].geo.bounds
        first_geo_radius = (xmax - xmin) / 2
        first_geo_center = Point(xmin + first_geo_radius, ymin + first_geo_radius)
        first_geo = first_geo_center.buffer(first_geo_radius)

        # the objects are really MultiLinesStrings made out of 2 lines in cross shape
        xmin, ymin, xmax, ymax = selected_objs[1].geo.bounds
        last_geo_radius = (xmax - xmin) / 2
        last_geo_center = Point(xmin + last_geo_radius, ymin + last_geo_radius)
        last_geo = last_geo_center.buffer(last_geo_radius)

        first_pos, last_pos = nearest_points(first_geo, last_geo)
        return first_pos, last_pos

    def measure_center_in_app(self):
        selected_objs = self.app.collection.get_selected()
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"

        geo_first = selected_objs[0].solid_geometry
        geo_second = selected_objs[1].solid_geometry
        if isinstance(selected_objs[0].solid_geometry, list):
            try:
                geo_first = MultiPolygon(geo_first)
            except Exception:
                geo_first = unary_union(geo_first)
        if isinstance(selected_objs[1].solid_geometry, list):
            try:
                geo_second = MultiPolygon(geo_second)
            except Exception:
                geo_second = unary_union(geo_second)

        first_bounds = geo_first.bounds     # xmin, ymin, xmax, ymax
        first_center_x = first_bounds[0] + (first_bounds[2] - first_bounds[0]) / 2
        first_center_y = first_bounds[1] + (first_bounds[3] - first_bounds[1]) / 2
        second_bounds = geo_second.bounds   # xmin, ymin, xmax, ymax
        second_center_x = second_bounds[0] + (second_bounds[2] - second_bounds[0]) / 2
        second_center_y = second_bounds[1] + (second_bounds[3] - second_bounds[1]) / 2
        return Point((first_center_x, first_center_y)), Point((second_center_x, second_center_y))

    def measure_center_in_geo_editor(self):
        selected_objs = self.app.geo_editor.selected
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"
        geo_first = selected_objs[0].geo
        geo_second = selected_objs[1].geo

        first_bounds = geo_first.bounds  # xmin, ymin, xmax, ymax
        first_center_x = first_bounds[0] + (first_bounds[2] - first_bounds[0]) / 2
        first_center_y = first_bounds[1] + (first_bounds[3] - first_bounds[1]) / 2
        second_bounds = geo_second.bounds  # xmin, ymin, xmax, ymax
        second_center_x = second_bounds[0] + (second_bounds[2] - second_bounds[0]) / 2
        second_center_y = second_bounds[1] + (second_bounds[3] - second_bounds[1]) / 2
        return Point((first_center_x, first_center_y)), Point((second_center_x, second_center_y))

    def measure_center_in_grb_editor(self):
        selected_objs = self.app.grb_editor.selected
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"

        geo_first = selected_objs[0].geo['solid']
        geo_second = selected_objs[1].geo['solid']

        first_bounds = geo_first.bounds  # xmin, ymin, xmax, ymax
        first_center_x = first_bounds[0] + (first_bounds[2] - first_bounds[0]) / 2
        first_center_y = first_bounds[1] + (first_bounds[3] - first_bounds[1]) / 2
        second_bounds = geo_second.bounds  # xmin, ymin, xmax, ymax
        second_center_x = second_bounds[0] + (second_bounds[2] - second_bounds[0]) / 2
        second_center_y = second_bounds[1] + (second_bounds[3] - second_bounds[1]) / 2
        return Point((first_center_x, first_center_y)), Point((second_center_x, second_center_y))

    def measure_center_in_exc_editor(self):
        selected_objs = self.app.exc_editor.selected
        if len(selected_objs) != 2:
            self.app.inform.emit('[WARNING_NOTCL] %s %s' %
                                 (_("Select two objects and no more. Currently the selection has objects: "),
                                  str(len(selected_objs))))
            return "fail", "fail"

        # the objects are really MultiLinesStrings made out of 2 lines in cross shape
        xmin, ymin, xmax, ymax = selected_objs[0].geo.bounds
        first_geo_radius = (xmax - xmin) / 2
        first_geo_center = Point(xmin + first_geo_radius, ymin + first_geo_radius)
        geo_first = first_geo_center.buffer(first_geo_radius)

        # the objects are really MultiLinesStrings made out of 2 lines in cross shape
        xmin, ymin, xmax, ymax = selected_objs[1].geo.bounds
        last_geo_radius = (xmax - xmin) / 2
        last_geo_center = Point(xmin + last_geo_radius, ymin + last_geo_radius)
        geo_second = last_geo_center.buffer(last_geo_radius)

        first_bounds = geo_first.bounds  # xmin, ymin, xmax, ymax
        first_center_x = first_bounds[0] + (first_bounds[2] - first_bounds[0]) / 2
        first_center_y = first_bounds[1] + (first_bounds[3] - first_bounds[1]) / 2
        second_bounds = geo_second.bounds  # xmin, ymin, xmax, ymax
        second_center_x = second_bounds[0] + (second_bounds[2] - second_bounds[0]) / 2
        second_center_y = second_bounds[1] + (second_bounds[3] - second_bounds[1]) / 2
        return Point((first_center_x, first_center_y)), Point((second_center_x, second_center_y))

    def on_jump_to_half_point(self):
        self.app.on_jump_to(custom_location=self.h_point)
        self.app.inform.emit('[success] %s: %s' %
                             (_("Jumped to the half point between the two selected objects"),
                              "(%.*f, %.*f)" % (self.decimals, self.h_point[0], self.decimals, self.h_point[1])))

    def update_angle(self, dx, dy):
        try:
            angle = math.degrees(math.atan2(dy, dx))
            if angle < 0:
                angle += 360
        except Exception as e:
            self.app.log.error("ObjectDistance.update_angle() -> %s" % str(e))
            return None
        return angle

    def display_angle(self, val):
        if val:
            self.ui.angle_entry.set_value(str(self.app.dec_format(val, self.decimals)))

    def update_start(self, pt):
        return self.app.dec_format(pt.x, self.decimals), self.app.dec_format(pt.y, self.decimals)

    def display_start(self, val):
        if val:
            self.ui.start_entry.set_value(str(val))

    def update_end_point(self, pt):
        # update the end point value
        return self.app.dec_format(pt.x, self.decimals), self.app.dec_format(pt.y, self.decimals)

    def display_end(self, val):
        if val:
            self.ui.stop_entry.set_value(str(val))

    @staticmethod
    def update_deltas(first_pt, second_pt):
        dx = first_pt.x - second_pt.x
        dy = first_pt.y - second_pt.y
        return dx, dy

    def display_deltas(self, dx, dy):
        if dx:
            self.ui.distance_x_entry.set_value(str(self.app.dec_format(abs(dx), self.decimals)))
        if dy:
            self.ui.distance_y_entry.set_value(str(self.app.dec_format(abs(dy), self.decimals)))

    @staticmethod
    def update_distance(dx, dy):
        return math.sqrt(dx ** 2 + dy ** 2)

    def display_distance(self, val):
        if val:
            self.ui.total_distance_entry.set_value('%.*f' % (self.decimals, abs(val)))

    @staticmethod
    def update_half_distance(first_pos, last_pos, dx, dy):
        return min(first_pos.x, last_pos.x) + (abs(dx) / 2), min(first_pos.y, last_pos.y) + (abs(dy) / 2)

    def display_half_distance(self, val):
        if val:
            new_val = (
                self.app.dec_format(val[0], self.decimals),
                self.app.dec_format(val[1], self.decimals)
            )
            self.ui.half_point_entry.set_value(str(new_val))

    def on_plugin_cleanup(self):
        self.active = False
        self.app.call_source = self.original_call_source
        self.app.inform.emit('%s' % _("Done."))


class ObjectDistanceUI:

    pluginName = _("Object Distance")

    def __init__(self, layout, app):
        self.app = app
        self.decimals = self.app.decimals
        self.layout = layout
        self.units = self.app.app_units.lower()

        # ## Title
        title_label = FCLabel("<font size=4><b>%s</b></font><br>" % self.pluginName)
        self.layout.addWidget(title_label)

        # #############################################################################################################
        # Parameters Frame
        # #############################################################################################################
        self.param_label = FCLabel('%s' % _("Parameters"), color='blue', bold=True)
        self.param_label.setToolTip(
            _("Parameters used for this tool.")
        )
        self.layout.addWidget(self.param_label)

        par_frame = FCFrame()
        self.layout.addWidget(par_frame)

        param_grid = GLay(v_spacing=5, h_spacing=3)
        par_frame.setLayout(param_grid)

        # Distance Type

        self.distance_type_label = FCLabel("%s:" % _("Type"))
        self.distance_type_label.setToolTip(
            _("The type of distance to be calculated.\n"
              "- Nearest points - minimal distance between objects\n"
              "- Center points - distance between the center of the bounding boxes")
        )

        self.distance_type_combo = FCComboBox2()
        self.distance_type_combo.addItems([_("Nearest points"), _("Center points")])
        param_grid.addWidget(self.distance_type_label, 0, 0)
        param_grid.addWidget(self.distance_type_combo, 0, 1)

        # #############################################################################################################
        # Coordinates Frame
        # #############################################################################################################
        self.coords_label = FCLabel('%s' % _("Coordinates"), color='green', bold=True)
        self.layout.addWidget(self.coords_label)

        coords_frame = FCFrame()
        self.layout.addWidget(coords_frame)

        coords_grid = GLay(v_spacing=5, h_spacing=3)
        coords_frame.setLayout(coords_grid)

        # separator_line = QtWidgets.QFrame()
        # separator_line.setFrameShape(QtWidgets.QFrame.Shape.HLine)
        # separator_line.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
        # grid0.addWidget(separator_line, 6, 0, 1, 2)

        # Start Point
        self.start_label = FCLabel("%s:" % _('Start point'))
        self.start_label.setToolTip(_("This is measuring Start point coordinates."))

        self.start_entry = FCEntry()
        self.start_entry.setReadOnly(True)
        self.start_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.start_entry.setToolTip(_("This is measuring Start point coordinates."))

        coords_grid.addWidget(self.start_label, 0, 0)
        coords_grid.addWidget(self.start_entry, 0, 1)
        coords_grid.addWidget(FCLabel("%s" % self.units), 0, 2)

        # End Point
        self.stop_label = FCLabel("%s:" % _('End point'))
        self.stop_label.setToolTip(_("This is the measuring Stop point coordinates."))

        self.stop_entry = FCEntry()
        self.stop_entry.setReadOnly(True)
        self.stop_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.stop_entry.setToolTip(_("This is the measuring Stop point coordinates."))

        coords_grid.addWidget(self.stop_label, 2, 0)
        coords_grid.addWidget(self.stop_entry, 2, 1)
        coords_grid.addWidget(FCLabel("%s" % self.units), 2, 2)

        # #############################################################################################################
        # Coordinates Frame
        # #############################################################################################################
        self.res_label = FCLabel('%s' % _("Results"), color='red', bold=True)
        self.layout.addWidget(self.res_label)

        res_frame = FCFrame()
        self.layout.addWidget(res_frame)

        res_grid = GLay(v_spacing=5, h_spacing=3)
        res_frame.setLayout(res_grid)

        # DX distance
        self.distance_x_label = FCLabel('%s:' % _("Dx"))
        self.distance_x_label.setToolTip(_("This is the distance measured over the X axis."))

        self.distance_x_entry = FCEntry()
        self.distance_x_entry.setReadOnly(True)
        self.distance_x_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.distance_x_entry.setToolTip(_("This is the distance measured over the X axis."))

        res_grid.addWidget(self.distance_x_label, 0, 0)
        res_grid.addWidget(self.distance_x_entry, 0, 1)
        res_grid.addWidget(FCLabel("%s" % self.units), 0, 2)

        # DY distance
        self.distance_y_label = FCLabel('%s:' % _("Dy"))
        self.distance_y_label.setToolTip(_("This is the distance measured over the Y axis."))

        self.distance_y_entry = FCEntry()
        self.distance_y_entry.setReadOnly(True)
        self.distance_y_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.distance_y_entry.setToolTip(_("This is the distance measured over the Y axis."))

        res_grid.addWidget(self.distance_y_label, 2, 0)
        res_grid.addWidget(self.distance_y_entry, 2, 1)
        res_grid.addWidget(FCLabel("%s" % self.units), 2, 2)

        # Angle
        self.angle_label = FCLabel('%s:' % _("Angle"))
        self.angle_label.setToolTip(_("This is orientation angle of the measuring line."))

        self.angle_entry = FCEntry()
        self.angle_entry.setReadOnly(True)
        self.angle_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.angle_entry.setToolTip(_("This is orientation angle of the measuring line."))

        res_grid.addWidget(self.angle_label, 4, 0)
        res_grid.addWidget(self.angle_entry, 4, 1)
        res_grid.addWidget(FCLabel("%s" % "°"), 4, 2)

        separator_line = QtWidgets.QFrame()
        separator_line.setFrameShape(QtWidgets.QFrame.Shape.HLine)
        separator_line.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
        res_grid.addWidget(separator_line, 6, 0, 1, 3)

        # Total Distance
        self.total_distance_label = FCLabel("<b>%s:</b>" % _('DISTANCE'))
        self.total_distance_label.setToolTip(_("This is the point to point Euclidian distance."))

        self.total_distance_entry = FCEntry()
        self.total_distance_entry.setReadOnly(True)
        self.total_distance_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight |
                                               QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.total_distance_entry.setToolTip(_("This is the point to point Euclidian distance."))

        res_grid.addWidget(self.total_distance_label, 8, 0)
        res_grid.addWidget(self.total_distance_entry, 8, 1)
        res_grid.addWidget(FCLabel("%s" % self.units), 8, 2)
        
        # Half Point
        self.half_point_label = FCLabel("<b>%s:</b>" % _('Half Point'))
        self.half_point_label.setToolTip(_("This is the middle point of the point to point Euclidean distance."))

        self.half_point_entry = FCEntry()
        self.half_point_entry.setReadOnly(True)
        self.half_point_entry.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter)
        self.half_point_entry.setToolTip(_("This is the middle point of the point to point Euclidean distance."))

        res_grid.addWidget(self.half_point_label, 10, 0)
        res_grid.addWidget(self.half_point_entry, 10, 1)
        res_grid.addWidget(FCLabel("%s" % self.units), 10, 2)

        # Buttons
        self.measure_btn = FCButton(_("Measure"))
        self.layout.addWidget(self.measure_btn)

        self.jump_hp_btn = FCButton(_("Jump to Half Point"))
        self.jump_hp_btn.setDisabled(True)
        self.layout.addWidget(self.jump_hp_btn)

        GLay.set_common_column_size([param_grid, coords_grid, res_grid], 0)

        self.layout.addStretch(1)

        # ## Reset Tool
        self.reset_button = QtWidgets.QPushButton(_("Reset Tool"))
        self.reset_button.setIcon(QtGui.QIcon(self.app.resource_location + '/reset32.png'))
        self.reset_button.setToolTip(
            _("Will reset the tool parameters.")
        )
        self.reset_button.setStyleSheet("""
                                        QPushButton
                                        {
                                            font-weight: bold;
                                        }
                                        """)
        self.layout.addWidget(self.reset_button)
        # #################################### FINSIHED GUI ###########################
        # #############################################################################

    def confirmation_message(self, accepted, minval, maxval):
        if accepted is False:
            self.app.inform[str, bool].emit('[WARNING_NOTCL] %s: [%.*f, %.*f]' % (_("Edited value is out of range"),
                                                                                  self.decimals,
                                                                                  minval,
                                                                                  self.decimals,
                                                                                  maxval), False)
        else:
            self.app.inform[str, bool].emit('[success] %s' % _("Edited value is within limits."), False)

    def confirmation_message_int(self, accepted, minval, maxval):
        if accepted is False:
            self.app.inform[str, bool].emit('[WARNING_NOTCL] %s: [%d, %d]' %
                                            (_("Edited value is out of range"), minval, maxval), False)
        else:
            self.app.inform[str, bool].emit('[success] %s' % _("Edited value is within limits."), False)