- moved all Excellon Advanced Prefeences to Drilling Tool Preferences

- updated Drilling Tool to use the new settings
- updated the Excellon Editor: the default_data dict is populated now on Editor entry
- Excellon Editor: added a new functionality: conversion of slots to drills
- Excellon UI: added a new feature that is grouped in Advanced Settings: a toggle tools table visibility checkbox

CHANGELOG.md

@@ -7,6 +7,14 @@ CHANGELOG for FlatCAM beta
 
 =================================================
 
+11.07.2020
+
+- moved all Excellon Advanced Prefeences to Drilling Tool Preferences
+- updated Drilling Tool to use the new settings
+- updated the Excellon Editor: the default_data dict is populated now on Editor entry
+- Excellon Editor: added a new functionality: conversion of slots to drills
+- Excellon UI: added a new feature that is grouped in Advanced Settings: a toggle tools table visibility checkbox 
+
 10.07.2020
 
 - Tool Drilling - moved some of the Excellon Preferences related to drilling operation to it's own group Drilling Tool Options

appEditors/AppExcEditor.py

@@ -6,10 +6,10 @@
 # ##########################################################
 
 from PyQt5 import QtGui, QtCore, QtWidgets
-from PyQt5.QtCore import Qt, QSettings
+from PyQt5.QtCore import Qt
 
 from camlib import distance, arc, FlatCAMRTreeStorage
-from appGUI.GUIElements import FCEntry, FCComboBox, FCTable, FCDoubleSpinner, RadioSet, FCSpinner
+from appGUI.GUIElements import FCEntry, FCComboBox, FCTable, FCDoubleSpinner, RadioSet, FCSpinner, FCButton
 from appEditors.AppGeoEditor import FCShapeTool, DrawTool, DrawToolShape, DrawToolUtilityShape, AppGeoEditor
 from appParsers.ParseExcellon import Excellon
 
@@ -142,7 +142,7 @@ class FCDrillArray(FCShapeTool):
         DrawTool.__init__(self, draw_app)
         self.name = 'drill_array'
 
-        self.draw_app.array_frame.show()
+        self.draw_app.e_ui.array_frame.show()
 
         self.selected_dia = None
         self.drill_axis = 'X'
@@ -219,15 +219,15 @@ class FCDrillArray(FCShapeTool):
         self.origin = origin
 
     def utility_geometry(self, data=None, static=None):
-        self.drill_axis = self.draw_app.drill_axis_radio.get_value()
-        self.drill_direction = self.draw_app.drill_direction_radio.get_value()
-        self.drill_array = self.draw_app.array_type_combo.get_value()
+        self.drill_axis = self.draw_app.e_ui.drill_axis_radio.get_value()
+        self.drill_direction = self.draw_app.e_ui.drill_direction_radio.get_value()
+        self.drill_array = self.draw_app.e_ui.array_type_combo.get_value()
         try:
-            self.drill_array_size = int(self.draw_app.drill_array_size_entry.get_value())
+            self.drill_array_size = int(self.draw_app.e_ui.drill_array_size_entry.get_value())
             try:
-                self.drill_pitch = float(self.draw_app.drill_pitch_entry.get_value())
-                self.drill_linear_angle = float(self.draw_app.linear_angle_spinner.get_value())
-                self.drill_angle = float(self.draw_app.drill_angle_entry.get_value())
+                self.drill_pitch = float(self.draw_app.e_ui.drill_pitch_entry.get_value())
+                self.drill_linear_angle = float(self.draw_app.e_ui.linear_angle_spinner.get_value())
+                self.drill_angle = float(self.draw_app.e_ui.drill_angle_entry.get_value())
             except TypeError:
                 self.draw_app.app.inform.emit('[ERROR_NOTCL] %s' %
                                               _("The value is not Float. Check for comma instead of dot separator."))
@@ -353,7 +353,7 @@ class FCDrillArray(FCShapeTool):
         self.complete = True
         self.draw_app.app.inform.emit('[success] %s' % _("Done. Drill Array added."))
         self.draw_app.in_action = False
-        self.draw_app.array_frame.hide()
+        self.draw_app.e_ui.array_frame.hide()
 
         self.draw_app.app.jump_signal.disconnect()
 
@@ -378,7 +378,7 @@ class FCSlot(FCShapeTool):
         self.name = 'slot_add'
         self.draw_app = draw_app
 
-        self.draw_app.slot_frame.show()
+        self.draw_app.e_ui.slot_frame.show()
 
         self.selected_dia = None
         try:
@@ -442,25 +442,25 @@ class FCSlot(FCShapeTool):
         self.steps_per_circ = self.draw_app.app.defaults["geometry_circle_steps"]
 
         try:
-            slot_length = float(self.draw_app.slot_length_entry.get_value())
+            slot_length = float(self.draw_app.e_ui.slot_length_entry.get_value())
         except ValueError:
             # try to convert comma to decimal point. if it's still not working error message and return
             try:
-                slot_length = float(self.draw_app.slot_length_entry.get_value().replace(',', '.'))
-                self.draw_app.slot_length_entry.set_value(slot_length)
+                slot_length = float(self.draw_app.e_ui.slot_length_entry.get_value().replace(',', '.'))
+                self.draw_app.e_ui.slot_length_entry.set_value(slot_length)
             except ValueError:
                 self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' %
                                               _("Value is missing or wrong format. Add it and retry."))
                 return
 
         try:
-            slot_angle = float(self.draw_app.slot_angle_spinner.get_value())
+            slot_angle = float(self.draw_app.e_ui.slot_angle_spinner.get_value())
         except ValueError:
             self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' %
                                           _("Value is missing or wrong format. Add it and retry."))
             return
 
-        if self.draw_app.slot_axis_radio.get_value() == 'X':
+        if self.draw_app.e_ui.slot_axis_radio.get_value() == 'X':
             self.half_width = slot_length / 2.0
             self.half_height = self.radius
         else:
@@ -501,7 +501,7 @@ class FCSlot(FCShapeTool):
                 geo.append(pt)
             geo.append(p4)
 
-            if self.draw_app.slot_axis_radio.get_value() == 'A':
+            if self.draw_app.e_ui.slot_axis_radio.get_value() == 'A':
                 return affinity.rotate(geom=Polygon(geo), angle=-slot_angle)
             else:
                 return Polygon(geo)
@@ -556,7 +556,7 @@ class FCSlot(FCShapeTool):
         self.draw_app.in_action = False
         self.complete = True
         self.draw_app.app.inform.emit('[success] %s' % _("Done. Adding Slot completed."))
-        self.draw_app.slot_frame.hide()
+        self.draw_app.e_ui.slot_frame.hide()
         self.draw_app.app.jump_signal.disconnect()
 
     def clean_up(self):
@@ -580,8 +580,8 @@ class FCSlotArray(FCShapeTool):
         self.name = 'slot_array'
         self.draw_app = draw_app
 
-        self.draw_app.slot_frame.show()
-        self.draw_app.slot_array_frame.show()
+        self.draw_app.e_ui.slot_frame.show()
+        self.draw_app.e_ui.slot_array_frame.show()
 
         self.selected_dia = None
         try:
@@ -662,15 +662,15 @@ class FCSlotArray(FCShapeTool):
         self.origin = origin
 
     def utility_geometry(self, data=None, static=None):
-        self.slot_axis = self.draw_app.slot_array_axis_radio.get_value()
-        self.slot_direction = self.draw_app.slot_array_direction_radio.get_value()
-        self.slot_array = self.draw_app.slot_array_type_combo.get_value()
+        self.slot_axis = self.draw_app.e_ui.slot_array_axis_radio.get_value()
+        self.slot_direction = self.draw_app.e_ui.slot_array_direction_radio.get_value()
+        self.slot_array = self.draw_app.e_ui.slot_array_type_combo.get_value()
         try:
-            self.slot_array_size = int(self.draw_app.slot_array_size_entry.get_value())
+            self.slot_array_size = int(self.draw_app.e_ui.slot_array_size_entry.get_value())
             try:
-                self.slot_pitch = float(self.draw_app.slot_array_pitch_entry.get_value())
-                self.slot_linear_angle = float(self.draw_app.slot_array_linear_angle_spinner.get_value())
-                self.slot_angle = float(self.draw_app.slot_array_angle_entry.get_value())
+                self.slot_pitch = float(self.draw_app.e_ui.slot_array_pitch_entry.get_value())
+                self.slot_linear_angle = float(self.draw_app.e_ui.slot_array_linear_angle_spinner.get_value())
+                self.slot_angle = float(self.draw_app.e_ui.slot_array_angle_entry.get_value())
             except TypeError:
                 self.draw_app.app.inform.emit('[ERROR_NOTCL] %s' %
                                               _("The value is not Float. Check for comma instead of dot separator."))
@@ -730,25 +730,25 @@ class FCSlotArray(FCShapeTool):
         self.steps_per_circ = self.draw_app.app.defaults["geometry_circle_steps"]
 
         try:
-            slot_length = float(self.draw_app.slot_length_entry.get_value())
+            slot_length = float(self.draw_app.e_ui.slot_length_entry.get_value())
         except ValueError:
             # try to convert comma to decimal point. if it's still not working error message and return
             try:
-                slot_length = float(self.draw_app.slot_length_entry.get_value().replace(',', '.'))
-                self.draw_app.slot_length_entry.set_value(slot_length)
+                slot_length = float(self.draw_app.e_ui.slot_length_entry.get_value().replace(',', '.'))
+                self.draw_app.e_ui.slot_length_entry.set_value(slot_length)
             except ValueError:
                 self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' %
                                               _("Value is missing or wrong format. Add it and retry."))
                 return
 
         try:
-            slot_angle = float(self.draw_app.slot_angle_spinner.get_value())
+            slot_angle = float(self.draw_app.e_ui.slot_angle_spinner.get_value())
         except ValueError:
             self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' %
                                           _("Value is missing or wrong format. Add it and retry."))
             return
 
-        if self.draw_app.slot_axis_radio.get_value() == 'X':
+        if self.draw_app.e_ui.slot_axis_radio.get_value() == 'X':
             self.half_width = slot_length / 2.0
             self.half_height = self.radius
         else:
@@ -815,7 +815,7 @@ class FCSlotArray(FCShapeTool):
 
         # this function return one slot in the slot array and the following will rotate that one slot around it's
         # center if the radio value is "A".
-        if self.draw_app.slot_axis_radio.get_value() == 'A':
+        if self.draw_app.e_ui.slot_axis_radio.get_value() == 'A':
             return affinity.rotate(Polygon(geo), -slot_angle)
         else:
             return Polygon(geo)
@@ -880,8 +880,8 @@ class FCSlotArray(FCShapeTool):
         self.complete = True
         self.draw_app.app.inform.emit('[success] %s' % _("Done. Slot Array added."))
         self.draw_app.in_action = False
-        self.draw_app.slot_frame.hide()
-        self.draw_app.slot_array_frame.hide()
+        self.draw_app.e_ui.slot_frame.hide()
+        self.draw_app.e_ui.slot_array_frame.hide()
         self.draw_app.app.jump_signal.disconnect()
 
     def clean_up(self):
@@ -902,7 +902,7 @@ class FCDrillResize(FCShapeTool):
 
         self.draw_app.app.inform.emit(_("Click on the Drill(s) to resize ..."))
         self.resize_dia = None
-        self.draw_app.resize_frame.show()
+        self.draw_app.e_ui.resize_frame.show()
         self.points = None
 
         # made this a set so there are no duplicates
@@ -927,7 +927,7 @@ class FCDrillResize(FCShapeTool):
             pass
 
         try:
-            new_dia = self.draw_app.resdrill_entry.get_value()
+            new_dia = self.draw_app.e_ui.resdrill_entry.get_value()
         except Exception:
             self.draw_app.app.inform.emit('[ERROR_NOTCL] %s' %
                                           _("Resize drill(s) failed. Please enter a diameter for resize."))
@@ -1116,7 +1116,7 @@ class FCDrillResize(FCShapeTool):
         # init this set() for another use perhaps
         self.selected_dia_set = set()
 
-        self.draw_app.resize_frame.hide()
+        self.draw_app.e_ui.resize_frame.hide()
         self.complete = True
 
         # MS: always return to the Select Tool
@@ -1348,10 +1348,10 @@ class FCDrillSelect(DrawTool):
         # here we store all shapes that were selected so we can search for the nearest to our click location
         self.sel_storage = AppExcEditor.make_storage()
 
-        self.exc_editor_app.resize_frame.hide()
-        self.exc_editor_app.array_frame.hide()
-        self.exc_editor_app.slot_frame.hide()
-        self.exc_editor_app.slot_array_frame.hide()
+        self.exc_editor_app.e_ui.resize_frame.hide()
+        self.exc_editor_app.e_ui.array_frame.hide()
+        self.exc_editor_app.e_ui.slot_frame.hide()
+        self.exc_editor_app.e_ui.slot_array_frame.hide()
 
     def click(self, point):
         key_modifier = QtWidgets.QApplication.keyboardModifiers()
@@ -1520,2633 +1520,2710 @@ class AppExcEditor(QtCore.QObject):
 
         self.app = app
         self.canvas = self.app.plotcanvas
+        self.units = self.app.defaults['units'].upper()
+
+        self.dec_format = self.app.dec_format
 
         # Number of decimals used by tools in this class
         self.decimals = self.app.decimals
 
-        # ## Current application units in Upper Case
-        self.units = self.app.defaults['units'].upper()
-
-        self.exc_edit_widget = QtWidgets.QWidget()
-        # ## Box for custom widgets
-        # This gets populated in offspring implementations.
-        layout = QtWidgets.QVBoxLayout()
-        self.exc_edit_widget.setLayout(layout)
+        self.e_ui = AppExcEditorUI(app=self.app)
+        
+        # SIGNALS
+        self.e_ui.convert_slots_btn.clicked.connect(self.on_slots_conversion)
+        self.app.ui.delete_drill_btn.triggered.connect(self.on_delete_btn)
+        self.e_ui.name_entry.returnPressed.connect(self.on_name_activate)
+        self.e_ui.addtool_btn.clicked.connect(self.on_tool_add)
+        self.e_ui.addtool_entry.editingFinished.connect(self.on_tool_add)
+        self.e_ui.deltool_btn.clicked.connect(self.on_tool_delete)
+        # self.tools_table_exc.selectionModel().currentChanged.connect(self.on_row_selected)
+        self.e_ui.tools_table_exc.cellPressed.connect(self.on_row_selected)
 
-        # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets
-        # this way I can hide/show the frame
-        self.drills_frame = QtWidgets.QFrame()
-        self.drills_frame.setContentsMargins(0, 0, 0, 0)
-        layout.addWidget(self.drills_frame)
-        self.tools_box = QtWidgets.QVBoxLayout()
-        self.tools_box.setContentsMargins(0, 0, 0, 0)
-        self.drills_frame.setLayout(self.tools_box)
+        self.e_ui.array_type_combo.currentIndexChanged.connect(self.on_array_type_combo)
+        self.e_ui.slot_array_type_combo.currentIndexChanged.connect(self.on_slot_array_type_combo)
 
-        # ## Page Title box (spacing between children)
-        self.title_box = QtWidgets.QHBoxLayout()
-        self.tools_box.addLayout(self.title_box)
+        self.e_ui.drill_axis_radio.activated_custom.connect(self.on_linear_angle_radio)
+        self.e_ui.slot_axis_radio.activated_custom.connect(self.on_slot_angle_radio)
 
-        # ## Page Title icon
-        pixmap = QtGui.QPixmap(self.app.resource_location + '/flatcam_icon32.png')
-        self.icon = QtWidgets.QLabel()
-        self.icon.setPixmap(pixmap)
-        self.title_box.addWidget(self.icon, stretch=0)
+        self.e_ui.slot_array_axis_radio.activated_custom.connect(self.on_slot_array_linear_angle_radio)
 
-        # ## Title label
-        self.title_label = QtWidgets.QLabel("<font size=5><b>%s</b></font>" % _('Excellon Editor'))
-        self.title_label.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
-        self.title_box.addWidget(self.title_label, stretch=1)
+        self.app.ui.exc_add_array_drill_menuitem.triggered.connect(self.exc_add_drill_array)
+        self.app.ui.exc_add_drill_menuitem.triggered.connect(self.exc_add_drill)
 
-        # ## Object name
-        self.name_box = QtWidgets.QHBoxLayout()
-        self.tools_box.addLayout(self.name_box)
-        name_label = QtWidgets.QLabel(_("Name:"))
-        self.name_box.addWidget(name_label)
-        self.name_entry = FCEntry()
-        self.name_box.addWidget(self.name_entry)
+        self.app.ui.exc_add_array_slot_menuitem.triggered.connect(self.exc_add_slot_array)
+        self.app.ui.exc_add_slot_menuitem.triggered.connect(self.exc_add_slot)
 
-        # ### Tools Drills ## ##
-        self.tools_table_label = QtWidgets.QLabel("<b>%s</b>" % _('Tools Table'))
-        self.tools_table_label.setToolTip(
-           _("Tools in this Excellon object\n"
-             "when are used for drilling.")
-        )
-        self.tools_box.addWidget(self.tools_table_label)
+        self.app.ui.exc_resize_drill_menuitem.triggered.connect(self.exc_resize_drills)
+        self.app.ui.exc_copy_drill_menuitem.triggered.connect(self.exc_copy_drills)
+        self.app.ui.exc_delete_drill_menuitem.triggered.connect(self.on_delete_btn)
 
-        self.tools_table_exc = FCTable()
-        # delegate = SpinBoxDelegate(units=self.units)
-        # self.tools_table_exc.setItemDelegateForColumn(1, delegate)
+        self.app.ui.exc_move_drill_menuitem.triggered.connect(self.exc_move_drills)
+        self.e_ui.exit_editor_button.clicked.connect(lambda: self.app.editor2object())
 
-        self.tools_box.addWidget(self.tools_table_exc)
+        self.exc_obj = None
 
-        self.tools_table_exc.setColumnCount(4)
-        self.tools_table_exc.setHorizontalHeaderLabels(['#', _('Diameter'), 'D', 'S'])
-        self.tools_table_exc.setSortingEnabled(False)
-        self.tools_table_exc.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
+        # ## Toolbar events and properties
+        self.tools_exc = {
+            "drill_select":     {"button": self.app.ui.select_drill_btn, "constructor": FCDrillSelect},
+            "drill_add":        {"button": self.app.ui.add_drill_btn, "constructor": FCDrillAdd},
+            "drill_array":      {"button": self.app.ui.add_drill_array_btn, "constructor": FCDrillArray},
+            "slot_add":         {"button": self.app.ui.add_slot_btn, "constructor": FCSlot},
+            "slot_array":       {"button": self.app.ui.add_slot_array_btn, "constructor": FCSlotArray},
+            "drill_resize":     {"button": self.app.ui.resize_drill_btn, "constructor": FCDrillResize},
+            "drill_copy":       {"button": self.app.ui.copy_drill_btn, "constructor": FCDrillCopy},
+            "drill_move":       {"button": self.app.ui.move_drill_btn, "constructor": FCDrillMove},
+        }
 
-        self.empty_label = QtWidgets.QLabel('')
-        self.tools_box.addWidget(self.empty_label)
+        # ## Data
+        self.active_tool = None
+        self.in_action = False
 
-        # ### Add a new Tool ## ##
-        self.addtool_label = QtWidgets.QLabel('<b>%s</b>' % _('Add/Delete Tool'))
-        self.addtool_label.setToolTip(
-            _("Add/Delete a tool to the tool list\n"
-              "for this Excellon object.")
-        )
-        self.tools_box.addWidget(self.addtool_label)
+        self.storage_dict = {}
+        self.current_storage = []
 
-        grid1 = QtWidgets.QGridLayout()
-        self.tools_box.addLayout(grid1)
-        grid1.setColumnStretch(0, 0)
-        grid1.setColumnStretch(1, 1)
+        # build the data from the Excellon point into a dictionary
+        #  {tool_dia: [geometry_in_points]}
+        self.points_edit = {}
+        self.slot_points_edit = {}
 
-        addtool_entry_lbl = QtWidgets.QLabel('%s:' % _('Tool Dia'))
-        addtool_entry_lbl.setToolTip(
-            _("Diameter for the new tool")
-        )
+        self.sorted_diameters = []
 
-        hlay = QtWidgets.QHBoxLayout()
-        self.addtool_entry = FCDoubleSpinner()
-        self.addtool_entry.set_precision(self.decimals)
-        self.addtool_entry.set_range(0.0000, 9999.9999)
+        self.new_drills = []
+        self.new_tools = {}
+        self.new_slots = []
 
-        hlay.addWidget(self.addtool_entry)
+        # dictionary to store the tool_row and diameters in Tool_table
+        # it will be updated everytime self.build_ui() is called
+        self.olddia_newdia = {}
 
-        self.addtool_btn = QtWidgets.QPushButton(_('Add Tool'))
-        self.addtool_btn.setToolTip(
-           _("Add a new tool to the tool list\n"
-             "with the diameter specified above.")
-        )
-        self.addtool_btn.setFixedWidth(80)
-        hlay.addWidget(self.addtool_btn)
+        self.tool2tooldia = {}
 
-        grid1.addWidget(addtool_entry_lbl, 0, 0)
-        grid1.addLayout(hlay, 0, 1)
+        # this will store the value for the last selected tool, for use after clicking on canvas when the selection
+        # is cleared but as a side effect also the selected tool is cleared
+        self.last_tool_selected = None
+        self.utility = []
 
-        grid2 = QtWidgets.QGridLayout()
-        self.tools_box.addLayout(grid2)
+        # this will flag if the Editor "tools" are launched from key shortcuts (True) or from menu toolbar (False)
+        self.launched_from_shortcuts = False
 
-        self.deltool_btn = QtWidgets.QPushButton(_('Delete Tool'))
-        self.deltool_btn.setToolTip(
-           _("Delete a tool in the tool list\n"
-             "by selecting a row in the tool table.")
-        )
-        grid2.addWidget(self.deltool_btn, 0, 1)
+        # this var will store the state of the toolbar before starting the editor
+        self.toolbar_old_state = False
 
-        # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets
-        # this way I can hide/show the frame
-        self.resize_frame = QtWidgets.QFrame()
-        self.resize_frame.setContentsMargins(0, 0, 0, 0)
-        self.tools_box.addWidget(self.resize_frame)
-        self.resize_box = QtWidgets.QVBoxLayout()
-        self.resize_box.setContentsMargins(0, 0, 0, 0)
-        self.resize_frame.setLayout(self.resize_box)
+        if self.units == 'MM':
+            self.tolerance = float(self.app.defaults["global_tolerance"])
+        else:
+            self.tolerance = float(self.app.defaults["global_tolerance"]) / 20
 
-        # ### Resize a  drill ## ##
-        self.emptyresize_label = QtWidgets.QLabel('')
-        self.resize_box.addWidget(self.emptyresize_label)
+        # VisPy Visuals
+        if self.app.is_legacy is False:
+            self.shapes = self.canvas.new_shape_collection(layers=1)
+            if self.canvas.big_cursor is True:
+                self.tool_shape = self.canvas.new_shape_collection(layers=1, line_width=2)
+            else:
+                self.tool_shape = self.canvas.new_shape_collection(layers=1)
+        else:
+            from appGUI.PlotCanvasLegacy import ShapeCollectionLegacy
+            self.shapes = ShapeCollectionLegacy(obj=self, app=self.app, name='shapes_exc_editor')
+            self.tool_shape = ShapeCollectionLegacy(obj=self, app=self.app, name='tool_shapes_exc_editor')
 
-        self.drillresize_label = QtWidgets.QLabel('<b>%s</b>' % _("Resize Drill(s)"))
-        self.drillresize_label.setToolTip(
-            _("Resize a drill or a selection of drills.")
-        )
-        self.resize_box.addWidget(self.drillresize_label)
+        self.app.pool_recreated.connect(self.pool_recreated)
 
-        grid3 = QtWidgets.QGridLayout()
-        self.resize_box.addLayout(grid3)
+        # Remove from scene
+        self.shapes.enabled = False
+        self.tool_shape.enabled = False
 
-        res_entry_lbl = QtWidgets.QLabel('%s:' % _('Resize Dia'))
-        res_entry_lbl.setToolTip(
-           _("Diameter to resize to.")
-        )
-        grid3.addWidget(res_entry_lbl, 0, 0)
+        # ## List of selected shapes.
+        self.selected = []
 
-        hlay2 = QtWidgets.QHBoxLayout()
-        self.resdrill_entry = FCDoubleSpinner()
-        self.resdrill_entry.set_precision(self.decimals)
-        self.resdrill_entry.set_range(0.0000, 9999.9999)
+        self.move_timer = QtCore.QTimer()
+        self.move_timer.setSingleShot(True)
 
-        hlay2.addWidget(self.resdrill_entry)
+        self.key = None  # Currently pressed key
+        self.modifiers = None
+        self.x = None  # Current mouse cursor pos
+        self.y = None
+        # Current snapped mouse pos
+        self.snap_x = None
+        self.snap_y = None
+        self.pos = None
 
-        self.resize_btn = QtWidgets.QPushButton(_('Resize'))
-        self.resize_btn.setToolTip(
-            _("Resize drill(s)")
-        )
-        self.resize_btn.setFixedWidth(80)
-        hlay2.addWidget(self.resize_btn)
-        grid3.addLayout(hlay2, 0, 1)
+        self.complete = False
 
-        self.resize_frame.hide()
+        def make_callback(thetool):
+            def f():
+                self.on_tool_select(thetool)
+            return f
 
-        # ####################################
-        # ### Add DRILL Array ################
-        # ####################################
+        for tool in self.tools_exc:
+            self.tools_exc[tool]["button"].triggered.connect(make_callback(tool))  # Events
+            self.tools_exc[tool]["button"].setCheckable(True)  # Checkable
 
-        # add a frame and inside add a vertical box layout. Inside this vbox layout I add
-        # all the add drill array  widgets
-        # this way I can hide/show the frame
-        self.array_frame = QtWidgets.QFrame()
-        self.array_frame.setContentsMargins(0, 0, 0, 0)
-        self.tools_box.addWidget(self.array_frame)
-        self.array_box = QtWidgets.QVBoxLayout()
-        self.array_box.setContentsMargins(0, 0, 0, 0)
-        self.array_frame.setLayout(self.array_box)
+        self.options = {
+            "global_gridx":     0.1,
+            "global_gridy":     0.1,
+            "snap_max":         0.05,
+            "grid_snap":        True,
+            "corner_snap":      False,
+            "grid_gap_link":    True
+        }
+        self.options.update(self.app.options)
 
-        self.emptyarray_label = QtWidgets.QLabel('')
-        self.array_box.addWidget(self.emptyarray_label)
+        for option in self.options:
+            if option in self.app.options:
+                self.options[option] = self.app.options[option]
 
-        self.drill_array_label = QtWidgets.QLabel('<b>%s</b>' % _("Add Drill Array"))
-        self.drill_array_label.setToolTip(
-            _("Add an array of drills (linear or circular array)")
-        )
-        self.array_box.addWidget(self.drill_array_label)
+        self.data_defaults = {}
 
-        self.array_type_combo = FCComboBox()
-        self.array_type_combo.setToolTip(
-           _("Select the type of drills array to create.\n"
-             "It can be Linear X(Y) or Circular")
-        )
-        self.array_type_combo.addItem(_("Linear"))
-        self.array_type_combo.addItem(_("Circular"))
+        self.rtree_exc_index = rtindex.Index()
+        # flag to show if the object was modified
+        self.is_modified = False
 
-        self.array_box.addWidget(self.array_type_combo)
+        self.edited_obj_name = ""
 
-        self.array_form = QtWidgets.QFormLayout()
-        self.array_box.addLayout(self.array_form)
+        # variable to store the total amount of drills per job
+        self.tot_drill_cnt = 0
+        self.tool_row = 0
 
-        # Set the number of drill holes in the drill array
-        self.drill_array_size_label = QtWidgets.QLabel('%s:' % _('Nr of drills'))
-        self.drill_array_size_label.setToolTip(_("Specify how many drills to be in the array."))
-        self.drill_array_size_label.setMinimumWidth(100)
+        # variable to store the total amount of slots per job
+        self.tot_slot_cnt = 0
+        self.tool_row_slots = 0
 
-        self.drill_array_size_entry = FCSpinner()
-        self.drill_array_size_entry.set_range(1, 9999)
-        self.array_form.addRow(self.drill_array_size_label, self.drill_array_size_entry)
+        self.tool_row = 0
 
-        self.array_linear_frame = QtWidgets.QFrame()
-        self.array_linear_frame.setContentsMargins(0, 0, 0, 0)
-        self.array_box.addWidget(self.array_linear_frame)
-        self.linear_box = QtWidgets.QVBoxLayout()
-        self.linear_box.setContentsMargins(0, 0, 0, 0)
-        self.array_linear_frame.setLayout(self.linear_box)
+        # store the status of the editor so the Delete at object level will not work until the edit is finished
+        self.editor_active = False
 
-        self.linear_form = QtWidgets.QFormLayout()
-        self.linear_box.addLayout(self.linear_form)
+        # def entry2option(option, entry):
+        #     self.options[option] = float(entry.text())
 
-        # Linear Drill Array direction
-        self.drill_axis_label = QtWidgets.QLabel('%s:' % _('Direction'))
-        self.drill_axis_label.setToolTip(
-            _("Direction on which the linear array is oriented:\n"
-              "- 'X' - horizontal axis \n"
-              "- 'Y' - vertical axis or \n"
-              "- 'Angle' - a custom angle for the array inclination")
-        )
-        self.drill_axis_label.setMinimumWidth(100)
+        # Event signals disconnect id holders
+        self.mp = None
+        self.mm = None
+        self.mr = None
 
-        self.drill_axis_radio = RadioSet([{'label': _('X'), 'value': 'X'},
-                                          {'label': _('Y'), 'value': 'Y'},
-                                          {'label': _('Angle'), 'value': 'A'}])
-        self.linear_form.addRow(self.drill_axis_label, self.drill_axis_radio)
+        # store the status of the editor so the Delete at object level will not work until the edit is finished
+        self.editor_active = False
+        log.debug("Initialization of the Excellon Editor is finished ...")
 
-        # Linear Drill Array pitch distance
-        self.drill_pitch_label = QtWidgets.QLabel('%s:' % _('Pitch'))
-        self.drill_pitch_label.setToolTip(
-            _("Pitch = Distance between elements of the array.")
-        )
-        self.drill_pitch_label.setMinimumWidth(100)
+    def pool_recreated(self, pool):
+        self.shapes.pool = pool
+        self.tool_shape.pool = pool
 
-        self.drill_pitch_entry = FCDoubleSpinner()
-        self.drill_pitch_entry.set_precision(self.decimals)
-        self.drill_pitch_entry.set_range(0.0000, 9999.9999)
+    @staticmethod
+    def make_storage():
+        # ## Shape storage.
+        storage = FlatCAMRTreeStorage()
+        storage.get_points = DrawToolShape.get_pts
 
-        self.linear_form.addRow(self.drill_pitch_label, self.drill_pitch_entry)
+        return storage
 
-        # Linear Drill Array angle
-        self.linear_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
-        self.linear_angle_label.setToolTip(
-           _("Angle at which the linear array is placed.\n"
-             "The precision is of max 2 decimals.\n"
-             "Min value is: -360 degrees.\n"
-             "Max value is:  360.00 degrees.")
-        )
-        self.linear_angle_label.setMinimumWidth(100)
+    def set_ui(self):
+        # updated units
+        self.units = self.app.defaults['units'].upper()
 
-        self.linear_angle_spinner = FCDoubleSpinner()
-        self.linear_angle_spinner.set_precision(self.decimals)
-        self.linear_angle_spinner.setSingleStep(1.0)
-        self.linear_angle_spinner.setRange(-360.00, 360.00)
-        self.linear_form.addRow(self.linear_angle_label, self.linear_angle_spinner)
+        self.olddia_newdia.clear()
+        self.tool2tooldia.clear()
 
-        self.array_circular_frame = QtWidgets.QFrame()
-        self.array_circular_frame.setContentsMargins(0, 0, 0, 0)
-        self.array_box.addWidget(self.array_circular_frame)
-        self.circular_box = QtWidgets.QVBoxLayout()
-        self.circular_box.setContentsMargins(0, 0, 0, 0)
-        self.array_circular_frame.setLayout(self.circular_box)
+        # update the olddia_newdia dict to make sure we have an updated state of the tool_table
+        for key in self.points_edit:
+            self.olddia_newdia[key] = key
 
-        self.drill_direction_label = QtWidgets.QLabel('%s:' % _('Direction'))
-        self.drill_direction_label.setToolTip(_("Direction for circular array."
-                                                "Can be CW = clockwise or CCW = counter clockwise."))
-        self.drill_direction_label.setMinimumWidth(100)
+        for key in self.slot_points_edit:
+            if key not in self.olddia_newdia:
+                self.olddia_newdia[key] = key
 
-        self.circular_form = QtWidgets.QFormLayout()
-        self.circular_box.addLayout(self.circular_form)
+        sort_temp = []
+        for diam in self.olddia_newdia:
+            sort_temp.append(float(diam))
+        self.sorted_diameters = sorted(sort_temp)
 
-        self.drill_direction_radio = RadioSet([{'label': _('CW'), 'value': 'CW'},
-                                               {'label': _('CCW'), 'value': 'CCW'}])
-        self.circular_form.addRow(self.drill_direction_label, self.drill_direction_radio)
+        # populate self.intial_table_rows dict with the tool number as keys and tool diameters as values
+        if self.exc_obj.diameterless is False:
+            for i in range(len(self.sorted_diameters)):
+                tt_dia = self.sorted_diameters[i]
+                self.tool2tooldia[i + 1] = tt_dia
+        else:
+            # the Excellon object has diameters that are bogus information, added by the application because the
+            # Excellon file has no tool diameter information. In this case do not order the diameter in the table
+            # but use the real order found in the exc_obj.tools
+            for k, v in self.exc_obj.tools.items():
+                tool_dia = float('%.*f' % (self.decimals, v['tooldia']))
+                self.tool2tooldia[int(k)] = tool_dia
 
-        self.drill_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
-        self.drill_angle_label.setToolTip(_("Angle at which each element in circular array is placed."))
-        self.drill_angle_label.setMinimumWidth(100)
+        # Init appGUI
+        self.e_ui.addtool_entry.set_value(float(self.app.defaults['excellon_editor_newdia']))
+        self.e_ui.drill_array_size_entry.set_value(int(self.app.defaults['excellon_editor_array_size']))
+        self.e_ui.drill_axis_radio.set_value(self.app.defaults['excellon_editor_lin_dir'])
+        self.e_ui.drill_pitch_entry.set_value(float(self.app.defaults['excellon_editor_lin_pitch']))
+        self.e_ui.linear_angle_spinner.set_value(float(self.app.defaults['excellon_editor_lin_angle']))
+        self.e_ui.drill_direction_radio.set_value(self.app.defaults['excellon_editor_circ_dir'])
+        self.e_ui.drill_angle_entry.set_value(float(self.app.defaults['excellon_editor_circ_angle']))
+
+        self.e_ui.slot_length_entry.set_value(float(self.app.defaults['excellon_editor_slot_length']))
+        self.e_ui.slot_axis_radio.set_value(self.app.defaults['excellon_editor_slot_direction'])
+        self.e_ui.slot_angle_spinner.set_value(float(self.app.defaults['excellon_editor_slot_angle']))
+
+        self.e_ui.slot_array_size_entry.set_value(int(self.app.defaults['excellon_editor_slot_array_size']))
+        self.e_ui.slot_array_axis_radio.set_value(self.app.defaults['excellon_editor_slot_lin_dir'])
+        self.e_ui.slot_array_pitch_entry.set_value(float(self.app.defaults['excellon_editor_slot_lin_pitch']))
+        self.e_ui.slot_array_linear_angle_spinner.set_value(float(self.app.defaults['excellon_editor_slot_lin_angle']))
+        self.e_ui.slot_array_direction_radio.set_value(self.app.defaults['excellon_editor_slot_circ_dir'])
+        self.e_ui.slot_array_angle_entry.set_value(float(self.app.defaults['excellon_editor_slot_circ_angle']))
+
+        self.e_ui.slot_array_circular_frame.hide()
+        self.e_ui.slot_array_linear_frame.show()
 
-        self.drill_angle_entry = FCDoubleSpinner()
-        self.drill_angle_entry.set_precision(self.decimals)
-        self.drill_angle_entry.setSingleStep(1.0)
-        self.drill_angle_entry.setRange(-360.00, 360.00)
+    def build_ui(self, first_run=None):
 
-        self.circular_form.addRow(self.drill_angle_label, self.drill_angle_entry)
+        try:
+            # if connected, disconnect the signal from the slot on item_changed as it creates issues
+            self.e_ui.tools_table_exc.itemChanged.disconnect()
+        except (TypeError, AttributeError):
+            pass
 
-        self.array_circular_frame.hide()
+        try:
+            self.e_ui.tools_table_exc.cellPressed.disconnect()
+        except (TypeError, AttributeError):
+            pass
 
-        self.linear_angle_spinner.hide()
-        self.linear_angle_label.hide()
+        # updated units
+        self.units = self.app.defaults['units'].upper()
 
-        self.array_frame.hide()
+        # make a new name for the new Excellon object (the one with edited content)
+        self.edited_obj_name = self.exc_obj.options['name']
+        self.e_ui.name_entry.set_value(self.edited_obj_name)
 
-        # ######################################################
-        # ##### ADDING SLOTS ###################################
-        # ######################################################
+        sort_temp = []
 
-        # add a frame and inside add a vertical box layout. Inside this vbox layout I add
-        # all the add slot  widgets
-        # this way I can hide/show the frame
-        self.slot_frame = QtWidgets.QFrame()
-        self.slot_frame.setContentsMargins(0, 0, 0, 0)
-        self.tools_box.addWidget(self.slot_frame)
-        self.slot_box = QtWidgets.QVBoxLayout()
-        self.slot_box.setContentsMargins(0, 0, 0, 0)
-        self.slot_frame.setLayout(self.slot_box)
+        for diam in self.olddia_newdia:
+            sort_temp.append(float(diam))
+        self.sorted_diameters = sorted(sort_temp)
 
-        self.emptyarray_label = QtWidgets.QLabel('')
-        self.slot_box.addWidget(self.emptyarray_label)
+        # here, self.sorted_diameters will hold in a oblique way, the number of tools
+        n = len(self.sorted_diameters)
+        # we have (n+2) rows because there are 'n' tools, each a row, plus the last 2 rows for totals.
+        self.e_ui.tools_table_exc.setRowCount(n + 2)
 
-        self.slot_label = QtWidgets.QLabel('<b>%s</b>' % _("Slot Parameters"))
-        self.slot_label.setToolTip(
-            _("Parameters for adding a slot (hole with oval shape)\n"
-              "either single or as an part of an array.")
-        )
-        self.slot_box.addWidget(self.slot_label)
+        self.tot_drill_cnt = 0
+        self.tot_slot_cnt = 0
 
-        self.slot_form = QtWidgets.QFormLayout()
-        self.slot_box.addLayout(self.slot_form)
+        self.tool_row = 0
+        # this variable will serve as the real tool_number
+        tool_id = 0
 
-        # Slot length
-        self.slot_length_label = QtWidgets.QLabel('%s:' % _('Length'))
-        self.slot_length_label.setToolTip(
-            _("Length = The length of the slot.")
-        )
-        self.slot_length_label.setMinimumWidth(100)
+        for tool_no in self.sorted_diameters:
+            tool_id += 1
+            drill_cnt = 0  # variable to store the nr of drills per tool
+            slot_cnt = 0  # variable to store the nr of slots per tool
 
-        self.slot_length_entry = FCDoubleSpinner()
-        self.slot_length_entry.set_precision(self.decimals)
-        self.slot_length_entry.setSingleStep(0.1)
-        self.slot_length_entry.setRange(0.0000, 9999.9999)
+            # Find no of drills for the current tool
+            for tool_dia in self.points_edit:
+                if float(tool_dia) == tool_no:
+                    drill_cnt = len(self.points_edit[tool_dia])
 
-        self.slot_form.addRow(self.slot_length_label, self.slot_length_entry)
+            self.tot_drill_cnt += drill_cnt
 
-        # Slot direction
-        self.slot_axis_label = QtWidgets.QLabel('%s:' % _('Direction'))
-        self.slot_axis_label.setToolTip(
-            _("Direction on which the slot is oriented:\n"
-              "- 'X' - horizontal axis \n"
-              "- 'Y' - vertical axis or \n"
-              "- 'Angle' - a custom angle for the slot inclination")
-        )
-        self.slot_axis_label.setMinimumWidth(100)
+            # try:
+            #     # Find no of slots for the current tool
+            #     for slot in self.slot_points_edit:
+            #         if float(slot) == tool_no:
+            #             slot_cnt += 1
+            #
+            #     self.tot_slot_cnt += slot_cnt
+            # except AttributeError:
+            #     # log.debug("No slots in the Excellon file")
+            #     # Find no of slots for the current tool
+            #     for tool_dia in self.slot_points_edit:
+            #         if float(tool_dia) == tool_no:
+            #             slot_cnt = len(self.slot_points_edit[tool_dia])
+            #
+            #     self.tot_slot_cnt += slot_cnt
 
-        self.slot_axis_radio = RadioSet([{'label': _('X'), 'value': 'X'},
-                                         {'label': _('Y'), 'value': 'Y'},
-                                         {'label': _('Angle'), 'value': 'A'}])
-        self.slot_form.addRow(self.slot_axis_label, self.slot_axis_radio)
+            for tool_dia in self.slot_points_edit:
+                if float(tool_dia) == tool_no:
+                    slot_cnt = len(self.slot_points_edit[tool_dia])
 
-        # Slot custom angle
-        self.slot_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
-        self.slot_angle_label.setToolTip(
-           _("Angle at which the slot is placed.\n"
-             "The precision is of max 2 decimals.\n"
-             "Min value is: -360 degrees.\n"
-             "Max value is:  360.00 degrees.")
-        )
-        self.slot_angle_label.setMinimumWidth(100)
+            self.tot_slot_cnt += slot_cnt
 
-        self.slot_angle_spinner = FCDoubleSpinner()
-        self.slot_angle_spinner.set_precision(self.decimals)
-        self.slot_angle_spinner.setWrapping(True)
-        self.slot_angle_spinner.setRange(-360.00, 360.00)
-        self.slot_angle_spinner.setSingleStep(1.0)
-        self.slot_form.addRow(self.slot_angle_label, self.slot_angle_spinner)
+            idd = QtWidgets.QTableWidgetItem('%d' % int(tool_id))
+            idd.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
+            self.e_ui.tools_table_exc.setItem(self.tool_row, 0, idd)  # Tool name/id
 
-        self.slot_frame.hide()
+            # Make sure that the drill diameter when in MM is with no more than 2 decimals
+            # There are no drill bits in MM with more than 2 decimals diameter
+            # For INCH the decimals should be no more than 4. There are no drills under 10mils
+            dia = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, self.olddia_newdia[tool_no]))
 
-        # ######################################################
-        # ##### ADDING SLOT ARRAY  #############################
-        # ######################################################
+            dia.setFlags(QtCore.Qt.ItemIsEnabled)
 
-        # add a frame and inside add a vertical box layout. Inside this vbox layout I add
-        # all the add slot  widgets
-        # this way I can hide/show the frame
-        self.slot_array_frame = QtWidgets.QFrame()
-        self.slot_array_frame.setContentsMargins(0, 0, 0, 0)
-        self.tools_box.addWidget(self.slot_array_frame)
-        self.slot_array_box = QtWidgets.QVBoxLayout()
-        self.slot_array_box.setContentsMargins(0, 0, 0, 0)
-        self.slot_array_frame.setLayout(self.slot_array_box)
+            drill_count = QtWidgets.QTableWidgetItem('%d' % drill_cnt)
+            drill_count.setFlags(QtCore.Qt.ItemIsEnabled)
 
-        self.emptyarray_label = QtWidgets.QLabel('')
-        self.slot_array_box.addWidget(self.emptyarray_label)
+            # if the slot number is zero is better to not clutter the GUI with zero's so we print a space
+            if slot_cnt > 0:
+                slot_count = QtWidgets.QTableWidgetItem('%d' % slot_cnt)
+            else:
+                slot_count = QtWidgets.QTableWidgetItem('')
+            slot_count.setFlags(QtCore.Qt.ItemIsEnabled)
 
-        self.slot_array_label = QtWidgets.QLabel('<b>%s</b>' % _("Slot Array Parameters"))
-        self.slot_array_label.setToolTip(
-            _("Parameters for the array of slots (linear or circular array)")
-        )
-        self.slot_array_box.addWidget(self.slot_array_label)
+            self.e_ui.tools_table_exc.setItem(self.tool_row, 1, dia)  # Diameter
+            self.e_ui.tools_table_exc.setItem(self.tool_row, 2, drill_count)  # Number of drills per tool
+            self.e_ui.tools_table_exc.setItem(self.tool_row, 3, slot_count)  # Number of drills per tool
 
-        self.l_form = QtWidgets.QFormLayout()
-        self.slot_array_box.addLayout(self.l_form)
+            if first_run is True:
+                # set now the last tool selected
+                self.last_tool_selected = int(tool_id)
 
-        self.slot_array_type_combo = FCComboBox()
-        self.slot_array_type_combo.setToolTip(
-            _("Select the type of slot array to create.\n"
-              "It can be Linear X(Y) or Circular")
-        )
-        self.slot_array_type_combo.addItem(_("Linear"))
-        self.slot_array_type_combo.addItem(_("Circular"))
+            self.tool_row += 1
 
-        self.slot_array_box.addWidget(self.slot_array_type_combo)
+        # make the diameter column editable
+        for row in range(self.tool_row):
+            self.e_ui.tools_table_exc.item(row, 1).setFlags(
+                QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
+            self.e_ui.tools_table_exc.item(row, 2).setForeground(QtGui.QColor(0, 0, 0))
+            self.e_ui.tools_table_exc.item(row, 3).setForeground(QtGui.QColor(0, 0, 0))
 
-        self.slot_array_form = QtWidgets.QFormLayout()
-        self.slot_array_box.addLayout(self.slot_array_form)
+        # add a last row with the Total number of drills
+        # HACK: made the text on this cell '9999' such it will always be the one before last when sorting
+        # it will have to have the foreground color (font color) white
+        empty = QtWidgets.QTableWidgetItem('9998')
+        empty.setForeground(QtGui.QColor(255, 255, 255))
 
-        # Set the number of slot holes in the slot array
-        self.slot_array_size_label = QtWidgets.QLabel('%s:' % _('Nr of slots'))
-        self.slot_array_size_label.setToolTip(_("Specify how many slots to be in the array."))
-        self.slot_array_size_label.setMinimumWidth(100)
+        empty.setFlags(empty.flags() ^ QtCore.Qt.ItemIsEnabled)
+        empty_b = QtWidgets.QTableWidgetItem('')
+        empty_b.setFlags(empty_b.flags() ^ QtCore.Qt.ItemIsEnabled)
 
-        self.slot_array_size_entry = FCSpinner()
-        self.slot_array_size_entry.set_range(0, 9999)
+        label_tot_drill_count = QtWidgets.QTableWidgetItem(_('Total Drills'))
+        tot_drill_count = QtWidgets.QTableWidgetItem('%d' % self.tot_drill_cnt)
 
-        self.slot_array_form.addRow(self.slot_array_size_label, self.slot_array_size_entry)
+        label_tot_drill_count.setFlags(label_tot_drill_count.flags() ^ QtCore.Qt.ItemIsEnabled)
+        tot_drill_count.setFlags(tot_drill_count.flags() ^ QtCore.Qt.ItemIsEnabled)
 
-        self.slot_array_linear_frame = QtWidgets.QFrame()
-        self.slot_array_linear_frame.setContentsMargins(0, 0, 0, 0)
-        self.slot_array_box.addWidget(self.slot_array_linear_frame)
-        self.slot_array_linear_box = QtWidgets.QVBoxLayout()
-        self.slot_array_linear_box.setContentsMargins(0, 0, 0, 0)
-        self.slot_array_linear_frame.setLayout(self.slot_array_linear_box)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 0, empty)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 1, label_tot_drill_count)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 2, tot_drill_count)  # Total number of drills
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 3, empty_b)
 
-        self.slot_array_linear_form = QtWidgets.QFormLayout()
-        self.slot_array_linear_box.addLayout(self.slot_array_linear_form)
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
 
-        # Linear Slot Array direction
-        self.slot_array_axis_label = QtWidgets.QLabel('%s:' % _('Direction'))
-        self.slot_array_axis_label.setToolTip(
-            _("Direction on which the linear array is oriented:\n"
-              "- 'X' - horizontal axis \n"
-              "- 'Y' - vertical axis or \n"
-              "- 'Angle' - a custom angle for the array inclination")
-        )
-        self.slot_array_axis_label.setMinimumWidth(100)
+        for k in [1, 2]:
+            self.e_ui.tools_table_exc.item(self.tool_row, k).setForeground(QtGui.QColor(127, 0, 255))
+            self.e_ui.tools_table_exc.item(self.tool_row, k).setFont(font)
 
-        self.slot_array_axis_radio = RadioSet([{'label': _('X'), 'value': 'X'},
-                                               {'label': _('Y'), 'value': 'Y'},
-                                               {'label': _('Angle'), 'value': 'A'}])
-        self.slot_array_linear_form.addRow(self.slot_array_axis_label, self.slot_array_axis_radio)
+        self.tool_row += 1
 
-        # Linear Slot Array pitch distance
-        self.slot_array_pitch_label = QtWidgets.QLabel('%s:' % _('Pitch'))
-        self.slot_array_pitch_label.setToolTip(
-            _("Pitch = Distance between elements of the array.")
-        )
-        self.slot_array_pitch_label.setMinimumWidth(100)
+        # add a last row with the Total number of slots
+        # HACK: made the text on this cell '9999' such it will always be the last when sorting
+        # it will have to have the foreground color (font color) white
+        empty_2 = QtWidgets.QTableWidgetItem('9999')
+        empty_2.setForeground(QtGui.QColor(255, 255, 255))
 
-        self.slot_array_pitch_entry = FCDoubleSpinner()
-        self.slot_array_pitch_entry.set_precision(self.decimals)
-        self.slot_array_pitch_entry.setSingleStep(0.1)
-        self.slot_array_pitch_entry.setRange(0.0000, 9999.9999)
+        empty_2.setFlags(empty_2.flags() ^ QtCore.Qt.ItemIsEnabled)
 
-        self.slot_array_linear_form.addRow(self.slot_array_pitch_label, self.slot_array_pitch_entry)
+        empty_3 = QtWidgets.QTableWidgetItem('')
+        empty_3.setFlags(empty_3.flags() ^ QtCore.Qt.ItemIsEnabled)
 
-        # Linear Slot Array angle
-        self.slot_array_linear_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
-        self.slot_array_linear_angle_label.setToolTip(
-            _("Angle at which the linear array is placed.\n"
-              "The precision is of max 2 decimals.\n"
-              "Min value is: -360 degrees.\n"
-              "Max value is:  360.00 degrees.")
-        )
-        self.slot_array_linear_angle_label.setMinimumWidth(100)
+        label_tot_slot_count = QtWidgets.QTableWidgetItem(_('Total Slots'))
+        tot_slot_count = QtWidgets.QTableWidgetItem('%d' % self.tot_slot_cnt)
+        label_tot_slot_count.setFlags(label_tot_slot_count.flags() ^ QtCore.Qt.ItemIsEnabled)
+        tot_slot_count.setFlags(tot_slot_count.flags() ^ QtCore.Qt.ItemIsEnabled)
 
-        self.slot_array_linear_angle_spinner = FCDoubleSpinner()
-        self.slot_array_linear_angle_spinner.set_precision(self.decimals)
-        self.slot_array_linear_angle_spinner.setSingleStep(1.0)
-        self.slot_array_linear_angle_spinner.setRange(-360.00, 360.00)
-        self.slot_array_linear_form.addRow(self.slot_array_linear_angle_label, self.slot_array_linear_angle_spinner)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 0, empty_2)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 1, label_tot_slot_count)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 2, empty_3)
+        self.e_ui.tools_table_exc.setItem(self.tool_row, 3, tot_slot_count)  # Total number of slots
 
-        self.slot_array_circular_frame = QtWidgets.QFrame()
-        self.slot_array_circular_frame.setContentsMargins(0, 0, 0, 0)
-        self.slot_array_box.addWidget(self.slot_array_circular_frame)
-        self.slot_array_circular_box = QtWidgets.QVBoxLayout()
-        self.slot_array_circular_box.setContentsMargins(0, 0, 0, 0)
-        self.slot_array_circular_frame.setLayout(self.slot_array_circular_box)
+        for kl in [1, 2, 3]:
+            self.e_ui.tools_table_exc.item(self.tool_row, kl).setFont(font)
+            self.e_ui.tools_table_exc.item(self.tool_row, kl).setForeground(QtGui.QColor(0, 70, 255))
 
-        self.slot_array_direction_label = QtWidgets.QLabel('%s:' % _('Direction'))
-        self.slot_array_direction_label.setToolTip(_("Direction for circular array."
-                                                     "Can be CW = clockwise or CCW = counter clockwise."))
-        self.slot_array_direction_label.setMinimumWidth(100)
+        # all the tools are selected by default
+        self.e_ui.tools_table_exc.selectColumn(0)
+        #
+        self.e_ui.tools_table_exc.resizeColumnsToContents()
+        self.e_ui.tools_table_exc.resizeRowsToContents()
 
-        self.slot_array_circular_form = QtWidgets.QFormLayout()
-        self.slot_array_circular_box.addLayout(self.slot_array_circular_form)
+        vertical_header = self.e_ui.tools_table_exc.verticalHeader()
+        # vertical_header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        vertical_header.hide()
+        self.e_ui.tools_table_exc.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 
-        self.slot_array_direction_radio = RadioSet([{'label': _('CW'), 'value': 'CW'},
-                                                    {'label': _('CCW'), 'value': 'CCW'}])
-        self.slot_array_circular_form.addRow(self.slot_array_direction_label, self.slot_array_direction_radio)
+        horizontal_header = self.e_ui.tools_table_exc.horizontalHeader()
+        horizontal_header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
+        horizontal_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
+        horizontal_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
+        horizontal_header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)
+        # horizontal_header.setStretchLastSection(True)
 
-        self.slot_array_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
-        self.slot_array_angle_label.setToolTip(_("Angle at which each element in circular array is placed."))
-        self.slot_array_angle_label.setMinimumWidth(100)
+        # self.e_ui.tools_table_exc.setSortingEnabled(True)
+        # sort by tool diameter
+        self.e_ui.tools_table_exc.sortItems(1)
 
-        self.slot_array_angle_entry = FCDoubleSpinner()
-        self.slot_array_angle_entry.set_precision(self.decimals)
-        self.slot_array_angle_entry.setSingleStep(1)
-        self.slot_array_angle_entry.setRange(-360.00, 360.00)
+        # After sorting, to display also the number of drills in the right row we need to update self.initial_rows dict
+        # with the new order. Of course the last 2 rows in the tool table are just for display therefore we don't
+        # use them
+        self.tool2tooldia.clear()
+        for row in range(self.e_ui.tools_table_exc.rowCount() - 2):
+            tool = int(self.e_ui.tools_table_exc.item(row, 0).text())
+            diameter = float(self.e_ui.tools_table_exc.item(row, 1).text())
+            self.tool2tooldia[tool] = diameter
 
-        self.slot_array_circular_form.addRow(self.slot_array_angle_label, self.slot_array_angle_entry)
+        self.e_ui.tools_table_exc.setMinimumHeight(self.e_ui.tools_table_exc.getHeight())
+        self.e_ui.tools_table_exc.setMaximumHeight(self.e_ui.tools_table_exc.getHeight())
 
-        self.slot_array_linear_angle_spinner.hide()
-        self.slot_array_linear_angle_label.hide()
+        # make sure no rows are selected so the user have to click the correct row, meaning selecting the correct tool
+        self.e_ui.tools_table_exc.clearSelection()
 
-        self.slot_array_frame.hide()
+        # Remove anything else in the GUI Selected Tab
+        self.app.ui.selected_scroll_area.takeWidget()
+        # Put ourself in the GUI Selected Tab
+        self.app.ui.selected_scroll_area.setWidget(self.e_ui.exc_edit_widget)
+        # Switch notebook to Selected page
+        self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
 
-        layout.addStretch()
+        # we reactivate the signals after the after the tool adding as we don't need to see the tool been populated
+        self.e_ui.tools_table_exc.itemChanged.connect(self.on_tool_edit)
+        self.e_ui.tools_table_exc.cellPressed.connect(self.on_row_selected)
 
-        # Editor
-        self.exit_editor_button = QtWidgets.QPushButton(_('Exit Editor'))
-        self.exit_editor_button.setToolTip(
-            _("Exit from Editor.")
-        )
-        self.exit_editor_button.setStyleSheet("""
-                                      QPushButton
-                                      {
-                                          font-weight: bold;
-                                      }
-                                      """)
-        layout.addWidget(self.exit_editor_button)
+    def on_tool_add(self, tooldia=None):
+        self.is_modified = True
+        if tooldia:
+            tool_dia = tooldia
+        else:
+            try:
+                tool_dia = float(self.e_ui.addtool_entry.get_value())
+            except ValueError:
+                # try to convert comma to decimal point. if it's still not working error message and return
+                try:
+                    tool_dia = float(self.e_ui.addtool_entry.get_value().replace(',', '.'))
+                except ValueError:
+                    self.app.inform.emit('[ERROR_NOTCL] %s' % _("Wrong value format entered, use a number."))
+                    return
 
-        self.exit_editor_button.clicked.connect(lambda: self.app.editor2object())
+        if tool_dia not in self.olddia_newdia:
+            storage_elem = AppGeoEditor.make_storage()
+            self.storage_dict[tool_dia] = storage_elem
 
-        # ## Toolbar events and properties
-        self.tools_exc = {
-            "drill_select": {"button": self.app.ui.select_drill_btn, "constructor": FCDrillSelect},
-            "drill_add": {"button": self.app.ui.add_drill_btn, "constructor": FCDrillAdd},
-            "drill_array": {"button": self.app.ui.add_drill_array_btn, "constructor": FCDrillArray},
-            "slot_add": {"button": self.app.ui.add_slot_btn, "constructor": FCSlot},
-            "slot_array": {"button": self.app.ui.add_slot_array_btn, "constructor": FCSlotArray},
-            "drill_resize": {"button": self.app.ui.resize_drill_btn, "constructor": FCDrillResize},
-            "drill_copy": {"button": self.app.ui.copy_drill_btn, "constructor": FCDrillCopy},
-            "drill_move": {"button": self.app.ui.move_drill_btn, "constructor": FCDrillMove},
-        }
+            # self.olddia_newdia dict keeps the evidence on current tools diameters as keys and gets updated on values
+            # each time a tool diameter is edited or added
+            self.olddia_newdia[tool_dia] = tool_dia
+        else:
+            self.app.inform.emit('[WARNING_NOTCL] %s' % _("Tool already in the original or actual tool list.\n" 
+                                                          "Save and reedit Excellon if you need to add this tool. "))
+            return
 
-        # ## Data
-        self.active_tool = None
+        # since we add a new tool, we update also the initial state of the tool_table through it's dictionary
+        # we add a new entry in the tool2tooldia dict
+        self.tool2tooldia[len(self.olddia_newdia)] = tool_dia
 
-        self.in_action = False
+        self.app.inform.emit('[success] %s: %s %s' % (_("Added new tool with dia"), str(tool_dia), str(self.units)))
 
-        self.storage_dict = {}
+        self.build_ui()
 
-        self.current_storage = []
+        # make a quick sort through the tool2tooldia dict so we find which row to select
+        row_to_be_selected = None
+        for key in sorted(self.tool2tooldia):
+            if self.tool2tooldia[key] == tool_dia:
+                row_to_be_selected = int(key) - 1
+                self.last_tool_selected = int(key)
+                break
+        try:
+            self.e_ui.tools_table_exc.selectRow(row_to_be_selected)
+        except TypeError as e:
+            log.debug("AppExcEditor.on_tool_add() --> %s" % str(e))
 
-        # build the data from the Excellon point into a dictionary
-        #  {tool_dia: [geometry_in_points]}
-        self.points_edit = {}
-        self.slot_points_edit = {}
+    def on_tool_delete(self, dia=None):
+        self.is_modified = True
+        deleted_tool_dia_list = []
 
-        self.sorted_diameters = []
+        try:
+            if dia is None or dia is False:
+                # deleted_tool_dia = float(self.e_ui.tools_table_exc.item(self.e_ui.tools_table_exc.currentRow(), 1).text())
+                for index in self.e_ui.tools_table_exc.selectionModel().selectedRows():
+                    row = index.row()
+                    deleted_tool_dia_list.append(float(self.e_ui.tools_table_exc.item(row, 1).text()))
+            else:
+                if isinstance(dia, list):
+                    for dd in dia:
+                        deleted_tool_dia_list.append(float('%.*f' % (self.decimals, dd)))
+                else:
+                    deleted_tool_dia_list.append(float('%.*f' % (self.decimals, dia)))
+        except Exception:
+            self.app.inform.emit('[WARNING_NOTCL] %s' % _("Select a tool in Tool Table"))
+            return
 
-        self.new_tools = {}
+        for deleted_tool_dia in deleted_tool_dia_list:
 
-        # dictionary to store the tool_row and diameters in Tool_table
-        # it will be updated everytime self.build_ui() is called
-        self.olddia_newdia = {}
+            # delete the storage used for that tool
+            storage_elem = AppGeoEditor.make_storage()
+            self.storage_dict[deleted_tool_dia] = storage_elem
+            self.storage_dict.pop(deleted_tool_dia, None)
 
-        self.tool2tooldia = {}
+            # I've added this flag_del variable because dictionary don't like
+            # having keys deleted while iterating through them
+            flag_del = []
+            # self.points_edit.pop(deleted_tool_dia, None)
+            for deleted_tool in self.tool2tooldia:
+                if self.tool2tooldia[deleted_tool] == deleted_tool_dia:
+                    flag_del.append(deleted_tool)
 
-        # this will store the value for the last selected tool, for use after clicking on canvas when the selection
-        # is cleared but as a side effect also the selected tool is cleared
-        self.last_tool_selected = None
-        self.utility = []
+            if flag_del:
+                for tool_to_be_deleted in flag_del:
+                    # delete the tool
+                    self.tool2tooldia.pop(tool_to_be_deleted, None)
 
-        # this will flag if the Editor "tools" are launched from key shortcuts (True) or from menu toolbar (False)
-        self.launched_from_shortcuts = False
+                    # delete also the drills from points_edit dict just in case we add the tool again,
+                    # we don't want to show the number of drills from before was deleter
+                    self.points_edit[deleted_tool_dia] = []
 
-        # this var will store the state of the toolbar before starting the editor
-        self.toolbar_old_state = False
+            self.olddia_newdia.pop(deleted_tool_dia, None)
 
-        if self.units == 'MM':
-            self.tolerance = float(self.app.defaults["global_tolerance"])
-        else:
-            self.tolerance = float(self.app.defaults["global_tolerance"]) / 20
+            self.app.inform.emit('[success] %s: %s %s' %
+                                 (_("Deleted tool with diameter"), str(deleted_tool_dia), str(self.units)))
 
-        self.app.ui.delete_drill_btn.triggered.connect(self.on_delete_btn)
-        self.name_entry.returnPressed.connect(self.on_name_activate)
-        self.addtool_btn.clicked.connect(self.on_tool_add)
-        self.addtool_entry.editingFinished.connect(self.on_tool_add)
-        self.deltool_btn.clicked.connect(self.on_tool_delete)
-        # self.tools_table_exc.selectionModel().currentChanged.connect(self.on_row_selected)
-        self.tools_table_exc.cellPressed.connect(self.on_row_selected)
+        self.replot()
+        # self.app.inform.emit("Could not delete selected tool")
 
-        self.array_type_combo.currentIndexChanged.connect(self.on_array_type_combo)
-        self.slot_array_type_combo.currentIndexChanged.connect(self.on_slot_array_type_combo)
+        self.build_ui()
 
-        self.drill_axis_radio.activated_custom.connect(self.on_linear_angle_radio)
-        self.slot_axis_radio.activated_custom.connect(self.on_slot_angle_radio)
+    def on_tool_edit(self, item_changed):
+        # if connected, disconnect the signal from the slot on item_changed as it creates issues
+        try:
+            self.e_ui.tools_table_exc.itemChanged.disconnect()
+        except TypeError:
+            pass
 
-        self.slot_array_axis_radio.activated_custom.connect(self.on_slot_array_linear_angle_radio)
+        try:
+            self.e_ui.tools_table_exc.cellPressed.disconnect()
+        except TypeError:
+            pass
+        # self.e_ui.tools_table_exc.selectionModel().currentChanged.disconnect()
 
-        self.app.ui.exc_add_array_drill_menuitem.triggered.connect(self.exc_add_drill_array)
-        self.app.ui.exc_add_drill_menuitem.triggered.connect(self.exc_add_drill)
+        self.is_modified = True
+        # new_dia = None
 
-        self.app.ui.exc_add_array_slot_menuitem.triggered.connect(self.exc_add_slot_array)
-        self.app.ui.exc_add_slot_menuitem.triggered.connect(self.exc_add_slot)
+        try:
+            new_dia = float(self.e_ui.tools_table_exc.currentItem().text())
+        except ValueError as e:
+            log.debug("AppExcEditor.on_tool_edit() --> %s" % str(e))
+            return
 
-        self.app.ui.exc_resize_drill_menuitem.triggered.connect(self.exc_resize_drills)
-        self.app.ui.exc_copy_drill_menuitem.triggered.connect(self.exc_copy_drills)
-        self.app.ui.exc_delete_drill_menuitem.triggered.connect(self.on_delete_btn)
+        row_of_item_changed = self.e_ui.tools_table_exc.currentRow()
+        # rows start with 0, tools start with 1 so we adjust the value by 1
+        key_in_tool2tooldia = row_of_item_changed + 1
+        old_dia = self.tool2tooldia[key_in_tool2tooldia]
 
-        self.app.ui.exc_move_drill_menuitem.triggered.connect(self.exc_move_drills)
+        # SOURCE storage
+        source_storage = self.storage_dict[old_dia]
 
-        self.exc_obj = None
+        # DESTINATION storage
+        # tool diameter is not used so we create a new tool with the desired diameter
+        if new_dia not in self.olddia_newdia:
+            destination_storage = AppGeoEditor.make_storage()
+            self.storage_dict[new_dia] = destination_storage
 
-        # VisPy Visuals
-        if self.app.is_legacy is False:
-            self.shapes = self.app.plotcanvas.new_shape_collection(layers=1)
-            if self.app.plotcanvas.big_cursor is True:
-                self.tool_shape = self.app.plotcanvas.new_shape_collection(layers=1, line_width=2)
-            else:
-                self.tool_shape = self.app.plotcanvas.new_shape_collection(layers=1)
+            # self.olddia_newdia dict keeps the evidence on current tools diameters as keys and gets updated on values
+            # each time a tool diameter is edited or added
+            self.olddia_newdia[new_dia] = new_dia
         else:
-            from appGUI.PlotCanvasLegacy import ShapeCollectionLegacy
-            self.shapes = ShapeCollectionLegacy(obj=self, app=self.app, name='shapes_exc_editor')
-            self.tool_shape = ShapeCollectionLegacy(obj=self, app=self.app, name='tool_shapes_exc_editor')
+            # tool diameter is already in use so we move the drills from the prior tool to the new tool
+            destination_storage = self.storage_dict[new_dia]
 
-        self.app.pool_recreated.connect(self.pool_recreated)
+        # since we add a new tool, we update also the intial state of the tool_table through it's dictionary
+        # we add a new entry in the tool2tooldia dict
+        self.tool2tooldia[len(self.olddia_newdia)] = new_dia
 
-        # Remove from scene
-        self.shapes.enabled = False
-        self.tool_shape.enabled = False
+        # CHANGE the elements geometry according to the new diameter
+        factor = new_dia / old_dia
+        new_geo = Polygon()
+        for shape_exc in source_storage.get_objects():
+            geo_list = []
+            if isinstance(shape_exc.geo, MultiLineString):
+                for subgeo in shape_exc.geo:
+                    geo_list.append(affinity.scale(subgeo, xfact=factor, yfact=factor, origin='center'))
+                new_geo = MultiLineString(geo_list)
+            elif isinstance(shape_exc.geo, Polygon):
+                # I don't have any info regarding the angle of the slot geometry, nor how thick it is or
+                # how long it is given the angle. So I will have to make an approximation because
+                # we need to conserve the slot length, we only resize the diameter for the tool
+                # Therefore scaling won't work and buffering will not work either.
 
-        # ## List of selected shapes.
-        self.selected = []
+                # First we get the Linestring that is one that the original slot is built around with the
+                # tool having the diameter sel_dia
+                poly = shape_exc.geo
+                xmin, ymin, xmax, ymax = poly.bounds
+                # a line that is certain to be bigger than our slot because it's the diagonal
+                # of it's bounding box
+                poly_diagonal = LineString([(xmin, ymin), (xmax, ymax)])
+                poly_centroid = poly.centroid
+                # center of the slot geometry
+                poly_center = (poly_centroid.x, poly_centroid.y)
 
-        self.move_timer = QtCore.QTimer()
-        self.move_timer.setSingleShot(True)
+                # make a list of intersections with the rotated line
+                list_of_cuttings = []
+                for angle in range(0, 359, 1):
+                    rot_poly_diagonal = affinity.rotate(poly_diagonal, angle=angle, origin=poly_center)
+                    cut_line = rot_poly_diagonal.intersection(poly)
+                    cut_line_len = cut_line.length
+                    list_of_cuttings.append(
+                        (cut_line_len, cut_line)
+                    )
+                # find the cut_line with the maximum length which is the LineString for which the start
+                # and stop point are the start and stop point of the slot as in the Gerber file
+                cut_line_with_max_length = max(list_of_cuttings, key=lambda i: i[0])[1]
+                # find the coordinates of this line
+                cut_line_with_max_length_coords = list(cut_line_with_max_length.coords)
+                # extract the first and last point of the line and build some buffered polygon circles
+                # around them
+                start_pt = Point(cut_line_with_max_length_coords[0])
+                stop_pt = Point(cut_line_with_max_length_coords[1])
+                start_cut_geo = start_pt.buffer(new_dia / 2)
+                stop_cut_geo = stop_pt.buffer(new_dia / 2)
 
-        self.key = None  # Currently pressed key
-        self.modifiers = None
-        self.x = None  # Current mouse cursor pos
-        self.y = None
-        # Current snapped mouse pos
-        self.snap_x = None
-        self.snap_y = None
-        self.pos = None
+                # and we cut the above circle polygons from our line and get in this way a line around
+                # which we can build the new slot by buffering with the new tool diameter
+                new_line = cut_line_with_max_length.difference(start_cut_geo)
+                new_line = new_line.difference(stop_cut_geo)
 
-        self.complete = False
+                # create the geometry for the resized slot by buffering with half of the
+                # new diameter value: new_dia
+                new_geo = new_line.buffer(new_dia / 2)
 
-        def make_callback(thetool):
-            def f():
-                self.on_tool_select(thetool)
-            return f
+            try:
+                self.points_edit.pop(old_dia, None)
+            except KeyError:
+                pass
+            try:
+                self.slot_points_edit.pop(old_dia, None)
+            except KeyError:
+                pass
 
-        for tool in self.tools_exc:
-            self.tools_exc[tool]["button"].triggered.connect(make_callback(tool))  # Events
-            self.tools_exc[tool]["button"].setCheckable(True)  # Checkable
+            # add bogus drill/slots points (for total count of drills/slots)
+            # for drills
+            if isinstance(shape_exc.geo, MultiLineString):
+                if new_dia not in self.points_edit:
+                    self.points_edit[new_dia] = [(0, 0)]
+                else:
+                    self.points_edit[new_dia].append((0, 0))
 
-        self.options = {
-            "global_gridx": 0.1,
-            "global_gridy": 0.1,
-            "snap_max": 0.05,
-            "grid_snap": True,
-            "corner_snap": False,
-            "grid_gap_link": True
-        }
-        self.options.update(self.app.options)
+            # for slots
+            if isinstance(shape_exc.geo, Polygon):
+                if new_dia not in self.slot_points_edit:
+                    self.slot_points_edit[new_dia] = [(0, 0)]
+                else:
+                    self.slot_points_edit[new_dia].append((0, 0))
 
-        for option in self.options:
-            if option in self.app.options:
-                self.options[option] = self.app.options[option]
+            self.add_exc_shape(shape=DrawToolShape(new_geo), storage=destination_storage)
 
-        self.data_defaults = {
-            "plot": self.app.defaults["excellon_plot"],
-            "solid": self.app.defaults["excellon_solid"],
-
-            "operation": self.app.defaults["excellon_operation"],
-            "milling_type": self.app.defaults["excellon_milling_type"],
-
-            "milling_dia": self.app.defaults["excellon_milling_dia"],
-
-            "cutz": self.app.defaults["excellon_cutz"],
-            "multidepth": self.app.defaults["excellon_multidepth"],
-            "depthperpass": self.app.defaults["excellon_depthperpass"],
-            "travelz": self.app.defaults["excellon_travelz"],
-            "feedrate": self.app.defaults["geometry_feedrate"],
-            "feedrate_z": self.app.defaults["excellon_feedrate_z"],
-            "feedrate_rapid": self.app.defaults["excellon_feedrate_rapid"],
-            "tooldia": self.app.defaults["excellon_tooldia"],
-            "slot_tooldia": self.app.defaults["excellon_slot_tooldia"],
-            "toolchange": self.app.defaults["excellon_toolchange"],
-            "toolchangez": self.app.defaults["excellon_toolchangez"],
-            "toolchangexy": self.app.defaults["excellon_toolchangexy"],
-            "extracut": self.app.defaults["geometry_extracut"],
-            "extracut_length": self.app.defaults["geometry_extracut_length"],
-            "endz": self.app.defaults["excellon_endz"],
-            "endxy": self.app.defaults["excellon_endxy"],
-            "startz": self.app.defaults["excellon_startz"],
-            "offset": self.app.defaults["excellon_offset"],
-            "spindlespeed": self.app.defaults["excellon_spindlespeed"],
-            "dwell": self.app.defaults["excellon_dwell"],
-            "dwelltime": self.app.defaults["excellon_dwelltime"],
-            "ppname_e": self.app.defaults["excellon_ppname_e"],
-            "ppname_g": self.app.defaults["geometry_ppname_g"],
-            "z_pdepth": self.app.defaults["excellon_z_pdepth"],
-            "feedrate_probe": self.app.defaults["excellon_feedrate_probe"],
-            "optimization_type": self.app.defaults["excellon_optimization_type"]
-        }
+        # update the UI and the CANVAS
+        self.build_ui()
+        self.replot()
 
-        self.rtree_exc_index = rtindex.Index()
-        # flag to show if the object was modified
-        self.is_modified = False
+        # delete the old tool
+        self.on_tool_delete(dia=old_dia)
 
-        self.edited_obj_name = ""
+        # we reactivate the signals after the after the tool editing
+        self.e_ui.tools_table_exc.itemChanged.connect(self.on_tool_edit)
+        self.e_ui.tools_table_exc.cellPressed.connect(self.on_row_selected)
 
-        # variable to store the total amount of drills per job
-        self.tot_drill_cnt = 0
-        self.tool_row = 0
+        self.app.inform.emit('[success] %s' % _("Done. Tool edit completed."))
 
-        # variable to store the total amount of slots per job
-        self.tot_slot_cnt = 0
-        self.tool_row_slots = 0
+        # self.e_ui.tools_table_exc.selectionModel().currentChanged.connect(self.on_row_selected)
 
-        self.tool_row = 0
+    def on_name_activate(self):
+        self.edited_obj_name = self.e_ui.name_entry.get_value()
 
-        # store the status of the editor so the Delete at object level will not work until the edit is finished
-        self.editor_active = False
+    def activate(self):
+        # adjust the status of the menu entries related to the editor
+        self.app.ui.menueditedit.setDisabled(True)
+        self.app.ui.menueditok.setDisabled(False)
+        # adjust the visibility of some of the canvas context menu
+        self.app.ui.popmenu_edit.setVisible(False)
+        self.app.ui.popmenu_save.setVisible(True)
 
-        # def entry2option(option, entry):
-        #     self.options[option] = float(entry.text())
+        self.connect_canvas_event_handlers()
 
-        # Event signals disconnect id holders
-        self.mp = None
-        self.mm = None
-        self.mr = None
+        # initialize working objects
+        self.storage_dict = {}
+        self.current_storage = []
+        self.points_edit = {}
+        self.sorted_diameters = []
+        self.new_drills = []
+        self.new_tools = {}
+        self.new_slots = []
 
-        # store the status of the editor so the Delete at object level will not work until the edit is finished
-        self.editor_active = False
-        log.debug("Initialization of the Excellon Editor is finished ...")
+        self.olddia_newdia = {}
 
-    def pool_recreated(self, pool):
-        self.shapes.pool = pool
-        self.tool_shape.pool = pool
+        self.shapes.enabled = True
+        self.tool_shape.enabled = True
+        # self.app.app_cursor.enabled = True
 
-    @staticmethod
-    def make_storage():
-        # ## Shape storage.
-        storage = FlatCAMRTreeStorage()
-        storage.get_points = DrawToolShape.get_pts
+        self.app.ui.corner_snap_btn.setVisible(True)
+        self.app.ui.snap_magnet.setVisible(True)
 
-        return storage
+        self.app.ui.exc_editor_menu.setDisabled(False)
+        self.app.ui.exc_editor_menu.menuAction().setVisible(True)
 
-    def set_ui(self):
-        # updated units
-        self.units = self.app.defaults['units'].upper()
+        self.app.ui.update_obj_btn.setEnabled(True)
+        self.app.ui.e_editor_cmenu.setEnabled(True)
 
-        self.olddia_newdia.clear()
-        self.tool2tooldia.clear()
+        self.app.ui.exc_edit_toolbar.setDisabled(False)
+        self.app.ui.exc_edit_toolbar.setVisible(True)
+        # self.app.ui.grid_toolbar.setDisabled(False)
 
-        # build the self.points_edit dict {dimaters: [point_list]}
-        for tool, tool_dict in self.exc_obj.tools.items():
-            tool_dia = float('%.*f' % (self.decimals, self.exc_obj.tools[tool]['tooldia']))
+        # start with GRID toolbar activated
+        if self.app.ui.grid_snap_btn.isChecked() is False:
+            self.app.ui.grid_snap_btn.trigger()
 
-            if 'drills' in tool_dict and tool_dict['drills']:
-                for drill in tool_dict['drills']:
-                    try:
-                        self.points_edit[tool_dia].append(drill)
-                    except KeyError:
-                        self.points_edit[tool_dia] = [drill]
+        self.app.ui.popmenu_disable.setVisible(False)
+        self.app.ui.cmenu_newmenu.menuAction().setVisible(False)
+        self.app.ui.popmenu_properties.setVisible(False)
+        self.app.ui.e_editor_cmenu.menuAction().setVisible(True)
+        self.app.ui.g_editor_cmenu.menuAction().setVisible(False)
+        self.app.ui.grb_editor_cmenu.menuAction().setVisible(False)
 
-        # build the self.slot_points_edit dict {dimaters: {"start": Point, "stop": Point}}
-        for tool, tool_dict in self.exc_obj.tools.items():
-            tool_dia = float('%.*f' % (self.decimals, self.exc_obj.tools[tool]['tooldia']))
-
-            if 'slots' in tool_dict and tool_dict['slots']:
-                for slot in tool_dict['slots']:
-                    try:
-                        self.slot_points_edit[tool_dia].append({
-                            "start": slot[0],
-                            "stop": slot[1]
-                        })
-                    except KeyError:
-                        self.slot_points_edit[tool_dia] = [{
-                            "start": slot[0],
-                            "stop": slot[1]
-                        }]
+        # Tell the App that the editor is active
+        self.editor_active = True
 
+        # show the UI
+        self.e_ui.drills_frame.show()
 
-        # update the olddia_newdia dict to make sure we have an updated state of the tool_table
-        for key in self.points_edit:
-            self.olddia_newdia[key] = key
+    def deactivate(self):
+        try:
+            QtGui.QGuiApplication.restoreOverrideCursor()
+        except Exception:
+            pass
 
-        for key in self.slot_points_edit:
-            if key not in self.olddia_newdia:
-                self.olddia_newdia[key] = key
+        # adjust the status of the menu entries related to the editor
+        self.app.ui.menueditedit.setDisabled(False)
+        self.app.ui.menueditok.setDisabled(True)
+        # adjust the visibility of some of the canvas context menu
+        self.app.ui.popmenu_edit.setVisible(True)
+        self.app.ui.popmenu_save.setVisible(False)
 
-        sort_temp = []
-        for diam in self.olddia_newdia:
-            sort_temp.append(float(diam))
-        self.sorted_diameters = sorted(sort_temp)
+        self.disconnect_canvas_event_handlers()
+        self.clear()
+        self.app.ui.exc_edit_toolbar.setDisabled(True)
 
-        # populate self.intial_table_rows dict with the tool number as keys and tool diameters as values
-        if self.exc_obj.diameterless is False:
-            for i in range(len(self.sorted_diameters)):
-                tt_dia = self.sorted_diameters[i]
-                self.tool2tooldia[i + 1] = tt_dia
-        else:
-            # the Excellon object has diameters that are bogus information, added by the application because the
-            # Excellon file has no tool diameter information. In this case do not order the diameter in the table
-            # but use the real order found in the exc_obj.tools
-            for k, v in self.exc_obj.tools.items():
-                tool_dia = float('%.*f' % (self.decimals, v['tooldia']))
-                self.tool2tooldia[int(k)] = tool_dia
+        self.app.ui.corner_snap_btn.setVisible(False)
+        self.app.ui.snap_magnet.setVisible(False)
 
-        # Init appGUI
-        self.addtool_entry.set_value(float(self.app.defaults['excellon_editor_newdia']))
-        self.drill_array_size_entry.set_value(int(self.app.defaults['excellon_editor_array_size']))
-        self.drill_axis_radio.set_value(self.app.defaults['excellon_editor_lin_dir'])
-        self.drill_pitch_entry.set_value(float(self.app.defaults['excellon_editor_lin_pitch']))
-        self.linear_angle_spinner.set_value(float(self.app.defaults['excellon_editor_lin_angle']))
-        self.drill_direction_radio.set_value(self.app.defaults['excellon_editor_circ_dir'])
-        self.drill_angle_entry.set_value(float(self.app.defaults['excellon_editor_circ_angle']))
-
-        self.slot_length_entry.set_value(float(self.app.defaults['excellon_editor_slot_length']))
-        self.slot_axis_radio.set_value(self.app.defaults['excellon_editor_slot_direction'])
-        self.slot_angle_spinner.set_value(float(self.app.defaults['excellon_editor_slot_angle']))
-
-        self.slot_array_size_entry.set_value(int(self.app.defaults['excellon_editor_slot_array_size']))
-        self.slot_array_axis_radio.set_value(self.app.defaults['excellon_editor_slot_lin_dir'])
-        self.slot_array_pitch_entry.set_value(float(self.app.defaults['excellon_editor_slot_lin_pitch']))
-        self.slot_array_linear_angle_spinner.set_value(float(self.app.defaults['excellon_editor_slot_lin_angle']))
-        self.slot_array_direction_radio.set_value(self.app.defaults['excellon_editor_slot_circ_dir'])
-        self.slot_array_angle_entry.set_value(float(self.app.defaults['excellon_editor_slot_circ_angle']))
-
-        self.slot_array_circular_frame.hide()
-        self.slot_array_linear_frame.show()
+        # set the Editor Toolbar visibility to what was before entering in the Editor
+        self.app.ui.exc_edit_toolbar.setVisible(False) if self.toolbar_old_state is False \
+            else self.app.ui.exc_edit_toolbar.setVisible(True)
 
-    def build_ui(self, first_run=None):
+        # Disable visuals
+        self.shapes.enabled = False
+        self.tool_shape.enabled = False
+        # self.app.app_cursor.enabled = False
 
-        try:
-            # if connected, disconnect the signal from the slot on item_changed as it creates issues
-            self.tools_table_exc.itemChanged.disconnect()
-        except (TypeError, AttributeError):
-            pass
+        # Tell the app that the editor is no longer active
+        self.editor_active = False
 
-        try:
-            self.tools_table_exc.cellPressed.disconnect()
-        except (TypeError, AttributeError):
-            pass
+        self.app.ui.exc_editor_menu.setDisabled(True)
+        self.app.ui.exc_editor_menu.menuAction().setVisible(False)
 
-        # updated units
-        self.units = self.app.defaults['units'].upper()
+        self.app.ui.update_obj_btn.setEnabled(False)
 
-        # make a new name for the new Excellon object (the one with edited content)
-        self.edited_obj_name = self.exc_obj.options['name']
-        self.name_entry.set_value(self.edited_obj_name)
+        self.app.ui.popmenu_disable.setVisible(True)
+        self.app.ui.cmenu_newmenu.menuAction().setVisible(True)
+        self.app.ui.popmenu_properties.setVisible(True)
+        self.app.ui.g_editor_cmenu.menuAction().setVisible(False)
+        self.app.ui.e_editor_cmenu.menuAction().setVisible(False)
+        self.app.ui.grb_editor_cmenu.menuAction().setVisible(False)
 
-        sort_temp = []
+        # Show original geometry
+        if self.exc_obj:
+            self.exc_obj.visible = True
 
-        for diam in self.olddia_newdia:
-            sort_temp.append(float(diam))
-        self.sorted_diameters = sorted(sort_temp)
+        # hide the UI
+        self.e_ui.drills_frame.hide()
 
-        # here, self.sorted_diameters will hold in a oblique way, the number of tools
-        n = len(self.sorted_diameters)
-        # we have (n+2) rows because there are 'n' tools, each a row, plus the last 2 rows for totals.
-        self.tools_table_exc.setRowCount(n + 2)
+    def connect_canvas_event_handlers(self):
+        # ## Canvas events
 
-        self.tot_drill_cnt = 0
-        self.tot_slot_cnt = 0
+        # first connect to new, then disconnect the old handlers
+        # don't ask why but if there is nothing connected I've seen issues
+        self.mp = self.canvas.graph_event_connect('mouse_press', self.on_canvas_click)
+        self.mm = self.canvas.graph_event_connect('mouse_move', self.on_canvas_move)
+        self.mr = self.canvas.graph_event_connect('mouse_release', self.on_exc_click_release)
 
-        self.tool_row = 0
-        # this variable will serve as the real tool_number
-        tool_id = 0
+        # make sure that the shortcuts key and mouse events will no longer be linked to the methods from FlatCAMApp
+        # but those from AppGeoEditor
+        if self.app.is_legacy is False:
+            self.app.plotcanvas.graph_event_disconnect('mouse_press', self.app.on_mouse_click_over_plot)
+            self.app.plotcanvas.graph_event_disconnect('mouse_move', self.app.on_mouse_move_over_plot)
+            self.app.plotcanvas.graph_event_disconnect('mouse_release', self.app.on_mouse_click_release_over_plot)
+            self.app.plotcanvas.graph_event_disconnect('mouse_double_click', self.app.on_mouse_double_click_over_plot)
+        else:
+            self.app.plotcanvas.graph_event_disconnect(self.app.mp)
+            self.app.plotcanvas.graph_event_disconnect(self.app.mm)
+            self.app.plotcanvas.graph_event_disconnect(self.app.mr)
+            self.app.plotcanvas.graph_event_disconnect(self.app.mdc)
 
-        for tool_no in self.sorted_diameters:
-            tool_id += 1
-            drill_cnt = 0  # variable to store the nr of drills per tool
-            slot_cnt = 0  # variable to store the nr of slots per tool
+        self.app.collection.view.clicked.disconnect()
 
-            # Find no of drills for the current tool
-            for tool_dia in self.points_edit:
-                if float(tool_dia) == tool_no:
-                    drill_cnt = len(self.points_edit[tool_dia])
+        self.app.ui.popmenu_copy.triggered.disconnect()
+        self.app.ui.popmenu_delete.triggered.disconnect()
+        self.app.ui.popmenu_move.triggered.disconnect()
 
-            self.tot_drill_cnt += drill_cnt
+        self.app.ui.popmenu_copy.triggered.connect(self.exc_copy_drills)
+        self.app.ui.popmenu_delete.triggered.connect(self.on_delete_btn)
+        self.app.ui.popmenu_move.triggered.connect(self.exc_move_drills)
 
-            # try:
-            #     # Find no of slots for the current tool
-            #     for slot in self.slot_points_edit:
-            #         if float(slot) == tool_no:
-            #             slot_cnt += 1
-            #
-            #     self.tot_slot_cnt += slot_cnt
-            # except AttributeError:
-            #     # log.debug("No slots in the Excellon file")
-            #     # Find no of slots for the current tool
-            #     for tool_dia in self.slot_points_edit:
-            #         if float(tool_dia) == tool_no:
-            #             slot_cnt = len(self.slot_points_edit[tool_dia])
-            #
-            #     self.tot_slot_cnt += slot_cnt
+        # Excellon Editor
+        self.app.ui.drill.triggered.connect(self.exc_add_drill)
+        self.app.ui.drill_array.triggered.connect(self.exc_add_drill_array)
 
-            for tool_dia in self.slot_points_edit:
-                if float(tool_dia) == tool_no:
-                    slot_cnt = len(self.slot_points_edit[tool_dia])
+    def disconnect_canvas_event_handlers(self):
+        # we restore the key and mouse control to FlatCAMApp method
+        # first connect to new, then disconnect the old handlers
+        # don't ask why but if there is nothing connected I've seen issues
+        self.app.mp = self.app.plotcanvas.graph_event_connect('mouse_press', self.app.on_mouse_click_over_plot)
+        self.app.mm = self.app.plotcanvas.graph_event_connect('mouse_move', self.app.on_mouse_move_over_plot)
+        self.app.mr = self.app.plotcanvas.graph_event_connect('mouse_release',
+                                                              self.app.on_mouse_click_release_over_plot)
+        self.app.mdc = self.app.plotcanvas.graph_event_connect('mouse_double_click',
+                                                               self.app.on_mouse_double_click_over_plot)
+        self.app.collection.view.clicked.connect(self.app.collection.on_mouse_down)
 
-            self.tot_slot_cnt += slot_cnt
+        if self.app.is_legacy is False:
+            self.canvas.graph_event_disconnect('mouse_press', self.on_canvas_click)
+            self.canvas.graph_event_disconnect('mouse_move', self.on_canvas_move)
+            self.canvas.graph_event_disconnect('mouse_release', self.on_exc_click_release)
+        else:
+            self.canvas.graph_event_disconnect(self.mp)
+            self.canvas.graph_event_disconnect(self.mm)
+            self.canvas.graph_event_disconnect(self.mr)
 
-            idd = QtWidgets.QTableWidgetItem('%d' % int(tool_id))
-            idd.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-            self.tools_table_exc.setItem(self.tool_row, 0, idd)  # Tool name/id
+        try:
+            self.app.ui.popmenu_copy.triggered.disconnect(self.exc_copy_drills)
+        except (TypeError, AttributeError):
+            pass
 
-            # Make sure that the drill diameter when in MM is with no more than 2 decimals
-            # There are no drill bits in MM with more than 2 decimals diameter
-            # For INCH the decimals should be no more than 4. There are no drills under 10mils
-            dia = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, self.olddia_newdia[tool_no]))
+        try:
+            self.app.ui.popmenu_delete.triggered.disconnect(self.on_delete_btn)
+        except (TypeError, AttributeError):
+            pass
 
-            dia.setFlags(QtCore.Qt.ItemIsEnabled)
+        try:
+            self.app.ui.popmenu_move.triggered.disconnect(self.exc_move_drills)
+        except (TypeError, AttributeError):
+            pass
 
-            drill_count = QtWidgets.QTableWidgetItem('%d' % drill_cnt)
-            drill_count.setFlags(QtCore.Qt.ItemIsEnabled)
+        self.app.ui.popmenu_copy.triggered.connect(self.app.on_copy_command)
+        self.app.ui.popmenu_delete.triggered.connect(self.app.on_delete)
+        self.app.ui.popmenu_move.triggered.connect(self.app.obj_move)
 
-            # if the slot number is zero is better to not clutter the GUI with zero's so we print a space
-            if slot_cnt > 0:
-                slot_count = QtWidgets.QTableWidgetItem('%d' % slot_cnt)
-            else:
-                slot_count = QtWidgets.QTableWidgetItem('')
-            slot_count.setFlags(QtCore.Qt.ItemIsEnabled)
+        # Excellon Editor
+        try:
+            self.app.ui.drill.triggered.disconnect(self.exc_add_drill)
+        except (TypeError, AttributeError):
+            pass
 
-            self.tools_table_exc.setItem(self.tool_row, 1, dia)  # Diameter
-            self.tools_table_exc.setItem(self.tool_row, 2, drill_count)  # Number of drills per tool
-            self.tools_table_exc.setItem(self.tool_row, 3, slot_count)  # Number of drills per tool
+        try:
+            self.app.ui.drill_array.triggered.disconnect(self.exc_add_drill_array)
+        except (TypeError, AttributeError):
+            pass
 
-            if first_run is True:
-                # set now the last tool selected
-                self.last_tool_selected = int(tool_id)
+        try:
+            self.app.jump_signal.disconnect()
+        except (TypeError, AttributeError):
+            pass
 
-            self.tool_row += 1
+    def clear(self):
+        self.active_tool = None
+        # self.shape_buffer = []
+        self.selected = []
 
-        # make the diameter column editable
-        for row in range(self.tool_row):
-            self.tools_table_exc.item(row, 1).setFlags(
-                QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-            self.tools_table_exc.item(row, 2).setForeground(QtGui.QColor(0, 0, 0))
-            self.tools_table_exc.item(row, 3).setForeground(QtGui.QColor(0, 0, 0))
+        self.points_edit = {}
+        self.new_tools = {}
+        self.new_drills = []
 
-        # add a last row with the Total number of drills
-        # HACK: made the text on this cell '9999' such it will always be the one before last when sorting
-        # it will have to have the foreground color (font color) white
-        empty = QtWidgets.QTableWidgetItem('9998')
-        empty.setForeground(QtGui.QColor(255, 255, 255))
+        # self.storage_dict = {}
 
-        empty.setFlags(empty.flags() ^ QtCore.Qt.ItemIsEnabled)
-        empty_b = QtWidgets.QTableWidgetItem('')
-        empty_b.setFlags(empty_b.flags() ^ QtCore.Qt.ItemIsEnabled)
+        self.shapes.clear(update=True)
+        self.tool_shape.clear(update=True)
 
-        label_tot_drill_count = QtWidgets.QTableWidgetItem(_('Total Drills'))
-        tot_drill_count = QtWidgets.QTableWidgetItem('%d' % self.tot_drill_cnt)
+        # self.storage = AppExcEditor.make_storage()
+        self.replot()
 
-        label_tot_drill_count.setFlags(label_tot_drill_count.flags() ^ QtCore.Qt.ItemIsEnabled)
-        tot_drill_count.setFlags(tot_drill_count.flags() ^ QtCore.Qt.ItemIsEnabled)
+    def edit_fcexcellon(self, exc_obj):
+        """
+        Imports the geometry from the given FlatCAM Excellon object
+        into the editor.
 
-        self.tools_table_exc.setItem(self.tool_row, 0, empty)
-        self.tools_table_exc.setItem(self.tool_row, 1, label_tot_drill_count)
-        self.tools_table_exc.setItem(self.tool_row, 2, tot_drill_count)  # Total number of drills
-        self.tools_table_exc.setItem(self.tool_row, 3, empty_b)
+        :param exc_obj: ExcellonObject object
+        :return: None
+        """
 
-        font = QtGui.QFont()
-        font.setBold(True)
-        font.setWeight(75)
+        self.deactivate()
+        self.activate()
 
-        for k in [1, 2]:
-            self.tools_table_exc.item(self.tool_row, k).setForeground(QtGui.QColor(127, 0, 255))
-            self.tools_table_exc.item(self.tool_row, k).setFont(font)
-
-        self.tool_row += 1
-
-        # add a last row with the Total number of slots
-        # HACK: made the text on this cell '9999' such it will always be the last when sorting
-        # it will have to have the foreground color (font color) white
-        empty_2 = QtWidgets.QTableWidgetItem('9999')
-        empty_2.setForeground(QtGui.QColor(255, 255, 255))
-
-        empty_2.setFlags(empty_2.flags() ^ QtCore.Qt.ItemIsEnabled)
-
-        empty_3 = QtWidgets.QTableWidgetItem('')
-        empty_3.setFlags(empty_3.flags() ^ QtCore.Qt.ItemIsEnabled)
+        # Hide original geometry
+        self.exc_obj = exc_obj
+        exc_obj.visible = False
 
-        label_tot_slot_count = QtWidgets.QTableWidgetItem(_('Total Slots'))
-        tot_slot_count = QtWidgets.QTableWidgetItem('%d' % self.tot_slot_cnt)
-        label_tot_slot_count.setFlags(label_tot_slot_count.flags() ^ QtCore.Qt.ItemIsEnabled)
-        tot_slot_count.setFlags(tot_slot_count.flags() ^ QtCore.Qt.ItemIsEnabled)
+        if self.exc_obj:
+            outname = self.exc_obj.options['name']
+        else:
+            outname = ''
 
-        self.tools_table_exc.setItem(self.tool_row, 0, empty_2)
-        self.tools_table_exc.setItem(self.tool_row, 1, label_tot_slot_count)
-        self.tools_table_exc.setItem(self.tool_row, 2, empty_3)
-        self.tools_table_exc.setItem(self.tool_row, 3, tot_slot_count)  # Total number of slots
+        self.data_defaults = {
+            "name":                         outname + '_drill',
+            "plot":                         self.app.defaults["excellon_plot"],
+            "solid":                        self.app.defaults["excellon_solid"],
+            "multicolored":                 self.app.defaults["excellon_multicolored"],
+            "merge_fuse_tools":             self.app.defaults["excellon_merge_fuse_tools"],
+            "format_upper_in":              self.app.defaults["excellon_format_upper_in"],
+            "format_lower_in":              self.app.defaults["excellon_format_lower_in"],
+            "format_upper_mm":              self.app.defaults["excellon_format_upper_mm"],
+            "lower_mm":                     self.app.defaults["excellon_format_lower_mm"],
+            "zeros":                        self.app.defaults["excellon_zeros"],
+
+            "tools_drill_tool_order":       self.app.defaults["tools_drill_tool_order"],
+            "tools_drill_cutz":             self.app.defaults["tools_drill_cutz"],
+            "tools_drill_multidepth":       self.app.defaults["tools_drill_multidepth"],
+            "tools_drill_depthperpass":     self.app.defaults["tools_drill_depthperpass"],
+            "tools_drill_travelz":          self.app.defaults["tools_drill_travelz"],
+
+            "tools_drill_feedrate_z":       self.app.defaults["tools_drill_feedrate_z"],
+            "tools_drill_feedrate_rapid":   self.app.defaults["tools_drill_feedrate_rapid"],
+
+            "tools_drill_toolchange":       self.app.defaults["tools_drill_toolchange"],
+            "tools_drill_toolchangez":      self.app.defaults["tools_drill_toolchangez"],
+            "tools_drill_toolchangexy":     self.app.defaults["tools_drill_toolchangexy"],
+
+            # Drill Slots
+            "tools_drill_drill_slots":      self.app.defaults["tools_drill_drill_slots"],
+            "tools_drill_drill_overlap":    self.app.defaults["tools_drill_drill_overlap"],
+            "tools_drill_last_drill":       self.app.defaults["tools_drill_last_drill"],
+
+            "tools_drill_endz":             self.app.defaults["tools_drill_endz"],
+            "tools_drill_endxy":            self.app.defaults["tools_drill_endxy"],
+            "tools_drill_startz":           self.app.defaults["tools_drill_startz"],
+            "tools_drill_offset":           self.app.defaults["tools_drill_offset"],
+            "tools_drill_spindlespeed":     self.app.defaults["tools_drill_spindlespeed"],
+            "tools_drill_dwell":            self.app.defaults["tools_drill_dwell"],
+            "tools_drill_dwelltime":        self.app.defaults["tools_drill_dwelltime"],
+            "tools_drill_ppname_e":         self.app.defaults["tools_drill_ppname_e"],
+            "tools_drill_z_pdepth":         self.app.defaults["tools_drill_z_pdepth"],
+            "tools_drill_feedrate_probe":   self.app.defaults["tools_drill_feedrate_probe"],
+            "tools_drill_spindledir":       self.app.defaults["tools_drill_spindledir"],
+            "tools_drill_f_plunge":         self.app.defaults["tools_drill_f_plunge"],
+            "tools_drill_f_retract":        self.app.defaults["tools_drill_f_retract"],
+
+            "tools_drill_area_exclusion":   self.app.defaults["tools_drill_area_exclusion"],
+            "tools_drill_area_shape":       self.app.defaults["tools_drill_area_shape"],
+            "tools_drill_area_strategy":    self.app.defaults["tools_drill_area_strategy"],
+            "tools_drill_area_overz":       self.app.defaults["tools_drill_area_overz"],
+        }
 
-        for kl in [1, 2, 3]:
-            self.tools_table_exc.item(self.tool_row, kl).setFont(font)
-            self.tools_table_exc.item(self.tool_row, kl).setForeground(QtGui.QColor(0, 70, 255))
+        # fill in self.default_data values from self.options
+        for opt_key, opt_val in self.app.options.items():
+            if opt_key.find('excellon_') == 0:
+                self.data_defaults[opt_key] = deepcopy(opt_val)
 
-        # all the tools are selected by default
-        self.tools_table_exc.selectColumn(0)
-        #
-        self.tools_table_exc.resizeColumnsToContents()
-        self.tools_table_exc.resizeRowsToContents()
+        self.points_edit = {}
+        # build the self.points_edit dict {dimaters: [point_list]}
+        for tool, tool_dict in self.exc_obj.tools.items():
+            tool_dia = self.dec_format(self.exc_obj.tools[tool]['tooldia'])
 
-        vertical_header = self.tools_table_exc.verticalHeader()
-        # vertical_header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        vertical_header.hide()
-        self.tools_table_exc.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+            if 'drills' in tool_dict and tool_dict['drills']:
+                for drill in tool_dict['drills']:
+                    try:
+                        self.points_edit[tool_dia].append(drill)
+                    except KeyError:
+                        self.points_edit[tool_dia] = [drill]
 
-        horizontal_header = self.tools_table_exc.horizontalHeader()
-        horizontal_header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
-        horizontal_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
-        horizontal_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
-        horizontal_header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)
-        # horizontal_header.setStretchLastSection(True)
+        self.slot_points_edit = {}
+        # build the self.slot_points_edit dict {dimaters: {"start": Point, "stop": Point}}
+        for tool, tool_dict in self.exc_obj.tools.items():
+            tool_dia = float('%.*f' % (self.decimals, self.exc_obj.tools[tool]['tooldia']))
 
-        # self.tools_table_exc.setSortingEnabled(True)
-        # sort by tool diameter
-        self.tools_table_exc.sortItems(1)
+            if 'slots' in tool_dict and tool_dict['slots']:
+                for slot in tool_dict['slots']:
+                    try:
+                        self.slot_points_edit[tool_dia].append({
+                            "start": slot[0],
+                            "stop": slot[1]
+                        })
+                    except KeyError:
+                        self.slot_points_edit[tool_dia] = [{
+                            "start": slot[0],
+                            "stop": slot[1]
+                        }]
 
-        # After sorting, to display also the number of drills in the right row we need to update self.initial_rows dict
-        # with the new order. Of course the last 2 rows in the tool table are just for display therefore we don't
-        # use them
-        self.tool2tooldia.clear()
-        for row in range(self.tools_table_exc.rowCount() - 2):
-            tool = int(self.tools_table_exc.item(row, 0).text())
-            diameter = float(self.tools_table_exc.item(row, 1).text())
-            self.tool2tooldia[tool] = diameter
+        # Set selection tolerance
+        # DrawToolShape.tolerance = fc_excellon.drawing_tolerance * 10
 
-        self.tools_table_exc.setMinimumHeight(self.tools_table_exc.getHeight())
-        self.tools_table_exc.setMaximumHeight(self.tools_table_exc.getHeight())
+        self.select_tool("drill_select")
 
-        # make sure no rows are selected so the user have to click the correct row, meaning selecting the correct tool
-        self.tools_table_exc.clearSelection()
+        # reset the tool table
+        self.e_ui.tools_table_exc.clear()
+        self.e_ui.tools_table_exc.setHorizontalHeaderLabels(['#', _('Diameter'), 'D', 'S'])
+        self.last_tool_selected = None
 
-        # Remove anything else in the GUI Selected Tab
-        self.app.ui.selected_scroll_area.takeWidget()
-        # Put ourself in the GUI Selected Tab
-        self.app.ui.selected_scroll_area.setWidget(self.exc_edit_widget)
-        # Switch notebook to Selected page
-        self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
+        self.set_ui()
 
-        # we reactivate the signals after the after the tool adding as we don't need to see the tool been populated
-        self.tools_table_exc.itemChanged.connect(self.on_tool_edit)
-        self.tools_table_exc.cellPressed.connect(self.on_row_selected)
+        # now that we hava data, create the appGUI interface and add it to the Tool Tab
+        self.build_ui(first_run=True)
 
-    def on_tool_add(self, tooldia=None):
-        self.is_modified = True
-        if tooldia:
-            tool_dia = tooldia
-        else:
-            try:
-                tool_dia = float(self.addtool_entry.get_value())
-            except ValueError:
-                # try to convert comma to decimal point. if it's still not working error message and return
-                try:
-                    tool_dia = float(self.addtool_entry.get_value().replace(',', '.'))
-                except ValueError:
-                    self.app.inform.emit('[ERROR_NOTCL] %s' %
-                                         _("Wrong value format entered, use a number."))
-                    return
+        # we activate this after the initial build as we don't need to see the tool been populated
+        self.e_ui.tools_table_exc.itemChanged.connect(self.on_tool_edit)
 
-        if tool_dia not in self.olddia_newdia:
+        # build the geometry for each tool-diameter, each drill will be represented by a '+' symbol
+        # and then add it to the storage elements (each storage elements is a member of a list
+        for tool_dia in self.points_edit:
             storage_elem = AppGeoEditor.make_storage()
+            for point in self.points_edit[tool_dia]:
+                # make a '+' sign, the line length is the tool diameter
+                start_hor_line = ((point.x - (tool_dia / 2)), point.y)
+                stop_hor_line = ((point.x + (tool_dia / 2)), point.y)
+                start_vert_line = (point.x, (point.y - (tool_dia / 2)))
+                stop_vert_line = (point.x, (point.y + (tool_dia / 2)))
+                shape_geo = MultiLineString([(start_hor_line, stop_hor_line), (start_vert_line, stop_vert_line)])
+                if shape_geo is not None:
+                    self.add_exc_shape(DrawToolShape(shape_geo), storage_elem)
             self.storage_dict[tool_dia] = storage_elem
 
-            # self.olddia_newdia dict keeps the evidence on current tools diameters as keys and gets updated on values
-            # each time a tool diameter is edited or added
-            self.olddia_newdia[tool_dia] = tool_dia
-        else:
-            self.app.inform.emit('[WARNING_NOTCL] %s' % _("Tool already in the original or actual tool list.\n" 
-                                                          "Save and reedit Excellon if you need to add this tool. "))
-            return
+        # slots
+        for tool_dia in self.slot_points_edit:
+            buf_value = float(tool_dia) / 2
+            for elem_dict in self.slot_points_edit[tool_dia]:
 
-        # since we add a new tool, we update also the initial state of the tool_table through it's dictionary
-        # we add a new entry in the tool2tooldia dict
-        self.tool2tooldia[len(self.olddia_newdia)] = tool_dia
+                line_geo = LineString([elem_dict['start'], elem_dict['stop']])
+                shape_geo = line_geo.buffer(buf_value)
 
-        self.app.inform.emit('[success] %s: %s %s' %
-                             (_("Added new tool with dia"), str(tool_dia), str(self.units)))
+                if tool_dia not in self.storage_dict:
+                    storage_elem = AppGeoEditor.make_storage()
+                    self.storage_dict[tool_dia] = storage_elem
 
-        self.build_ui()
+                if shape_geo is not None:
+                    self.add_exc_shape(DrawToolShape(shape_geo), self.storage_dict[tool_dia])
 
-        # make a quick sort through the tool2tooldia dict so we find which row to select
-        row_to_be_selected = None
-        for key in sorted(self.tool2tooldia):
-            if self.tool2tooldia[key] == tool_dia:
-                row_to_be_selected = int(key) - 1
-                self.last_tool_selected = int(key)
-                break
-        try:
-            self.tools_table_exc.selectRow(row_to_be_selected)
-        except TypeError as e:
-            log.debug("AppExcEditor.on_tool_add() --> %s" % str(e))
+        self.replot()
 
-    def on_tool_delete(self, dia=None):
-        self.is_modified = True
-        deleted_tool_dia_list = []
+        # add a first tool in the Tool Table but only if the Excellon Object is empty
+        if not self.tool2tooldia:
+            self.on_tool_add(self.dec_format(float(self.app.defaults['excellon_editor_newdia'])))
 
-        try:
-            if dia is None or dia is False:
-                # deleted_tool_dia = float(self.tools_table_exc.item(self.tools_table_exc.currentRow(), 1).text())
-                for index in self.tools_table_exc.selectionModel().selectedRows():
-                    row = index.row()
-                    deleted_tool_dia_list.append(float(self.tools_table_exc.item(row, 1).text()))
-            else:
-                if isinstance(dia, list):
-                    for dd in dia:
-                        deleted_tool_dia_list.append(float('%.*f' % (self.decimals, dd)))
-                else:
-                    deleted_tool_dia_list.append(float('%.*f' % (self.decimals, dia)))
-        except Exception:
-            self.app.inform.emit('[WARNING_NOTCL] %s' % _("Select a tool in Tool Table"))
-            return
+    def update_fcexcellon(self, exc_obj):
+        """
+        Create a new Excellon object that contain the edited content of the source Excellon object
 
-        for deleted_tool_dia in deleted_tool_dia_list:
+        :param exc_obj: ExcellonObject
+        :return: None
+        """
 
-            # delete the storage used for that tool
-            storage_elem = AppGeoEditor.make_storage()
-            self.storage_dict[deleted_tool_dia] = storage_elem
-            self.storage_dict.pop(deleted_tool_dia, None)
+        # this dictionary will contain tooldia's as keys and a list of coordinates tuple as values
+        # the values of this dict are coordinates of the holes (drills)
+        edited_points = {}
 
-            # I've added this flag_del variable because dictionary don't like
-            # having keys deleted while iterating through them
-            flag_del = []
-            # self.points_edit.pop(deleted_tool_dia, None)
-            for deleted_tool in self.tool2tooldia:
-                if self.tool2tooldia[deleted_tool] == deleted_tool_dia:
-                    flag_del.append(deleted_tool)
+        """
+         - this dictionary will contain tooldia's as keys and a list of another dicts as values
+         - the dict element of the list has the structure
+         ================  ====================================
+        Key               Value
+        ================  ====================================
+        start             (Shapely.Point) Start point of the slot
+        stop              (Shapely.Point) Stop point of the slot
+        ================  ====================================
+        """
+        edited_slot_points = {}
 
-            if flag_del:
-                for tool_to_be_deleted in flag_del:
-                    # delete the tool
-                    self.tool2tooldia.pop(tool_to_be_deleted, None)
+        for storage_tooldia in self.storage_dict:
+            for x in self.storage_dict[storage_tooldia].get_objects():
+                if isinstance(x.geo, MultiLineString):
+                    # all x.geo in self.storage_dict[storage] are MultiLinestring objects for drills
+                    # each MultiLineString is made out of Linestrings
+                    # select first Linestring object in the current MultiLineString
+                    first_linestring = x.geo[0]
+                    # get it's coordinates
+                    first_linestring_coords = first_linestring.coords
+                    x_coord = first_linestring_coords[0][0] + (float(first_linestring.length / 2))
+                    y_coord = first_linestring_coords[0][1]
 
-                    # delete also the drills from points_edit dict just in case we add the tool again,
-                    # we don't want to show the number of drills from before was deleter
-                    self.points_edit[deleted_tool_dia] = []
+                    # create a tuple with the coordinates (x, y) and add it to the list that is the value of the
+                    # edited_points dictionary
+                    point = (x_coord, y_coord)
+                    if storage_tooldia not in edited_points:
+                        edited_points[storage_tooldia] = [point]
+                    else:
+                        edited_points[storage_tooldia].append(point)
+                elif isinstance(x.geo, Polygon):
+                    # create a tuple with the points (start, stop) and add it to the list that is the value of the
+                    # edited_points dictionary
 
-            self.olddia_newdia.pop(deleted_tool_dia, None)
+                    # first determine the start and stop coordinates for the slot knowing the geometry and the tool
+                    # diameter
+                    radius = float(storage_tooldia) / 2
+                    radius = radius - 0.0000001
 
-            self.app.inform.emit('[success] %s: %s %s' %
-                                 (_("Deleted tool with diameter"), str(deleted_tool_dia), str(self.units)))
+                    poly = x.geo
+                    poly = poly.buffer(-radius)
 
-        self.replot()
-        # self.app.inform.emit("Could not delete selected tool")
+                    if not poly.is_valid or poly.is_empty:
+                        # print("Polygon not valid: %s" % str(poly.wkt))
+                        continue
 
-        self.build_ui()
+                    xmin, ymin, xmax, ymax = poly.bounds
+                    line_one = LineString([(xmin, ymin), (xmax, ymax)]).intersection(poly).length
+                    line_two = LineString([(xmin, ymax), (xmax, ymin)]).intersection(poly).length
 
-    def on_tool_edit(self, item_changed):
-        # if connected, disconnect the signal from the slot on item_changed as it creates issues
-        try:
-            self.tools_table_exc.itemChanged.disconnect()
-        except TypeError:
-            pass
+                    if line_one < line_two:
+                        point_elem = {
+                            "start": (xmin, ymax),
+                            "stop": (xmax, ymin)
+                        }
+                    else:
+                        point_elem = {
+                            "start": (xmin, ymin),
+                            "stop": (xmax, ymax)
+                        }
 
-        try:
-            self.tools_table_exc.cellPressed.disconnect()
-        except TypeError:
-            pass
-        # self.tools_table_exc.selectionModel().currentChanged.disconnect()
+                    if storage_tooldia not in edited_slot_points:
+                        edited_slot_points[storage_tooldia] = [point_elem]
+                    else:
+                        edited_slot_points[storage_tooldia].append(point_elem)
 
-        self.is_modified = True
-        # new_dia = None
+        # recreate the drills and tools to be added to the new Excellon edited object
+        # first, we look in the tool table if one of the tool diameters was changed then
+        # append that a tuple formed by (old_dia, edited_dia) to a list
+        changed_key = set()
+        for initial_dia in self.olddia_newdia:
+            edited_dia = self.olddia_newdia[initial_dia]
+            if edited_dia != initial_dia:
+                # for drills
+                for old_dia in edited_points:
+                    if old_dia == initial_dia:
+                        changed_key.add((old_dia, edited_dia))
+                # for slots
+                for old_dia in edited_slot_points:
+                    if old_dia == initial_dia:
+                        changed_key.add((old_dia, edited_dia))
+            # if the initial_dia is not in edited_points it means it is a new tool with no drill points
+            # (and we have to add it)
+            # because in case we have drill points it will have to be already added in edited_points
+            # if initial_dia not in edited_points.keys():
+            #     edited_points[initial_dia] = []
 
-        try:
-            new_dia = float(self.tools_table_exc.currentItem().text())
-        except ValueError as e:
-            log.debug("AppExcEditor.on_tool_edit() --> %s" % str(e))
-            return
+        for el in changed_key:
+            edited_points[el[1]] = edited_points.pop(el[0])
+            edited_slot_points[el[1]] = edited_slot_points.pop(el[0])
 
-        row_of_item_changed = self.tools_table_exc.currentRow()
-        # rows start with 0, tools start with 1 so we adjust the value by 1
-        key_in_tool2tooldia = row_of_item_changed + 1
-        old_dia = self.tool2tooldia[key_in_tool2tooldia]
+        # Let's sort the edited_points dictionary by keys (diameters) and store the result in a zipped list
+        # ordered_edited_points is a ordered list of tuples;
+        # element[0] of the tuple is the diameter and
+        # element[1] of the tuple is a list of coordinates (a tuple themselves)
+        ordered_edited_points = sorted(zip(edited_points.keys(), edited_points.values()))
 
-        # SOURCE storage
-        source_storage = self.storage_dict[old_dia]
+        current_tool = 0
+        for tool_dia in ordered_edited_points:
+            current_tool += 1
 
-        # DESTINATION storage
-        # tool diameter is not used so we create a new tool with the desired diameter
-        if new_dia not in self.olddia_newdia:
-            destination_storage = AppGeoEditor.make_storage()
-            self.storage_dict[new_dia] = destination_storage
+            # create the self.tools for the new Excellon object (the one with edited content)
+            if current_tool not in self.new_tools:
+                self.new_tools[current_tool] = {}
+            self.new_tools[current_tool]['tooldia'] = float(tool_dia[0])
 
-            # self.olddia_newdia dict keeps the evidence on current tools diameters as keys and gets updated on values
-            # each time a tool diameter is edited or added
-            self.olddia_newdia[new_dia] = new_dia
-        else:
-            # tool diameter is already in use so we move the drills from the prior tool to the new tool
-            destination_storage = self.storage_dict[new_dia]
+            # add in self.tools the 'solid_geometry' key, the value (a list) is populated below
+            self.new_tools[current_tool]['solid_geometry'] = []
 
-        # since we add a new tool, we update also the intial state of the tool_table through it's dictionary
-        # we add a new entry in the tool2tooldia dict
-        self.tool2tooldia[len(self.olddia_newdia)] = new_dia
+            # create the self.drills for the new Excellon object (the one with edited content)
+            for point in tool_dia[1]:
+                try:
+                    self.new_tools[current_tool]['drills'].append(Point(point))
+                except KeyError:
+                    self.new_tools[current_tool]['drills'] = [Point(point)]
 
-        # CHANGE the elements geometry according to the new diameter
-        factor = new_dia / old_dia
-        new_geo = Polygon()
-        for shape_exc in source_storage.get_objects():
-            geo_list = []
-            if isinstance(shape_exc.geo, MultiLineString):
-                for subgeo in shape_exc.geo:
-                    geo_list.append(affinity.scale(subgeo, xfact=factor, yfact=factor, origin='center'))
-                new_geo = MultiLineString(geo_list)
-            elif isinstance(shape_exc.geo, Polygon):
-                # I don't have any info regarding the angle of the slot geometry, nor how thick it is or
-                # how long it is given the angle. So I will have to make an approximation because
-                # we need to conserve the slot length, we only resize the diameter for the tool
-                # Therefore scaling won't work and buffering will not work either.
+                # repopulate the 'solid_geometry' for each tool
+                poly = Point(point).buffer(float(tool_dia[0]) / 2.0, int(int(exc_obj.geo_steps_per_circle) / 4))
+                self.new_tools[current_tool]['solid_geometry'].append(poly)
 
-                # First we get the Linestring that is one that the original slot is built around with the
-                # tool having the diameter sel_dia
-                poly = shape_exc.geo
-                xmin, ymin, xmax, ymax = poly.bounds
-                # a line that is certain to be bigger than our slot because it's the diagonal
-                # of it's bounding box
-                poly_diagonal = LineString([(xmin, ymin), (xmax, ymax)])
-                poly_centroid = poly.centroid
-                # center of the slot geometry
-                poly_center = (poly_centroid.x, poly_centroid.y)
+        ordered_edited_slot_points = sorted(zip(edited_slot_points.keys(), edited_slot_points.values()))
+        for tool_dia in ordered_edited_slot_points:
 
-                # make a list of intersections with the rotated line
-                list_of_cuttings = []
-                for angle in range(0, 359, 1):
-                    rot_poly_diagonal = affinity.rotate(poly_diagonal, angle=angle, origin=poly_center)
-                    cut_line = rot_poly_diagonal.intersection(poly)
-                    cut_line_len = cut_line.length
-                    list_of_cuttings.append(
-                        (cut_line_len, cut_line)
-                    )
-                # find the cut_line with the maximum length which is the LineString for which the start
-                # and stop point are the start and stop point of the slot as in the Gerber file
-                cut_line_with_max_length = max(list_of_cuttings, key=lambda i: i[0])[1]
-                # find the coordinates of this line
-                cut_line_with_max_length_coords = list(cut_line_with_max_length.coords)
-                # extract the first and last point of the line and build some buffered polygon circles
-                # around them
-                start_pt = Point(cut_line_with_max_length_coords[0])
-                stop_pt = Point(cut_line_with_max_length_coords[1])
-                start_cut_geo = start_pt.buffer(new_dia / 2)
-                stop_cut_geo = stop_pt.buffer(new_dia / 2)
+            tool_exist_flag = False
+            for tool in self.new_tools:
+                if tool_dia[0] == self.new_tools[tool]["tooldia"]:
+                    current_tool = tool
+                    tool_exist_flag = True
+                    break
 
-                # and we cut the above circle polygons from our line and get in this way a line around
-                # which we can build the new slot by buffering with the new tool diameter
-                new_line = cut_line_with_max_length.difference(start_cut_geo)
-                new_line = new_line.difference(stop_cut_geo)
+            if tool_exist_flag is False:
+                current_tool += 1
 
-                # create the geometry for the resized slot by buffering with half of the
-                # new diameter value: new_dia
-                new_geo = new_line.buffer(new_dia / 2)
+                # create the self.tools for the new Excellon object (the one with edited content)
+                if current_tool not in self.new_tools:
+                    self.new_tools[current_tool] = {}
+                self.new_tools[current_tool]['tooldia'] = float(tool_dia[0])
 
-            try:
-                self.points_edit.pop(old_dia, None)
-            except KeyError:
-                pass
-            try:
-                self.slot_points_edit.pop(old_dia, None)
-            except KeyError:
-                pass
+                # add in self.tools the 'solid_geometry' key, the value (a list) is populated below
+                self.new_tools[current_tool]['solid_geometry'] = []
 
-            # add bogus drill/slots points (for total count of drills/slots)
-            # for drills
-            if isinstance(shape_exc.geo, MultiLineString):
-                if new_dia not in self.points_edit:
-                    self.points_edit[new_dia] = [(0, 0)]
-                else:
-                    self.points_edit[new_dia].append((0, 0))
+            # create the self.slots for the new Excellon object (the one with edited content)
+            for coord_dict in tool_dia[1]:
+                slot = (
+                    Point(coord_dict['start']),
+                    Point(coord_dict['stop'])
+                )
+                try:
+                    self.new_tools[current_tool]['slots'].append(slot)
+                except KeyError:
+                    self.new_tools[current_tool]['slots'] = [slot]
 
-            # for slots
-            if isinstance(shape_exc.geo, Polygon):
-                if new_dia not in self.slot_points_edit:
-                    self.slot_points_edit[new_dia] = [(0, 0)]
-                else:
-                    self.slot_points_edit[new_dia].append((0, 0))
+                # repopulate the 'solid_geometry' for each tool
+                poly = LineString([coord_dict['start'], coord_dict['stop']]).buffer(
+                    float(tool_dia[0]) / 2.0, int(int(exc_obj.geo_steps_per_circle) / 4)
+                )
+                self.new_tools[current_tool]['solid_geometry'].append(poly)
 
-            self.add_exc_shape(shape=DrawToolShape(new_geo), storage=destination_storage)
+        if self.is_modified is True:
+            if "_edit" in self.edited_obj_name:
+                try:
+                    idd = int(self.edited_obj_name[-1]) + 1
+                    self.edited_obj_name = self.edited_obj_name[:-1] + str(idd)
+                except ValueError:
+                    self.edited_obj_name += "_1"
+            else:
+                self.edited_obj_name += "_edit"
 
-        # update the UI and the CANVAS
-        self.build_ui()
-        self.replot()
+        self.app.worker_task.emit({'fcn': self.new_edited_excellon,
+                                   'params': [self.edited_obj_name,
+                                              self.new_drills,
+                                              self.new_slots,
+                                              self.new_tools]})
 
-        # delete the old tool
-        self.on_tool_delete(dia=old_dia)
+        return self.edited_obj_name
 
-        # we reactivate the signals after the after the tool editing
-        self.tools_table_exc.itemChanged.connect(self.on_tool_edit)
-        self.tools_table_exc.cellPressed.connect(self.on_row_selected)
+    @staticmethod
+    def update_options(obj):
+        try:
+            if not obj.options:
+                obj.options = {}
+                obj.options['xmin'] = 0
+                obj.options['ymin'] = 0
+                obj.options['xmax'] = 0
+                obj.options['ymax'] = 0
+                return True
+            else:
+                return False
+        except AttributeError:
+            obj.options = {}
+            return True
 
-        self.app.inform.emit('[success] %s' %
-                             _("Done. Tool edit completed."))
+    def new_edited_excellon(self, outname, n_drills, n_slots, n_tools):
+        """
+        Creates a new Excellon object for the edited Excellon. Thread-safe.
 
-        # self.tools_table_exc.selectionModel().currentChanged.connect(self.on_row_selected)
+        :param outname:     Name of the resulting object. None causes the
+                            name to be that of the file.
+        :type outname:      str
 
-    def on_name_activate(self):
-        self.edited_obj_name = self.name_entry.get_value()
+        :param n_drills:    The new Drills storage
+        :param n_slots:     The new Slots storage
+        :param n_tools:     The new Tools storage
+        :return:            None
+        """
 
-    def activate(self):
-        # adjust the status of the menu entries related to the editor
-        self.app.ui.menueditedit.setDisabled(True)
-        self.app.ui.menueditok.setDisabled(False)
-        # adjust the visibility of some of the canvas context menu
-        self.app.ui.popmenu_edit.setVisible(False)
-        self.app.ui.popmenu_save.setVisible(True)
+        self.app.log.debug("Update the Excellon object with edited content. Source is %s" %
+                           self.exc_obj.options['name'])
 
-        self.connect_canvas_event_handlers()
+        new_drills = n_drills
+        new_slots = n_slots
+        new_tools = n_tools
 
-        # initialize working objects
-        self.storage_dict = {}
-        self.current_storage = []
-        self.points_edit = {}
-        self.sorted_diameters = []
-        self.new_drills = []
-        self.new_tools = {}
-        self.new_slots = []
+        # How the object should be initialized
+        def obj_init(excellon_obj, app_obj):
 
-        self.olddia_newdia = {}
+            excellon_obj.drills = deepcopy(new_drills)
+            excellon_obj.tools = deepcopy(new_tools)
+            excellon_obj.slots = deepcopy(new_slots)
 
-        self.shapes.enabled = True
-        self.tool_shape.enabled = True
-        # self.app.app_cursor.enabled = True
+            excellon_obj.options['name'] = outname
 
-        self.app.ui.corner_snap_btn.setVisible(True)
-        self.app.ui.snap_magnet.setVisible(True)
+            # add a 'data' dict for each tool with the default values
+            for tool in excellon_obj.tools:
+                excellon_obj.tools[tool]['data'] = {}
+                excellon_obj.tools[tool]['data'].update(deepcopy(self.data_defaults))
 
-        self.app.ui.exc_editor_menu.setDisabled(False)
-        self.app.ui.exc_editor_menu.menuAction().setVisible(True)
+            try:
+                excellon_obj.create_geometry()
+            except KeyError:
+                self.app.inform.emit('[ERROR_NOTCL] %s' %
+                                     _("There are no Tools definitions in the file. Aborting Excellon creation.")
+                                     )
+            except Exception:
+                msg = '[ERROR] %s' % \
+                      _("An internal error has ocurred. See Shell.\n")
+                msg += traceback.format_exc()
+                app_obj.inform.emit(msg)
+                return
 
-        self.app.ui.update_obj_btn.setEnabled(True)
-        self.app.ui.e_editor_cmenu.setEnabled(True)
+        with self.app.proc_container.new(_("Creating Excellon.")):
 
-        self.app.ui.exc_edit_toolbar.setDisabled(False)
-        self.app.ui.exc_edit_toolbar.setVisible(True)
-        # self.app.ui.grid_toolbar.setDisabled(False)
+            try:
+                edited_obj = self.app.app_obj.new_object("excellon", outname, obj_init)
+                edited_obj.source_file = self.app.export_excellon(obj_name=edited_obj.options['name'],
+                                                                  local_use=edited_obj,
+                                                                  filename=None,
+                                                                  use_thread=False)
+            except Exception as e:
+                self.deactivate()
+                log.error("Error on Edited object creation: %s" % str(e))
+                return
 
-        # start with GRID toolbar activated
-        if self.app.ui.grid_snap_btn.isChecked() is False:
-            self.app.ui.grid_snap_btn.trigger()
+            self.deactivate()
+            self.app.inform.emit('[success] %s' % _("Excellon editing finished."))
 
-        self.app.ui.popmenu_disable.setVisible(False)
-        self.app.ui.cmenu_newmenu.menuAction().setVisible(False)
-        self.app.ui.popmenu_properties.setVisible(False)
-        self.app.ui.e_editor_cmenu.menuAction().setVisible(True)
-        self.app.ui.g_editor_cmenu.menuAction().setVisible(False)
-        self.app.ui.grb_editor_cmenu.menuAction().setVisible(False)
+    def on_tool_select(self, tool):
+        """
+        Behavior of the toolbar. Tool initialization.
 
-        # Tell the App that the editor is active
-        self.editor_active = True
+        :rtype : None
+        """
+        current_tool = tool
 
-        # show the UI
-        self.drills_frame.show()
+        self.app.log.debug("on_tool_select('%s')" % tool)
 
-    def deactivate(self):
-        try:
-            QtGui.QGuiApplication.restoreOverrideCursor()
-        except Exception:
-            pass
+        if self.last_tool_selected is None and current_tool != 'drill_select':
+            # self.draw_app.select_tool('drill_select')
+            self.complete = True
+            current_tool = 'drill_select'
+            self.app.inform.emit('[WARNING_NOTCL] %s' % _("Cancelled. There is no Tool/Drill selected"))
 
-        # adjust the status of the menu entries related to the editor
-        self.app.ui.menueditedit.setDisabled(False)
-        self.app.ui.menueditok.setDisabled(True)
-        # adjust the visibility of some of the canvas context menu
-        self.app.ui.popmenu_edit.setVisible(True)
-        self.app.ui.popmenu_save.setVisible(False)
+        # This is to make the group behave as radio group
+        if current_tool in self.tools_exc:
+            if self.tools_exc[current_tool]["button"].isChecked():
+                self.app.log.debug("%s is checked." % current_tool)
+                for t in self.tools_exc:
+                    if t != current_tool:
+                        self.tools_exc[t]["button"].setChecked(False)
 
-        self.disconnect_canvas_event_handlers()
-        self.clear()
-        self.app.ui.exc_edit_toolbar.setDisabled(True)
+                # this is where the Editor toolbar classes (button's) are instantiated
+                self.active_tool = self.tools_exc[current_tool]["constructor"](self)
+                # self.app.inform.emit(self.active_tool.start_msg)
+            else:
+                self.app.log.debug("%s is NOT checked." % current_tool)
+                for t in self.tools_exc:
+                    self.tools_exc[t]["button"].setChecked(False)
 
-        self.app.ui.corner_snap_btn.setVisible(False)
-        self.app.ui.snap_magnet.setVisible(False)
+                self.select_tool('drill_select')
+                self.active_tool = FCDrillSelect(self)
 
-        # set the Editor Toolbar visibility to what was before entering in the Editor
-        self.app.ui.exc_edit_toolbar.setVisible(False) if self.toolbar_old_state is False \
-            else self.app.ui.exc_edit_toolbar.setVisible(True)
+    def on_row_selected(self, row, col):
+        if col == 0:
+            key_modifier = QtWidgets.QApplication.keyboardModifiers()
+            if self.app.defaults["global_mselect_key"] == 'Control':
+                modifier_to_use = Qt.ControlModifier
+            else:
+                modifier_to_use = Qt.ShiftModifier
 
-        # Disable visuals
-        self.shapes.enabled = False
-        self.tool_shape.enabled = False
-        # self.app.app_cursor.enabled = False
+            if key_modifier == modifier_to_use:
+                pass
+            else:
+                self.selected = []
 
-        # Tell the app that the editor is no longer active
-        self.editor_active = False
+            try:
+                selected_dia = self.tool2tooldia[self.e_ui.tools_table_exc.currentRow() + 1]
+                self.last_tool_selected = int(self.e_ui.tools_table_exc.currentRow()) + 1
+                for obj in self.storage_dict[selected_dia].get_objects():
+                    self.selected.append(obj)
+            except Exception as e:
+                self.app.log.debug(str(e))
 
-        self.app.ui.exc_editor_menu.setDisabled(True)
-        self.app.ui.exc_editor_menu.menuAction().setVisible(False)
+            self.replot()
 
-        self.app.ui.update_obj_btn.setEnabled(False)
+    def on_canvas_click(self, event):
+        """
+        event.x and .y have canvas coordinates
+        event.xdata and .ydata have plot coordinates
 
-        self.app.ui.popmenu_disable.setVisible(True)
-        self.app.ui.cmenu_newmenu.menuAction().setVisible(True)
-        self.app.ui.popmenu_properties.setVisible(True)
-        self.app.ui.g_editor_cmenu.menuAction().setVisible(False)
-        self.app.ui.e_editor_cmenu.menuAction().setVisible(False)
-        self.app.ui.grb_editor_cmenu.menuAction().setVisible(False)
+        :param event:       Event object dispatched by VisPy
+        :return:            None
+        """
+        if self.app.is_legacy is False:
+            event_pos = event.pos
+            # event_is_dragging = event.is_dragging
+            # right_button = 2
+        else:
+            event_pos = (event.xdata, event.ydata)
+            # event_is_dragging = self.app.plotcanvas.is_dragging
+            # right_button = 3
+
+        self.pos = self.canvas.translate_coords(event_pos)
+
+        if self.app.grid_status():
+            self.pos = self.app.geo_editor.snap(self.pos[0], self.pos[1])
+        else:
+            self.pos = (self.pos[0], self.pos[1])
+
+        if event.button == 1:
+            self.app.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
+                                                   "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (0, 0))
+
+            # Selection with left mouse button
+            if self.active_tool is not None and event.button == 1:
+                # Dispatch event to active_tool
+                # msg = self.active_tool.click(self.app.geo_editor.snap(event.xdata, event.ydata))
+                self.active_tool.click(self.app.geo_editor.snap(self.pos[0], self.pos[1]))
+
+                # If it is a shape generating tool
+                if isinstance(self.active_tool, FCShapeTool) and self.active_tool.complete:
+                    if self.current_storage is not None:
+                        self.on_exc_shape_complete(self.current_storage)
+                        self.build_ui()
+
+                    # MS: always return to the Select Tool if modifier key is not pressed
+                    # else return to the current tool
+                    key_modifier = QtWidgets.QApplication.keyboardModifiers()
+                    if self.app.defaults["global_mselect_key"] == 'Control':
+                        modifier_to_use = Qt.ControlModifier
+                    else:
+                        modifier_to_use = Qt.ShiftModifier
+
+                    # if modifier key is pressed then we add to the selected list the current shape but if it's already
+                    # in the selected list, we removed it. Therefore first click selects, second deselects.
+                    if key_modifier == modifier_to_use:
+                        self.select_tool(self.active_tool.name)
+                    else:
+                        # return to Select tool but not for FCDrillAdd or FCSlot
+                        if isinstance(self.active_tool, FCDrillAdd) or isinstance(self.active_tool, FCSlot):
+                            self.select_tool(self.active_tool.name)
+                        else:
+                            self.select_tool("drill_select")
+                        return
 
-        # Show original geometry
-        if self.exc_obj:
-            self.exc_obj.visible = True
+                if isinstance(self.active_tool, FCDrillSelect):
+                    # self.app.log.debug("Replotting after click.")
+                    self.replot()
+            else:
+                self.app.log.debug("No active tool to respond to click!")
 
-        # hide the UI
-        self.drills_frame.hide()
+    def on_exc_shape_complete(self, storage):
+        self.app.log.debug("on_shape_complete()")
 
-    def connect_canvas_event_handlers(self):
-        # ## Canvas events
+        # Add shape
+        if type(storage) is list:
+            for item_storage in storage:
+                self.add_exc_shape(self.active_tool.geometry, item_storage)
+        else:
+            self.add_exc_shape(self.active_tool.geometry, storage)
 
-        # first connect to new, then disconnect the old handlers
-        # don't ask why but if there is nothing connected I've seen issues
-        self.mp = self.canvas.graph_event_connect('mouse_press', self.on_canvas_click)
-        self.mm = self.canvas.graph_event_connect('mouse_move', self.on_canvas_move)
-        self.mr = self.canvas.graph_event_connect('mouse_release', self.on_exc_click_release)
+        # Remove any utility shapes
+        self.delete_utility_geometry()
+        self.tool_shape.clear(update=True)
 
-        # make sure that the shortcuts key and mouse events will no longer be linked to the methods from FlatCAMApp
-        # but those from AppGeoEditor
-        if self.app.is_legacy is False:
-            self.app.plotcanvas.graph_event_disconnect('mouse_press', self.app.on_mouse_click_over_plot)
-            self.app.plotcanvas.graph_event_disconnect('mouse_move', self.app.on_mouse_move_over_plot)
-            self.app.plotcanvas.graph_event_disconnect('mouse_release', self.app.on_mouse_click_release_over_plot)
-            self.app.plotcanvas.graph_event_disconnect('mouse_double_click', self.app.on_mouse_double_click_over_plot)
-        else:
-            self.app.plotcanvas.graph_event_disconnect(self.app.mp)
-            self.app.plotcanvas.graph_event_disconnect(self.app.mm)
-            self.app.plotcanvas.graph_event_disconnect(self.app.mr)
-            self.app.plotcanvas.graph_event_disconnect(self.app.mdc)
+        # Replot and reset tool.
+        self.replot()
+        # self.active_tool = type(self.active_tool)(self)
 
-        self.app.collection.view.clicked.disconnect()
+    def add_exc_shape(self, shape, storage):
+        """
+        Adds a shape to a specified shape storage.
 
-        self.app.ui.popmenu_copy.triggered.disconnect()
-        self.app.ui.popmenu_delete.triggered.disconnect()
-        self.app.ui.popmenu_move.triggered.disconnect()
+        :param shape:       Shape to be added.
+        :type shape:        DrawToolShape
+        :param storage:     object where to store the shapes
+        :return:            None
+        """
+        # List of DrawToolShape?
+        if isinstance(shape, list):
+            for subshape in shape:
+                self.add_exc_shape(subshape, storage)
+            return
 
-        self.app.ui.popmenu_copy.triggered.connect(self.exc_copy_drills)
-        self.app.ui.popmenu_delete.triggered.connect(self.on_delete_btn)
-        self.app.ui.popmenu_move.triggered.connect(self.exc_move_drills)
+        assert isinstance(shape, DrawToolShape), \
+            "Expected a DrawToolShape, got %s" % str(type(shape))
 
-        # Excellon Editor
-        self.app.ui.drill.triggered.connect(self.exc_add_drill)
-        self.app.ui.drill_array.triggered.connect(self.exc_add_drill_array)
+        assert shape.geo is not None, \
+            "Shape object has empty geometry (None)"
 
-    def disconnect_canvas_event_handlers(self):
-        # we restore the key and mouse control to FlatCAMApp method
-        # first connect to new, then disconnect the old handlers
-        # don't ask why but if there is nothing connected I've seen issues
-        self.app.mp = self.app.plotcanvas.graph_event_connect('mouse_press', self.app.on_mouse_click_over_plot)
-        self.app.mm = self.app.plotcanvas.graph_event_connect('mouse_move', self.app.on_mouse_move_over_plot)
-        self.app.mr = self.app.plotcanvas.graph_event_connect('mouse_release',
-                                                              self.app.on_mouse_click_release_over_plot)
-        self.app.mdc = self.app.plotcanvas.graph_event_connect('mouse_double_click',
-                                                               self.app.on_mouse_double_click_over_plot)
-        self.app.collection.view.clicked.connect(self.app.collection.on_mouse_down)
+        assert (isinstance(shape.geo, list) and len(shape.geo) > 0) or not isinstance(shape.geo, list), \
+            "Shape objects has empty geometry ([])"
 
-        if self.app.is_legacy is False:
-            self.canvas.graph_event_disconnect('mouse_press', self.on_canvas_click)
-            self.canvas.graph_event_disconnect('mouse_move', self.on_canvas_move)
-            self.canvas.graph_event_disconnect('mouse_release', self.on_exc_click_release)
+        if isinstance(shape, DrawToolUtilityShape):
+            self.utility.append(shape)
         else:
-            self.canvas.graph_event_disconnect(self.mp)
-            self.canvas.graph_event_disconnect(self.mm)
-            self.canvas.graph_event_disconnect(self.mr)
+            storage.insert(shape)  # TODO: Check performance
 
-        try:
-            self.app.ui.popmenu_copy.triggered.disconnect(self.exc_copy_drills)
-        except (TypeError, AttributeError):
-            pass
+    def add_shape(self, shape):
+        """
+        Adds a shape to the shape storage.
 
-        try:
-            self.app.ui.popmenu_delete.triggered.disconnect(self.on_delete_btn)
-        except (TypeError, AttributeError):
-            pass
+        :param shape:       Shape to be added.
+        :type shape:        DrawToolShape
+        :return:            None
+        """
 
-        try:
-            self.app.ui.popmenu_move.triggered.disconnect(self.exc_move_drills)
-        except (TypeError, AttributeError):
-            pass
+        # List of DrawToolShape?
+        if isinstance(shape, list):
+            for subshape in shape:
+                self.add_shape(subshape)
+            return
 
-        self.app.ui.popmenu_copy.triggered.connect(self.app.on_copy_command)
-        self.app.ui.popmenu_delete.triggered.connect(self.app.on_delete)
-        self.app.ui.popmenu_move.triggered.connect(self.app.obj_move)
+        assert isinstance(shape, DrawToolShape), \
+            "Expected a DrawToolShape, got %s" % type(shape)
 
-        # Excellon Editor
-        try:
-            self.app.ui.drill.triggered.disconnect(self.exc_add_drill)
-        except (TypeError, AttributeError):
-            pass
+        assert shape.geo is not None, \
+            "Shape object has empty geometry (None)"
 
-        try:
-            self.app.ui.drill_array.triggered.disconnect(self.exc_add_drill_array)
-        except (TypeError, AttributeError):
-            pass
+        assert (isinstance(shape.geo, list) and len(shape.geo) > 0) or not isinstance(shape.geo, list), \
+            "Shape objects has empty geometry ([])"
 
-        try:
-            self.app.jump_signal.disconnect()
-        except (TypeError, AttributeError):
-            pass
+        if isinstance(shape, DrawToolUtilityShape):
+            self.utility.append(shape)
+        # else:
+        #     self.storage.insert(shape)
 
-    def clear(self):
-        self.active_tool = None
-        # self.shape_buffer = []
-        self.selected = []
+    def on_exc_click_release(self, event):
+        """
+        Handler of the "mouse_release" event.
+        It will pop-up the context menu on right mouse click unless there was a panning move (decided in the
+        "mouse_move" event handler) and only if the current tool is the Select tool.
+        It will 'close' a Editor tool if it is the case.
 
-        self.points_edit = {}
-        self.new_tools = {}
-        self.new_drills = []
+        :param event:       Event object dispatched by VisPy SceneCavas
+        :return:            None
+        """
 
-        # self.storage_dict = {}
+        if self.app.is_legacy is False:
+            event_pos = event.pos
+            # event_is_dragging = event.is_dragging
+            right_button = 2
+        else:
+            event_pos = (event.xdata, event.ydata)
+            # event_is_dragging = self.app.plotcanvas.is_dragging
+            right_button = 3
 
-        self.shapes.clear(update=True)
-        self.tool_shape.clear(update=True)
+        pos_canvas = self.canvas.translate_coords(event_pos)
 
-        # self.storage = AppExcEditor.make_storage()
-        self.replot()
+        if self.app.grid_status():
+            pos = self.app.geo_editor.snap(pos_canvas[0], pos_canvas[1])
+        else:
+            pos = (pos_canvas[0], pos_canvas[1])
 
-    def edit_fcexcellon(self, exc_obj):
-        """
-        Imports the geometry from the given FlatCAM Excellon object
-        into the editor.
+        # if the released mouse button was RMB then test if it was a panning motion or not, if not it was a context
+        # canvas menu
+        try:
+            if event.button == right_button:  # right click
+                if self.app.ui.popMenu.mouse_is_panning is False:
+                    try:
+                        QtGui.QGuiApplication.restoreOverrideCursor()
+                    except Exception:
+                        pass
+                    if self.active_tool.complete is False and not isinstance(self.active_tool, FCDrillSelect):
+                        self.active_tool.complete = True
+                        self.in_action = False
+                        self.delete_utility_geometry()
+                        self.app.inform.emit('[success] %s' % _("Done."))
+                        self.select_tool('drill_select')
+                    else:
+                        if isinstance(self.active_tool, FCDrillAdd):
+                            self.active_tool.complete = True
+                            self.in_action = False
+                            self.delete_utility_geometry()
+                            self.app.inform.emit('[success] %s' % _("Done."))
+                            self.select_tool('drill_select')
 
-        :param exc_obj: ExcellonObject object
-        :return: None
-        """
+                        self.app.cursor = QtGui.QCursor()
+                        self.app.populate_cmenu_grids()
+                        self.app.ui.popMenu.popup(self.app.cursor.pos())
 
-        assert isinstance(exc_obj, Excellon), \
-            "Expected an Excellon Object, got %s" % type(exc_obj)
+        except Exception as e:
+            log.warning("AppExcEditor.on_exc_click_release() RMB click --> Error: %s" % str(e))
+            raise
 
-        self.deactivate()
-        self.activate()
+        # if the released mouse button was LMB then test if we had a right-to-left selection or a left-to-right
+        # selection and then select a type of selection ("enclosing" or "touching")
+        try:
+            if event.button == 1:  # left click
+                if self.app.selection_type is not None:
+                    self.draw_selection_area_handler(self.pos, pos, self.app.selection_type)
+                    self.app.selection_type = None
 
-        # Hide original geometry
-        self.exc_obj = exc_obj
-        exc_obj.visible = False
+                elif isinstance(self.active_tool, FCDrillSelect):
+                    self.active_tool.click_release((self.pos[0], self.pos[1]))
 
-        self.points_edit = {}
-        self.slot_points_edit = {}
+                    # if there are selected objects then plot them
+                    if self.selected:
+                        self.replot()
+        except Exception as e:
+            log.warning("AppExcEditor.on_exc_click_release() LMB click --> Error: %s" % str(e))
+            raise
 
-        # Set selection tolerance
-        # DrawToolShape.tolerance = fc_excellon.drawing_tolerance * 10
+    def draw_selection_area_handler(self, start, end, sel_type):
+        """
+        This function is called whenever we have a left mouse click release and only we have a left mouse click drag,
+        be it from left to right or from right to left. The direction of the drag is decided in the "mouse_move"
+        event handler.
+        Pressing a modifier key (eg. Ctrl, Shift or Alt) will change the behavior of the selection.
 
-        self.select_tool("drill_select")
+        Depending on which tool belongs the selected shapes, the corresponding rows in the Tools Table are selected or
+        deselected.
 
-        # reset the tool table
-        self.tools_table_exc.clear()
-        self.tools_table_exc.setHorizontalHeaderLabels(['#', _('Diameter'), 'D', 'S'])
-        self.last_tool_selected = None
+        :param start:       mouse position when the selection LMB click was done
+        :param end:         mouse position when the left mouse button is released
+        :param sel_type:    if True it's a left to right selection (enclosure), if False it's a 'touch' selection
+        :return:
+        """
 
-        self.set_ui()
+        start_pos = (start[0], start[1])
+        end_pos = (end[0], end[1])
+        poly_selection = Polygon([start_pos, (end_pos[0], start_pos[1]), end_pos, (start_pos[0], end_pos[1])])
+        modifiers = None
 
-        # now that we hava data, create the appGUI interface and add it to the Tool Tab
-        self.build_ui(first_run=True)
+        # delete the selection shape that was just drawn, we no longer need it
+        self.app.delete_selection_shape()
+
+        # detect if a modifier key was pressed while the left mouse button was released
+        self.modifiers = QtWidgets.QApplication.keyboardModifiers()
+        if self.modifiers == QtCore.Qt.ShiftModifier:
+            modifiers = 'Shift'
+        elif self.modifiers == QtCore.Qt.ControlModifier:
+            modifiers = 'Control'
 
-        # we activate this after the initial build as we don't need to see the tool been populated
-        self.tools_table_exc.itemChanged.connect(self.on_tool_edit)
+        if modifiers == self.app.defaults["global_mselect_key"]:
+            for storage in self.storage_dict:
+                for obj in self.storage_dict[storage].get_objects():
+                    if (sel_type is True and poly_selection.contains(obj.geo)) or \
+                            (sel_type is False and poly_selection.intersects(obj.geo)):
 
-        # build the geometry for each tool-diameter, each drill will be represented by a '+' symbol
-        # and then add it to the storage elements (each storage elements is a member of a list
-        for tool_dia in self.points_edit:
-            storage_elem = AppGeoEditor.make_storage()
-            for point in self.points_edit[tool_dia]:
-                # make a '+' sign, the line length is the tool diameter
-                start_hor_line = ((point.x - (tool_dia / 2)), point.y)
-                stop_hor_line = ((point.x + (tool_dia / 2)), point.y)
-                start_vert_line = (point.x, (point.y - (tool_dia / 2)))
-                stop_vert_line = (point.x, (point.y + (tool_dia / 2)))
-                shape_geo = MultiLineString([(start_hor_line, stop_hor_line), (start_vert_line, stop_vert_line)])
-                if shape_geo is not None:
-                    self.add_exc_shape(DrawToolShape(shape_geo), storage_elem)
-            self.storage_dict[tool_dia] = storage_elem
+                        if obj in self.selected:
+                            # remove the shape object from the selected shapes storage
+                            self.selected.remove(obj)
+                        else:
+                            # add the shape object to the selected shapes storage
+                            self.selected.append(obj)
+        else:
+            # clear the selection shapes storage
+            self.selected = []
+            # then add to the selection shapes storage the shapes that are included (touched) by the selection rectangle
+            for storage in self.storage_dict:
+                for obj in self.storage_dict[storage].get_objects():
+                    if (sel_type is True and poly_selection.contains(obj.geo)) or \
+                            (sel_type is False and poly_selection.intersects(obj.geo)):
+                        self.selected.append(obj)
 
-        # slots
-        for tool_dia in self.slot_points_edit:
-            buf_value = float(tool_dia) / 2
-            for elem_dict in self.slot_points_edit[tool_dia]:
+        try:
+            self.e_ui.tools_table_exc.cellPressed.disconnect()
+        except Exception:
+            pass
 
-                line_geo = LineString([elem_dict['start'], elem_dict['stop']])
-                shape_geo = line_geo.buffer(buf_value)
+        # first deselect all rows (tools) in the Tools Table
+        self.e_ui.tools_table_exc.clearSelection()
+        # and select the rows (tools) in the tool table according to the diameter(s) of the selected shape(s)
+        self.e_ui.tools_table_exc.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
+        for storage in self.storage_dict:
+            for shape_s in self.selected:
+                if shape_s in self.storage_dict[storage].get_objects():
+                    for key_tool_nr in self.tool2tooldia:
+                        if self.tool2tooldia[key_tool_nr] == storage:
+                            row_to_sel = key_tool_nr - 1
+                            # item = self.e_ui.tools_table_exc.item(row_to_sel, 1)
+                            # self.e_ui.tools_table_exc.setCurrentItem(item)
+                            # item.setSelected(True)
 
-                if tool_dia not in self.storage_dict:
-                    storage_elem = AppGeoEditor.make_storage()
-                    self.storage_dict[tool_dia] = storage_elem
+                            # if the row to be selected is not already in the selected rows then select it
+                            # otherwise don't do it as it seems that we have a toggle effect
+                            if row_to_sel not in set(index.row() for index in self.e_ui.tools_table_exc.selectedIndexes()):
+                                self.e_ui.tools_table_exc.selectRow(row_to_sel)
+                            self.last_tool_selected = int(key_tool_nr)
 
-                if shape_geo is not None:
-                    self.add_exc_shape(DrawToolShape(shape_geo), self.storage_dict[tool_dia])
+        self.e_ui.tools_table_exc.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
 
+        self.e_ui.tools_table_exc.cellPressed.connect(self.on_row_selected)
         self.replot()
 
-        # add a first tool in the Tool Table but only if the Excellon Object is empty
-        if not self.tool2tooldia:
-            self.on_tool_add(tooldia=float('%.*f' % (self.decimals,
-                                                     float(self.app.defaults['excellon_editor_newdia']))))
-
-    def update_fcexcellon(self, exc_obj):
-        """
-        Create a new Excellon object that contain the edited content of the source Excellon object
-
-        :param exc_obj: ExcellonObject
-        :return: None
+    def on_canvas_move(self, event):
         """
+        Called on 'mouse_move' event.
+        It updates the mouse cursor if the grid snapping is ON.
+        It decide if we have a mouse drag and if it is done with the right mouse click. Then it passes this info to a
+        class object which is used in the "mouse_release" handler to decide if to pop-up the context menu or not.
+        It draws utility_geometry for the Editor tools.
+        Update the position labels from status bar.
+        Decide if we have a right to left or a left to right mouse drag with left mouse button and call a function
+        that will draw a selection shape on canvas.
 
-        # this dictionary will contain tooldia's as keys and a list of coordinates tuple as values
-        # the values of this dict are coordinates of the holes (drills)
-        edited_points = {}
+        event.pos have canvas screen coordinates
 
+        :param event:       Event object dispatched by VisPy SceneCavas
+        :return:            None
         """
-         - this dictionary will contain tooldia's as keys and a list of another dicts as values
-         - the dict element of the list has the structure
-         ================  ====================================
-        Key               Value
-        ================  ====================================
-        start             (Shapely.Point) Start point of the slot
-        stop              (Shapely.Point) Stop point of the slot
-        ================  ====================================
-        """
-        edited_slot_points = {}
 
-        for storage_tooldia in self.storage_dict:
-            for x in self.storage_dict[storage_tooldia].get_objects():
-                if isinstance(x.geo, MultiLineString):
-                    # all x.geo in self.storage_dict[storage] are MultiLinestring objects for drills
-                    # each MultiLineString is made out of Linestrings
-                    # select first Linestring object in the current MultiLineString
-                    first_linestring = x.geo[0]
-                    # get it's coordinates
-                    first_linestring_coords = first_linestring.coords
-                    x_coord = first_linestring_coords[0][0] + (float(first_linestring.length / 2))
-                    y_coord = first_linestring_coords[0][1]
+        if self.app.is_legacy is False:
+            event_pos = event.pos
+            event_is_dragging = event.is_dragging
+            right_button = 2
+        else:
+            event_pos = (event.xdata, event.ydata)
+            event_is_dragging = self.app.plotcanvas.is_dragging
+            right_button = 3
 
-                    # create a tuple with the coordinates (x, y) and add it to the list that is the value of the
-                    # edited_points dictionary
-                    point = (x_coord, y_coord)
-                    if storage_tooldia not in edited_points:
-                        edited_points[storage_tooldia] = [point]
-                    else:
-                        edited_points[storage_tooldia].append(point)
-                elif isinstance(x.geo, Polygon):
-                    # create a tuple with the points (start, stop) and add it to the list that is the value of the
-                    # edited_points dictionary
+        pos = self.canvas.translate_coords(event_pos)
+        event.xdata, event.ydata = pos[0], pos[1]
 
-                    # first determine the start and stop coordinates for the slot knowing the geometry and the tool
-                    # diameter
-                    radius = float(storage_tooldia) / 2
-                    radius = radius - 0.0000001
+        self.x = event.xdata
+        self.y = event.ydata
 
-                    poly = x.geo
-                    poly = poly.buffer(-radius)
+        self.app.ui.popMenu.mouse_is_panning = False
 
-                    if not poly.is_valid or poly.is_empty:
-                        print("Polygon not valid: %s" % str(poly.wkt))
-                        continue
+        # if the RMB is clicked and mouse is moving over plot then 'panning_action' is True
+        if event.button == right_button and event_is_dragging == 1:
+            self.app.ui.popMenu.mouse_is_panning = True
+            return
 
-                    xmin, ymin, xmax, ymax = poly.bounds
-                    line_one = LineString([(xmin, ymin), (xmax, ymax)]).intersection(poly).length
-                    line_two = LineString([(xmin, ymax), (xmax, ymin)]).intersection(poly).length
+        try:
+            x = float(event.xdata)
+            y = float(event.ydata)
+        except TypeError:
+            return
 
-                    if line_one < line_two:
-                        point_elem = {
-                            "start": (xmin, ymax),
-                            "stop": (xmax, ymin)
-                        }
-                    else:
-                        point_elem = {
-                            "start": (xmin, ymin),
-                            "stop": (xmax, ymax)
-                        }
+        if self.active_tool is None:
+            return
 
-                    if storage_tooldia not in edited_slot_points:
-                        edited_slot_points[storage_tooldia] = [point_elem]
-                    else:
-                        edited_slot_points[storage_tooldia].append(point_elem)
+        # ## Snap coordinates
+        if self.app.grid_status():
+            x, y = self.app.geo_editor.snap(x, y)
 
-        # recreate the drills and tools to be added to the new Excellon edited object
-        # first, we look in the tool table if one of the tool diameters was changed then
-        # append that a tuple formed by (old_dia, edited_dia) to a list
-        changed_key = set()
-        for initial_dia in self.olddia_newdia:
-            edited_dia = self.olddia_newdia[initial_dia]
-            if edited_dia != initial_dia:
-                # for drills
-                for old_dia in edited_points:
-                    if old_dia == initial_dia:
-                        changed_key.add((old_dia, edited_dia))
-                # for slots
-                for old_dia in edited_slot_points:
-                    if old_dia == initial_dia:
-                        changed_key.add((old_dia, edited_dia))
-            # if the initial_dia is not in edited_points it means it is a new tool with no drill points
-            # (and we have to add it)
-            # because in case we have drill points it will have to be already added in edited_points
-            # if initial_dia not in edited_points.keys():
-            #     edited_points[initial_dia] = []
+            # Update cursor
+            self.app.app_cursor.set_data(np.asarray([(x, y)]), symbol='++', edge_color=self.app.cursor_color_3D,
+                                         edge_width=self.app.defaults["global_cursor_width"],
+                                         size=self.app.defaults["global_cursor_size"])
 
-        for el in changed_key:
-            edited_points[el[1]] = edited_points.pop(el[0])
-            edited_slot_points[el[1]] = edited_slot_points.pop(el[0])
+        self.snap_x = x
+        self.snap_y = y
 
-        # Let's sort the edited_points dictionary by keys (diameters) and store the result in a zipped list
-        # ordered_edited_points is a ordered list of tuples;
-        # element[0] of the tuple is the diameter and
-        # element[1] of the tuple is a list of coordinates (a tuple themselves)
-        ordered_edited_points = sorted(zip(edited_points.keys(), edited_points.values()))
+        if self.pos is None:
+            self.pos = (0, 0)
+        self.app.dx = x - self.pos[0]
+        self.app.dy = y - self.pos[1]
 
-        current_tool = 0
-        for tool_dia in ordered_edited_points:
-            current_tool += 1
+        # # update the position label in the infobar since the APP mouse event handlers are disconnected
+        self.app.ui.position_label.setText("&nbsp;<b>X</b>: %.4f&nbsp;&nbsp;   "
+                                           "<b>Y</b>: %.4f&nbsp;" % (x, y))
+        # # update the reference position label in the infobar since the APP mouse event handlers are disconnected
+        self.app.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
+                                               "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (self.app.dx, self.app.dy))
 
-            # create the self.tools for the new Excellon object (the one with edited content)
-            if current_tool not in self.new_tools:
-                self.new_tools[current_tool] = {}
-            self.new_tools[current_tool]['tooldia'] = float(tool_dia[0])
+        units = self.app.defaults["units"].lower()
+        self.app.plotcanvas.text_hud.text = \
+            'Dx:\t{:<.4f} [{:s}]\nDy:\t{:<.4f} [{:s}]\n\nX:  \t{:<.4f} [{:s}]\nY:  \t{:<.4f} [{:s}]'.format(
+                self.app.dx, units, self.app.dy, units, x, units, y, units)
 
-            # add in self.tools the 'solid_geometry' key, the value (a list) is populated below
-            self.new_tools[current_tool]['solid_geometry'] = []
+        # ## Utility geometry (animated)
+        self.update_utility_geometry(data=(x, y))
 
-            # create the self.drills for the new Excellon object (the one with edited content)
-            for point in tool_dia[1]:
-                try:
-                    self.new_tools[current_tool]['drills'].append(Point(point))
-                except KeyError:
-                    self.new_tools[current_tool]['drills'] = [Point(point)]
+        # ## Selection area on canvas section # ##
+        if event_is_dragging == 1 and event.button == 1:
+            # I make an exception for FCDrillAdd and FCDrillArray because clicking and dragging while making regions
+            # can create strange issues. Also for FCSlot and FCSlotArray
+            if isinstance(self.active_tool, FCDrillAdd) or isinstance(self.active_tool, FCDrillArray) or \
+                    isinstance(self.active_tool, FCSlot) or isinstance(self.active_tool, FCSlotArray):
+                self.app.selection_type = None
+            else:
+                dx = pos[0] - self.pos[0]
+                self.app.delete_selection_shape()
+                if dx < 0:
+                    self.app.draw_moving_selection_shape((self.pos[0], self.pos[1]), (x, y),
+                                                         color=self.app.defaults["global_alt_sel_line"],
+                                                         face_color=self.app.defaults['global_alt_sel_fill'])
+                    self.app.selection_type = False
+                else:
+                    self.app.draw_moving_selection_shape((self.pos[0], self.pos[1]), (x, y))
+                    self.app.selection_type = True
+        else:
+            self.app.selection_type = None
 
-                # repopulate the 'solid_geometry' for each tool
-                poly = Point(point).buffer(float(tool_dia[0]) / 2.0, int(int(exc_obj.geo_steps_per_circle) / 4))
-                self.new_tools[current_tool]['solid_geometry'].append(poly)
+        # Update cursor
+        self.app.app_cursor.set_data(np.asarray([(x, y)]), symbol='++', edge_color=self.app.cursor_color_3D,
+                                     edge_width=self.app.defaults["global_cursor_width"],
+                                     size=self.app.defaults["global_cursor_size"])
 
-        ordered_edited_slot_points = sorted(zip(edited_slot_points.keys(), edited_slot_points.values()))
-        for tool_dia in ordered_edited_slot_points:
+    def update_utility_geometry(self, data):
+        # ### Utility geometry (animated) ###
+        geo = self.active_tool.utility_geometry(data=data)
+        if isinstance(geo, DrawToolShape) and geo.geo is not None:
+            # Remove any previous utility shape
+            self.tool_shape.clear(update=True)
+            self.draw_utility_geometry(geo=geo)
 
-            tool_exist_flag = False
-            for tool in self.new_tools:
-                if tool_dia[0] == self.new_tools[tool]["tooldia"]:
-                    current_tool = tool
-                    tool_exist_flag = True
-                    break
+    def on_canvas_key_release(self, event):
+        self.key = None
 
-            if tool_exist_flag is False:
-                current_tool += 1
+    def draw_utility_geometry(self, geo):
+        # Add the new utility shape
+        try:
+            # this case is for the Font Parse
+            for el in list(geo.geo):
+                if type(el) == MultiPolygon:
+                    for poly in el:
+                        self.tool_shape.add(
+                            shape=poly,
+                            color=(self.app.defaults["global_draw_color"] + '80'),
+                            update=False,
+                            layer=0,
+                            tolerance=None
+                        )
+                elif type(el) == MultiLineString:
+                    for linestring in el:
+                        self.tool_shape.add(
+                            shape=linestring,
+                            color=(self.app.defaults["global_draw_color"] + '80'),
+                            update=False,
+                            layer=0,
+                            tolerance=None
+                        )
+                else:
+                    self.tool_shape.add(
+                        shape=el,
+                        color=(self.app.defaults["global_draw_color"] + '80'),
+                        update=False,
+                        layer=0,
+                        tolerance=None
+                    )
+        except TypeError:
+            self.tool_shape.add(
+                shape=geo.geo, color=(self.app.defaults["global_draw_color"] + '80'),
+                update=False, layer=0, tolerance=None)
+        self.tool_shape.redraw()
 
-                # create the self.tools for the new Excellon object (the one with edited content)
-                if current_tool not in self.new_tools:
-                    self.new_tools[current_tool] = {}
-                self.new_tools[current_tool]['tooldia'] = float(tool_dia[0])
+    def replot(self):
+        self.plot_all()
 
-                # add in self.tools the 'solid_geometry' key, the value (a list) is populated below
-                self.new_tools[current_tool]['solid_geometry'] = []
+    def plot_all(self):
+        """
+        Plots all shapes in the editor.
 
-            # create the self.slots for the new Excellon object (the one with edited content)
-            for coord_dict in tool_dia[1]:
-                slot = (
-                    Point(coord_dict['start']),
-                    Point(coord_dict['stop'])
-                )
-                try:
-                    self.new_tools[current_tool]['slots'].append(slot)
-                except KeyError:
-                    self.new_tools[current_tool]['slots'] = [slot]
+        :return:    None
+        :rtype:     None
+        """
 
-                # repopulate the 'solid_geometry' for each tool
-                poly = LineString([coord_dict['start'], coord_dict['stop']]).buffer(
-                    float(tool_dia[0]) / 2.0, int(int(exc_obj.geo_steps_per_circle) / 4)
-                )
-                self.new_tools[current_tool]['solid_geometry'].append(poly)
+        self.shapes.clear(update=True)
 
-        if self.is_modified is True:
-            if "_edit" in self.edited_obj_name:
-                try:
-                    idd = int(self.edited_obj_name[-1]) + 1
-                    self.edited_obj_name = self.edited_obj_name[:-1] + str(idd)
-                except ValueError:
-                    self.edited_obj_name += "_1"
-            else:
-                self.edited_obj_name += "_edit"
+        for storage in self.storage_dict:
+            for shape_plus in self.storage_dict[storage].get_objects():
+                if shape_plus.geo is None:
+                    continue
 
-        self.app.worker_task.emit({'fcn': self.new_edited_excellon,
-                                   'params': [self.edited_obj_name,
-                                              self.new_drills,
-                                              self.new_slots,
-                                              self.new_tools]})
+                if shape_plus in self.selected:
+                    self.plot_shape(geometry=shape_plus.geo, color=self.app.defaults['global_sel_draw_color'] + 'FF',
+                                    linewidth=2)
+                    continue
+                self.plot_shape(geometry=shape_plus.geo, color=self.app.defaults['global_draw_color'] + 'FF')
 
-        return self.edited_obj_name
+        for shape_form in self.utility:
+            self.plot_shape(geometry=shape_form.geo, linewidth=1)
+            continue
 
-    @staticmethod
-    def update_options(obj):
-        try:
-            if not obj.options:
-                obj.options = {}
-                obj.options['xmin'] = 0
-                obj.options['ymin'] = 0
-                obj.options['xmax'] = 0
-                obj.options['ymax'] = 0
-                return True
-            else:
-                return False
-        except AttributeError:
-            obj.options = {}
-            return True
+        self.shapes.redraw()
 
-    def new_edited_excellon(self, outname, n_drills, n_slots, n_tools):
+    def plot_shape(self, geometry=None, color='0x000000FF', linewidth=1):
         """
-        Creates a new Excellon object for the edited Excellon. Thread-safe.
-
-        :param outname:     Name of the resulting object. None causes the
-                            name to be that of the file.
-        :type outname:      str
+        Plots a geometric object or list of objects without rendering. Plotted objects
+        are returned as a list. This allows for efficient/animated rendering.
 
-        :param n_drills:    The new Drills storage
-        :param n_slots:     The new Slots storage
-        :param n_tools:     The new Tools storage
-        :return:            None
+        :param geometry:    Geometry to be plotted (Any Shapely.geom kind or list of such)
+        :param color:       Shape color
+        :param linewidth:   Width of lines in # of pixels.
+        :return:            List of plotted elements.
         """
+        plot_elements = []
 
-        self.app.log.debug("Update the Excellon object with edited content. Source is %s" %
-                           self.exc_obj.options['name'])
+        if geometry is None:
+            geometry = self.active_tool.geometry
 
-        new_drills = n_drills
-        new_slots = n_slots
-        new_tools = n_tools
+        try:
+            for geo in geometry:
+                plot_elements += self.plot_shape(geometry=geo, color=color, linewidth=linewidth)
 
-        # How the object should be initialized
-        def obj_init(excellon_obj, app_obj):
+        # ## Non-iterable
+        except TypeError:
+            # ## DrawToolShape
+            if isinstance(geometry, DrawToolShape):
+                plot_elements += self.plot_shape(geometry=geometry.geo, color=color, linewidth=linewidth)
 
-            excellon_obj.drills = deepcopy(new_drills)
-            excellon_obj.tools = deepcopy(new_tools)
-            excellon_obj.slots = deepcopy(new_slots)
+            # ## Polygon: Descend into exterior and each interior.
+            if type(geometry) == Polygon:
+                plot_elements += self.plot_shape(geometry=geometry.exterior, color=color, linewidth=linewidth)
+                plot_elements += self.plot_shape(geometry=geometry.interiors, color=color, linewidth=linewidth)
 
-            excellon_obj.options['name'] = outname
+            if type(geometry) == LineString or type(geometry) == LinearRing:
+                plot_elements.append(self.shapes.add(shape=geometry, color=color, layer=0, tolerance=self.tolerance))
 
-            # add a 'data' dict for each tool with the default values
-            for tool in excellon_obj.tools:
-                excellon_obj.tools[tool]['data'] = {}
-                excellon_obj.tools[tool]['data'].update(deepcopy(self.data_defaults))
+            if type(geometry) == Point:
+                pass
 
-            try:
-                excellon_obj.create_geometry()
-            except KeyError:
-                self.app.inform.emit('[ERROR_NOTCL] %s' %
-                                     _("There are no Tools definitions in the file. Aborting Excellon creation.")
-                                     )
-            except Exception:
-                msg = '[ERROR] %s' % \
-                      _("An internal error has ocurred. See Shell.\n")
-                msg += traceback.format_exc()
-                app_obj.inform.emit(msg)
-                return
+        return plot_elements
 
-        with self.app.proc_container.new(_("Creating Excellon.")):
+    def on_shape_complete(self):
+        # Add shape
+        self.add_shape(self.active_tool.geometry)
 
-            try:
-                edited_obj = self.app.app_obj.new_object("excellon", outname, obj_init)
-                edited_obj.source_file = self.app.export_excellon(obj_name=edited_obj.options['name'],
-                                                                  local_use=edited_obj,
-                                                                  filename=None,
-                                                                  use_thread=False)
-            except Exception as e:
-                self.deactivate()
-                log.error("Error on Edited object creation: %s" % str(e))
-                return
+        # Remove any utility shapes
+        self.delete_utility_geometry()
+        self.tool_shape.clear(update=True)
 
-            self.deactivate()
-            self.app.inform.emit('[success] %s' % _("Excellon editing finished."))
+        # Replot and reset tool.
+        self.replot()
+        # self.active_tool = type(self.active_tool)(self)
 
-    def on_tool_select(self, tool):
+    def get_selected(self):
         """
-        Behavior of the toolbar. Tool initialization.
+        Returns list of shapes that are selected in the editor.
 
-        :rtype : None
+        :return: List of shapes.
         """
-        current_tool = tool
+        return self.selected
 
-        self.app.log.debug("on_tool_select('%s')" % tool)
+    def delete_selected(self):
+        temp_ref = [s for s in self.selected]
+        for shape_sel in temp_ref:
+            self.delete_shape(shape_sel)
 
-        if self.last_tool_selected is None and current_tool != 'drill_select':
-            # self.draw_app.select_tool('drill_select')
-            self.complete = True
-            current_tool = 'drill_select'
-            self.app.inform.emit('[WARNING_NOTCL] %s' %
-                                 _("Cancelled. There is no Tool/Drill selected"))
+        self.selected = []
+        self.build_ui()
+        self.app.inform.emit('[success] %s' % _("Done. Drill(s) deleted."))
+
+    def delete_shape(self, del_shape):
+        self.is_modified = True
+
+        if del_shape in self.utility:
+            self.utility.remove(del_shape)
+            return
+
+        for storage in self.storage_dict:
+            # try:
+            #     self.storage_dict[storage].remove(shape)
+            # except:
+            #     pass
+            if del_shape in self.storage_dict[storage].get_objects():
+                if isinstance(del_shape.geo, MultiLineString):
+                    self.storage_dict[storage].remove(del_shape)
+                    # a hack to make the tool_table display less drills per diameter
+                    # self.points_edit it's only useful first time when we load the data into the storage
+                    # but is still used as referecen when building tool_table in self.build_ui()
+                    # the number of drills displayed in column 2 is just a len(self.points_edit) therefore
+                    # deleting self.points_edit elements (doesn't matter who but just the number)
+                    # solved the display issue.
+                    del self.points_edit[storage][0]
+                else:
+                    self.storage_dict[storage].remove(del_shape)
+                    del self.slot_points_edit[storage][0]
 
-        # This is to make the group behave as radio group
-        if current_tool in self.tools_exc:
-            if self.tools_exc[current_tool]["button"].isChecked():
-                self.app.log.debug("%s is checked." % current_tool)
-                for t in self.tools_exc:
-                    if t != current_tool:
-                        self.tools_exc[t]["button"].setChecked(False)
+        if del_shape in self.selected:
+            self.selected.remove(del_shape)
 
-                # this is where the Editor toolbar classes (button's) are instantiated
-                self.active_tool = self.tools_exc[current_tool]["constructor"](self)
-                # self.app.inform.emit(self.active_tool.start_msg)
-            else:
-                self.app.log.debug("%s is NOT checked." % current_tool)
-                for t in self.tools_exc:
-                    self.tools_exc[t]["button"].setChecked(False)
+    def delete_utility_geometry(self):
+        for_deletion = [util_shape for util_shape in self.utility]
+        for util_shape in for_deletion:
+            self.delete_shape(util_shape)
 
-                self.select_tool('drill_select')
-                self.active_tool = FCDrillSelect(self)
+        self.tool_shape.clear(update=True)
+        self.tool_shape.redraw()
 
-    def on_row_selected(self, row, col):
-        if col == 0:
-            key_modifier = QtWidgets.QApplication.keyboardModifiers()
-            if self.app.defaults["global_mselect_key"] == 'Control':
-                modifier_to_use = Qt.ControlModifier
-            else:
-                modifier_to_use = Qt.ShiftModifier
+    def on_delete_btn(self):
+        self.delete_selected()
+        self.replot()
 
-            if key_modifier == modifier_to_use:
-                pass
-            else:
-                self.selected = []
+    def select_tool(self, toolname):
+        """
+        Selects a drawing tool. Impacts the object and appGUI.
 
-            try:
-                selected_dia = self.tool2tooldia[self.tools_table_exc.currentRow() + 1]
-                self.last_tool_selected = int(self.tools_table_exc.currentRow()) + 1
-                for obj in self.storage_dict[selected_dia].get_objects():
-                    self.selected.append(obj)
-            except Exception as e:
-                self.app.log.debug(str(e))
+        :param toolname:    Name of the tool.
+        :return:            None
+        """
+        self.tools_exc[toolname]["button"].setChecked(True)
+        self.on_tool_select(toolname)
 
-            self.replot()
+    def set_selected(self, sel_shape):
 
-    # def toolbar_tool_toggle(self, key):
-    #     self.options[key] = self.sender().isChecked()
-    #     if self.options[key] is True:
-    #         return 1
-    #     else:
-    #         return 0
+        # Remove and add to the end.
+        if sel_shape in self.selected:
+            self.selected.remove(sel_shape)
 
-    def on_canvas_click(self, event):
-        """
-        event.x and .y have canvas coordinates
-        event.xdata and .ydata have plot coordinates
+        self.selected.append(sel_shape)
 
-        :param event: Event object dispatched by VisPy
-        :return: None
-        """
-        if self.app.is_legacy is False:
-            event_pos = event.pos
-            # event_is_dragging = event.is_dragging
-            # right_button = 2
+    def set_unselected(self, unsel_shape):
+        if unsel_shape in self.selected:
+            self.selected.remove(unsel_shape)
+
+    def on_array_type_combo(self):
+        if self.e_ui.array_type_combo.currentIndex() == 0:
+            self.e_ui.array_circular_frame.hide()
+            self.e_ui.array_linear_frame.show()
         else:
-            event_pos = (event.xdata, event.ydata)
-            # event_is_dragging = self.app.plotcanvas.is_dragging
-            # right_button = 3
+            self.delete_utility_geometry()
+            self.e_ui.array_circular_frame.show()
+            self.e_ui.array_linear_frame.hide()
+            self.app.inform.emit(_("Click on the circular array Center position"))
 
-        self.pos = self.canvas.translate_coords(event_pos)
+    def on_slot_array_type_combo(self):
+        if self.e_ui.slot_array_type_combo.currentIndex() == 0:
+            self.e_ui.slot_array_circular_frame.hide()
+            self.e_ui.slot_array_linear_frame.show()
+        else:
+            self.delete_utility_geometry()
+            self.e_ui.slot_array_circular_frame.show()
+            self.e_ui.slot_array_linear_frame.hide()
+            self.app.inform.emit(_("Click on the circular array Center position"))
 
-        if self.app.grid_status():
-            self.pos = self.app.geo_editor.snap(self.pos[0], self.pos[1])
+    def on_linear_angle_radio(self):
+        val = self.e_ui.drill_axis_radio.get_value()
+        if val == 'A':
+            self.e_ui.linear_angle_spinner.show()
+            self.e_ui.linear_angle_label.show()
         else:
-            self.pos = (self.pos[0], self.pos[1])
+            self.e_ui.linear_angle_spinner.hide()
+            self.e_ui.linear_angle_label.hide()
 
-        if event.button == 1:
-            self.app.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
-                                                   "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (0, 0))
+    def on_slot_array_linear_angle_radio(self):
+        val = self.e_ui.slot_array_axis_radio.get_value()
+        if val == 'A':
+            self.e_ui.slot_array_linear_angle_spinner.show()
+            self.e_ui.slot_array_linear_angle_label.show()
+        else:
+            self.e_ui.slot_array_linear_angle_spinner.hide()
+            self.e_ui.slot_array_linear_angle_label.hide()
 
-            # Selection with left mouse button
-            if self.active_tool is not None and event.button == 1:
-                # Dispatch event to active_tool
-                # msg = self.active_tool.click(self.app.geo_editor.snap(event.xdata, event.ydata))
-                self.active_tool.click(self.app.geo_editor.snap(self.pos[0], self.pos[1]))
+    def on_slot_angle_radio(self):
+        val = self.e_ui.slot_axis_radio.get_value()
+        if val == 'A':
+            self.e_ui.slot_angle_spinner.show()
+            self.e_ui.slot_angle_label.show()
+        else:
+            self.e_ui.slot_angle_spinner.hide()
+            self.e_ui.slot_angle_label.hide()
 
-                # If it is a shape generating tool
-                if isinstance(self.active_tool, FCShapeTool) and self.active_tool.complete:
-                    if self.current_storage is not None:
-                        self.on_exc_shape_complete(self.current_storage)
-                        self.build_ui()
+    def exc_add_drill(self):
+        self.select_tool('drill_add')
+        return
 
-                    # MS: always return to the Select Tool if modifier key is not pressed
-                    # else return to the current tool
-                    key_modifier = QtWidgets.QApplication.keyboardModifiers()
-                    if self.app.defaults["global_mselect_key"] == 'Control':
-                        modifier_to_use = Qt.ControlModifier
-                    else:
-                        modifier_to_use = Qt.ShiftModifier
+    def exc_add_drill_array(self):
+        self.select_tool('drill_array')
+        return
 
-                    # if modifier key is pressed then we add to the selected list the current shape but if it's already
-                    # in the selected list, we removed it. Therefore first click selects, second deselects.
-                    if key_modifier == modifier_to_use:
-                        self.select_tool(self.active_tool.name)
-                    else:
-                        # return to Select tool but not for FCDrillAdd or FCSlot
-                        if isinstance(self.active_tool, FCDrillAdd) or isinstance(self.active_tool, FCSlot):
-                            self.select_tool(self.active_tool.name)
-                        else:
-                            self.select_tool("drill_select")
-                        return
+    def exc_add_slot(self):
+        self.select_tool('slot_add')
+        return
 
-                if isinstance(self.active_tool, FCDrillSelect):
-                    # self.app.log.debug("Replotting after click.")
-                    self.replot()
-            else:
-                self.app.log.debug("No active tool to respond to click!")
+    def exc_add_slot_array(self):
+        self.select_tool('slot_array')
+        return
 
-    def on_exc_shape_complete(self, storage):
-        self.app.log.debug("on_shape_complete()")
+    def exc_resize_drills(self):
+        self.select_tool('drill_resize')
+        return
 
-        # Add shape
-        if type(storage) is list:
-            for item_storage in storage:
-                self.add_exc_shape(self.active_tool.geometry, item_storage)
-        else:
-            self.add_exc_shape(self.active_tool.geometry, storage)
+    def exc_copy_drills(self):
+        self.select_tool('drill_copy')
+        return
 
-        # Remove any utility shapes
-        self.delete_utility_geometry()
-        self.tool_shape.clear(update=True)
+    def exc_move_drills(self):
+        self.select_tool('drill_move')
+        return
 
-        # Replot and reset tool.
+    def on_slots_conversion(self):
+        # selected rows
+        selected_rows = set()
+        for it in self.e_ui.tools_table_exc.selectedItems():
+            selected_rows.add(it.row())
+
+        # convert a Polygon (slot) to a MultiLineString (drill)
+        def convert_slot2drill(geo_elem, tool_dia):
+            point = geo_elem.centroid
+            start_hor_line = ((point.x - (tool_dia / 2)), point.y)
+            stop_hor_line = ((point.x + (tool_dia / 2)), point.y)
+            start_vert_line = (point.x, (point.y - (tool_dia / 2)))
+            stop_vert_line = (point.x, (point.y + (tool_dia / 2)))
+            return MultiLineString([(start_hor_line, stop_hor_line), (start_vert_line, stop_vert_line)])
+
+        # temporary new storage: a dist with keys the tool diameter and values Rtree storage
+        new_storage_dict = {}
+
+        for row in selected_rows:
+            table_tooldia = self.dec_format(float(self.e_ui.tools_table_exc.item(row, 1).text()))
+            for dict_dia, geo_dict in self.storage_dict.items():
+                if self.dec_format(float(dict_dia)) == table_tooldia:
+                    storage_elem = AppGeoEditor.make_storage()
+                    for shape in geo_dict.get_objects():
+                        if isinstance(shape.geo, MultiLineString):
+                            # it's a drill just add it as it is to storage
+                            self.add_exc_shape(shape, storage_elem)
+                        if isinstance(shape.geo, Polygon):
+                            # it's a slot, convert drill to slot and then add it to storage
+                            new_shape = convert_slot2drill(shape.geo, table_tooldia)
+                            self.add_exc_shape(DrawToolShape(new_shape), storage_elem)
+
+                    new_storage_dict[table_tooldia] = storage_elem
+
+        self.storage_dict.update(new_storage_dict)
         self.replot()
-        # self.active_tool = type(self.active_tool)(self)
 
-    def add_exc_shape(self, shape, storage):
-        """
-        Adds a shape to a specified shape storage.
 
-        :param shape: Shape to be added.
-        :type shape: DrawToolShape
-        :param storage: object where to store the shapes
-        :return: None
-        """
-        # List of DrawToolShape?
-        if isinstance(shape, list):
-            for subshape in shape:
-                self.add_exc_shape(subshape, storage)
-            return
+class AppExcEditorUI:
+    def __init__(self, app):
+        self.app = app
 
-        assert isinstance(shape, DrawToolShape), \
-            "Expected a DrawToolShape, got %s" % str(type(shape))
+        # Number of decimals used by tools in this class
+        self.decimals = self.app.decimals
 
-        assert shape.geo is not None, \
-            "Shape object has empty geometry (None)"
+        # ## Current application units in Upper Case
+        self.units = self.app.defaults['units'].upper()
 
-        assert (isinstance(shape.geo, list) and len(shape.geo) > 0) or not isinstance(shape.geo, list), \
-            "Shape objects has empty geometry ([])"
+        self.exc_edit_widget = QtWidgets.QWidget()
+        # ## Box for custom widgets
+        # This gets populated in offspring implementations.
+        layout = QtWidgets.QVBoxLayout()
+        self.exc_edit_widget.setLayout(layout)
 
-        if isinstance(shape, DrawToolUtilityShape):
-            self.utility.append(shape)
-        else:
-            storage.insert(shape)  # TODO: Check performance
+        # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets
+        # this way I can hide/show the frame
+        self.drills_frame = QtWidgets.QFrame()
+        self.drills_frame.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self.drills_frame)
+        self.tools_box = QtWidgets.QVBoxLayout()
+        self.tools_box.setContentsMargins(0, 0, 0, 0)
+        self.drills_frame.setLayout(self.tools_box)
 
-    def add_shape(self, shape):
-        """
-        Adds a shape to the shape storage.
+        # ## Page Title box (spacing between children)
+        self.title_box = QtWidgets.QHBoxLayout()
+        self.tools_box.addLayout(self.title_box)
 
-        :param shape: Shape to be added.
-        :type shape: DrawToolShape
-        :return: None
-        """
+        # ## Page Title icon
+        pixmap = QtGui.QPixmap(self.app.resource_location + '/flatcam_icon32.png')
+        self.icon = QtWidgets.QLabel()
+        self.icon.setPixmap(pixmap)
+        self.title_box.addWidget(self.icon, stretch=0)
 
-        # List of DrawToolShape?
-        if isinstance(shape, list):
-            for subshape in shape:
-                self.add_shape(subshape)
-            return
+        # ## Title label
+        self.title_label = QtWidgets.QLabel("<font size=5><b>%s</b></font>" % _('Excellon Editor'))
+        self.title_label.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
+        self.title_box.addWidget(self.title_label, stretch=1)
 
-        assert isinstance(shape, DrawToolShape), \
-            "Expected a DrawToolShape, got %s" % type(shape)
+        # ## Object name
+        self.name_box = QtWidgets.QHBoxLayout()
+        self.tools_box.addLayout(self.name_box)
+        name_label = QtWidgets.QLabel(_("Name:"))
+        self.name_box.addWidget(name_label)
+        self.name_entry = FCEntry()
+        self.name_box.addWidget(self.name_entry)
 
-        assert shape.geo is not None, \
-            "Shape object has empty geometry (None)"
+        # ### Tools Drills ## ##
+        self.tools_table_label = QtWidgets.QLabel("<b>%s</b>" % _('Tools Table'))
+        self.tools_table_label.setToolTip(
+            _("Tools in this Excellon object\n"
+              "when are used for drilling.")
+        )
+        self.tools_box.addWidget(self.tools_table_label)
 
-        assert (isinstance(shape.geo, list) and len(shape.geo) > 0) or not isinstance(shape.geo, list), \
-            "Shape objects has empty geometry ([])"
+        self.tools_table_exc = FCTable()
+        # delegate = SpinBoxDelegate(units=self.units)
+        # self.e_ui.tools_table_exc.setItemDelegateForColumn(1, delegate)
 
-        if isinstance(shape, DrawToolUtilityShape):
-            self.utility.append(shape)
-        # else:
-        #     self.storage.insert(shape)
+        self.tools_box.addWidget(self.tools_table_exc)
 
-    def on_exc_click_release(self, event):
-        """
-        Handler of the "mouse_release" event.
-        It will pop-up the context menu on right mouse click unless there was a panning move (decided in the
-        "mouse_move" event handler) and only if the current tool is the Select tool.
-        It will 'close' a Editor tool if it is the case.
+        self.tools_table_exc.setColumnCount(4)
+        self.tools_table_exc.setHorizontalHeaderLabels(['#', _('Diameter'), 'D', 'S'])
+        self.tools_table_exc.setSortingEnabled(False)
+        self.tools_table_exc.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
 
-        :param event: Event object dispatched by VisPy SceneCavas
-        :return: None
-        """
+        separator_line = QtWidgets.QFrame()
+        separator_line.setFrameShape(QtWidgets.QFrame.HLine)
+        separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        self.tools_box.addWidget(separator_line)
 
-        if self.app.is_legacy is False:
-            event_pos = event.pos
-            # event_is_dragging = event.is_dragging
-            right_button = 2
-        else:
-            event_pos = (event.xdata, event.ydata)
-            # event_is_dragging = self.app.plotcanvas.is_dragging
-            right_button = 3
+        self.convert_slots_btn = FCButton('%s' % _("Convert Slots"))
+        self.convert_slots_btn.setToolTip(
+            _("Convert the slots in the selected tools to drills.")
+        )
+        self.tools_box.addWidget(self.convert_slots_btn)
 
-        pos_canvas = self.canvas.translate_coords(event_pos)
+        separator_line = QtWidgets.QFrame()
+        separator_line.setFrameShape(QtWidgets.QFrame.HLine)
+        separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        self.tools_box.addWidget(separator_line)
 
-        if self.app.grid_status():
-            pos = self.app.geo_editor.snap(pos_canvas[0], pos_canvas[1])
-        else:
-            pos = (pos_canvas[0], pos_canvas[1])
+        # ### Add a new Tool ## ##
+        self.addtool_label = QtWidgets.QLabel('<b>%s</b>' % _('Add/Delete Tool'))
+        self.addtool_label.setToolTip(
+            _("Add/Delete a tool to the tool list\n"
+              "for this Excellon object.")
+        )
+        self.tools_box.addWidget(self.addtool_label)
 
-        # if the released mouse button was RMB then test if it was a panning motion or not, if not it was a context
-        # canvas menu
-        try:
-            if event.button == right_button:  # right click
-                if self.app.ui.popMenu.mouse_is_panning is False:
-                    try:
-                        QtGui.QGuiApplication.restoreOverrideCursor()
-                    except Exception:
-                        pass
-                    if self.active_tool.complete is False and not isinstance(self.active_tool, FCDrillSelect):
-                        self.active_tool.complete = True
-                        self.in_action = False
-                        self.delete_utility_geometry()
-                        self.app.inform.emit('[success] %s' %
-                                             _("Done."))
-                        self.select_tool('drill_select')
-                    else:
-                        if isinstance(self.active_tool, FCDrillAdd):
-                            self.active_tool.complete = True
-                            self.in_action = False
-                            self.delete_utility_geometry()
-                            self.app.inform.emit('[success] %s' %
-                                                 _("Done."))
-                            self.select_tool('drill_select')
+        grid1 = QtWidgets.QGridLayout()
+        self.tools_box.addLayout(grid1)
+        grid1.setColumnStretch(0, 0)
+        grid1.setColumnStretch(1, 1)
 
-                        self.app.cursor = QtGui.QCursor()
-                        self.app.populate_cmenu_grids()
-                        self.app.ui.popMenu.popup(self.app.cursor.pos())
+        addtool_entry_lbl = QtWidgets.QLabel('%s:' % _('Tool Dia'))
+        addtool_entry_lbl.setToolTip(
+            _("Diameter for the new tool")
+        )
 
-        except Exception as e:
-            log.warning("AppExcEditor.on_exc_click_release() RMB click --> Error: %s" % str(e))
-            raise
+        hlay = QtWidgets.QHBoxLayout()
+        self.addtool_entry = FCDoubleSpinner()
+        self.addtool_entry.set_precision(self.decimals)
+        self.addtool_entry.set_range(0.0000, 9999.9999)
 
-        # if the released mouse button was LMB then test if we had a right-to-left selection or a left-to-right
-        # selection and then select a type of selection ("enclosing" or "touching")
-        try:
-            if event.button == 1:  # left click
-                if self.app.selection_type is not None:
-                    self.draw_selection_area_handler(self.pos, pos, self.app.selection_type)
-                    self.app.selection_type = None
+        hlay.addWidget(self.addtool_entry)
 
-                elif isinstance(self.active_tool, FCDrillSelect):
-                    self.active_tool.click_release((self.pos[0], self.pos[1]))
+        self.addtool_btn = QtWidgets.QPushButton(_('Add Tool'))
+        self.addtool_btn.setToolTip(
+            _("Add a new tool to the tool list\n"
+              "with the diameter specified above.")
+        )
+        self.addtool_btn.setFixedWidth(80)
+        hlay.addWidget(self.addtool_btn)
 
-                    # if there are selected objects then plot them
-                    if self.selected:
-                        self.replot()
-        except Exception as e:
-            log.warning("AppExcEditor.on_exc_click_release() LMB click --> Error: %s" % str(e))
-            raise
+        grid1.addWidget(addtool_entry_lbl, 0, 0)
+        grid1.addLayout(hlay, 0, 1)
 
-    def draw_selection_area_handler(self, start, end, sel_type):
-        """
-        This function is called whenever we have a left mouse click release and only we have a left mouse click drag,
-        be it from left to right or from right to left. The direction of the drag is decided in the "mouse_move"
-        event handler.
-        Pressing a modifier key (eg. Ctrl, Shift or Alt) will change the behavior of the selection.
+        grid2 = QtWidgets.QGridLayout()
+        self.tools_box.addLayout(grid2)
 
-        Depending on which tool belongs the selected shapes, the corresponding rows in the Tools Table are selected or
-        deselected.
+        self.deltool_btn = QtWidgets.QPushButton(_('Delete Tool'))
+        self.deltool_btn.setToolTip(
+            _("Delete a tool in the tool list\n"
+              "by selecting a row in the tool table.")
+        )
+        grid2.addWidget(self.deltool_btn, 0, 1)
 
-        :param start: mouse position when the selection LMB click was done
-        :param end: mouse position when the left mouse button is released
-        :param sel_type: if True it's a left to right selection (enclosure), if False it's a 'touch' selection
-        :return:
-        """
+        # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets
+        # this way I can hide/show the frame
+        self.resize_frame = QtWidgets.QFrame()
+        self.resize_frame.setContentsMargins(0, 0, 0, 0)
+        self.tools_box.addWidget(self.resize_frame)
+        self.resize_box = QtWidgets.QVBoxLayout()
+        self.resize_box.setContentsMargins(0, 0, 0, 0)
+        self.resize_frame.setLayout(self.resize_box)
 
-        start_pos = (start[0], start[1])
-        end_pos = (end[0], end[1])
-        poly_selection = Polygon([start_pos, (end_pos[0], start_pos[1]), end_pos, (start_pos[0], end_pos[1])])
-        modifiers = None
+        # ### Resize a  drill ## ##
+        self.emptyresize_label = QtWidgets.QLabel('')
+        self.resize_box.addWidget(self.emptyresize_label)
 
-        # delete the selection shape that was just drawn, we no longer need it
-        self.app.delete_selection_shape()
+        self.drillresize_label = QtWidgets.QLabel('<b>%s</b>' % _("Resize Drill(s)"))
+        self.drillresize_label.setToolTip(
+            _("Resize a drill or a selection of drills.")
+        )
+        self.resize_box.addWidget(self.drillresize_label)
 
-        # detect if a modifier key was pressed while the left mouse button was released
-        self.modifiers = QtWidgets.QApplication.keyboardModifiers()
-        if self.modifiers == QtCore.Qt.ShiftModifier:
-            modifiers = 'Shift'
-        elif self.modifiers == QtCore.Qt.ControlModifier:
-            modifiers = 'Control'
+        grid3 = QtWidgets.QGridLayout()
+        self.resize_box.addLayout(grid3)
 
-        if modifiers == self.app.defaults["global_mselect_key"]:
-            for storage in self.storage_dict:
-                for obj in self.storage_dict[storage].get_objects():
-                    if (sel_type is True and poly_selection.contains(obj.geo)) or \
-                            (sel_type is False and poly_selection.intersects(obj.geo)):
+        res_entry_lbl = QtWidgets.QLabel('%s:' % _('Resize Dia'))
+        res_entry_lbl.setToolTip(
+            _("Diameter to resize to.")
+        )
+        grid3.addWidget(res_entry_lbl, 0, 0)
 
-                        if obj in self.selected:
-                            # remove the shape object from the selected shapes storage
-                            self.selected.remove(obj)
-                        else:
-                            # add the shape object to the selected shapes storage
-                            self.selected.append(obj)
-        else:
-            # clear the selection shapes storage
-            self.selected = []
-            # then add to the selection shapes storage the shapes that are included (touched) by the selection rectangle
-            for storage in self.storage_dict:
-                for obj in self.storage_dict[storage].get_objects():
-                    if (sel_type is True and poly_selection.contains(obj.geo)) or \
-                            (sel_type is False and poly_selection.intersects(obj.geo)):
-                        self.selected.append(obj)
+        hlay2 = QtWidgets.QHBoxLayout()
+        self.resdrill_entry = FCDoubleSpinner()
+        self.resdrill_entry.set_precision(self.decimals)
+        self.resdrill_entry.set_range(0.0000, 9999.9999)
 
-        try:
-            self.tools_table_exc.cellPressed.disconnect()
-        except Exception:
-            pass
+        hlay2.addWidget(self.resdrill_entry)
 
-        # first deselect all rows (tools) in the Tools Table
-        self.tools_table_exc.clearSelection()
-        # and select the rows (tools) in the tool table according to the diameter(s) of the selected shape(s)
-        self.tools_table_exc.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
-        for storage in self.storage_dict:
-            for shape_s in self.selected:
-                if shape_s in self.storage_dict[storage].get_objects():
-                    for key_tool_nr in self.tool2tooldia:
-                        if self.tool2tooldia[key_tool_nr] == storage:
-                            row_to_sel = key_tool_nr - 1
-                            # item = self.tools_table_exc.item(row_to_sel, 1)
-                            # self.tools_table_exc.setCurrentItem(item)
-                            # item.setSelected(True)
+        self.resize_btn = QtWidgets.QPushButton(_('Resize'))
+        self.resize_btn.setToolTip(
+            _("Resize drill(s)")
+        )
+        self.resize_btn.setFixedWidth(80)
+        hlay2.addWidget(self.resize_btn)
+        grid3.addLayout(hlay2, 0, 1)
 
-                            # if the row to be selected is not already in the selected rows then select it
-                            # otherwise don't do it as it seems that we have a toggle effect
-                            if row_to_sel not in set(index.row() for index in self.tools_table_exc.selectedIndexes()):
-                                self.tools_table_exc.selectRow(row_to_sel)
-                            self.last_tool_selected = int(key_tool_nr)
+        self.resize_frame.hide()
 
-        self.tools_table_exc.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
+        # ####################################
+        # ### Add DRILL Array ################
+        # ####################################
 
-        self.tools_table_exc.cellPressed.connect(self.on_row_selected)
-        self.replot()
+        # add a frame and inside add a vertical box layout. Inside this vbox layout I add
+        # all the add drill array  widgets
+        # this way I can hide/show the frame
+        self.array_frame = QtWidgets.QFrame()
+        self.array_frame.setContentsMargins(0, 0, 0, 0)
+        self.tools_box.addWidget(self.array_frame)
+        self.array_box = QtWidgets.QVBoxLayout()
+        self.array_box.setContentsMargins(0, 0, 0, 0)
+        self.array_frame.setLayout(self.array_box)
 
-    def on_canvas_move(self, event):
-        """
-        Called on 'mouse_move' event.
-        It updates the mouse cursor if the grid snapping is ON.
-        It decide if we have a mouse drag and if it is done with the right mouse click. Then it passes this info to a
-        class object which is used in the "mouse_release" handler to decide if to pop-up the context menu or not.
-        It draws utility_geometry for the Editor tools.
-        Update the position labels from status bar.
-        Decide if we have a right to left or a left to right mouse drag with left mouse button and call a function
-        that will draw a selection shape on canvas.
+        self.emptyarray_label = QtWidgets.QLabel('')
+        self.array_box.addWidget(self.emptyarray_label)
 
-        event.pos have canvas screen coordinates
+        self.drill_array_label = QtWidgets.QLabel('<b>%s</b>' % _("Add Drill Array"))
+        self.drill_array_label.setToolTip(
+            _("Add an array of drills (linear or circular array)")
+        )
+        self.array_box.addWidget(self.drill_array_label)
 
-        :param event: Event object dispatched by VisPy SceneCavas
-        :return: None
-        """
+        self.array_type_combo = FCComboBox()
+        self.array_type_combo.setToolTip(
+            _("Select the type of drills array to create.\n"
+              "It can be Linear X(Y) or Circular")
+        )
+        self.array_type_combo.addItem(_("Linear"))
+        self.array_type_combo.addItem(_("Circular"))
 
-        if self.app.is_legacy is False:
-            event_pos = event.pos
-            event_is_dragging = event.is_dragging
-            right_button = 2
-        else:
-            event_pos = (event.xdata, event.ydata)
-            event_is_dragging = self.app.plotcanvas.is_dragging
-            right_button = 3
+        self.array_box.addWidget(self.array_type_combo)
 
-        pos = self.canvas.translate_coords(event_pos)
-        event.xdata, event.ydata = pos[0], pos[1]
+        self.array_form = QtWidgets.QFormLayout()
+        self.array_box.addLayout(self.array_form)
 
-        self.x = event.xdata
-        self.y = event.ydata
+        # Set the number of drill holes in the drill array
+        self.drill_array_size_label = QtWidgets.QLabel('%s:' % _('Nr of drills'))
+        self.drill_array_size_label.setToolTip(_("Specify how many drills to be in the array."))
+        self.drill_array_size_label.setMinimumWidth(100)
 
-        self.app.ui.popMenu.mouse_is_panning = False
+        self.drill_array_size_entry = FCSpinner()
+        self.drill_array_size_entry.set_range(1, 9999)
+        self.array_form.addRow(self.drill_array_size_label, self.drill_array_size_entry)
 
-        # if the RMB is clicked and mouse is moving over plot then 'panning_action' is True
-        if event.button == right_button and event_is_dragging == 1:
-            self.app.ui.popMenu.mouse_is_panning = True
-            return
+        self.array_linear_frame = QtWidgets.QFrame()
+        self.array_linear_frame.setContentsMargins(0, 0, 0, 0)
+        self.array_box.addWidget(self.array_linear_frame)
+        self.linear_box = QtWidgets.QVBoxLayout()
+        self.linear_box.setContentsMargins(0, 0, 0, 0)
+        self.array_linear_frame.setLayout(self.linear_box)
 
-        try:
-            x = float(event.xdata)
-            y = float(event.ydata)
-        except TypeError:
-            return
+        self.linear_form = QtWidgets.QFormLayout()
+        self.linear_box.addLayout(self.linear_form)
 
-        if self.active_tool is None:
-            return
+        # Linear Drill Array direction
+        self.drill_axis_label = QtWidgets.QLabel('%s:' % _('Direction'))
+        self.drill_axis_label.setToolTip(
+            _("Direction on which the linear array is oriented:\n"
+              "- 'X' - horizontal axis \n"
+              "- 'Y' - vertical axis or \n"
+              "- 'Angle' - a custom angle for the array inclination")
+        )
+        self.drill_axis_label.setMinimumWidth(100)
 
-        # ## Snap coordinates
-        if self.app.grid_status():
-            x, y = self.app.geo_editor.snap(x, y)
+        self.drill_axis_radio = RadioSet([{'label': _('X'), 'value': 'X'},
+                                          {'label': _('Y'), 'value': 'Y'},
+                                          {'label': _('Angle'), 'value': 'A'}])
+        self.linear_form.addRow(self.drill_axis_label, self.drill_axis_radio)
 
-            # Update cursor
-            self.app.app_cursor.set_data(np.asarray([(x, y)]), symbol='++', edge_color=self.app.cursor_color_3D,
-                                         edge_width=self.app.defaults["global_cursor_width"],
-                                         size=self.app.defaults["global_cursor_size"])
+        # Linear Drill Array pitch distance
+        self.drill_pitch_label = QtWidgets.QLabel('%s:' % _('Pitch'))
+        self.drill_pitch_label.setToolTip(
+            _("Pitch = Distance between elements of the array.")
+        )
+        self.drill_pitch_label.setMinimumWidth(100)
 
-        self.snap_x = x
-        self.snap_y = y
+        self.drill_pitch_entry = FCDoubleSpinner()
+        self.drill_pitch_entry.set_precision(self.decimals)
+        self.drill_pitch_entry.set_range(0.0000, 9999.9999)
 
-        if self.pos is None:
-            self.pos = (0, 0)
-        self.app.dx = x - self.pos[0]
-        self.app.dy = y - self.pos[1]
+        self.linear_form.addRow(self.drill_pitch_label, self.drill_pitch_entry)
 
-        # # update the position label in the infobar since the APP mouse event handlers are disconnected
-        self.app.ui.position_label.setText("&nbsp;<b>X</b>: %.4f&nbsp;&nbsp;   "
-                                           "<b>Y</b>: %.4f&nbsp;" % (x, y))
-        # # update the reference position label in the infobar since the APP mouse event handlers are disconnected
-        self.app.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
-                                               "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (self.app.dx, self.app.dy))
+        # Linear Drill Array angle
+        self.linear_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
+        self.linear_angle_label.setToolTip(
+            _("Angle at which the linear array is placed.\n"
+              "The precision is of max 2 decimals.\n"
+              "Min value is: -360 degrees.\n"
+              "Max value is:  360.00 degrees.")
+        )
+        self.linear_angle_label.setMinimumWidth(100)
 
-        units = self.app.defaults["units"].lower()
-        self.app.plotcanvas.text_hud.text = \
-            'Dx:\t{:<.4f} [{:s}]\nDy:\t{:<.4f} [{:s}]\n\nX:  \t{:<.4f} [{:s}]\nY:  \t{:<.4f} [{:s}]'.format(
-                self.app.dx, units, self.app.dy, units, x, units, y, units)
+        self.linear_angle_spinner = FCDoubleSpinner()
+        self.linear_angle_spinner.set_precision(self.decimals)
+        self.linear_angle_spinner.setSingleStep(1.0)
+        self.linear_angle_spinner.setRange(-360.00, 360.00)
+        self.linear_form.addRow(self.linear_angle_label, self.linear_angle_spinner)
 
-        # ## Utility geometry (animated)
-        self.update_utility_geometry(data=(x, y))
+        self.array_circular_frame = QtWidgets.QFrame()
+        self.array_circular_frame.setContentsMargins(0, 0, 0, 0)
+        self.array_box.addWidget(self.array_circular_frame)
+        self.circular_box = QtWidgets.QVBoxLayout()
+        self.circular_box.setContentsMargins(0, 0, 0, 0)
+        self.array_circular_frame.setLayout(self.circular_box)
 
-        # ## Selection area on canvas section # ##
-        if event_is_dragging == 1 and event.button == 1:
-            # I make an exception for FCDrillAdd and FCDrillArray because clicking and dragging while making regions
-            # can create strange issues. Also for FCSlot and FCSlotArray
-            if isinstance(self.active_tool, FCDrillAdd) or isinstance(self.active_tool, FCDrillArray) or \
-                    isinstance(self.active_tool, FCSlot) or isinstance(self.active_tool, FCSlotArray):
-                self.app.selection_type = None
-            else:
-                dx = pos[0] - self.pos[0]
-                self.app.delete_selection_shape()
-                if dx < 0:
-                    self.app.draw_moving_selection_shape((self.pos[0], self.pos[1]), (x, y),
-                                                         color=self.app.defaults["global_alt_sel_line"],
-                                                         face_color=self.app.defaults['global_alt_sel_fill'])
-                    self.app.selection_type = False
-                else:
-                    self.app.draw_moving_selection_shape((self.pos[0], self.pos[1]), (x, y))
-                    self.app.selection_type = True
-        else:
-            self.app.selection_type = None
+        self.drill_direction_label = QtWidgets.QLabel('%s:' % _('Direction'))
+        self.drill_direction_label.setToolTip(_("Direction for circular array."
+                                                "Can be CW = clockwise or CCW = counter clockwise."))
+        self.drill_direction_label.setMinimumWidth(100)
 
-        # Update cursor
-        self.app.app_cursor.set_data(np.asarray([(x, y)]), symbol='++', edge_color=self.app.cursor_color_3D,
-                                     edge_width=self.app.defaults["global_cursor_width"],
-                                     size=self.app.defaults["global_cursor_size"])
+        self.circular_form = QtWidgets.QFormLayout()
+        self.circular_box.addLayout(self.circular_form)
 
-    def update_utility_geometry(self, data):
-        # ### Utility geometry (animated) ###
-        geo = self.active_tool.utility_geometry(data=data)
-        if isinstance(geo, DrawToolShape) and geo.geo is not None:
-            # Remove any previous utility shape
-            self.tool_shape.clear(update=True)
-            self.draw_utility_geometry(geo=geo)
+        self.drill_direction_radio = RadioSet([{'label': _('CW'), 'value': 'CW'},
+                                               {'label': _('CCW'), 'value': 'CCW'}])
+        self.circular_form.addRow(self.drill_direction_label, self.drill_direction_radio)
 
-    def on_canvas_key_release(self, event):
-        self.key = None
+        self.drill_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
+        self.drill_angle_label.setToolTip(_("Angle at which each element in circular array is placed."))
+        self.drill_angle_label.setMinimumWidth(100)
 
-    def draw_utility_geometry(self, geo):
-        # Add the new utility shape
-        try:
-            # this case is for the Font Parse
-            for el in list(geo.geo):
-                if type(el) == MultiPolygon:
-                    for poly in el:
-                        self.tool_shape.add(
-                            shape=poly,
-                            color=(self.app.defaults["global_draw_color"] + '80'),
-                            update=False,
-                            layer=0,
-                            tolerance=None
-                        )
-                elif type(el) == MultiLineString:
-                    for linestring in el:
-                        self.tool_shape.add(
-                            shape=linestring,
-                            color=(self.app.defaults["global_draw_color"] + '80'),
-                            update=False,
-                            layer=0,
-                            tolerance=None
-                        )
-                else:
-                    self.tool_shape.add(
-                        shape=el,
-                        color=(self.app.defaults["global_draw_color"] + '80'),
-                        update=False,
-                        layer=0,
-                        tolerance=None
-                    )
-        except TypeError:
-            self.tool_shape.add(
-                shape=geo.geo, color=(self.app.defaults["global_draw_color"] + '80'),
-                update=False, layer=0, tolerance=None)
-        self.tool_shape.redraw()
+        self.drill_angle_entry = FCDoubleSpinner()
+        self.drill_angle_entry.set_precision(self.decimals)
+        self.drill_angle_entry.setSingleStep(1.0)
+        self.drill_angle_entry.setRange(-360.00, 360.00)
 
-    def replot(self):
-        self.plot_all()
+        self.circular_form.addRow(self.drill_angle_label, self.drill_angle_entry)
 
-    def plot_all(self):
-        """
-        Plots all shapes in the editor.
+        self.array_circular_frame.hide()
 
-        :return: None
-        :rtype: None
-        """
-        # self.app.log.debug("plot_all()")
-        self.shapes.clear(update=True)
+        self.linear_angle_spinner.hide()
+        self.linear_angle_label.hide()
 
-        for storage in self.storage_dict:
-            for shape_plus in self.storage_dict[storage].get_objects():
-                if shape_plus.geo is None:
-                    continue
+        self.array_frame.hide()
 
-                if shape_plus in self.selected:
-                    self.plot_shape(geometry=shape_plus.geo, color=self.app.defaults['global_sel_draw_color'] + 'FF',
-                                    linewidth=2)
-                    continue
-                self.plot_shape(geometry=shape_plus.geo, color=self.app.defaults['global_draw_color'] + 'FF')
+        # ######################################################
+        # ##### ADDING SLOTS ###################################
+        # ######################################################
 
-        # for shape in self.storage.get_objects():
-        #     if shape.geo is None:  # TODO: This shouldn't have happened
-        #         continue
-        #
-        #     if shape in self.selected:
-        #         self.plot_shape(geometry=shape.geo, color=self.app.defaults['global_sel_draw_color'], linewidth=2)
-        #         continue
-        #
-        #     self.plot_shape(geometry=shape.geo, color=self.app.defaults['global_draw_color'])
+        # add a frame and inside add a vertical box layout. Inside this vbox layout I add
+        # all the add slot  widgets
+        # this way I can hide/show the frame
+        self.slot_frame = QtWidgets.QFrame()
+        self.slot_frame.setContentsMargins(0, 0, 0, 0)
+        self.tools_box.addWidget(self.slot_frame)
+        self.slot_box = QtWidgets.QVBoxLayout()
+        self.slot_box.setContentsMargins(0, 0, 0, 0)
+        self.slot_frame.setLayout(self.slot_box)
 
-        for shape_form in self.utility:
-            self.plot_shape(geometry=shape_form.geo, linewidth=1)
-            continue
+        self.emptyarray_label = QtWidgets.QLabel('')
+        self.slot_box.addWidget(self.emptyarray_label)
 
-        self.shapes.redraw()
+        self.slot_label = QtWidgets.QLabel('<b>%s</b>' % _("Slot Parameters"))
+        self.slot_label.setToolTip(
+            _("Parameters for adding a slot (hole with oval shape)\n"
+              "either single or as an part of an array.")
+        )
+        self.slot_box.addWidget(self.slot_label)
 
-    def plot_shape(self, geometry=None, color='0x000000FF', linewidth=1):
-        """
-        Plots a geometric object or list of objects without rendering. Plotted objects
-        are returned as a list. This allows for efficient/animated rendering.
+        self.slot_form = QtWidgets.QFormLayout()
+        self.slot_box.addLayout(self.slot_form)
 
-        :param geometry: Geometry to be plotted (Any Shapely.geom kind or list of such)
-        :param color: Shape color
-        :param linewidth: Width of lines in # of pixels.
-        :return: List of plotted elements.
-        """
-        plot_elements = []
+        # Slot length
+        self.slot_length_label = QtWidgets.QLabel('%s:' % _('Length'))
+        self.slot_length_label.setToolTip(
+            _("Length = The length of the slot.")
+        )
+        self.slot_length_label.setMinimumWidth(100)
 
-        if geometry is None:
-            geometry = self.active_tool.geometry
+        self.slot_length_entry = FCDoubleSpinner()
+        self.slot_length_entry.set_precision(self.decimals)
+        self.slot_length_entry.setSingleStep(0.1)
+        self.slot_length_entry.setRange(0.0000, 9999.9999)
 
-        try:
-            for geo in geometry:
-                plot_elements += self.plot_shape(geometry=geo, color=color, linewidth=linewidth)
+        self.slot_form.addRow(self.slot_length_label, self.slot_length_entry)
 
-        # ## Non-iterable
-        except TypeError:
-            # ## DrawToolShape
-            if isinstance(geometry, DrawToolShape):
-                plot_elements += self.plot_shape(geometry=geometry.geo, color=color, linewidth=linewidth)
+        # Slot direction
+        self.slot_axis_label = QtWidgets.QLabel('%s:' % _('Direction'))
+        self.slot_axis_label.setToolTip(
+            _("Direction on which the slot is oriented:\n"
+              "- 'X' - horizontal axis \n"
+              "- 'Y' - vertical axis or \n"
+              "- 'Angle' - a custom angle for the slot inclination")
+        )
+        self.slot_axis_label.setMinimumWidth(100)
 
-            # ## Polygon: Descend into exterior and each interior.
-            if type(geometry) == Polygon:
-                plot_elements += self.plot_shape(geometry=geometry.exterior, color=color, linewidth=linewidth)
-                plot_elements += self.plot_shape(geometry=geometry.interiors, color=color, linewidth=linewidth)
+        self.slot_axis_radio = RadioSet([{'label': _('X'), 'value': 'X'},
+                                         {'label': _('Y'), 'value': 'Y'},
+                                         {'label': _('Angle'), 'value': 'A'}])
+        self.slot_form.addRow(self.slot_axis_label, self.slot_axis_radio)
 
-            if type(geometry) == LineString or type(geometry) == LinearRing:
-                plot_elements.append(self.shapes.add(shape=geometry, color=color, layer=0, tolerance=self.tolerance))
+        # Slot custom angle
+        self.slot_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
+        self.slot_angle_label.setToolTip(
+            _("Angle at which the slot is placed.\n"
+              "The precision is of max 2 decimals.\n"
+              "Min value is: -360 degrees.\n"
+              "Max value is:  360.00 degrees.")
+        )
+        self.slot_angle_label.setMinimumWidth(100)
 
-            if type(geometry) == Point:
-                pass
+        self.slot_angle_spinner = FCDoubleSpinner()
+        self.slot_angle_spinner.set_precision(self.decimals)
+        self.slot_angle_spinner.setWrapping(True)
+        self.slot_angle_spinner.setRange(-360.00, 360.00)
+        self.slot_angle_spinner.setSingleStep(1.0)
+        self.slot_form.addRow(self.slot_angle_label, self.slot_angle_spinner)
 
-        return plot_elements
+        self.slot_frame.hide()
 
-    def on_shape_complete(self):
-        self.app.log.debug("on_shape_complete()")
+        # ######################################################
+        # ##### ADDING SLOT ARRAY  #############################
+        # ######################################################
 
-        # Add shape
-        self.add_shape(self.active_tool.geometry)
+        # add a frame and inside add a vertical box layout. Inside this vbox layout I add
+        # all the add slot  widgets
+        # this way I can hide/show the frame
+        self.slot_array_frame = QtWidgets.QFrame()
+        self.slot_array_frame.setContentsMargins(0, 0, 0, 0)
+        self.tools_box.addWidget(self.slot_array_frame)
+        self.slot_array_box = QtWidgets.QVBoxLayout()
+        self.slot_array_box.setContentsMargins(0, 0, 0, 0)
+        self.slot_array_frame.setLayout(self.slot_array_box)
 
-        # Remove any utility shapes
-        self.delete_utility_geometry()
-        self.tool_shape.clear(update=True)
+        self.emptyarray_label = QtWidgets.QLabel('')
+        self.slot_array_box.addWidget(self.emptyarray_label)
 
-        # Replot and reset tool.
-        self.replot()
-        # self.active_tool = type(self.active_tool)(self)
+        self.slot_array_label = QtWidgets.QLabel('<b>%s</b>' % _("Slot Array Parameters"))
+        self.slot_array_label.setToolTip(
+            _("Parameters for the array of slots (linear or circular array)")
+        )
+        self.slot_array_box.addWidget(self.slot_array_label)
 
-    def get_selected(self):
-        """
-        Returns list of shapes that are selected in the editor.
+        self.l_form = QtWidgets.QFormLayout()
+        self.slot_array_box.addLayout(self.l_form)
 
-        :return: List of shapes.
-        """
-        # return [shape for shape in self.shape_buffer if shape["selected"]]
-        return self.selected
+        self.slot_array_type_combo = FCComboBox()
+        self.slot_array_type_combo.setToolTip(
+            _("Select the type of slot array to create.\n"
+              "It can be Linear X(Y) or Circular")
+        )
+        self.slot_array_type_combo.addItem(_("Linear"))
+        self.slot_array_type_combo.addItem(_("Circular"))
 
-    def delete_selected(self):
-        temp_ref = [s for s in self.selected]
-        for shape_sel in temp_ref:
-            self.delete_shape(shape_sel)
+        self.slot_array_box.addWidget(self.slot_array_type_combo)
 
-        self.selected = []
-        self.build_ui()
-        self.app.inform.emit('[success] %s' %
-                             _("Done. Drill(s) deleted."))
+        self.slot_array_form = QtWidgets.QFormLayout()
+        self.slot_array_box.addLayout(self.slot_array_form)
 
-    def delete_shape(self, del_shape):
-        self.is_modified = True
+        # Set the number of slot holes in the slot array
+        self.slot_array_size_label = QtWidgets.QLabel('%s:' % _('Nr of slots'))
+        self.slot_array_size_label.setToolTip(_("Specify how many slots to be in the array."))
+        self.slot_array_size_label.setMinimumWidth(100)
 
-        if del_shape in self.utility:
-            self.utility.remove(del_shape)
-            return
+        self.slot_array_size_entry = FCSpinner()
+        self.slot_array_size_entry.set_range(0, 9999)
 
-        for storage in self.storage_dict:
-            # try:
-            #     self.storage_dict[storage].remove(shape)
-            # except:
-            #     pass
-            if del_shape in self.storage_dict[storage].get_objects():
-                if isinstance(del_shape.geo, MultiLineString):
-                    self.storage_dict[storage].remove(del_shape)
-                    # a hack to make the tool_table display less drills per diameter
-                    # self.points_edit it's only useful first time when we load the data into the storage
-                    # but is still used as referecen when building tool_table in self.build_ui()
-                    # the number of drills displayed in column 2 is just a len(self.points_edit) therefore
-                    # deleting self.points_edit elements (doesn't matter who but just the number)
-                    # solved the display issue.
-                    del self.points_edit[storage][0]
-                else:
-                    self.storage_dict[storage].remove(del_shape)
-                    del self.slot_points_edit[storage][0]
+        self.slot_array_form.addRow(self.slot_array_size_label, self.slot_array_size_entry)
 
-        if del_shape in self.selected:
-            self.selected.remove(del_shape)
+        self.slot_array_linear_frame = QtWidgets.QFrame()
+        self.slot_array_linear_frame.setContentsMargins(0, 0, 0, 0)
+        self.slot_array_box.addWidget(self.slot_array_linear_frame)
+        self.slot_array_linear_box = QtWidgets.QVBoxLayout()
+        self.slot_array_linear_box.setContentsMargins(0, 0, 0, 0)
+        self.slot_array_linear_frame.setLayout(self.slot_array_linear_box)
 
-    def delete_utility_geometry(self):
-        for_deletion = [util_shape for util_shape in self.utility]
-        for util_shape in for_deletion:
-            self.delete_shape(util_shape)
+        self.slot_array_linear_form = QtWidgets.QFormLayout()
+        self.slot_array_linear_box.addLayout(self.slot_array_linear_form)
 
-        self.tool_shape.clear(update=True)
-        self.tool_shape.redraw()
+        # Linear Slot Array direction
+        self.slot_array_axis_label = QtWidgets.QLabel('%s:' % _('Direction'))
+        self.slot_array_axis_label.setToolTip(
+            _("Direction on which the linear array is oriented:\n"
+              "- 'X' - horizontal axis \n"
+              "- 'Y' - vertical axis or \n"
+              "- 'Angle' - a custom angle for the array inclination")
+        )
+        self.slot_array_axis_label.setMinimumWidth(100)
 
-    def on_delete_btn(self):
-        self.delete_selected()
-        self.replot()
+        self.slot_array_axis_radio = RadioSet([{'label': _('X'), 'value': 'X'},
+                                               {'label': _('Y'), 'value': 'Y'},
+                                               {'label': _('Angle'), 'value': 'A'}])
+        self.slot_array_linear_form.addRow(self.slot_array_axis_label, self.slot_array_axis_radio)
 
-    def select_tool(self, toolname):
-        """
-        Selects a drawing tool. Impacts the object and appGUI.
+        # Linear Slot Array pitch distance
+        self.slot_array_pitch_label = QtWidgets.QLabel('%s:' % _('Pitch'))
+        self.slot_array_pitch_label.setToolTip(
+            _("Pitch = Distance between elements of the array.")
+        )
+        self.slot_array_pitch_label.setMinimumWidth(100)
 
-        :param toolname: Name of the tool.
-        :return: None
-        """
-        self.tools_exc[toolname]["button"].setChecked(True)
-        self.on_tool_select(toolname)
+        self.slot_array_pitch_entry = FCDoubleSpinner()
+        self.slot_array_pitch_entry.set_precision(self.decimals)
+        self.slot_array_pitch_entry.setSingleStep(0.1)
+        self.slot_array_pitch_entry.setRange(0.0000, 9999.9999)
 
-    def set_selected(self, sel_shape):
+        self.slot_array_linear_form.addRow(self.slot_array_pitch_label, self.slot_array_pitch_entry)
 
-        # Remove and add to the end.
-        if sel_shape in self.selected:
-            self.selected.remove(sel_shape)
+        # Linear Slot Array angle
+        self.slot_array_linear_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
+        self.slot_array_linear_angle_label.setToolTip(
+            _("Angle at which the linear array is placed.\n"
+              "The precision is of max 2 decimals.\n"
+              "Min value is: -360 degrees.\n"
+              "Max value is:  360.00 degrees.")
+        )
+        self.slot_array_linear_angle_label.setMinimumWidth(100)
 
-        self.selected.append(sel_shape)
+        self.slot_array_linear_angle_spinner = FCDoubleSpinner()
+        self.slot_array_linear_angle_spinner.set_precision(self.decimals)
+        self.slot_array_linear_angle_spinner.setSingleStep(1.0)
+        self.slot_array_linear_angle_spinner.setRange(-360.00, 360.00)
+        self.slot_array_linear_form.addRow(self.slot_array_linear_angle_label, self.slot_array_linear_angle_spinner)
 
-    def set_unselected(self, unsel_shape):
-        if unsel_shape in self.selected:
-            self.selected.remove(unsel_shape)
+        self.slot_array_circular_frame = QtWidgets.QFrame()
+        self.slot_array_circular_frame.setContentsMargins(0, 0, 0, 0)
+        self.slot_array_box.addWidget(self.slot_array_circular_frame)
+        self.slot_array_circular_box = QtWidgets.QVBoxLayout()
+        self.slot_array_circular_box.setContentsMargins(0, 0, 0, 0)
+        self.slot_array_circular_frame.setLayout(self.slot_array_circular_box)
 
-    def on_array_type_combo(self):
-        if self.array_type_combo.currentIndex() == 0:
-            self.array_circular_frame.hide()
-            self.array_linear_frame.show()
-        else:
-            self.delete_utility_geometry()
-            self.array_circular_frame.show()
-            self.array_linear_frame.hide()
-            self.app.inform.emit(_("Click on the circular array Center position"))
+        self.slot_array_direction_label = QtWidgets.QLabel('%s:' % _('Direction'))
+        self.slot_array_direction_label.setToolTip(_("Direction for circular array."
+                                                     "Can be CW = clockwise or CCW = counter clockwise."))
+        self.slot_array_direction_label.setMinimumWidth(100)
 
-    def on_slot_array_type_combo(self):
-        if self.slot_array_type_combo.currentIndex() == 0:
-            self.slot_array_circular_frame.hide()
-            self.slot_array_linear_frame.show()
-        else:
-            self.delete_utility_geometry()
-            self.slot_array_circular_frame.show()
-            self.slot_array_linear_frame.hide()
-            self.app.inform.emit(_("Click on the circular array Center position"))
+        self.slot_array_circular_form = QtWidgets.QFormLayout()
+        self.slot_array_circular_box.addLayout(self.slot_array_circular_form)
 
-    def on_linear_angle_radio(self):
-        val = self.drill_axis_radio.get_value()
-        if val == 'A':
-            self.linear_angle_spinner.show()
-            self.linear_angle_label.show()
-        else:
-            self.linear_angle_spinner.hide()
-            self.linear_angle_label.hide()
+        self.slot_array_direction_radio = RadioSet([{'label': _('CW'), 'value': 'CW'},
+                                                    {'label': _('CCW'), 'value': 'CCW'}])
+        self.slot_array_circular_form.addRow(self.slot_array_direction_label, self.slot_array_direction_radio)
 
-    def on_slot_array_linear_angle_radio(self):
-        val = self.slot_array_axis_radio.get_value()
-        if val == 'A':
-            self.slot_array_linear_angle_spinner.show()
-            self.slot_array_linear_angle_label.show()
-        else:
-            self.slot_array_linear_angle_spinner.hide()
-            self.slot_array_linear_angle_label.hide()
+        self.slot_array_angle_label = QtWidgets.QLabel('%s:' % _('Angle'))
+        self.slot_array_angle_label.setToolTip(_("Angle at which each element in circular array is placed."))
+        self.slot_array_angle_label.setMinimumWidth(100)
 
-    def on_slot_angle_radio(self):
-        val = self.slot_axis_radio.get_value()
-        if val == 'A':
-            self.slot_angle_spinner.show()
-            self.slot_angle_label.show()
-        else:
-            self.slot_angle_spinner.hide()
-            self.slot_angle_label.hide()
+        self.slot_array_angle_entry = FCDoubleSpinner()
+        self.slot_array_angle_entry.set_precision(self.decimals)
+        self.slot_array_angle_entry.setSingleStep(1)
+        self.slot_array_angle_entry.setRange(-360.00, 360.00)
 
-    def exc_add_drill(self):
-        self.select_tool('drill_add')
-        return
+        self.slot_array_circular_form.addRow(self.slot_array_angle_label, self.slot_array_angle_entry)
 
-    def exc_add_drill_array(self):
-        self.select_tool('drill_array')
-        return
+        self.slot_array_linear_angle_spinner.hide()
+        self.slot_array_linear_angle_label.hide()
 
-    def exc_add_slot(self):
-        self.select_tool('slot_add')
-        return
+        self.slot_array_frame.hide()
 
-    def exc_add_slot_array(self):
-        self.select_tool('slot_array')
-        return
+        self.tools_box.addStretch()
 
-    def exc_resize_drills(self):
-        self.select_tool('drill_resize')
-        return
+        layout.addStretch()
 
-    def exc_copy_drills(self):
-        self.select_tool('drill_copy')
-        return
+        # Editor
+        self.exit_editor_button = QtWidgets.QPushButton(_('Exit Editor'))
+        self.exit_editor_button.setToolTip(
+            _("Exit from Editor.")
+        )
+        self.exit_editor_button.setStyleSheet("""
+                                      QPushButton
+                                      {
+                                          font-weight: bold;
+                                      }
+                                      """)
+        layout.addWidget(self.exit_editor_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 exc_move_drills(self):
-        self.select_tool('drill_move')
-        return
+    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)
 
 
 def get_shapely_list_bounds(geometry_list):

appGUI/ObjectUI.py

@@ -255,9 +255,7 @@ class GerberObjectUI(ObjectUI):
         # Aperture Table Visibility CB
         self.aperture_table_visibility_cb = FCCheckBox()
         self.aperture_table_visibility_cb.setToolTip(
-            _("Toggle the display of the Gerber Apertures Table.\n"
-              "When unchecked, it will delete all mark shapes\n"
-              "that are drawn on canvas.")
+            _("Toggle the display of the Tools Table.")
         )
         # self.aperture_table_visibility_cb.setLayoutDirection(QtCore.Qt.RightToLeft)
         hlay_plot.addWidget(self.aperture_table_visibility_cb)
@@ -507,7 +505,7 @@ class ExcellonObjectUI(ObjectUI):
         grid_h.setColumnStretch(1, 1)
 
         self.plot_options_label = QtWidgets.QLabel("<b>%s:</b>" % _("Plot Options"))
-        self.plot_options_label.setMinimumWidth(90)
+        # self.plot_options_label.setMinimumWidth(90)
 
         grid_h.addWidget(self.plot_options_label, 0, 0)
 
@@ -516,7 +514,7 @@ class ExcellonObjectUI(ObjectUI):
         self.solid_cb.setToolTip(
             _("Solid circles.")
         )
-        self.solid_cb.setMinimumWidth(50)
+        # self.solid_cb.setMinimumWidth(50)
         grid_h.addWidget(self.solid_cb, 0, 1)
 
         # Multicolored CB
@@ -524,12 +522,11 @@ class ExcellonObjectUI(ObjectUI):
         self.multicolored_cb.setToolTip(
             _("Draw polygons in different colors.")
         )
-        self.multicolored_cb.setMinimumWidth(55)
+        # self.multicolored_cb.setMinimumWidth(55)
         grid_h.addWidget(self.multicolored_cb, 0, 2)
 
         # ## Object name
         self.name_hlay = QtWidgets.QHBoxLayout()
-        grid_h.addLayout(self.name_hlay, 1, 0, 1, 3)
 
         name_label = QtWidgets.QLabel("<b>%s:</b>" % _("Name"))
         self.name_entry = FCEntry()
@@ -537,27 +534,23 @@ class ExcellonObjectUI(ObjectUI):
         self.name_hlay.addWidget(name_label)
         self.name_hlay.addWidget(self.name_entry)
 
-        # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets
-        # this way I can hide/show the frame
-        self.drills_frame = QtWidgets.QFrame()
-        self.drills_frame.setContentsMargins(0, 0, 0, 0)
-        self.custom_box.addWidget(self.drills_frame)
-        self.tools_box = QtWidgets.QVBoxLayout()
-        self.tools_box.setContentsMargins(0, 0, 0, 0)
-        self.drills_frame.setLayout(self.tools_box)
-
-        hlay_plot = QtWidgets.QHBoxLayout()
-        self.tools_box.addLayout(hlay_plot)
+        grid_h.addLayout(self.name_hlay, 1, 0, 1, 3)
 
         # ### Tools Drills ####
-        self.tools_table_label = QtWidgets.QLabel('<b>%s:</b>' % _('Tools Table'))
+        self.tools_table_label = QtWidgets.QLabel('<b>%s</b>' % _('Tools Table'))
         self.tools_table_label.setToolTip(
             _("Tools in this Excellon object\n"
               "when are used for drilling.")
         )
-        hlay_plot.addWidget(self.tools_table_label)
+
+        # Table Visibility CB
+        self.table_visibility_cb = FCCheckBox()
+        self.table_visibility_cb.setToolTip(
+            _("Toggle the display of the Tools Table.")
+        )
 
         # Plot CB
+        hlay_plot = QtWidgets.QHBoxLayout()
         self.plot_cb = FCCheckBox(_('Plot'))
         self.plot_cb.setToolTip(
             _("Plot (show) this object.")
@@ -566,6 +559,19 @@ class ExcellonObjectUI(ObjectUI):
         hlay_plot.addStretch()
         hlay_plot.addWidget(self.plot_cb)
 
+        grid_h.addWidget(self.tools_table_label, 2, 0)
+        grid_h.addWidget(self.table_visibility_cb, 2, 1)
+        grid_h.addLayout(hlay_plot, 2, 2)
+
+        # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets
+        # this way I can hide/show the frame
+        self.drills_frame = QtWidgets.QFrame()
+        self.drills_frame.setContentsMargins(0, 0, 0, 0)
+        self.custom_box.addWidget(self.drills_frame)
+        self.tools_box = QtWidgets.QVBoxLayout()
+        self.tools_box.setContentsMargins(0, 0, 0, 0)
+        self.drills_frame.setLayout(self.tools_box)
+
         self.tools_table = FCTable()
         self.tools_table.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
         self.tools_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)

appGUI/preferences/PreferencesUIManager.py

@@ -198,15 +198,7 @@ class PreferencesUIManager:
             "excellon_slot_tooldia": self.ui.excellon_defaults_form.excellon_opt_group.slot_tooldia_entry,
 
             # Excellon Advanced Options
-            "excellon_offset":          self.ui.excellon_defaults_form.excellon_adv_opt_group.offset_entry,
-            "excellon_toolchangexy":    self.ui.excellon_defaults_form.excellon_adv_opt_group.toolchangexy_entry,
-            "excellon_startz":          self.ui.excellon_defaults_form.excellon_adv_opt_group.estartz_entry,
-            "excellon_feedrate_rapid":  self.ui.excellon_defaults_form.excellon_adv_opt_group.feedrate_rapid_entry,
-            "excellon_z_pdepth":        self.ui.excellon_defaults_form.excellon_adv_opt_group.pdepth_entry,
-            "excellon_feedrate_probe":  self.ui.excellon_defaults_form.excellon_adv_opt_group.feedrate_probe_entry,
-            "excellon_spindledir":      self.ui.excellon_defaults_form.excellon_adv_opt_group.spindledir_radio,
-            "excellon_f_plunge":        self.ui.excellon_defaults_form.excellon_adv_opt_group.fplunge_cb,
-            "excellon_f_retract":       self.ui.excellon_defaults_form.excellon_adv_opt_group.fretract_cb,
+            "excellon_tools_table_display": self.ui.excellon_defaults_form.excellon_adv_opt_group.table_visibility_cb,
 
             # Excellon Export
             "excellon_exp_units":       self.ui.excellon_defaults_form.excellon_exp_group.excellon_units_radio,
@@ -358,9 +350,20 @@ class PreferencesUIManager:
             "tools_drill_toolchangez":  self.ui.tools_defaults_form.tools_drill_group.toolchangez_entry,
             "tools_drill_ppname_e":     self.ui.tools_defaults_form.tools_drill_group.pp_excellon_name_cb,
 
-            "tools_drill_drill_slots":  self.ui.tools_defaults_form.tools_drill_group.drill_slots_cb,
-            "tools_drill_drill_overlap": self.ui.tools_defaults_form.tools_drill_group.drill_overlap_entry,
-            "tools_drill_last_drill":   self.ui.tools_defaults_form.tools_drill_group.last_drill_cb,
+            "tools_drill_drill_slots":      self.ui.tools_defaults_form.tools_drill_group.drill_slots_cb,
+            "tools_drill_drill_overlap":    self.ui.tools_defaults_form.tools_drill_group.drill_overlap_entry,
+            "tools_drill_last_drill":       self.ui.tools_defaults_form.tools_drill_group.last_drill_cb,
+
+            # Advanced Options
+            "tools_drill_offset":           self.ui.tools_defaults_form.tools_drill_group.offset_entry,
+            "tools_drill_toolchangexy":     self.ui.tools_defaults_form.tools_drill_group.toolchangexy_entry,
+            "tools_drill_startz":           self.ui.tools_defaults_form.tools_drill_group.estartz_entry,
+            "tools_drill_feedrate_rapid":   self.ui.tools_defaults_form.tools_drill_group.feedrate_rapid_entry,
+            "tools_drill_z_pdepth":         self.ui.tools_defaults_form.tools_drill_group.pdepth_entry,
+            "tools_drill_feedrate_probe":   self.ui.tools_defaults_form.tools_drill_group.feedrate_probe_entry,
+            "tools_drill_spindledir":       self.ui.tools_defaults_form.tools_drill_group.spindledir_radio,
+            "tools_drill_f_plunge":         self.ui.tools_defaults_form.tools_drill_group.fplunge_cb,
+            "tools_drill_f_retract":        self.ui.tools_defaults_form.tools_drill_group.fretract_cb,
 
             # NCC Tool
             "tools_ncctools":           self.ui.tools_defaults_form.tools_ncc_group.ncc_tool_dia_entry,

appGUI/preferences/excellon/ExcellonAdvOptPrefGroupUI.py

@@ -39,117 +39,16 @@ class ExcellonAdvOptPrefGroupUI(OptionsGroupUI):
         )
         self.layout.addWidget(self.exc_label)
 
-        grid1 = QtWidgets.QGridLayout()
-        self.layout.addLayout(grid1)
+        grid0 = QtWidgets.QGridLayout()
+        grid0.setColumnStretch(0, 0)
+        grid0.setColumnStretch(1, 1)
+        self.layout.addLayout(grid0)
 
-        # Offset Z
-        offsetlabel = QtWidgets.QLabel('%s:' % _('Offset Z'))
-        offsetlabel.setToolTip(
-            _("Some drill bits (the larger ones) need to drill deeper\n"
-              "to create the desired exit hole diameter due of the tip shape.\n"
-              "The value here can compensate the Cut Z parameter."))
-        self.offset_entry = FCDoubleSpinner()
-        self.offset_entry.set_precision(self.decimals)
-        self.offset_entry.set_range(-999.9999, 999.9999)
-
-        grid1.addWidget(offsetlabel, 0, 0)
-        grid1.addWidget(self.offset_entry, 0, 1)
-
-        # ToolChange X,Y
-        toolchange_xy_label = QtWidgets.QLabel('%s:' % _('Toolchange X,Y'))
-        toolchange_xy_label.setToolTip(
-            _("Toolchange X,Y position.")
-        )
-        self.toolchangexy_entry = NumericalEvalTupleEntry(border_color='#0069A9')
-
-        grid1.addWidget(toolchange_xy_label, 1, 0)
-        grid1.addWidget(self.toolchangexy_entry, 1, 1)
-
-        # Start Z
-        startzlabel = QtWidgets.QLabel('%s:' % _('Start Z'))
-        startzlabel.setToolTip(
-            _("Height of the tool just after start.\n"
-              "Delete the value if you don't need this feature.")
-        )
-        self.estartz_entry = NumericalEvalEntry(border_color='#0069A9')
-
-        grid1.addWidget(startzlabel, 2, 0)
-        grid1.addWidget(self.estartz_entry, 2, 1)
-
-        # Feedrate Rapids
-        fr_rapid_label = QtWidgets.QLabel('%s:' % _('Feedrate Rapids'))
-        fr_rapid_label.setToolTip(
-            _("Tool speed while drilling\n"
-              "(in units per minute).\n"
-              "This is for the rapid move G00.\n"
-              "It is useful only for Marlin,\n"
-              "ignore for any other cases.")
-        )
-        self.feedrate_rapid_entry = FCDoubleSpinner()
-        self.feedrate_rapid_entry.set_precision(self.decimals)
-        self.feedrate_rapid_entry.set_range(0, 99999.9999)
-
-        grid1.addWidget(fr_rapid_label, 3, 0)
-        grid1.addWidget(self.feedrate_rapid_entry, 3, 1)
-
-        # Probe depth
-        self.pdepth_label = QtWidgets.QLabel('%s:' % _("Probe Z depth"))
-        self.pdepth_label.setToolTip(
-            _("The maximum depth that the probe is allowed\n"
-              "to probe. Negative value, in current units.")
+        # Table Visibility CB
+        self.table_visibility_cb = FCCheckBox(label=_('Table Show/Hide'))
+        self.table_visibility_cb.setToolTip(
+            _("Toggle the display of the Tools Table.")
         )
-        self.pdepth_entry = FCDoubleSpinner()
-        self.pdepth_entry.set_precision(self.decimals)
-        self.pdepth_entry.set_range(-99999.9999, 0.0000)
-
-        grid1.addWidget(self.pdepth_label, 4, 0)
-        grid1.addWidget(self.pdepth_entry, 4, 1)
-
-        # Probe feedrate
-        self.feedrate_probe_label = QtWidgets.QLabel('%s:' % _("Feedrate Probe"))
-        self.feedrate_probe_label.setToolTip(
-           _("The feedrate used while the probe is probing.")
-        )
-        self.feedrate_probe_entry = FCDoubleSpinner()
-        self.feedrate_probe_entry.set_precision(self.decimals)
-        self.feedrate_probe_entry.set_range(0, 99999.9999)
-
-        grid1.addWidget(self.feedrate_probe_label, 5, 0)
-        grid1.addWidget(self.feedrate_probe_entry, 5, 1)
-
-        # Spindle direction
-        spindle_dir_label = QtWidgets.QLabel('%s:' % _('Spindle direction'))
-        spindle_dir_label.setToolTip(
-            _("This sets the direction that the spindle is rotating.\n"
-              "It can be either:\n"
-              "- CW = clockwise or\n"
-              "- CCW = counter clockwise")
-        )
-
-        self.spindledir_radio = RadioSet([{'label': _('CW'), 'value': 'CW'},
-                                          {'label': _('CCW'), 'value': 'CCW'}])
-        grid1.addWidget(spindle_dir_label, 6, 0)
-        grid1.addWidget(self.spindledir_radio, 6, 1)
-
-        self.fplunge_cb = FCCheckBox('%s' % _('Fast Plunge'))
-        self.fplunge_cb.setToolTip(
-            _("By checking this, the vertical move from\n"
-              "Z_Toolchange to Z_move is done with G0,\n"
-              "meaning the fastest speed available.\n"
-              "WARNING: the move is done at Toolchange X,Y coords.")
-        )
-        grid1.addWidget(self.fplunge_cb, 7, 0, 1, 2)
-
-        self.fretract_cb = FCCheckBox('%s' % _('Fast Retract'))
-        self.fretract_cb.setToolTip(
-            _("Exit hole strategy.\n"
-              " - When uncheked, while exiting the drilled hole the drill bit\n"
-              "will travel slow, with set feedrate (G1), up to zero depth and then\n"
-              "travel as fast as possible (G0) to the Z Move (travel height).\n"
-              " - When checked the travel from Z cut (cut depth) to Z_move\n"
-              "(travel height) is done as fast as possible (G0) in one move.")
-        )
-
-        grid1.addWidget(self.fretract_cb, 8, 0, 1, 2)
+        grid0.addWidget(self.table_visibility_cb, 0, 0, 1, 2)
 
         self.layout.addStretch()

appGUI/preferences/gerber/GerberAdvOptPrefGroupUI.py

@@ -51,10 +51,7 @@ class GerberAdvOptPrefGroupUI(OptionsGroupUI):
         # Aperture Table Visibility CB
         self.aperture_table_visibility_cb = FCCheckBox(label=_('Table Show/Hide'))
         self.aperture_table_visibility_cb.setToolTip(
-            _("Toggle the display of the Gerber Apertures Table.\n"
-              "Also, on hide, it will delete all mark shapes\n"
-              "that are drawn on canvas.")
-
+            _("Toggle the display of the Tools Table.")
         )
         grid0.addWidget(self.aperture_table_visibility_cb, 1, 0, 1, 2)
 

appGUI/preferences/tools/ToolsDrillPrefGroupUI.py

@@ -2,7 +2,7 @@ from PyQt5 import QtWidgets
 from PyQt5.QtCore import QSettings, Qt
 
 from appGUI.GUIElements import RadioSet, FCDoubleSpinner, FCComboBox, FCCheckBox, FCSpinner, NumericalEvalTupleEntry, \
-    OptionalInputSection
+    OptionalInputSection, NumericalEvalEntry
 from appGUI.preferences.OptionsGroupUI import OptionsGroupUI
 
 import gettext
@@ -268,4 +268,125 @@ class ToolsDrillPrefGroupUI(OptionsGroupUI):
         )
         grid0.addWidget(self.last_drill_cb, 24, 0, 1, 3)
 
+        separator_line = QtWidgets.QFrame()
+        separator_line.setFrameShape(QtWidgets.QFrame.HLine)
+        separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        grid0.addWidget(separator_line, 26, 0, 1, 3)
+
+        self.exc_label = QtWidgets.QLabel('<b>%s:</b>' % _('Advanced Options'))
+        self.exc_label.setToolTip(
+            _("A list of advanced parameters.")
+        )
+        grid0.addWidget(self.exc_label, 28, 0, 1, 3)
+
+        # Offset Z
+        offsetlabel = QtWidgets.QLabel('%s:' % _('Offset Z'))
+        offsetlabel.setToolTip(
+            _("Some drill bits (the larger ones) need to drill deeper\n"
+              "to create the desired exit hole diameter due of the tip shape.\n"
+              "The value here can compensate the Cut Z parameter."))
+        self.offset_entry = FCDoubleSpinner()
+        self.offset_entry.set_precision(self.decimals)
+        self.offset_entry.set_range(-999.9999, 999.9999)
+
+        grid0.addWidget(offsetlabel, 29, 0)
+        grid0.addWidget(self.offset_entry, 29, 1, 1, 2)
+
+        # ToolChange X,Y
+        toolchange_xy_label = QtWidgets.QLabel('%s:' % _('Toolchange X,Y'))
+        toolchange_xy_label.setToolTip(
+            _("Toolchange X,Y position.")
+        )
+        self.toolchangexy_entry = NumericalEvalTupleEntry(border_color='#0069A9')
+
+        grid0.addWidget(toolchange_xy_label, 31, 0)
+        grid0.addWidget(self.toolchangexy_entry, 31, 1, 1, 2)
+
+        # Start Z
+        startzlabel = QtWidgets.QLabel('%s:' % _('Start Z'))
+        startzlabel.setToolTip(
+            _("Height of the tool just after start.\n"
+              "Delete the value if you don't need this feature.")
+        )
+        self.estartz_entry = NumericalEvalEntry(border_color='#0069A9')
+
+        grid0.addWidget(startzlabel, 33, 0)
+        grid0.addWidget(self.estartz_entry, 33, 1, 1, 2)
+
+        # Feedrate Rapids
+        fr_rapid_label = QtWidgets.QLabel('%s:' % _('Feedrate Rapids'))
+        fr_rapid_label.setToolTip(
+            _("Tool speed while drilling\n"
+              "(in units per minute).\n"
+              "This is for the rapid move G00.\n"
+              "It is useful only for Marlin,\n"
+              "ignore for any other cases.")
+        )
+        self.feedrate_rapid_entry = FCDoubleSpinner()
+        self.feedrate_rapid_entry.set_precision(self.decimals)
+        self.feedrate_rapid_entry.set_range(0, 99999.9999)
+
+        grid0.addWidget(fr_rapid_label, 35, 0)
+        grid0.addWidget(self.feedrate_rapid_entry, 35, 1, 1, 2)
+
+        # Probe depth
+        self.pdepth_label = QtWidgets.QLabel('%s:' % _("Probe Z depth"))
+        self.pdepth_label.setToolTip(
+            _("The maximum depth that the probe is allowed\n"
+              "to probe. Negative value, in current units.")
+        )
+        self.pdepth_entry = FCDoubleSpinner()
+        self.pdepth_entry.set_precision(self.decimals)
+        self.pdepth_entry.set_range(-99999.9999, 0.0000)
+
+        grid0.addWidget(self.pdepth_label, 37, 0)
+        grid0.addWidget(self.pdepth_entry, 37, 1, 1, 2)
+
+        # Probe feedrate
+        self.feedrate_probe_label = QtWidgets.QLabel('%s:' % _("Feedrate Probe"))
+        self.feedrate_probe_label.setToolTip(
+           _("The feedrate used while the probe is probing.")
+        )
+        self.feedrate_probe_entry = FCDoubleSpinner()
+        self.feedrate_probe_entry.set_precision(self.decimals)
+        self.feedrate_probe_entry.set_range(0, 99999.9999)
+
+        grid0.addWidget(self.feedrate_probe_label, 38, 0)
+        grid0.addWidget(self.feedrate_probe_entry, 38, 1, 1, 2)
+
+        # Spindle direction
+        spindle_dir_label = QtWidgets.QLabel('%s:' % _('Spindle direction'))
+        spindle_dir_label.setToolTip(
+            _("This sets the direction that the spindle is rotating.\n"
+              "It can be either:\n"
+              "- CW = clockwise or\n"
+              "- CCW = counter clockwise")
+        )
+
+        self.spindledir_radio = RadioSet([{'label': _('CW'), 'value': 'CW'},
+                                          {'label': _('CCW'), 'value': 'CCW'}])
+        grid0.addWidget(spindle_dir_label, 40, 0)
+        grid0.addWidget(self.spindledir_radio, 40, 1, 1, 2)
+
+        self.fplunge_cb = FCCheckBox('%s' % _('Fast Plunge'))
+        self.fplunge_cb.setToolTip(
+            _("By checking this, the vertical move from\n"
+              "Z_Toolchange to Z_move is done with G0,\n"
+              "meaning the fastest speed available.\n"
+              "WARNING: the move is done at Toolchange X,Y coords.")
+        )
+        grid0.addWidget(self.fplunge_cb, 42, 0, 1, 3)
+
+        self.fretract_cb = FCCheckBox('%s' % _('Fast Retract'))
+        self.fretract_cb.setToolTip(
+            _("Exit hole strategy.\n"
+              " - When uncheked, while exiting the drilled hole the drill bit\n"
+              "will travel slow, with set feedrate (G1), up to zero depth and then\n"
+              "travel as fast as possible (G0) to the Z Move (travel height).\n"
+              " - When checked the travel from Z cut (cut depth) to Z_move\n"
+              "(travel height) is done as fast as possible (G0) in one move.")
+        )
+
+        grid0.addWidget(self.fretract_cb, 45, 0, 1, 3)
+
         self.layout.addStretch()

appObjects/FlatCAMExcellon.py

@@ -241,13 +241,18 @@ class ExcellonObject(FlatCAMObj, Excellon):
 
         self.units = self.app.defaults['units'].upper()
 
+        # fill in self.options values  for the Drilling Tool from self.app.options
+        for opt_key, opt_val in self.app.options.items():
+            if opt_key.find('tools_drill_') == 0:
+                self.options[opt_key] = deepcopy(opt_val)
+
         self.form_fields.update({
-            "plot": self.ui.plot_cb,
-            "solid": self.ui.solid_cb,
-            "multicolored": self.ui.multicolored_cb,
+            "plot":             self.ui.plot_cb,
+            "solid":            self.ui.solid_cb,
+            "multicolored":     self.ui.multicolored_cb,
 
-            "tooldia": self.ui.tooldia_entry,
-            "slot_tooldia": self.ui.slot_tooldia_entry,
+            "tooldia":          self.ui.tooldia_entry,
+            "slot_tooldia":     self.ui.slot_tooldia_entry,
         })
 
         self.to_form()
@@ -258,8 +263,13 @@ class ExcellonObject(FlatCAMObj, Excellon):
 
             self.ui.tools_table.setColumnHidden(4, True)
             self.ui.tools_table.setColumnHidden(5, True)
+            self.ui.table_visibility_cb.set_value(True)
+            self.ui.table_visibility_cb.hide()
         else:
             self.ui.level.setText('<span style="color:red;"><b>%s</b></span>' % _('Advanced'))
+            self.ui.table_visibility_cb.show()
+            self.ui.table_visibility_cb.set_value(self.app.defaults["excellon_tools_table_display"])
+            self.on_table_visibility_toggle(state=self.app.defaults["excellon_tools_table_display"])
 
         assert isinstance(self.ui, ExcellonObjectUI), \
             "Expected a ExcellonObjectUI, got %s" % type(self.ui)
@@ -278,6 +288,7 @@ class ExcellonObject(FlatCAMObj, Excellon):
         self.ui.generate_milling_slots_button.clicked.connect(self.on_generate_milling_slots_button_click)
 
         self.ui.tools_table.horizontalHeader().sectionClicked.connect(self.on_toggle_rows)
+        self.ui.table_visibility_cb.stateChanged.connect(self.on_table_visibility_toggle)
 
         self.units_found = self.app.defaults['units']
 
@@ -526,7 +537,6 @@ class ExcellonObject(FlatCAMObj, Excellon):
         # rows selected
         self.ui.tools_table.clicked.connect(self.on_row_selection_change)
 
-
     def ui_disconnect(self):
         """
         Will disconnect all signals in the Excellon UI that needs to be disconnected
@@ -671,6 +681,9 @@ class ExcellonObject(FlatCAMObj, Excellon):
             item[0] = str(item[0])
         return table_tools_items
 
+    def on_table_visibility_toggle(self, state):
+        self.ui.tools_table.show() if state else self.ui.tools_table.hide()
+
     def export_excellon(self, whole, fract, e_zeros=None, form='dec', factor=1, slot_type='routing'):
         """
         Returns two values, first is a boolean , if 1 then the file has slots and second contain the Excellon code

appTools/ToolDrilling.py

@@ -26,8 +26,6 @@ import appTranslation as fcTranslate
 import builtins
 import platform
 
-from Common import GracefulException as grace
-
 fcTranslate.apply_language('strings')
 if '_' not in builtins.__dict__:
     _ = gettext.gettext
@@ -303,36 +301,6 @@ class ToolDrilling(AppTool, Excellon):
             "format_upper_mm":              self.app.defaults["excellon_format_upper_mm"],
             "lower_mm":                     self.app.defaults["excellon_format_lower_mm"],
             "zeros":                        self.app.defaults["excellon_zeros"],
-            "excellon_units":               self.app.defaults["excellon_units"],
-            "excellon_update":              self.app.defaults["excellon_update"],
-
-            "excellon_optimization_type":   self.app.defaults["excellon_optimization_type"],
-
-            "excellon_search_time":         self.app.defaults["excellon_search_time"],
-
-            "excellon_plot_fill":           self.app.defaults["excellon_plot_fill"],
-            "excellon_plot_line":           self.app.defaults["excellon_plot_line"],
-
-            # Excellon Options
-            "tooldia":                      self.app.defaults["excellon_tooldia"],
-            "slot_tooldia":                 self.app.defaults["excellon_slot_tooldia"],
-
-            # Excellon Advanced Options
-            "offset":                       self.app.defaults["excellon_offset"],
-            "toolchangexy":                 self.app.defaults["excellon_toolchangexy"],
-            "startz":                       self.app.defaults["excellon_startz"],
-            "feedrate_rapid":               self.app.defaults["excellon_feedrate_rapid"],
-            "z_pdepth":                     self.app.defaults["excellon_z_pdepth"],
-            "feedrate_probe":               self.app.defaults["excellon_feedrate_probe"],
-            "spindledir":                   self.app.defaults["excellon_spindledir"],
-            "f_plunge":                     self.app.defaults["excellon_f_plunge"],
-            "f_retract":                    self.app.defaults["excellon_f_retract"],
-
-            "excellon_area_exclusion":      self.app.defaults["excellon_area_exclusion"],
-            "excellon_area_shape":          self.app.defaults["excellon_area_shape"],
-            "excellon_area_strategy":       self.app.defaults["excellon_area_strategy"],
-            "excellon_area_overz":          self.app.defaults["excellon_area_overz"],
-
 
             "tools_drill_tool_order":       self.app.defaults["tools_drill_tool_order"],
             "tools_drill_cutz":             self.app.defaults["tools_drill_cutz"],
@@ -357,6 +325,21 @@ class ToolDrilling(AppTool, Excellon):
             "tools_drill_drill_overlap":    self.app.defaults["tools_drill_drill_overlap"],
             "tools_drill_last_drill":       self.app.defaults["tools_drill_last_drill"],
 
+            # Advanced Options
+            "tools_drill_offset":           self.app.defaults["tools_drill_offset"],
+            "tools_drill_toolchangexy":     self.app.defaults["tools_drill_toolchangexy"],
+            "tools_drill_startz":           self.app.defaults["tools_drill_startz"],
+            "tools_drill_feedrate_rapid":   self.app.defaults["tools_drill_feedrate_rapid"],
+            "tools_drill_z_pdepth":         self.app.defaults["tools_drill_z_pdepth"],
+            "tools_drill_feedrate_probe":   self.app.defaults["tools_drill_feedrate_probe"],
+            "tools_drill_spindledir":       self.app.defaults["tools_drill_spindledir"],
+            "tools_drill_f_plunge":         self.app.defaults["tools_drill_f_plunge"],
+            "tools_drill_f_retract":        self.app.defaults["tools_drill_f_retract"],
+
+            "tools_drill_area_exclusion":   self.app.defaults["tools_drill_area_exclusion"],
+            "tools_drill_area_shape":       self.app.defaults["tools_drill_area_shape"],
+            "tools_drill_area_strategy":    self.app.defaults["tools_drill_area_strategy"],
+            "tools_drill_area_overz":       self.app.defaults["tools_drill_area_overz"],
         }
 
         # fill in self.default_data values from self.options
@@ -396,22 +379,23 @@ class ToolDrilling(AppTool, Excellon):
         self.t_ui.maxdepth_entry.set_value(self.app.defaults["tools_drill_depthperpass"])
         self.t_ui.travelz_entry.set_value(self.app.defaults["tools_drill_travelz"])
         self.t_ui.feedrate_z_entry.set_value(self.app.defaults["tools_drill_feedrate_z"])
-        self.t_ui.feedrate_rapid_entry.set_value(self.app.defaults["excellon_feedrate_rapid"])
+        self.t_ui.feedrate_rapid_entry.set_value(self.app.defaults["tools_drill_feedrate_rapid"])
         self.t_ui.spindlespeed_entry.set_value(self.app.defaults["tools_drill_spindlespeed"])
         self.t_ui.dwell_cb.set_value(self.app.defaults["tools_drill_dwell"])
         self.t_ui.dwelltime_entry.set_value(self.app.defaults["tools_drill_dwelltime"])
-        self.t_ui.offset_entry.set_value(self.app.defaults["excellon_offset"])
+        self.t_ui.offset_entry.set_value(self.app.defaults["tools_drill_offset"])
         self.t_ui.toolchange_cb.set_value(self.app.defaults["tools_drill_toolchange"])
         self.t_ui.toolchangez_entry.set_value(self.app.defaults["tools_drill_toolchangez"])
-        self.t_ui.estartz_entry.set_value(self.app.defaults["excellon_startz"])
+        self.t_ui.estartz_entry.set_value(self.app.defaults["tools_drill_startz"])
         self.t_ui.endz_entry.set_value(self.app.defaults["tools_drill_endz"])
         self.t_ui.endxy_entry.set_value(self.app.defaults["tools_drill_endxy"])
-        self.t_ui.pdepth_entry.set_value(self.app.defaults["excellon_z_pdepth"])
-        self.t_ui.feedrate_probe_entry.set_value(self.app.defaults["excellon_feedrate_probe"])
-        self.t_ui.exclusion_cb.set_value(self.app.defaults["excellon_area_exclusion"])
-        self.t_ui.strategy_radio.set_value(self.app.defaults["excellon_area_strategy"])
-        self.t_ui.over_z_entry.set_value(self.app.defaults["excellon_area_overz"])
-        self.t_ui.area_shape_radio.set_value(self.app.defaults["excellon_area_shape"])
+        self.t_ui.pdepth_entry.set_value(self.app.defaults["tools_drill_z_pdepth"])
+        self.t_ui.feedrate_probe_entry.set_value(self.app.defaults["tools_drill_feedrate_probe"])
+
+        self.t_ui.exclusion_cb.set_value(self.app.defaults["tools_drill_area_exclusion"])
+        self.t_ui.strategy_radio.set_value(self.app.defaults["tools_drill_area_shape"])
+        self.t_ui.over_z_entry.set_value(self.app.defaults["tools_drill_area_strategy"])
+        self.t_ui.area_shape_radio.set_value(self.app.defaults["tools_drill_area_overz"])
 
         # Drill slots - part of the Advanced Excellon params
         self.t_ui.drill_slots_cb.set_value(self.app.defaults["tools_drill_drill_slots"])

defaults.py

@@ -258,21 +258,8 @@ class FlatCAMDefaults:
         "excellon_tooldia": 0.8,
         "excellon_slot_tooldia": 1.8,
 
-        # Excellon Advanced Options
-        "excellon_offset": 0.0,
-        "excellon_toolchangexy": "0.0, 0.0",
-        "excellon_startz": None,
-        "excellon_feedrate_rapid": 1500,
-        "excellon_z_pdepth": -0.02,
-        "excellon_feedrate_probe": 75,
-        "excellon_spindledir": 'CW',
-        "excellon_f_plunge": False,
-        "excellon_f_retract": False,
-
-        "excellon_area_exclusion": False,
-        "excellon_area_shape": "polygon",
-        "excellon_area_strategy": "over",
-        "excellon_area_overz": 1.0,
+        # Excellon Advanced options
+        "excellon_tools_table_display": True,
 
         # Excellon Export
         "excellon_exp_units": 'INCH',
@@ -432,6 +419,22 @@ class FlatCAMDefaults:
         "tools_drill_drill_overlap": 0.0,
         "tools_drill_last_drill": True,
 
+        # Advanced Options
+        "tools_drill_offset": 0.0,
+        "tools_drill_toolchangexy": "0.0, 0.0",
+        "tools_drill_startz": None,
+        "tools_drill_feedrate_rapid": 1500,
+        "tools_drill_z_pdepth": -0.02,
+        "tools_drill_feedrate_probe": 75,
+        "tools_drill_spindledir": 'CW',
+        "tools_drill_f_plunge": False,
+        "tools_drill_f_retract": False,
+
+        "tools_drill_area_exclusion": False,
+        "tools_drill_area_shape": "polygon",
+        "tools_drill_area_strategy": "over",
+        "tools_drill_area_overz": 1.0,
+
         # NCC Tool
         "tools_ncctools": "1.0, 0.5",
         "tools_nccorder": 'rev',