Create a new descendant thought by dragging a handle

1 files changed, 65 insertions, 4 deletions

diff --git a/view.py b/view.py
index ccbbc82..26725a1 100644
--- a/view.py
+++ b/view.py
@@ -19,7 +19,8 @@ from gettext import gettext as _
 
 import gobject
 import gtk
-from gaphas import GtkView, Canvas, state
+from gaphas import GtkView, Canvas, state, Line
+from gaphas.tool import HandleTool, DefaultTool, ConnectHandleTool
 
 # We'd rather not depend on sugar in this class
 from sugar.graphics import style
@@ -34,12 +35,15 @@ class MindMapView(GtkView):
         self._model = None
         self._row_changed_sid = None
         self._row_deleted_sid = None
-        self._selected_thought = None
 
         GtkView.__init__(self)
 
         self.canvas = Canvas()
 
+        tool = DefaultTool()
+        tool.prepend(NewThoughtTool())
+        self.tool = tool
+
         if model is not None:
             self.model = model
 
@@ -87,9 +91,9 @@ class MindMapView(GtkView):
     model = property(get_model, set_model)
 
     def __row_changed_cb(self, model, path, iter):
-        #logging.debug('__row_changed_cb %r' % path)
-
         row = model[iter]
+        #logging.debug('__row_changed_cb %r' % ((row[0], row[1], row[2], row[3], row[4],),))
+
         thought_view = self._get_thought_by_id(row[0])
         if thought_view is None:
             thought_view = ThoughtView(row[0], row[1], row[2], row[3], row[4])
@@ -116,3 +120,60 @@ class MindMapView(GtkView):
                 return item
         return None
 
+class NewThoughtTool(HandleTool):
+
+    def __init__(self):
+        HandleTool.__init__(self)
+        self._new_connection = None
+        self._parent_thought = None
+
+    def grab_handle(self, item, handle):
+        logging.debug('NewThoughtTool.grab_handle %r %r' % (item, handle))
+        HandleTool.grab_handle(self, item, handle)
+
+    def ungrab_handle(self):
+        logging.debug('NewThoughtTool.ungrab_handle')
+        HandleTool.ungrab_handle(self)
+        self._new_connection = None
+
+    def on_button_release(self, context, event):
+        HandleTool.on_button_release(self, context, event)
+        context.view.model.create_new_thought(x=event.x, y=event.y,
+                                              parent_id=self._parent_thought.id)
+
+    def move(self, view, item, handle, pos):
+        #logging.debug('NewThoughtTool.move')
+        if isinstance(item, ThoughtView) and handle == item.new_thought_handle:
+            matrix = view.canvas.get_matrix_i2c(item)
+            offset = matrix[4], matrix[5]
+
+            if self._new_connection is None:
+                self._new_connection = Line()
+                view.canvas.add(self._new_connection)
+                start_handle = self._new_connection.handles()[0]
+                start_handle.x = item.handles()[4].pos[0] + offset[0]
+                start_handle.y = item.handles()[4].pos[1] + offset[1]
+                #logging.debug('created line starting at %r %r' % item.handles()[4].pos)
+
+                self._parent_thought = item
+
+            end_handle = self._new_connection.handles()[1]
+            end_handle.x = pos[0]
+            end_handle.y = pos[1]
+            view.canvas.request_update(self._new_connection)
+            #logging.debug('moved line end to %r %r' % (end_handle.x, end_handle.y))
+        else:
+            HandleTool.move(self, view, item, handle, pos)
+
+    def glue(self, view, item, handle, vpos):
+        #logging.debug('NewThoughtTool.glue')
+        HandleTool.glue(self, view, item, handle, vpos)
+
+    def connect(self, view, item, handle, vpos):
+        logging.debug('NewThoughtTool.connect')
+        HandleTool.connect(self, view, item, handle, vpos)
+
+    def disconnect(self, view, item, handle):
+        logging.debug('NewThoughtTool.disconnect')
+        HandleTool.disconnect(self, view, item, handle)
+