use drag_source_set instead of manual activation

Author: vantu5z

GraphView/drag_n_drop.py

@@ -20,24 +20,34 @@ class DragAndDrop():
     Add Drag-n-Drop feature to GraphView addon.
     """
 
-    def __init__(self, widget, dbstate):
-        self.ready = False          # True - when drag can be started
-        self.do_drag = False        # True - when drag is started
-
+    def __init__(self, canvas, dbstate):
         self.drag_person = None
         self.drag_family = None
 
         self.dbstate = dbstate
-        self.widget = widget
-        self.widget.connect("drag_data_get", self.drag_data_get)
-        self.widget.connect("drag_begin", self.begin)
-        self.widget.connect("drag_end", self.stop)
+        self.canvas = canvas
+        self.canvas.connect("drag_data_get", self.drag_data_get)
+        self.canvas.connect("drag_begin", self.begin)
+        self.canvas.connect("drag_end", self.stop)
+
+        self.enable_dnd(True)
+
+    def enable_dnd(self, state):
+        """
+        Enable or disable drag-n-drop for canvas widget.
+        """
+        if state:
+            self.canvas.drag_source_set(
+                Gdk.ModifierType.BUTTON1_MASK,
+                [],
+                Gdk.DragAction.COPY)
+        else:
+            self.canvas.drag_source_unset()
 
     def begin(self, widget, context):
         """
         Called when drag is start.
         """
-        self.do_drag = True
         tgs = [x.name() for x in context.list_targets()]
         # set icon depending on person or family drag
         if DdTargets.PERSON_LINK.drag_type in tgs:
@@ -49,29 +59,36 @@ def stop(self, *args):
         """
         Called when drag is end.
         """
-        self.ready = False
-        self.do_drag = False
         self.drag_person = None
         self.drag_family = None
 
-    def is_ready(self):
+    def set_target(self, node_class, handle):
         """
-        Check if we ready to drag.
-        """
-        return self.ready and (not self.do_drag)
-
-    def set_ready(self, node_class, handle):
-        """
-        Set ready to drag state.
+        Set targets for drag-n-drop.
         """
         self.stop()
+        tglist = Gtk.TargetList.new([])
         if node_class == 'node':
             self.drag_person = self.dbstate.db.get_person_from_handle(handle)
+            tglist.add(DdTargets.PERSON_LINK.atom_drag_type,
+                       DdTargets.PERSON_LINK.target_flags,
+                       DdTargets.PERSON_LINK.app_id,
+                       )
+            # allow drag to a text document, info on drag_get will be 0
+            tglist.add_text_targets(0)
         elif node_class == 'familynode':
             self.drag_family = self.dbstate.db.get_family_from_handle(handle)
+            tglist.add(DdTargets.FAMILY_LINK.atom_drag_type,
+                       DdTargets.FAMILY_LINK.target_flags,
+                       DdTargets.FAMILY_LINK.app_id,
+                       )
+            # allow drag to a text document, info on drag_get will be 1
+            tglist.add_text_targets(1)
 
-        if self.drag_person or self.drag_family:
-            self.ready = True
+        if tglist:
+            self.canvas.drag_source_set_target_list(tglist)
+        else:
+            self.enable_dnd(False)
 
     def drag_data_get(self, widget, context, sel_data, info, time):
         """
@@ -109,33 +126,3 @@ def drag_data_get(self, widget, context, sel_data, info, time):
                     mother = '...'
                 sel_data.set_text(
                     _('Family of %s and %s') % (father, mother), -1)
-
-    def start_drag(self, pos_x, pos_y, event):
-        """
-        Activate drag.
-        """
-        # setup targets
-        tglist = Gtk.TargetList.new([])
-        if self.drag_person is not None:
-            tglist.add(DdTargets.PERSON_LINK.atom_drag_type,
-                       DdTargets.PERSON_LINK.target_flags,
-                       DdTargets.PERSON_LINK.app_id,
-                       )
-            # allow drag to a text document, info on drag_get will be 0
-            tglist.add_text_targets(0)
-        if self.drag_family is not None:
-            tglist.add(DdTargets.FAMILY_LINK.atom_drag_type,
-                       DdTargets.FAMILY_LINK.target_flags,
-                       DdTargets.FAMILY_LINK.app_id,
-                       )
-            # allow drag to a text document, info on drag_get will be 1
-            tglist.add_text_targets(1)
-
-        # start drag
-        self.widget.drag_begin_with_coordinates(
-            tglist,
-            Gdk.DragAction.COPY,
-            1,                      # left mouse button = 1
-            event,
-            pos_x, pos_y)
-        return True

GraphView/graphview.py

@@ -1154,7 +1154,8 @@ def __init__(self, view, dbstate, uistate):
         self.bold_size = self.norm_size = 0  # font sizes to send to dot
 
         # setup drag and drop
-        self.dnd = DragAndDrop(self.get_widget(), self.dbstate)
+        self.dnd = DragAndDrop(self.canvas, self.dbstate)
+        self.canvas.connect("drag-begin", self.del_click_events)
 
     def add_popover(self, widget, container):
         """
@@ -1474,8 +1475,6 @@ def populate(self, active_person):
         if self.uistate.window.get_window().is_visible():
             process_pending_events()
 
-        self.dnd.stop()
-
         self.clear()
         self.active_person_handle = active_person
 
@@ -1606,7 +1605,8 @@ def button_press(self, item, _target, event):
             return False
 
         button = event.get_button()[1]
-        if button == 1 or button == 2:
+        if button in (1, 2):
+            self.dnd.enable_dnd(False)
             window = self.canvas.get_parent().get_window()
             window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.FLEUR))
             self._last_x = event.x_root
@@ -1626,14 +1626,14 @@ def button_release(self, item, target, event):
         """
         Exit from scroll mode when button release.
         """
-        self.dnd.stop()
         button = event.get_button()[1]
         if((button == 1 or button == 2) and
            event.type == getattr(Gdk.EventType, "BUTTON_RELEASE")):
 
             self.motion_notify_event(item, target, event)
             self.canvas.get_parent().get_window().set_cursor(None)
             self._in_move = False
+            self.dnd.enable_dnd(True)
             return True
         return False
 
@@ -1655,29 +1655,6 @@ def motion_notify_event(self, _item, _target, event):
                      (event.y_root - self._last_y) * scale_coef)
             self.vadjustment.set_value(new_y)
             return True
-
-        if not (event.type == Gdk.EventType.MOTION_NOTIFY):
-            return False
-
-        if self.dnd.is_ready():
-            # start drag when cursor moved more then 5
-            # to separate it from simple click
-            if ((abs(self._last_x - event.x_root) > 5)
-                    or (abs(self._last_y - event.y_root) > 5)):
-                self.uistate.set_busy_cursor(False)
-                # Remove all single click events
-                for click_item in self.click_events:
-                    if not click_item.is_destroyed():
-                        GLib.source_remove(click_item.get_id())
-                self.click_events.clear()
-
-                # translate to drag_widget coords
-                scale_coef = self.canvas.get_scale()
-                x = self._last_x * scale_coef - self.hadjustment.get_value()
-                y = self._last_y * scale_coef - self.vadjustment.get_value()
-
-                self.dnd.start_drag(x, y, event)
-
         return False
 
     def set_zoom(self, value):
@@ -1688,6 +1665,15 @@ def set_zoom(self, value):
         self.view._config.set('interface.graphview-scale', value)
         self.canvas.set_scale(value / self.transform_scale)
 
+    def del_click_events(self, *args):
+        """
+        Remove all single click events.
+        """
+        for click_item in self.click_events:
+            if not click_item.is_destroyed():
+                GLib.source_remove(click_item.get_id())
+        self.click_events.clear()
+
     def select_node(self, item, target, event):
         """
         Perform actions when a node is clicked.
@@ -1704,11 +1690,7 @@ def select_node(self, item, target, event):
 
         # perform double click on node by left mouse button
         if event.type == getattr(Gdk.EventType, "DOUBLE_BUTTON_PRESS"):
-            # Remove all single click events
-            for click_item in self.click_events:
-                if not click_item.is_destroyed():
-                    GLib.source_remove(click_item.get_id())
-            self.click_events.clear()
+            self.del_click_events()
             if button == 1 and node_class == 'node':
                 GLib.idle_add(self.actions.edit_person, None, handle)
                 return True
@@ -1719,11 +1701,8 @@ def select_node(self, item, target, event):
         if event.type != getattr(Gdk.EventType, "BUTTON_PRESS"):
             return False
 
-        if button == 1 and node_class:                      # left mouse
-            # set drag mode, it will be applied on motion event
-            self.dnd.set_ready(node_class, handle)
-            self._last_x = event.x_root
-            self._last_y = event.y_root
+        if button == 1 and node_class in ('node', 'familynode'):
+            self.dnd.set_target(node_class, handle)
 
         if button == 1 and node_class == 'node':            # left mouse
             if handle == self.active_person_handle: