Load graph function fully working.

Author: Minimuino

examples/RPN_test.kv

@@ -13,33 +13,33 @@ RootWidget:
     AtomWidget:
         pos: [769.0, 892.0]
         color: .800, .800, .800
-        atom_name: 'a'
+        text: 'a'
     AtomWidget:
         pos: [1010.0, 891.0]
         color: .800, .800, .800
-        atom_name: 'b'
+        text: 'b'
     EllipseWidget:
         pos: [606.0, 326.0]
         color: .800, .800, .800
         size: [629.0, 501.0000000000001]
         AtomWidget:
             pos: [749.0, 695.0]
-            atom_name: 'c'
+            text: 'c'
         SquareWidget:
             pos: [728.0, 452.0]
             size: [411.0, 141.0]
             AtomWidget:
                 pos: [791.0, 513.0]
                 color: .800, .800, .800
-                atom_name: 'd'
+                text: 'd'
             AtomWidget:
                 pos: [972.0, 506.0]
                 color: .800, .800, .800
-                atom_name: 'e'
+                text: 'e'
         SquareWidget:
             pos: [974.0, 626.0]
             size: [140.0, 113.0]
             AtomWidget:
                 pos: [1011.0, 670.0]
                 color: .800, .800, .800
-                atom_name: 'f'
+                text: 'f'

src/asp_graph.py

@@ -296,8 +296,12 @@ def get_tree(self, depth):
         if (depth % 2) <> 0:
             strl.append(' '*4*(depth+1) + 'color: .800, .800, .800')
         if isinstance(self, AtomWidget):
+            strl.append(' '*4*(depth+1) + 'text: \'{0}\''.format(self.text))
             strl.append(' '*4*(depth+1) +
-                        'atom_name: \'{0}\''.format(self.text))
+                        'line_info: {0}'.format(self.get_line_info_str()))
+        elif isinstance(self, NexusWidget):
+            strl.append(' '*4*(depth+1) +
+                        'line_info: {0}'.format(self.get_line_info_str()))
         else:
             for ch in self.children:
                 strl.append(ch.get_tree(depth+1))
@@ -578,20 +582,45 @@ def test_all_collisions(cls, widget):
     def get_all_lines(cls):
         return tuple(cls._lines)
 
-    def __init__(self, hook):
+    @classmethod
+    def clear_lines(cls):
+        while cls._lines:
+            cls._lines[0].delete()
+
+    @classmethod
+    def build_from_graph(cls, graph, hook_list):
+        line = cls()
+
+        def _build(node, seen):
+            not_seen = set(graph[node]) - seen
+            hook0 = hook_list[node]
+            hook0.line = line
+            for n in not_seen:
+                hook1 = hook_list[n]
+                line._add_segment(hook0, hook1)
+                hook1.line = line
+                _build(n, seen.union({node}))
+
+        _build(0, set())
+        line.hook_list = hook_list
+        line.grabbed_segment = None
+        line._updated = False
+
+    def __init__(self, hook=None):
         self.segment_list = []
-        self.hook_list = [hook]
+        self.hook_list = [hook] if hook is not None else None
         self.grabbed_segment = None
-        self.grabbed_hook = hook
+        self.grabbed_hook = hook if hook is not None else None
         self.line_id = len(Line._lines)
-        self._add_segment(hook, hook)
+        if hook is not None:
+            self._add_segment(hook, hook)
         Line._lines.append(self)
         # Graph
         self._updated = True
         self._graph = {0: []}
         self._components = [[0]]
         # TODO: remove this attribute if not necessary
-        self._containers = [hook.get_container()]
+        self._containers = [hook.get_container()] if hook is not None else []
 
     def _add_segment(self, hook0, hook1):
         s = Segment(hook0, hook1)
@@ -652,6 +681,12 @@ def _update_graph(self):
         #                        if key in hacl}
         #     return Line.connected_components(container_graph)
 
+    def get_full_graph(self):
+        graph = {}
+        for i, hook in enumerate(self.hook_list):
+            graph[i] = [self._get_hook_index(h) for h in self._get_connected_hooks(hook)]
+        return graph
+
     def get_segment_ids(self, hook):
         l = []
         for i, s in enumerate(self.segment_list):
@@ -897,6 +932,7 @@ class NexusWidget(HookWidget):
 
     def __init__(self, **kwargs):
         super(NexusWidget, self).__init__(**kwargs)
+        self.line_info = []
         # Init position correction
         self.pos = (self.pos[0] - self.width/2, self.pos[1] - self.height/2)
 
@@ -981,6 +1017,10 @@ def get_as_text(self, connective='&'):
             txt += '(' + first_var + ' = ' + var + ')'
         return txt
 
+    def get_line_info_str(self):
+        return '[({0}, {1})]'.format(self.line.line_id,
+                                     self.line._get_hook_index(self))
+
 class Atom(widget.Widget):
 
     name = prop.StringProperty('')
@@ -1030,8 +1070,9 @@ def _deferred_init(self):
         '''Special method to be called only when loading an AtomWidget from a
         save file.
         '''
-        # Only if self was loaded from a file, it will have an `atom_name` field
-        self.atom = NameManager.Instance().get(self.atom_name)
+        # Only if self was loaded from a file, it will have a valid text field
+        # equal to the name of the corresponding Atom
+        self.atom = NameManager.Instance().get(self.text)
         self.text = self.atom.name
         self.hook_points = self.atom.hook_points
 
@@ -1116,6 +1157,44 @@ def get_as_text(self):
             txt += ')'
         return txt
 
+    def get_line_info(self):
+        assert len(self.line_info) == len(filter(lambda x: x==True, self._hook_points))
+        i = 0
+        result = []
+        if self._hook_points[0]:
+            result.append((self.line_info[i][0], self.line_info[i][1],
+                           self.ids['hook_left'].__self__))
+            i += 1
+        if self._hook_points[1]:
+            result.append((self.line_info[i][0], self.line_info[i][1],
+                           self.ids['hook_right'].__self__))
+            i += 1
+        if self._hook_points[2]:
+            result.append((self.line_info[i][0], self.line_info[i][1],
+                           self.ids['hook_top'].__self__))
+            i += 1
+        if self._hook_points[3]:
+            result.append((self.line_info[i][0], self.line_info[i][1],
+                           self.ids['hook_bottom'].__self__))
+            i += 1
+        return result
+
+    def get_line_info_str(self):
+        result = []
+        if self._hook_points[0]:
+            hook = self.ids.hook_left.__self__
+            result.append((hook.line.line_id, hook.line._get_hook_index(hook)))
+        if self._hook_points[1]:
+            hook = self.ids.hook_right.__self__
+            result.append((hook.line.line_id, hook.line._get_hook_index(hook)))
+        if self._hook_points[2]:
+            hook = self.ids.hook_top.__self__
+            result.append((hook.line.line_id, hook.line._get_hook_index(hook)))
+        if self._hook_points[3]:
+            hook = self.ids.hook_bottom.__self__
+            result.append((hook.line.line_id, hook.line._get_hook_index(hook)))
+        return str(result)
+
 class CustomLabel(label.Label):
 
     def on_texture(self, instance, value):

src/main.kv

@@ -78,7 +78,8 @@
     # Width is computed by CustomLabel as a function of font_size and text,
     # both being determined by AtomWidget height and text, respectively.
 
-    text: 'atom'
+    text: '__atom__'
+    line_info: []
     width: customlabel.width
     height: 20
     CustomLabel:

src/main.py

@@ -408,6 +408,7 @@ def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
             self.show_load()
         elif keycode[1] == 'y':
             print self.name_manager.get_all()
+            print asp.Line.get_all_lines()
         elif keycode[1] == 't':
             self.toggle_sidepanel()
         elif keycode[1] == 'tab':
@@ -428,9 +429,9 @@ def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
         return True
 
     def on_resize(self, window, width, height):
-        self.active_graph.size = self.active_graph.parent.size
         if self.show_sidepanel:
             self.ids.sidepanel.width = self.width * .15
+        self.active_graph.size = self.ids.stencilview.size
 
     def toggle_sidepanel(self):
         self.show_sidepanel = not self.show_sidepanel
@@ -514,8 +515,11 @@ def delete_atom(self):
     def clear_atoms(self):
         self.ids.name_list.clear_widgets()
         self.name_manager.clear()
+        self.update_atom_editor('')
+        asp.AtomWidget.active_atom = None
 
     def new_graph(self):
+        asp.Line.clear_lines()
         self.active_graph.delete_tree()
         self.clear_atoms()
         # TODO: Migrate to tab system
@@ -527,6 +531,7 @@ def new_graph(self):
 
     def close_graph(self):
         if self.active_graph is not None:
+            asp.Line.clear_lines()
             self.active_graph.delete_tree()
             self.active_graph.delete_root()
             self.clear_atoms()
@@ -585,11 +590,17 @@ def load(self, path, filename):
         self.close_graph()
 
         f = os.path.join(path, filename[0])
+        # Temporal line storage. Its contents are arranged as follows:
+        # { line_id: (graph, hook_list) , ... }
+        lines = {}
         with open(f, 'r') as stream:
             for line in stream:
                 if line.startswith(NameParser.TOKENS['name']):
-                    name, hooks = NameParser.parse_line(line)
+                    name, hooks = NameParser.parse_name(line)
                     self.register_atom(name, hooks)
+                if line.startswith(NameParser.TOKENS['line']):
+                    line_id, graph = NameParser.parse_line(line)
+                    lines[line_id] = (graph, [None] * len(graph))
 
         new_graph = lang.Builder.load_file(f)
         self.ids.stencilview.add_widget(new_graph)
@@ -599,6 +610,19 @@ def load(self, path, filename):
         for w in self.active_graph.walk(restrict=True):
             if isinstance(w, asp.AtomWidget):
                 w._deferred_init()
+                for i in w.get_line_info():
+                    line_id = i[0]
+                    hook_index = i[1]
+                    lines[line_id][1][hook_index] = i[2]
+            elif isinstance(w, asp.NexusWidget):
+                for i in w.line_info:
+                    line_id = i[0]
+                    hook_index = i[1]
+                    lines[line_id][1][hook_index] = w
+
+        for line, info in lines.iteritems():
+            print line, info
+            asp.Line.build_from_graph(info[0], info[1])
 
         self.set_mode(self.modestr)
         self.set_item(self.itemstr)
@@ -609,6 +633,9 @@ def save(self, path, filename):
             stream.write('#:kivy 1.0.9\n\n')
             for (name, atom) in self.name_manager.get_all():
                 stream.write(NameParser.get_name_str(name, atom.hook_points))
+            for line in asp.Line.get_all_lines():
+                stream.write(NameParser.get_line_str(line.line_id,
+                                                     line.get_full_graph()))
             stream.write('\n')
             stream.write(self.active_graph.get_tree(0))
         self.dismiss_popup()

src/name_manager.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+from ast import literal_eval
+
 class Singleton:
     """A non-thread-safe helper class to implement singletons.
     It should be used as a decorator (not a metaclass) to the
@@ -78,14 +80,16 @@ def get_all(self, namespace_idx=0):
             return []
 
 class NameParser:
-    """Class for parsing a list of names from a loaded file or string.
-    The name must be in the format:
+    """Class for parsing a list of names or lines from a loaded file or string.
+    Specifications must be in the format:
 
     #name: 'AtomName', [Hook0Value, Hook1Value, Hook2Value, Hook3Value]
 
+    #line: LineId, {Hook0Id: [HookIds, ...], Hook2Id: [HookIds, ...], ...}
     """
 
-    TOKENS = {'name': '#name:'}
+    TOKENS = {'name': '#name:',
+              'line': '#line:'}
 
     @staticmethod
     def str_to_bool(s):
@@ -97,29 +101,40 @@ def str_to_bool(s):
             raise ValueError("Cannot covert {} to a bool".format(s))
 
     @classmethod
-    def parse_line(cls, line):
+    def parse_name(cls, line):
         name = ''
         hooks = []
 
-        parts = line.split("'")
-        if len(parts) == 3:
-            name = parts[1]
-
-        open_bracket = line.find("[")
-        close_bracket = line.find("]")
-        parts = line[(open_bracket+1):(close_bracket)].split(',')
-        for p in parts:
-            print p
-            boolstring = p.translate(None, ' ')
-            hooks.append(cls.str_to_bool(boolstring))
+        data = line.lstrip(cls.TOKENS['name'])
+        data = data.lstrip()
+        name, hooks = literal_eval(data)
 
         if (name == '') or (len(hooks) != 4):
             raise AssertionError("Wrong name specification: {}".format(line))
 
         return name, hooks
 
+    @classmethod
+    def parse_line(cls, line):
+        line_id = None
+        graph = None
+
+        data = line.lstrip(cls.TOKENS['line'])
+        data = data.lstrip()
+        line_id, graph = literal_eval(data)
+
+        if (line_id is None) or (graph is None):
+            raise AssertionError("Wrong line specification: {}".format(line))
+
+        return line_id, graph
+
     @classmethod
     def get_name_str(cls, name, hooks):
         s = cls.TOKENS['name'] + " '{0}', [{1}, {2}, {3}, {4}]\n".format(
             name, str(hooks[0]), str(hooks[1]), str(hooks[2]), str(hooks[3]))
         return s
+
+    @classmethod
+    def get_line_str(cls, line_id, graph):
+        s = cls.TOKENS['line'] + ' ' + str(line_id) + ', ' + str(graph) + '\n'
+        return s