Create a new descendant thought by dragging a handle

3 files changed, 88 insertions, 8 deletions

diff --git a/model.py b/model.py
index 38d1ca6..f15758b 100644
--- a/model.py
+++ b/model.py
@@ -31,9 +31,14 @@ class MindMapModel(gtk.TreeStore):
         self._thoughts_by_id = {}
         self._thoughts = []
 
-    def create_new_thought(self, name='', x=0, y=0, color=''):
+    def create_new_thought(self, name='', x=0, y=0, color='', parent_id=None):
         thought_id = self._next_thought_id
-        self.append(None, (thought_id, name, x, y, color))
+
+        parent = None
+        if parent_id is not None:
+            parent = self.find_by_id(parent_id).iter
+
+        self.append(parent, (thought_id, name, x, y, color))
         self._next_thought_id += 1
         return thought_id
 
@@ -68,5 +73,11 @@ class MindMapModel(gtk.TreeStore):
         for row in rows:
             if row[0] == thought_id:
                 return row
-            self.find_by_id(thought_id, row.iterchildren())
+
+            children = row.iterchildren()
+            found_row = self.find_by_id(thought_id, children)
+            if found_row is not None:
+                return found_row
+
+        return None
 
diff --git a/thoughtview.py b/thoughtview.py
index d3ecc1c..478dd00 100644
--- a/thoughtview.py
+++ b/thoughtview.py
@@ -24,6 +24,7 @@ import gtk
 from sugar.graphics import style
 
 from gaphas.examples import Box, Text
+from gaphas.connector import Handle
 
 class ThoughtView(Box):
 
@@ -33,7 +34,8 @@ class ThoughtView(Box):
     def __init__(self, thought_id, name, x, y, color):
         Box.__init__(self)
 
-        logging.debug('ThoughtView %r %r' % (thought_id, name))
+        self.new_thought_handle = Handle()
+        self._handles.append(self.new_thought_handle)
         
         self.id = thought_id
         self._name = name
@@ -93,3 +95,9 @@ class ThoughtView(Box):
         context.cairo.show_layout(layout)
         context.cairo.restore()
 
+    def normalize(self):
+        updated = super(ThoughtView, self).normalize()
+        self.new_thought_handle.x = 20
+        self.new_thought_handle.y = 20
+        return updated
+
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)
+