- fixed drawing of selection box when dragging mouse on screen and the selection shape drawing on the selected objects

- fixed the moving drawing shape in Tool Move in legacy graphic engine
- fixed moving geometry in Tool Measurement in legacy graphic engine

FlatCAMApp.py

@@ -2474,6 +2474,11 @@ class App(QtCore.QObject):
         self.isHovering = False
         self.notHovering = True
 
+        # Event signals disconnect id holders
+        self.mp = None
+        self.mm = None
+        self.mr = None
+
         # when True, the app has to return from any thread
         self.abort_flag = False
 
@@ -7688,16 +7693,14 @@ class App(QtCore.QObject):
                         # Update cursor
                         self.app_cursor.set_data(np.asarray([(pos[0], pos[1])]),
                                                  symbol='++', edge_color='black', size=20)
-                    else:
-                        self.app_cursor.set_data(event, (pos[0], pos[1]))
                 else:
                     pos = (pos_canvas[0], pos_canvas[1])
 
                 self.ui.position_label.setText("&nbsp;&nbsp;&nbsp;&nbsp;<b>X</b>: %.4f&nbsp;&nbsp;   "
                                                "<b>Y</b>: %.4f" % (pos[0], pos[1]))
 
-                dx = pos[0] - self.rel_point1[0]
-                dy = pos[1] - self.rel_point1[1]
+                dx = pos[0] - float(self.rel_point1[0])
+                dy = pos[1] - float(self.rel_point1[1])
                 self.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
                                                    "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (dx, dy))
                 self.mouse = [pos[0], pos[1]]
@@ -7707,11 +7710,13 @@ class App(QtCore.QObject):
                     self.delete_selection_shape()
                     if dx < 0:
                         self.draw_moving_selection_shape(self.pos, pos, color=self.defaults['global_alt_sel_line'],
-                                                     face_color=self.defaults['global_alt_sel_fill'])
+                                                         face_color=self.defaults['global_alt_sel_fill'])
                         self.selection_type = False
-                    else:
+                    elif dx > 0:
                         self.draw_moving_selection_shape(self.pos, pos)
                         self.selection_type = True
+                    else:
+                        self.selection_type = None
 
                 # hover effect - enabled in Preferences -> General -> GUI Settings
                 if self.defaults['global_hover']:
@@ -7878,6 +7883,7 @@ class App(QtCore.QObject):
                         # add objects to the objects_under_the_click list only if the object is plotted
                         # (active and not disabled)
                         objects_under_the_click_list.append(obj.options['name'])
+
         try:
             # If there is no element in the overlapped objects list then make everyone inactive
             # because we selected "nothing"
@@ -8041,17 +8047,27 @@ class App(QtCore.QObject):
             hover_rect = hover_rect.buffer(-0.00393)
             hover_rect = hover_rect.buffer(0.00787)
 
+        # if color:
+        #     face = Color(color)
+        #     face.alpha = 0.2
+        #     outline = Color(color, alpha=0.8)
+        # else:
+        #     face = Color(self.defaults['global_sel_fill'])
+        #     face.alpha = 0.2
+        #     outline = self.defaults['global_sel_line']
+
         if color:
-            face = Color(color)
-            face.alpha = 0.2
-            outline = Color(color, alpha=0.8)
+            face = color[:-2] + str(hex(int(0.2 * 255)))[2:]
+            outline = color[:-2] + str(hex(int(0.8 * 255)))[2:]
         else:
-            face = Color(self.defaults['global_sel_fill'])
-            face.alpha = 0.2
+            face = self.defaults['global_sel_fill'][:-2] + str(hex(int(0.2 * 255)))[2:]
             outline = self.defaults['global_sel_line']
 
         self.hover_shapes.add(hover_rect, color=outline, face_color=face, update=True, layer=0, tolerance=None)
 
+        if self.is_legacy is True:
+            self.hover_shapes.redraw()
+
     def delete_selection_shape(self):
         self.move_tool.sel_shapes.clear()
         self.move_tool.sel_shapes.redraw()
@@ -8076,12 +8092,19 @@ class App(QtCore.QObject):
             sel_rect = sel_rect.buffer(-0.00393)
             sel_rect = sel_rect.buffer(0.00787)
 
+        # if color:
+        #     face = Color(color, alpha=0.2)
+        #     outline = Color(color, alpha=0.8)
+        # else:
+        #     face = Color(self.defaults['global_sel_fill'], alpha=0.2)
+        #     outline = Color(self.defaults['global_sel_line'], alpha=0.8)
+
         if color:
-            face = Color(color, alpha=0.2)
-            outline = Color(color, alpha=0.8)
+            face = color[:-2] + str(hex(int(0.2 * 255)))[2:]
+            outline = color[:-2] + str(hex(int(0.8 * 255)))[2:]
         else:
-            face = Color(self.defaults['global_sel_fill'], alpha=0.2)
-            outline = Color(self.defaults['global_sel_line'], alpha=0.8)
+            face = self.defaults['global_sel_fill'][:-2] + str(hex(int(0.2 * 255)))[2:]
+            outline = self.defaults['global_sel_line'][:-2] + str(hex(int(0.8 * 255)))[2:]
 
         self.sel_objects_list.append(self.move_tool.sel_shapes.add(sel_rect,
                                                                    color=outline,
@@ -8089,6 +8112,8 @@ class App(QtCore.QObject):
                                                                    update=True,
                                                                    layer=0,
                                                                    tolerance=None))
+        if self.is_legacy is True:
+            self.move_tool.sel_shapes.redraw()
 
     def draw_moving_selection_shape(self, old_coords, coords, **kwargs):
         """
@@ -8121,10 +8146,15 @@ class App(QtCore.QObject):
         pt4 = (x0, y1)
         sel_rect = Polygon([pt1, pt2, pt3, pt4])
 
-        color_t = Color(face_color)
-        color_t.alpha = face_alpha
+        # color_t = Color(face_color)
+        # color_t.alpha = face_alpha
+
+        color_t = face_color[:-2] + str(hex(int(face_alpha * 255)))[2:]
+
         self.move_tool.sel_shapes.add(sel_rect, color=color, face_color=color_t, update=True,
                                       layer=0, tolerance=None)
+        if self.is_legacy is True:
+            self.move_tool.sel_shapes.redraw()
 
     def on_file_new_click(self):
         if self.collection.get_list() and self.should_we_save:

README.md

@@ -18,6 +18,9 @@ CAD program, and create G-Code for Isolation routing.
 - in legacy graphic engine fixed the travel vs cut lines in CNCJob objects
 - final fix for key shortcuts with modifier in legacy graphic engine
 - refactored some of the code in the legacy graphic engine
+- fixed drawing of selection box when dragging mouse on screen and the selection shape drawing on the selected objects
+- fixed the moving drawing shape in Tool Move in legacy graphic engine
+- fixed moving geometry in Tool Measurement in legacy graphic engine
 
 20.09.2019
 

flatcamEditors/FlatCAMExcEditor.py

@@ -2088,6 +2088,11 @@ class FlatCAMExcEditor(QtCore.QObject):
         def entry2option(option, entry):
             self.options[option] = float(entry.text())
 
+        # Event signals disconnect id holders
+        self.mp = None
+        self.mm = None
+        self.mr = None
+
         # 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 FlatCAM Excellon Editor is finished ...")
@@ -3307,9 +3312,6 @@ class FlatCAMExcEditor(QtCore.QObject):
 
         if self.app.grid_status() == True:
             self.pos  = self.app.geo_editor.snap(self.pos[0], self.pos[1])
-            # Update cursor
-            self.app.app_cursor.set_data(np.asarray([(self.pos[0], self.pos[1])]), symbol='++', edge_color='black',
-                                         size=20)
         else:
             self.pos = (self.pos[0], self.pos[1])
 

flatcamEditors/FlatCAMGeoEditor.py

@@ -3169,6 +3169,11 @@ class FlatCAMGeoEditor(QtCore.QObject):
 
         self.transform_complete.connect(self.on_transform_complete)
 
+        # Event signals disconnect id holders
+        self.mp = None
+        self.mm = None
+        self.mr = None
+
         # 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 FlatCAM Geometry Editor is finished ...")
@@ -3326,6 +3331,7 @@ class FlatCAMGeoEditor(QtCore.QObject):
             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_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)
@@ -3652,9 +3658,6 @@ class FlatCAMGeoEditor(QtCore.QObject):
 
         if self.app.grid_status() == True:
             self.pos = self.app.geo_editor.snap(self.pos[0], self.pos[1])
-            # Update cursor
-            self.app.app_cursor.set_data(np.asarray([(self.pos[0], self.pos[1])]), symbol='++', edge_color='black',
-                                         size=20)
         else:
             self.pos = (self.pos[0], self.pos[1])
 

flatcamEditors/FlatCAMGrbEditor.py

@@ -2833,6 +2833,11 @@ class FlatCAMGrbEditor(QtCore.QObject):
 
         self.app.pool_recreated.connect(self.pool_recreated)
 
+        # Event signals disconnect id holders
+        self.mp = None
+        self.mm = None
+        self.mr = None
+
         # Remove from scene
         self.shapes.enabled = False
         self.tool_shape.enabled = False
@@ -4154,9 +4159,6 @@ class FlatCAMGrbEditor(QtCore.QObject):
 
         if self.app.grid_status() == True:
             self.pos = self.app.geo_editor.snap(self.pos[0], self.pos[1])
-            # Update cursor
-            self.app.app_cursor.set_data(np.asarray([(self.pos[0], self.pos[1])]), symbol='++', edge_color='black',
-                                         size=20)
         else:
             self.pos = (self.pos[0], self.pos[1])
 

flatcamGUI/PlotCanvasLegacy.py

@@ -715,8 +715,13 @@ class ShapeCollectionLegacy():
     def add(self, shape=None, color=None, face_color=None, alpha=None, visible=True,
             update=False, layer=1, tolerance=0.01, obj=None, gcode_parsed=None, tool_tolerance=None, tooldia=None):
 
+
         self._color = color[:-2] if color is not None else None
         self._face_color = face_color[:-2] if face_color is not None else None
+        self._alpha = int(face_color[-2:], 16) / 255 if face_color is not None else 0.75
+        if alpha is not None:
+            self._alpha = alpha
+
         self._visible = visible
         self._update = update
 
@@ -726,12 +731,16 @@ class ShapeCollectionLegacy():
         self._tool_tolerance = tool_tolerance
         self._tooldia = tooldia
 
+        # if self._update:
+        #     self.clear()
+
         try:
             for sh in shape:
                 self.shape_id += 1
                 self.shape_dict.update({
                     'color': self._color,
                     'face_color': self._face_color,
+                    'alpha': self._alpha,
                     'shape': sh
                 })
 
@@ -743,6 +752,7 @@ class ShapeCollectionLegacy():
             self.shape_dict.update({
                 'color': self._color,
                 'face_color': self._face_color,
+                'alpha': self._alpha,
                 'shape': shape
             })
 
@@ -764,15 +774,19 @@ class ShapeCollectionLegacy():
 
     def redraw(self):
         path_num = 0
+        try:
+            obj_type = self.obj.kind
+        except AttributeError:
+            obj_type = 'utility'
         if self._visible:
             for element in self._shapes:
-                if self.obj.kind == 'excellon':
+                if obj_type == 'excellon':
                     # Plot excellon (All polygons?)
                     if self.obj.options["solid"]:
                         patch = PolygonPatch(self._shapes[element]['shape'],
                                              facecolor="#C40000",
                                              edgecolor="#750000",
-                                             alpha=0.75,
+                                             alpha=self._shapes[element]['alpha'],
                                              zorder=3)
                         self.axes.add_patch(patch)
                     else:
@@ -781,7 +795,7 @@ class ShapeCollectionLegacy():
                         for ints in self._shapes[element]['shape'].interiors:
                             x, y = ints.coords.xy
                             self.axes.plot(x, y, 'o-')
-                elif self.obj.kind == 'geometry':
+                elif obj_type== 'geometry':
                     if type(self._shapes[element]['shape']) == Polygon:
                         x, y = self._shapes[element]['shape'].exterior.coords.xy
                         self.axes.plot(x, y, self._shapes[element]['color'], linestyle='-')
@@ -792,7 +806,7 @@ class ShapeCollectionLegacy():
                         x, y = element.coords.xy
                         self.axes.plot(x, y, self._shapes[element]['color'], marker='-')
                         return
-                elif self.obj.kind == 'gerber':
+                elif obj_type == 'gerber':
                     if self.obj.options["multicolored"]:
                         linespec = '-'
                     else:
@@ -803,7 +817,7 @@ class ShapeCollectionLegacy():
                             patch = PolygonPatch(self._shapes[element]['shape'],
                                                  facecolor=self._shapes[element]['face_color'],
                                                  edgecolor=self._shapes[element]['color'],
-                                                 alpha=0.75,
+                                                 alpha=self._shapes[element]['alpha'],
                                                  zorder=2)
                             self.axes.add_patch(patch)
                         except AssertionError:
@@ -815,7 +829,7 @@ class ShapeCollectionLegacy():
                         for ints in self._shapes[element]['shape'].interiors:
                             x, y = ints.coords.xy
                             self.axes.plot(x, y, linespec)
-                elif self.obj.kind == 'cncjob':
+                elif obj_type == 'cncjob':
 
                     if self._shapes[element]['face_color'] is None:
                         linespec = '--'
@@ -828,16 +842,39 @@ class ShapeCollectionLegacy():
                         path_num += 1
                         if isinstance(self._shapes[element]['shape'], Polygon):
                             self.axes.annotate(str(path_num), xy=self._shapes[element]['shape'].exterior.coords[0],
-                                               xycoords='data')
+                                               xycoords='data', fontsize=20)
                         else:
                             self.axes.annotate(str(path_num), xy=self._shapes[element]['shape'].coords[0],
-                                               xycoords='data')
+                                               xycoords='data', fontsize=20)
 
                         patch = PolygonPatch(self._shapes[element]['shape'],
                                              facecolor=self._shapes[element]['face_color'],
                                              edgecolor=self._shapes[element]['color'],
-                                             alpha=0.75, zorder=2)
+                                             alpha=self._shapes[element]['alpha'], zorder=2)
                         self.axes.add_patch(patch)
+                elif obj_type == 'utility':
+                    # not a FlatCAM object, must be utility
+                    if self._shapes[element]['face_color']:
+                        try:
+                            patch = PolygonPatch(self._shapes[element]['shape'],
+                                                 facecolor=self._shapes[element]['face_color'],
+                                                 edgecolor=self._shapes[element]['color'],
+                                                 alpha=self._shapes[element]['alpha'],
+                                                 zorder=2)
+                            self.axes.add_patch(patch)
+                        except AssertionError:
+                            FlatCAMApp.App.log.warning("A geometry component was not a polygon:")
+                            FlatCAMApp.App.log.warning(str(element))
+                    else:
+                        if isinstance(self._shapes[element]['shape'], Polygon):
+                            x, y = self._shapes[element]['shape'].exterior.xy
+                            self.axes.plot(x, y, self._shapes[element]['color'], linestyle='-')
+                            for ints in self._shapes[element]['shape'].interiors:
+                                x, y = ints.coords.xy
+                                self.axes.plot(x, y, self._shapes[element]['color'], linestyle='-')
+                        else:
+                            x, y = self._shapes[element]['shape'].coords.xy
+                            self.axes.plot(x, y, self._shapes[element]['color'], linestyle='-')
 
         self.app.plotcanvas.auto_adjust_axes()
 

flatcamTools/ToolMeasurement.py

@@ -310,8 +310,7 @@ class Measurement(FlatCAMTool):
             if len(self.points) == 1:
                 self.start_entry.set_value("(%.4f, %.4f)" % pos)
                 self.app.inform.emit(_("MEASURING: Click on the Destination point ..."))
-
-            if len(self.points) == 2:
+            elif len(self.points) == 2:
                 dx = self.points[1][0] - self.points[0][0]
                 dy = self.points[1][1] - self.points[0][1]
                 d = sqrt(dx ** 2 + dy ** 2)
@@ -323,8 +322,8 @@ class Measurement(FlatCAMTool):
                 self.distance_x_entry.set_value('%.4f' % abs(dx))
                 self.distance_y_entry.set_value('%.4f' % abs(dy))
                 self.total_distance_entry.set_value('%.4f' % abs(d))
-                self.app.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
-                                                       "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (pos[0], pos[1]))
+                self.app.ui.rel_position_label.setText("<b>Dx</b>: {0:.4f}&nbsp;&nbsp;  <b>Dy</b>: "
+                                                       "{0:.4f}&nbsp;&nbsp;&nbsp;&nbsp;".format(pos[0], pos[1]))
                 self.deactivate_measure_tool()
 
     def on_mouse_move_meas(self, event):
@@ -334,39 +333,57 @@ class Measurement(FlatCAMTool):
             else:
                 event_pos = (event.xdata, event.ydata)
 
-            pos_canvas = self.app.plotcanvas.translate_coords(event_pos)
+            try:
+                x = float(event_pos[0])
+                y = float(event_pos[1])
+            except TypeError:
+                return
+
+            pos_canvas = self.app.plotcanvas.translate_coords((x, y))
+
             if self.app.grid_status() == True:
                 pos = self.app.geo_editor.snap(pos_canvas[0], pos_canvas[1])
-                # Update cursor
-                self.app.app_cursor.set_data(np.asarray([(pos[0], pos[1])]),
-                                             symbol='++', edge_color='black', size=20)
+                if self.app.is_legacy is False:
+                    # Update cursor
+                    self.app.app_cursor.set_data(np.asarray([(pos[0], pos[1])]),
+                                                 symbol='++', edge_color='black', size=20)
             else:
                 pos = (pos_canvas[0], pos_canvas[1])
 
+            self.app.ui.position_label.setText("&nbsp;&nbsp;&nbsp;&nbsp;<b>X</b>: {0:.4f}&nbsp;&nbsp;   "
+                                               "<b>Y</b>: {0:.4f}".format(pos[0], pos[1]))
+
             if self.rel_point1 is not None:
-                dx = pos[0] - self.rel_point1[0]
-                dy = pos[1] - self.rel_point1[1]
+                dx = pos[0] - float(self.rel_point1[0])
+                dy = pos[1] - float(self.rel_point1[1])
             else:
                 dx = pos[0]
                 dy = pos[1]
 
-            self.app.ui.position_label.setText("&nbsp;&nbsp;&nbsp;&nbsp;<b>X</b>: %.4f&nbsp;&nbsp;   "
-                                               "<b>Y</b>: %.4f" % (pos[0], pos[1]))
-            self.app.ui.rel_position_label.setText("<b>Dx</b>: %.4f&nbsp;&nbsp;  <b>Dy</b>: "
-                                                   "%.4f&nbsp;&nbsp;&nbsp;&nbsp;" % (dx, dy))
+            self.app.ui.rel_position_label.setText("<b>Dx</b>: {0:.4f}&nbsp;&nbsp;  <b>Dy</b>: "
+                                                   "{0:.4f}&nbsp;&nbsp;&nbsp;&nbsp;".format(dx, dy))
+
             # update utility geometry
+
             if len(self.points) == 1:
                 self.utility_geometry(pos=pos)
         except Exception as e:
+            log.debug("Measurement.on_mouse_move_meas() --> %s" % str(e))
             self.app.ui.position_label.setText("")
             self.app.ui.rel_position_label.setText("")
 
     def utility_geometry(self, pos):
         # first delete old shape
         self.delete_shape()
+
         # second draw the new shape of the utility geometry
-        self.meas_line = LineString([pos, self.points[0]])
-        self.sel_shapes.add(self.meas_line, color='black', update=True, layer=0, tolerance=None)
+        meas_line = LineString([pos, self.points[0]])
+
+        color = '#00000000'
+        self.sel_shapes.add(meas_line, color=color, update=True, layer=0, tolerance=None)
+
+        if self.app.is_legacy is True:
+            self.sel_shapes.redraw()
 
     def delete_shape(self):
         self.sel_shapes.clear()

flatcamTools/ToolMove.py

@@ -212,7 +212,14 @@ class ToolMove(FlatCAMTool):
             event_pos = event.pos
         else:
             event_pos = (event.xdata, event.ydata)
-        pos_canvas = self.app.plotcanvas.translate_coords(event_pos)
+
+        try:
+            x = float(event_pos[0])
+            y = float(event_pos[1])
+        except TypeError:
+            return
+
+        pos_canvas = self.app.plotcanvas.translate_coords((x, y))
 
         # if GRID is active we need to get the snapped positions
         if self.app.grid_status() == True:
@@ -270,8 +277,12 @@ class ToolMove(FlatCAMTool):
             p2 = (xmaximal, yminimal)
             p3 = (xmaximal, ymaximal)
             p4 = (xminimal, ymaximal)
+
             self.old_coords = [p1, p2, p3, p4]
-            self.draw_shape(self.old_coords)
+            self.draw_shape(Polygon(self.old_coords))
+
+            if self.app.is_legacy is True:
+                self.sel_shapes.redraw()
 
     def update_sel_bbox(self, pos):
         self.delete_shape()
@@ -280,24 +291,30 @@ class ToolMove(FlatCAMTool):
         pt2 = (self.old_coords[1][0] + pos[0], self.old_coords[1][1] + pos[1])
         pt3 = (self.old_coords[2][0] + pos[0], self.old_coords[2][1] + pos[1])
         pt4 = (self.old_coords[3][0] + pos[0], self.old_coords[3][1] + pos[1])
+        self.draw_shape(Polygon([pt1, pt2, pt3, pt4]))
 
-        self.draw_shape([pt1, pt2, pt3, pt4])
+        if self.app.is_legacy is True:
+            self.sel_shapes.redraw()
 
     def delete_shape(self):
         self.sel_shapes.clear()
         self.sel_shapes.redraw()
 
-    def draw_shape(self, coords):
-        self.sel_rect = Polygon(coords)
+    def draw_shape(self, shape):
+
         if self.app.ui.general_defaults_form.general_app_group.units_radio.get_value().upper() == 'MM':
-            self.sel_rect = self.sel_rect.buffer(-0.1)
-            self.sel_rect = self.sel_rect.buffer(0.2)
+            proc_shape = shape.buffer(-0.1)
+            proc_shape = proc_shape.buffer(0.2)
         else:
-            self.sel_rect = self.sel_rect.buffer(-0.00393)
-            self.sel_rect = self.sel_rect.buffer(0.00787)
+            proc_shape = shape.buffer(-0.00393)
+            proc_shape = proc_shape.buffer(0.00787)
+
+        # face = Color('blue')
+        # face.alpha = 0.2
+
+        face = '#0000FFAF' + str(hex(int(0.2 * 255)))[2:]
+        outline = '#0000FFAF'
 
-        blue_t = Color('blue')
-        blue_t.alpha = 0.2
-        self.sel_shapes.add(self.sel_rect, color='blue', face_color=blue_t, update=True, layer=0, tolerance=None)
+        self.sel_shapes.add(proc_shape, color=outline, face_color=face, update=True, layer=0, tolerance=None)
 
 # end of file