Merge lp:~spud/spud/slice-view into lp:spud

[Fraser Waters]

Adds slice view.

There is one small issue with this merge. The main view will NOT update the view of the currently selected row if that row is changed in the slice view. If this is merged in that should be marked as a bug.

[lp:~spud/spud/slice-view]

442. By Fraser Waters on 2011-07-25

Added node paramater to choice _on_set_*

443. By Fraser Waters on 2011-07-25

Slice view is bigger and better aligned.

444. By Fraser Waters on 2011-07-25

No longer includes inactive nodes.

445. By Fraser Waters on 2011-07-25

Main view updates when slice view closed.

446. By Fraser Waters on 2011-07-25

Can't slice if nothing to slice on.

447. By Fraser Waters on 2011-07-25

If can't slice display message in statusbar.

[Patrick Farrell (pefarrell)]

Fraser and I have gone through several iterations; I have tried to break it, and can't. I've also read through the code changes and it all looks good. I'm going to merge this so that I can push a new diamond package out, so that users can give us bug reports.

review: Approve

=== added file 'diamond/diamond/attributewidget.py'
--- diamond/diamond/attributewidget.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/attributewidget.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,341 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gobject
+import gtk
+
+import datatype
+import dialogs
+
+class AttributeWidget(gtk.Frame):
+
+  __gsignals__ = { "on-store" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
+                   "update-name"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())}
+
+  def __init__(self):
+    gtk.Frame.__init__(self)
+
+    scrolledWindow = gtk.ScrolledWindow()
+    scrolledWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+
+    treeview = self.treeview = gtk.TreeView()
+
+    model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
+    treeview.set_model(model)
+    treeview.connect("motion-notify-event", self.treeview_mouse_over)
+
+    key_renderer = gtk.CellRendererText()
+    key_renderer.set_property("editable", False)
+
+    column1 = gtk.TreeViewColumn("Name", key_renderer, text = 0)
+    column1.set_cell_data_func(key_renderer, self.key_data_func)
+    column1.set_property("min-width", 75)
+
+    entry_renderer = gtk.CellRendererText()
+    entry_renderer.connect("edited", self.entry_edited)
+    entry_renderer.connect("editing-started", self.entry_edit_start)
+
+    combo_renderer = gtk.CellRendererCombo()
+    combo_renderer.set_property("text-column", 0)
+    combo_renderer.connect("edited", self.combo_selected)
+    combo_renderer.connect("editing-started", self.combo_edit_start)
+
+    column2 = gtk.TreeViewColumn("Value", entry_renderer, text = 1)
+    column2.pack_start(combo_renderer)
+    column2.set_attributes(combo_renderer, text = 1)
+    column2.set_cell_data_func(entry_renderer, self.entry_data_func)
+    column2.set_cell_data_func(combo_renderer, self.combo_data_func)
+    column2.set_property("expand", True)
+    column2.set_property("min-width", 75)
+
+    icon_renderer = gtk.CellRendererPixbuf()
+
+    column3 = gtk.TreeViewColumn("", icon_renderer)
+    column3.set_cell_data_func(icon_renderer, self.icon_data_func)
+
+    treeview.append_column(column1)
+    treeview.append_column(column2)
+    treeview.append_column(column3)
+
+    scrolledWindow.add(treeview)
+
+    label = gtk.Label()
+    label.set_markup("<b>Attributes</b>")
+
+    self.set_label_widget(label)
+    self.set_shadow_type(gtk.SHADOW_NONE)
+    self.add(scrolledWindow)
+
+  def update(self, node):
+
+    self.treeview.get_model().clear()
+
+    self.node = node
+
+    if node is None or not node.attrs.keys():
+      self.set_property("visible", False)
+    else:
+      self.set_property("visible", True)
+
+      for key in node.attrs.keys():
+        model = self.treeview.get_model()
+        cell_model = gtk.ListStore(gobject.TYPE_STRING)
+
+        iter = model.append()
+        model.set_value(iter, 0, key)
+        model.set_value(iter, 2, cell_model)
+
+        if isinstance(node.attrs[key][0], tuple):
+          if node.attrs[key][1] is None:
+            if isinstance(node.attrs[key][0][0], tuple):
+              model.set_value(iter, 1, "Select " + datatype.print_type(node.attrs[key][0][1]) + "...")
+            else:
+              model.set_value(iter, 1, "Select...")
+          else:
+            model.set_value(iter, 1, node.attrs[key][1])
+
+          if isinstance(node.attrs[key][0][0], tuple):
+            opts = node.attrs[key][0][0]
+          else:
+            opts = node.attrs[key][0]
+
+          for opt in opts:
+            cell_iter = cell_model.append()
+            cell_model.set_value(cell_iter, 0, opt)
+
+          self.treeview.get_column(2).set_property("visible", True)
+        elif node.attrs[key][0] is None:
+          model.set_value(iter, 1, "No data")
+        elif node.attrs[key][1] is None:
+          model.set_value(iter, 1, datatype.print_type(node.attrs[key][0]))
+        else:
+          model.set_value(iter, 1, node.attrs[key][1])
+
+      self.treeview.queue_resize()
+
+    return
+
+  def treeview_mouse_over(self, widget, event):
+    """
+    Called when the mouse moves over the attributes widget. Sets the
+    appropriate attribute widget tooltip.
+    """
+
+    path_info = self.treeview.get_path_at_pos(int(event.x), int(event.y))
+    if path_info is None:
+      try:
+        self.treeview.set_tooltip_text("")
+        self.treeview.set_property("has-tooltip", False)
+      except:
+        pass
+      return
+
+    path = path_info[0]
+    col = path_info[1]
+    if col is not self.treeview.get_column(1):
+      try:
+        self.treeview.set_tooltip_text("")
+        self.treeview.set_property("has-tooltip", False)
+      except:
+        pass
+      return
+
+    iter = self.treeview.get_model().get_iter(path)
+    iter_key = self.treeview.get_model().get_value(iter, 0)
+
+    return
+
+  def key_data_func(self, col, cell_renderer, model, iter):
+    """
+    Attribute name data function. Sets the cell renderer text colours.
+    """
+
+    iter_key = model.get_value(iter, 0)
+
+    if not self.node.active or self.node.attrs[iter_key][0] is None or self.node.attrs[iter_key][0] == "fixed":
+      cell_renderer.set_property("foreground", "grey")
+    elif self.node.attrs[iter_key][1] is None:
+      cell_renderer.set_property("foreground", "blue")
+    else:
+      cell_renderer.set_property("foreground", "black")
+
+    return
+
+  def entry_data_func(self, col, cell_renderer, model, iter):
+    """
+    Attribute text data function. Hides the renderer if a combo box is required,
+    and sets colours and editability otherwise.
+    """
+
+    iter_key = model.get_value(iter, 0)
+
+    if not self.node.active or self.node.attrs[iter_key][0] is None or self.node.attrs[iter_key][0] == "fixed":
+      cell_renderer.set_property("editable", False)
+      cell_renderer.set_property("foreground", "grey")
+      cell_renderer.set_property("visible", True)
+    elif not isinstance(self.node.attrs[iter_key][0], tuple):
+      cell_renderer.set_property("editable", True)
+      cell_renderer.set_property("visible", True)
+      if self.node.attrs[iter_key][1] is None:
+        cell_renderer.set_property("foreground", "blue")
+      else:
+        cell_renderer.set_property("foreground", "black")
+    else:
+      cell_renderer.set_property("editable", False)
+      cell_renderer.set_property("visible", False)
+
+    return
+
+  def combo_data_func(self, col, cell_renderer, model, iter):
+    """
+    Attribute combo box data function. Hides the renderer if a combo box is not
+    required, and sets the combo box options otherwise. Adds an entry if required.
+    """
+
+    iter_key = model.get_value(iter, 0)
+
+    if self.node.active and isinstance(self.node.attrs[iter_key][0], tuple):
+      cell_renderer.set_property("editable", True)
+      cell_renderer.set_property("visible", True)
+      if isinstance(self.node.attrs[iter_key][0][0], tuple):
+        cell_renderer.set_property("has-entry", True)
+      else:
+        cell_renderer.set_property("has-entry", False)
+      if self.node.attrs[iter_key][1] is None:
+        cell_renderer.set_property("foreground", "blue")
+      else:
+        cell_renderer.set_property("foreground", "black")
+    else:
+      cell_renderer.set_property("visible", False)
+      cell_renderer.set_property("editable", False)
+    cell_renderer.set_property("model", model.get_value(iter, 2))
+
+    return
+
+  def icon_data_func(self, col, cell_renderer, model, iter):
+    """
+    Attribute icon data function. Used to add downward pointing arrows for combo
+    attributes, for consistency with the LHS.
+    """
+
+    iter_key = model.get_value(iter, 0)
+
+    if self.node.active and isinstance(self.node.attrs[iter_key][0], tuple):
+      cell_renderer.set_property("stock-id", gtk.STOCK_GO_DOWN)
+    else:
+      cell_renderer.set_property("stock-id", None)
+
+    return
+
+  def entry_edit_start(self, cell_renderer, editable, path):
+    """
+    Called when editing is started on an attribute text cell. Used to delete the
+    printable_type placeholder.
+    """
+
+    iter = self.treeview.get_model().get_iter(path)
+    iter_key = self.treeview.get_model().get_value(iter, 0)
+
+    if self.node.attrs[iter_key][1] is None:
+      editable.set_text("")
+
+    return
+
+  def combo_edit_start(self, cell_renderer, editable, path):
+    """
+    Called when editing is started on an attribute combo cell. Used to delete the
+    select placeholder for mixed entry / combo attributes.
+    """
+
+    iter = self.treeview.get_model().get_iter(path)
+    iter_key = self.treeview.get_model().get_value(iter, 0)
+
+    if isinstance(self.node.attrs[iter_key][0][0], tuple) and self.node.attrs[iter_key][1] is None:
+      editable.child.set_text("")
+
+    return
+
+  def entry_edited(self, cell_renderer, path, new_text):
+    """
+    Called when editing is finished on an attribute text cell. Updates data in the
+    treestore.
+    """
+
+    iter = self.treeview.get_model().get_iter(path)
+    iter_key = self.treeview.get_model().get_value(iter, 0)
+
+    if self.node.get_attr(iter_key) is None and new_text == "":
+      return
+
+    value_check = self.node.validity_check(self.node.attrs[iter_key][0], new_text)
+
+    if value_check is not None and value_check != self.node.attrs[iter_key][1]:
+      if iter_key == "name" and not self._name_check(value_check):
+        return
+
+      self.treeview.get_model().set_value(iter, 1, value_check)
+      self.node.set_attr(iter_key, value_check)
+      if iter_key == "name":
+        self.emit("update-name")
+
+      self.emit("on-store")
+
+    return
+
+  def combo_selected(self, cell_renderer, path, new_text):
+    """
+    Called when an attribute combo box element is selected, or combo box entry
+    element entry is edited. Updates data in the treestore.
+    """
+
+    iter = self.treeview.get_model().get_iter(path)
+    iter_key = self.treeview.get_model().get_value(iter, 0)
+
+    if new_text is None:
+      return
+
+    if isinstance(self.node.attrs[iter_key][0][0], tuple) and new_text not in self.node.attrs[iter_key][0][0]:
+      if self.node.get_attr(iter_key) is None and new_text == "":
+        return
+
+      new_text = self.node.validity_check(self.node.attrs[iter_key][0][1], new_text)
+      if iter_key == "name" and not self._name_check(new_text):
+        return False
+    if new_text != self.selected_node.attrs[iter_key][1]:
+      self.treeview.get_model().set_value(iter, 1, new_text)
+      self.node.set_attr(iter_key, new_text)
+      if iter_key == "name":
+        self.emit("update-name")
+
+      self.emit("on-store")
+
+    return
+
+  def _name_check(self, value):
+    """
+    Check to see if the supplied data is a valid tree name.
+    """
+
+    valid_chars = "_:[]1234567890qwertyuioplkjhgfdsazxcvbnmMNBVCXZASDFGHJKLPOIUYTREWQ"
+    for char in value:
+      if char not in valid_chars:
+        dialogs.error(None, "Invalid value entered")
+        return False
+
+    return True
+
+gobject.type_register(AttributeWidget)

=== modified file 'diamond/diamond/choice.py'
--- diamond/diamond/choice.py	2009-08-07 14:17:55 +0000
+++ diamond/diamond/choice.py	2011-07-25 13:56:22 +0000
@@ -21,10 +21,19 @@
 import StringIO
 from lxml import etree
 
+
+import gobject
+
 import tree
 
-class Choice:
+class Choice(gobject.GObject):
+
+  __gsignals__ = { "on-set-data" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (str,)),
+                   "on-set-attr"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (str, str))}
+
   def __init__(self, l, cardinality=''):
+    gobject.GObject.__init__(self)
+
     self.l = l
     if l == []:
       raise Exception
@@ -33,6 +42,9 @@
     for choice in l:
       assert choice.__class__ is tree.Tree
       name = name + choice.name + ":"
+      choice.connect("on-set-data", self._on_set_data)
+      choice.connect("on-set-attr", self._on_set_attr)
+
     name = name[:-1]
     self.name = name
     self.schemaname = name
@@ -40,6 +52,12 @@
     self.parent = None
     self.set_default_active()
 
+  def _on_set_data(self, node, data):
+    self.emit("on-set-data", data)
+
+  def _on_set_attr(self, node, attr, value):
+    self.emit("on-set-attr", attr, value)
+
   def set_default_active(self):
     self.active = True
     if self.cardinality == '?' or self.cardinality == '*':
@@ -126,3 +144,57 @@
 
   def choices(self):
     return self.l
+
+  def is_comment(self):
+    return False
+
+  def get_comment(self):
+    return None
+
+  def get_display_name(self):
+    """
+    This is a fluidity hack, allowing the name displayed in the treeview on the
+    left to be different to the element name. If it has an attribute name="xxx",
+    element_tag (xxx) is displayed.
+    """
+
+    return self.get_current_tree().get_display_name()
+
+  def get_name(self):
+    return self.get_current_tree().get_name()
+
+  def get_children(self):
+    return [self.get_current_tree()]
+
+  def get_choices(self):
+    return self.l
+
+  def is_hidden(self):
+    """
+    Tests whether the supplied choice should be hidden in view.
+    """
+    return False
+
+  def get_name_path(self, leaf = True):
+    name = self.get_display_name() if leaf else self.get_name()
+
+    if self.parent is None:
+      return name
+    else:
+
+      pname = self.parent.get_name_path(False)
+
+      if name is None:
+        return pname
+      elif pname is None:
+        return name
+      else:
+        return pname + "/" + name
+
+  def get_mixed_data(self):
+    return self
+
+  def is_sliceable(self):
+    return self.get_current_tree().is_sliceable()
+
+gobject.type_register(Choice)

=== added file 'diamond/diamond/commentwidget.py'
--- diamond/diamond/commentwidget.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/commentwidget.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,146 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gobject
+import gtk
+
+class CommentWidget(gtk.Frame):
+
+  __gsignals__ = { "on-store"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())}
+
+  def __init__(self):
+    gtk.Frame.__init__(self)
+    
+    scrolledWindow = gtk.ScrolledWindow()
+    scrolledWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+
+    textView = self.textView = gtk.TextView()
+    textView.set_editable(False)
+    textView.set_wrap_mode(gtk.WRAP_WORD)
+    textView.set_cursor_visible(False)
+    textView.connect("focus-in-event", self.focus_in)
+    textView.connect("focus-out-event", self.focus_out)
+    textView.get_buffer().create_tag("tag")
+    
+    scrolledWindow.add(textView)
+
+    label = gtk.Label()
+    label.set_markup("<b>Comment</b>")
+
+    self.set_shadow_type(gtk.SHADOW_NONE)
+    self.set_label_widget(label)
+    self.add(scrolledWindow)
+    
+    self.comment_tree = None                           
+    return
+
+  def update(self, node):
+    """
+    Update the widget with the given node
+    """
+
+    #before updateing store the old
+    self.store()
+
+    if node is None or not node.active:
+      self.textView.get_buffer().set_text("")
+      self.textView.set_cursor_visible(False)
+      self.textView.set_editable(False)
+      try:
+        self.textView.set_tooltip_text("")
+        self.textView.set_property("has-tooltip", False)
+      except:
+        pass
+
+      return
+
+    self.comment_tree = comment_tree = node.get_comment()
+    text_tag = self.textView.get_buffer().get_tag_table().lookup("tag")
+    if comment_tree is None:
+      self.textView.get_buffer().set_text("No comment")
+      self.textView.set_cursor_visible(False)
+      self.textView.set_editable(False)
+      text_tag.set_property("foreground", "grey")
+      try:
+        self.textView.set_tooltip_text("")
+        self.textView.set_property("has-tooltip", False)
+      except:
+        pass
+    else:
+      if comment_tree.data is None:
+        self.textView.get_buffer().set_text("(string)")
+      else:
+        self.textView.get_buffer().set_text(comment_tree.data)
+      if node.active:
+        self.textView.set_cursor_visible(True)
+        self.textView.set_editable(True)
+        text_tag.set_property("foreground", "black")
+      else:
+        self.textView.set_cursor_visible(False)
+        self.textView.set_editable(False)
+        text_tag.set_property("foreground", "grey")
+
+    buffer_bounds = self.textView.get_buffer().get_bounds()
+    self.textView.get_buffer().apply_tag(text_tag, buffer_bounds[0], buffer_bounds[1])
+
+    self.interacted = False
+
+    return
+
+  def store(self):
+    """
+    Store data in the node comment.
+    """
+   
+    comment_tree = self.comment_tree
+    if comment_tree is None or not self.interacted:
+      return
+
+    data_buffer_bounds = self.textView.get_buffer().get_bounds()
+    new_comment = self.textView.get_buffer().get_text(data_buffer_bounds[0], data_buffer_bounds[1])
+
+    if new_comment != comment_tree.data:
+      if new_comment == "":
+        comment_tree.data = None
+        comment_tree.active = False
+      else:
+        comment_tree.set_data(new_comment)
+        comment_tree.active = True
+        self.emit("on-store")
+    return
+
+  def focus_in(self, widget, event):
+    """
+    Called when the comment widget gains focus. Removes the printable_type
+    placeholder.
+    """
+
+    comment_tree = self.comment_tree
+    if not comment_tree is None and not self.interacted:
+      self.interacted = True
+      if comment_tree.data is None:
+        self.textView.get_buffer().set_text("")
+
+    return
+
+  def focus_out(self, widget, event):
+    """"
+    Called when the comment widget loses focus. Stores the comment.
+    """
+    self.store()
+  
+gobject.type_register(CommentWidget)

=== added file 'diamond/diamond/databuttonswidget.py'
--- diamond/diamond/databuttonswidget.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/databuttonswidget.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gobject
+import gtk
+
+class DataButtonsWidget(gtk.HBox):
+
+  __gsignals__ = { "revert" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
+                   "store"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())}
+
+  def __init__(self):
+    gtk.HBox.__gobject_init__(self)
+    revertButton = gtk.Button()
+    revertButton.set_label("Revert data")
+    revertButton.connect("clicked", self._revert)
+
+    storeButton = gtk.Button()
+    storeButton.set_label("Store data")
+    storeButton.connect("clicked", self._store)
+
+    self.pack_end(revertButton)
+    self.pack_start(storeButton)
+
+    return
+
+  def _revert(self, widget = None):
+    self.emit("revert")
+
+  def _store(self, widget = None):
+    self.emit("store")
+
+gobject.type_register(DataButtonsWidget)

=== added file 'diamond/diamond/datatype.py'
--- diamond/diamond/datatype.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/datatype.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import plist
+
+def print_type(datatype, bracket = True):
+  """
+  Create a string to be displayed in place of empty data / attributes.
+  """
+
+  def familiar_type(type_as_printable):
+    """
+    Convert some type names to more familiar equivalents.
+    """
+
+    if type_as_printable == "decim":
+      return "float"
+    elif type_as_printable == "int":
+      return "integer"
+    elif type_as_printable == "str":
+      return "string"
+    else:
+      return type_as_printable
+
+  def type_name(datatype):
+    """
+    Return a human readable version of datatype.
+    """
+
+    datatype_string = str(datatype)
+
+    if datatype_string[:7] == "<type '" and datatype_string[len(datatype_string) - 2:] == "'>":
+      value_type_split = datatype_string.split("'")
+      return familiar_type(value_type_split[1])
+
+    value_type_split1 = datatype_string.split(".")
+    value_type_split2 = value_type_split1[len(value_type_split1) - 1].split(" ")
+    if len(value_type_split2) == 1:
+      return familiar_type(value_type_split2[0][0:len(value_type_split2[0]) - 6])
+    else:
+      return familiar_type(value_type_split2[0])
+
+  #print_type
+
+  if isinstance(datatype, plist.List):
+    if (isinstance(datatype.cardinality, int) and datatype.cardinality == 1) or datatype.cardinality == "":
+      type_as_printable = type_name(datatype.datatype).lower()
+    else:
+      type_as_printable = type_name(datatype).lower() + " of "
+      list_type_as_printable = type_name(datatype.datatype).lower()
+      if isinstance(datatype.cardinality, int):
+        type_as_printable += str(datatype.cardinality) + " " + list_type_as_printable + "s"
+      else:
+        type_as_printable += list_type_as_printable + "s"
+  else:
+    type_as_printable = type_name(datatype).lower()
+
+  if bracket:
+    type_as_printable = "(" + type_as_printable + ")"
+
+  return type_as_printable

=== added file 'diamond/diamond/datawidget.py'
--- diamond/diamond/datawidget.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/datawidget.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,501 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gobject
+import gtk
+import pango
+
+import dialogs
+import datatype
+import mixedtree
+
+class DataWidget(gtk.VBox):
+
+  __gsignals__ = { "on-store"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())}
+
+  def __init__(self):
+    gtk.VBox.__init__(self)
+    
+    frame = self.frame = gtk.Frame()
+    
+    label = gtk.Label()
+    label.set_markup("<b>Data</b>")
+    
+    frame.set_label_widget(label)
+    frame.set_shadow_type(gtk.SHADOW_NONE)
+
+    self.pack_start(frame)
+    self.buttons = None
+    return
+
+  def set_buttons(self, buttons):
+    self.buttons = buttons
+    buttons.connect("revert", self.revert)
+    buttons.connect("store", self.store)
+    buttons.show_all()
+
+  def update(self, node):
+
+    self.node = node
+
+    if not self.is_node_editable():
+      self.set_data_fixed()
+    elif node.is_tensor(self.geometry_dim_tree):
+      self.set_data_tensor()
+    elif isinstance(node.datatype, tuple):
+      self.set_data_combo()
+    else:
+      self.set_data_entry()
+
+    return
+ 
+  def revert(self, button = None):
+    """
+    "Revert Data" button click signal handler. Reverts data in the data frame.
+    """
+
+    self.update(self.node)
+
+    return 
+  
+  def store(self, button = None):
+    """
+    "Store Data" button click signal handler. Stores data from the data frame
+    in the treestore.
+    """
+
+    if not self.is_node_editable():
+      return True
+    elif self.node.is_tensor(self.geometry_dim_tree):
+      return self.data_tensor_store()
+    elif isinstance(self.node.datatype, tuple):
+      return self.data_combo_store()
+    else:
+      return self.data_entry_store()
+
+# This would be nice, look at it later
+#    if self.scherror.errlist_is_open():
+#      if self.scherror.errlist_type == 0:
+#         self.scherror.on_validate_schematron()
+#      else:
+#         self.scherror.on_validate()
+
+  def is_node_editable(self):
+    return (self.node is not None
+       and self.node.active
+       and self.node.datatype is not None
+       and self.node.datatype != "fixed"
+       and (not self.node.is_tensor(self.geometry_dim_tree) or self.geometry_dim_tree.data is not None))
+       # not A or B == A implies B
+       # A B T
+       # 0 0 1
+       # 0 1 1
+       # 1 0 0
+       # 1 1 1
+
+  def add_scrolled_window(self):
+    scrolledWindow = gtk.ScrolledWindow()
+    scrolledWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+    self.frame.add(scrolledWindow)
+    scrolledWindow.show()
+    return scrolledWindow
+
+  def add_text_view(self):
+    scrolledWindow = self.add_scrolled_window()
+    self.set_child_packing(self.frame, True, True, 0, gtk.PACK_START)
+    
+    try:
+      import gtksourceview2
+      buf = gtksourceview2.Buffer()
+      lang_manager = gtksourceview2.LanguageManager()
+      buf.set_highlight_matching_brackets(True)
+      if self.node is not None and self.node.is_python_code():
+        python = lang_manager.get_language("python")
+        buf.set_language(python)
+        buf.set_highlight_syntax(True)
+      textview = gtksourceview2.View(buffer=buf)
+      textview.set_auto_indent(True)
+      textview.set_insert_spaces_instead_of_tabs(True)
+      textview.set_tab_width(2)
+      if self.node is not None and self.node.is_python_code():
+        textview.set_show_line_numbers(True)
+        font_desc = pango.FontDescription("monospace")
+        if font_desc:
+          textview.modify_font(font_desc)
+    except ImportError:
+      textview = gtk.TextView()
+
+    textview.set_pixels_above_lines(2)
+    textview.set_pixels_below_lines(2)
+    textview.set_wrap_mode(gtk.WRAP_WORD)
+    textview.connect("focus-in-event", self.entry_focus_in)
+
+    scrolledWindow.add(textview)
+    textview.show()
+    return textview
+
+  def set_data_empty(self):
+    """
+    Empty the data frame.
+    """
+
+    if self.frame.child is not None:
+      if isinstance(self.data, gtk.TextView):
+        self.data.handler_block_by_func(self.entry_focus_in)
+      elif isinstance(self.data, gtk.ComboBox):
+        self.data.handler_block_by_func(self.combo_focus_child)
+
+      self.frame.remove(self.frame.child)
+
+    self.interacted = False
+
+    return
+
+  def set_data_fixed(self):
+    """
+    Create a non-editable text view to show help or fixed data.
+    """
+    
+    self.set_data_empty()
+   
+    self.data = self.add_text_view()
+
+    self.data.get_buffer().create_tag("tag")
+    text_tag = self.data.get_buffer().get_tag_table().lookup("tag")
+
+    self.data.set_cursor_visible(False)
+    self.data.set_editable(False)
+    self.buttons.hide()
+    text_tag.set_property("foreground", "grey")
+
+    if self.node is None:
+      self.data.get_buffer().set_text("")
+    elif not self.node.active:
+      self.data.get_buffer().set_text("Inactive node")
+    elif self.node.datatype is None:
+      self.data.get_buffer().set_text("No data")
+    elif self.node.is_tensor(self.geometry_dim_tree):
+      self.data.get_buffer().set_text("Dimension not set")
+    else: # self.node.datatype == "fixed":
+      self.data.get_buffer().set_text(self.node.data)
+ 
+    buffer_bounds = self.data.get_buffer().get_bounds()
+    self.data.get_buffer().apply_tag(text_tag, buffer_bounds[0], buffer_bounds[1])
+
+    return
+
+  def set_data_entry(self):
+    """
+    Create a text view for data entry in the data frame.
+    """
+
+    self.set_data_empty()
+
+    self.data = self.add_text_view()
+
+    self.data.get_buffer().create_tag("tag")
+    text_tag = self.data.get_buffer().get_tag_table().lookup("tag")
+ 
+    self.data.set_cursor_visible(True)
+    self.data.set_editable(True)
+    self.buttons.show()
+
+    if self.node.data is None:
+      self.data.get_buffer().set_text(datatype.print_type(self.node.datatype))
+      text_tag.set_property("foreground", "blue")
+    else:
+      self.data.get_buffer().set_text(self.node.data)
+
+    buffer_bounds = self.data.get_buffer().get_bounds()
+    self.data.get_buffer().apply_tag(text_tag, buffer_bounds[0], buffer_bounds[1])
+
+    return
+
+  def set_data_tensor(self):
+    """
+    Create a table container packed with appropriate widgets for tensor data entry
+    in the node data frame.
+    """
+
+    self.set_data_empty()
+
+    scrolledWindow = self.add_scrolled_window()
+
+    dim1, dim2 = self.node.tensor_shape(self.geometry_dim_tree)
+    self.data = gtk.Table(dim1, dim2)
+    scrolledWindow.add_with_viewport(self.data)
+    scrolledWindow.child.set_property("shadow-type", gtk.SHADOW_NONE)
+
+    self.set_child_packing(self.frame, True, True, 0, gtk.PACK_START)
+
+    is_symmetric = self.node.is_symmetric_tensor(self.geometry_dim_tree)
+    for i in range(dim1):
+      for j in range(dim2):
+        iindex = dim1 - i - 1
+        jindex = dim2 - j - 1
+
+        if not is_symmetric or i >= j:
+          entry = gtk.Entry()
+          entry.connect("focus-in-event", self.tensor_element_focus_in, jindex, iindex)
+          self.data.attach(entry, jindex, jindex + 1, iindex, iindex + 1)
+
+          if self.node.data is None:
+            entry.set_text(datatype.print_type(self.node.datatype.datatype))
+            entry.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
+          else:
+            entry.set_text(self.node.data.split(" ")[jindex + iindex * dim2])
+
+    self.interacted = [False for i in range(dim1 * dim2)]
+    self.show_all()
+
+    return
+
+  def set_data_combo(self):
+    """
+    Create a combo box for node data selection in the node data frame. Add an
+    entry if required.
+    """
+
+    self.set_data_empty()
+
+    if isinstance(self.node.datatype[0], tuple):
+      self.data = gtk.combo_box_entry_new_text()
+    else:
+      self.data = gtk.combo_box_new_text()
+
+    self.frame.add(self.data)
+    self.data.show()
+
+    self.data.connect("set-focus-child", self.combo_focus_child)
+
+    self.set_child_packing(self.frame, False, False, 0, gtk.PACK_START)
+
+    if isinstance(self.node.datatype[0], tuple):
+      self.buttons.show()
+    else:
+      self.buttons.hide()
+
+    if self.node.data is None:
+      if isinstance(self.node.datatype[0], tuple):
+        self.data.child.set_text("Select " + datatype.print_type(self.node.datatype[1]) + "...")
+      else:
+        self.data.append_text("Select...")
+        self.data.set_active(0)
+      self.data.child.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
+      self.data.child.modify_text(gtk.STATE_PRELIGHT, gtk.gdk.color_parse("blue"))
+
+    if isinstance(self.node.datatype[0], tuple):
+      options = self.node.datatype[0]
+    else:
+      options = self.node.datatype
+
+    for (i, opt) in enumerate(options):
+      self.data.append_text(opt)
+      if self.node.data == opt:
+        self.data.set_active(i)
+
+    if (isinstance(self.node.datatype[0], tuple)
+       and self.node.data is not None
+       and self.node.data not in self.node.datatype[0]):
+      self.data.child.set_text(self.node.data)
+
+    self.data.connect("changed", self.combo_changed)
+
+    return
+
+  def data_entry_store(self):
+    """
+    Attempt to store data read from a textview packed in the data frame.
+    """
+
+    new_data = self.data.get_buffer().get_text(*self.data.get_buffer().get_bounds())
+
+    if new_data == "":
+      return True
+
+    if self.node.data is None and not self.interacted:
+      return True
+    else:
+      value_check = self.node.validity_check(self.node.datatype, new_data)
+      if value_check is None:
+        dialogs.error(None, "Invalid value entered")
+        return False
+      elif value_check != self.node.data:
+        self.node.set_data(value_check)
+        if (isinstance(self.node, mixedtree.MixedTree)
+           and "shape" in self.node.child.attrs.keys()
+           and self.node.child.attrs["shape"][0] is int
+           and isinstance(self.node.datatype, plist.List)
+           and self.node.datatype.cardinality == "+"):
+          self.node.child.set_attr("shape", str(len(value_check.split(" "))))
+
+        self.emit("on-store")
+        self.interacted = False
+
+    return True
+
+  def data_tensor_store(self):
+    """
+    Attempt to store data read from tensor data entry widgets packed in the 
+    data frame.
+    """
+
+    dim1, dim2 = self.node.tensor_shape(self.geometry_dim_tree)
+    is_symmetric = self.node.is_symmetric_tensor(self.geometry_dim_tree)
+
+    if True not in self.interacted:
+      return True
+
+    entry_values = []
+    for i in range(dim1):
+      for j in range(dim2):
+        if is_symmetric and i > j:
+          entry_values.append(self.data.get_children()[i + j * dim1].get_text())
+        else:
+          entry_values.append(self.data.get_children()[j + i * dim2].get_text())
+
+    changed = False
+    for i in range(dim1):
+      for j in range(dim2):
+        if (self.interacted[j + i * dim2]
+           and entry_values[j + i * dim2] != ""
+           and (self.node.data is None
+                or self.node.data.split(" ")[j + i * dim2] != entry_values[j + i * dim2])):
+          changed = True
+    if not changed:
+      return True
+    elif (self.node.data is None and False in self.interacted) or "" in entry_values:
+      dialogs.error(None, "Invalid value entered")
+      return False
+
+    new_data = ""
+    for i in range(dim1):
+      for j in range(dim2):
+        new_data += " " + entry_values[j + i * dim2]
+
+    value_check = self.node.validity_check(self.node.datatype, new_data)
+    if value_check is None:
+      return False
+    elif not value_check == self.node.data:
+      self.node.set_data(value_check)
+
+      dim1, dim2 = self.node.tensor_shape(self.geometry_dim_tree)
+      if int(self.node.child.attrs["rank"][1]) == 1:
+        self.node.child.set_attr("shape", str(dim1))
+      else:
+        self.node.child.set_attr("shape", str(dim1) + " " + str(dim2))
+
+      self.emit("on-store")
+      self.interacted = [False for i in range(dim1 * dim2)]
+
+    return True
+
+  def data_combo_store(self):
+    """
+    Attempt to store data read from a combo box entry packed in the node data.
+    """
+
+    if not isinstance(self.node.datatype[0], tuple):
+      return True
+
+    new_data = self.data.get_text()
+
+    if self.node.data is None and not self.interacted:
+      return True
+    elif not new_data in self.node.datatype[0]:
+      new_data = self.node.validity_check(self.node.datatype[1], new_data)
+      if new_data is None:
+        return False
+
+    if not new_data == self.node.data:
+      self.node.set_data(new_data)
+      self.emit("on-store")
+      self.interacted = False
+
+    return True
+  
+  def entry_focus_in(self, widget, event):
+    """
+    Called when a text view data entry widget gains focus. Used to delete the
+    printable_type placeholder.
+    """
+
+    if (self.node is not None
+       and self.node.datatype is not None
+       and not self.node.is_tensor(self.geometry_dim_tree)
+       and self.node.data is None
+       and not self.interacted):
+      self.data.get_buffer().set_text("")
+
+    self.interacted = True
+
+    return
+
+  def tensor_element_focus_in(self, widget, event, row, col):
+    """
+    Called when a tensor data entry widget gains focus. Used to delete the
+    printable_type placeholder.
+    """
+
+    dim1, dim2 = self.node.tensor_shape(self.geometry_dim_tree)
+    if not self.interacted[col + row * dim2]:
+      self.interacted[col + row * dim2] = True
+      if self.node.is_symmetric_tensor(self.geometry_dim_tree):
+        self.interacted[row + col * dim1] = True
+      if self.node.data is None:
+        widget.set_text("")
+        widget.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
+
+    return
+
+  def combo_focus_child(self, container, widget):
+    """
+    Called when a data selection widget gains focus. Used to delete the select
+    placeholder.
+    """
+    if not self.interacted:
+      self.interacted = True
+      if self.node.data is None:
+        self.data.handler_block_by_func(self.combo_changed)
+        if isinstance(self.node.datatype[0], tuple):
+          self.data.child.set_text("")
+        else:
+          self.data.remove_text(0)
+
+        self.data.child.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
+        self.data.child.modify_text(gtk.STATE_PRELIGHT, gtk.gdk.color_parse("black"))
+        self.data.handler_unblock_by_func(self.combo_changed)
+
+    return
+
+  def combo_changed(self, combo_box):
+    """
+    Called when a data combo box element is selected. Updates data in the
+    treestore.
+    """
+
+    if not isinstance(self.node.datatype[0], tuple):
+      text = self.data.get_active_text()
+      if text is None:
+        return
+
+      self.node.set_data(text)
+      self.emit("on-store")      
+      self.interacted = False
+    return
+
+gobject.type_register(DataWidget)

=== added file 'diamond/diamond/descriptionwidget.py'
--- diamond/diamond/descriptionwidget.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/descriptionwidget.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gtk
+import re
+import TextBufferMarkup
+import webbrowser
+
+class DescriptionWidget(gtk.Frame):
+  def __init__(self):
+    gtk.Frame.__init__(self)
+
+    scrolledWindow = gtk.ScrolledWindow()
+    scrolledWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+
+    textView = self.textView = gtk.TextView()
+    textView.set_editable(False)
+    textView.set_wrap_mode(gtk.WRAP_WORD)
+    textView.set_cursor_visible(False)
+
+    textView.set_buffer(TextBufferMarkup.PangoBuffer())
+    textView.connect("button-release-event", self.mouse_button_release)
+    textView.connect("motion-notify-event", self.mouse_over)
+
+    scrolledWindow.add(textView)
+
+    label = gtk.Label()
+    label.set_markup("<b>Description</b>")
+
+    self.set_shadow_type(gtk.SHADOW_NONE)
+    self.set_label_widget(label)
+    self.add(scrolledWindow)
+
+    return 
+
+  def update(self, node):
+    if node is None:
+      self.set_description("<span foreground=\"grey\">No node selected</span>")
+    elif node.doc is None:
+      self.set_description("<span foreground=\"red\">No documentation</span>")
+    else:
+      self.set_description(node.doc)
+
+    return
+
+  def set_description(self, text):
+    """
+    Set the node description.
+    """
+    
+    #text saved in self.text without markup
+    self.text = text = self.render_whitespace(text)
+    link_bounds = self.link_bounds = self.get_link_bounds(text)
+
+    if link_bounds:
+      new_text = []
+      index = 0
+      for bounds in link_bounds:  
+        new_text.append(text[index:bounds[0]])
+        new_text.append("<span foreground=\"blue\" underline=\"single\">")
+        new_text.append(text[bounds[0]:bounds[1]])
+        new_text.append("</span>")
+        index = bounds[1]
+             
+      new_text.append(text[index:])
+      text = ''.join(new_text)
+
+    self.textView.get_buffer().set_text(text)
+
+    return
+
+  def get_link_bounds(self, text):
+    """
+    Return a list of tuples corresponding to the start and end points of links in
+    the supplied string.
+    """
+    text = text.lower()
+    bounds = []
+
+    for match in re.finditer(r"\b(" #start at beginging of word
+                                +r"(?:https?://|www\.)" #http:// https:// or www.
+                                +r"(?:[a-z0-9][a-z0-9_\-]*[a-z0-9]\.)*" #Domains
+                                +r"(?:[a-z][a-z0-9\-]*[a-z0-9])" #TLD
+                                +r"(?:/([a-z0-9$_.+\\*'(),;:@&=\-]|%[0-9a-f]{2})*)*" #path
+                                +r"(?:\?([a-z0-9$_.+!*'(),;:@&=\-]|%[0-9a-f]{2})*)?" #query
+                                +r")", text):
+      bounds.append(match.span())
+
+    return bounds   
+
+  def render_whitespace(self, desc):
+    ''' Render the line wrapping in desc as follows:
+    
+    * Newlines followed by 0-1 spaces are ignored.
+    * Blank lines start new paragraphs.
+    * Newlines followed by more than 1 space are honoured.
+    '''
+    
+    text = []
+    para = False
+    literal = False
+
+    for line in desc.split("\n"):
+
+      if line == "" or line.isspace(): #Blank line, start paragraph
+        if literal: #if following a literal line add newlines
+          text.append("\n")
+        para = True
+
+      elif line[0] == " " and line[1] == " ": # >1 space, treat literaly
+        text.append("\n")
+        text.append(line)
+        para = False
+        literal = True
+
+      else: #normal case
+        if para: #add if starting a new paragraph
+          text.append("\n   ")
+        text.append(line)
+        para = False
+        literal = False
+
+    return ''.join(text)
+ 
+  def get_hyperlink(self, x, y):
+    """
+    Given an x and y window position (eg from a mouse click) return the hyperlink
+    at that position if there is one. Else return None.
+    """
+    if self.text is None:
+      return None
+    
+    buffer_pos = self.textView.window_to_buffer_coords(gtk.TEXT_WINDOW_TEXT, x, y)
+    char_offset = self.textView.get_iter_at_location(buffer_pos[0], buffer_pos[1]).get_offset()
+
+    for bounds in self.link_bounds:
+      if char_offset >= bounds[0] and char_offset <= bounds[1]:
+        return self.text[bounds[0]:bounds[1]]
+
+    return None
+                         
+  def mouse_over(self, widget, event):
+    """
+    Called when the mouse moves over the node description widget. Sets the cursor
+    to a hand if the mouse hovers over a link.
+
+    Based on code from HyperTextDemo class in hypertext.py from PyGTK 2.12 demos
+    """
+
+    if self.get_hyperlink(int(event.x), int(event.y)) is not None:
+      self.textView.get_window(gtk.TEXT_WINDOW_TEXT).set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
+    else:
+      self.textView.get_window(gtk.TEXT_WINDOW_TEXT).set_cursor(gtk.gdk.Cursor(gtk.gdk.XTERM))
+
+    return
+
+  def mouse_button_release(self, widget, event):
+    """
+    Called when a mouse button is released over the node description widget.
+    Launches a browser if the mouse release was over a link, the left mouse button
+    was released and no text was selected.
+
+    Based on code from HyperTextDemo class in hypertext.py from PyGTK 2.12 demos
+    """
+
+    if not event.button == 1:
+      return
+
+    if self.textView.get_buffer().get_selection_bounds():
+      return
+
+    hyperlink = self.get_hyperlink(int(event.x), int(event.y))
+    if hyperlink is not None:
+      webbrowser.open(hyperlink)
+
+    return

=== modified file 'diamond/diamond/interface.py'
--- diamond/diamond/interface.py	2011-07-20 17:19:44 +0000
+++ diamond/diamond/interface.py	2011-07-25 13:56:22 +0000
@@ -20,7 +20,6 @@
 import re
 import sys
 import tempfile
-import webbrowser
 import cStringIO as StringIO
 
 import pango
@@ -28,18 +27,28 @@
 import gtk
 import gtk.glade
 
+import choice
+import config
+import datatype
 import debug
 import dialogs
-import choice
-import config
+import mixedtree
 import plist
+import plugins
 import schema
 import scherror
 import tree
-import plugins
+
 import StringIO
 import TextBufferMarkup
 
+import attributewidget
+import commentwidget
+import descriptionwidget
+import databuttonswidget
+import datawidget
+import sliceview
+
 from lxml import etree
 
 try:
@@ -60,14 +69,13 @@
   logofile: the GUI logo file
   main_window: GUI toplevel window
   node_attrs: RHS attributes entry widget
-  node_comment: RHS comment entry widget
-  node_comment_interacted: used to determine if the comment widget has been interacted with without the comment being stored
+  description: RHS description widget
+  data = RHS data widget
+  comment: RHS comment entry widget
   node_data: RHS data entry widget
   node_data_buttons_hbox: container for "Revert Data" and "Store Data" buttons
   node_data_interacted: used to determine if a node data widget has been interacted with without data being stored
   node_data_frame: frame containing data entry widgets
-  node_desc: RHS description widget
-  node_desc_link_bounds: a list of tuples corresponding to the start and end points of links in the current tree.Tree / MixedTree documentation
   options_tree_select_func_enabled: boolean, true if the options tree select function is enabled (used to overcome a nasty clash with the treeview clicked signal) - re-enabled on next options_tree_select_func call
   selected_node: a tree.Tree or MixedTree containing data to be displayed on the RHS
   selected_iter: last iter set by on_select_row
@@ -83,7 +91,6 @@
 
 Important routines:
   cellcombo_edited: called when a choice is selected on the left-hand pane
-  init_options_frame: initialise the right-hand side
   init_treemodel: set up the treemodel and treeview
   on_treeview_clicked: when a row is clicked, process the consequences (e.g. activate inactive instance)
   set_treestore: stuff the treestore with a given tree.Tree
@@ -105,6 +112,8 @@
     self.find      = DiamondFindDialog(self, gladefile)
     self.popup = self.gui.get_widget("popupmenu")
 
+    self.add_custom_widgets()
+    
     self.plugin_buttonbox = self.gui.get_widget("plugin_buttonbox")
     self.plugin_buttonbox.set_layout(gtk.BUTTONBOX_START)
     self.plugin_buttonbox.show()
@@ -129,7 +138,8 @@
                     "on_about": self.on_about,
                     "on_copy_spud_path": self.on_copy_spud_path,
                     "on_copy": self.on_copy,
-                    "on_paste": self.on_paste}
+                    "on_paste": self.on_paste,
+                    "on_slice": self.on_slice}
     self.gui.signal_autoconnect(signals)
 
     self.main_window = self.gui.get_widget("mainWindow")
@@ -147,7 +157,7 @@
     self.suffix = suffix
 
     self.selected_node = None
-    self.init_options_frame()
+    self.update_options_frame()
 
     self.file_path = os.getcwd()
     self.schemafile_path = os.getcwd()
@@ -338,6 +348,7 @@
       
     self.treeview.freeze_child_notify()
     self.treeview.set_model(None)
+    self.signals = {}
     self.set_treestore(None, [self.tree], True)
     self.treeview.set_model(self.treestore)
     self.treeview.thaw_child_notify()
@@ -426,7 +437,7 @@
     one.
     """
 
-    self.node_data_store()
+    self.data.store()
 
     if self.filename is None:
       return self.on_save_as(widget)
@@ -521,35 +532,10 @@
     return
 
   def on_display_properties_toggled(self, widget=None):
-    self.options_frame.set_property("visible", not self.options_frame.get_property("visible"))
+    optionsFrame = self.gui.get_widget("optionsFrame")
+    optionsFrame.set_property("visible", not optionsFrame.get_property("visible"))
     return
 
-  def set_cell_node(self, iter):
-      node = self.get_painted_tree(iter)
-
-      if isinstance(node, MixedTree):
-        node = node.child
-
-      if node.data is not None:
-        self.data_renderer.set_property("foreground", "black")
-        self.treestore.set_value(iter, 4, node.data)
-      elif isinstance(node, tree.Tree) and not node.not_editable():
-        self.data_renderer.set_property("foreground", "gray")
-
-        datatype = ""
-
-        if isinstance(node.datatype, plist.List):
-          datatype = "(" + node.datatype.datatype.__name__ + ")"
-        elif isinstance(node.datatype, tuple):
-          datatype = str(node.datatype)
-        else:
-          datatype = node.datatype.__name__
-
-        self.treestore.set_value(iter, 4, datatype)
-
-  def expand_fill_data(self, model, path, iter, user_data):
-      return self.set_cell_node(iter)
-
   def on_go_to_node(self, widget=None):
    """
    Go to a node, identified by an XPath
@@ -566,7 +552,6 @@
     """
 
     self.treeview.expand_all()
-    self.treestore.foreach(self.expand_fill_data, None)
 
     return
 
@@ -624,8 +609,6 @@
       pass
 
     about.set_logo(logo)
-    about.connect("destroy", dialogs.close_dialog)
-    about.connect("response", dialogs.close_dialog)
     about.show()
 
     return
@@ -652,13 +635,13 @@
       return self._get_focus_widget(focus)
 
   def on_copy(self, widget=None):
-    
-    widget = self._get_focus_widget(self.main_window)
-    if widget is not self.treeview and gobject.signal_lookup("copy-clipboard", widget):
-      widget.emit("copy-clipboard")
-      return
+    if not isinstance(widget, gtk.MenuItem):
+      widget = self._get_focus_widget(self.main_window)
+      if widget is not self.treeview and gobject.signal_lookup("copy-clipboard", widget):
+        widget.emit("copy-clipboard")
+        return
 
-    if isinstance(self.selected_node, MixedTree):
+    if isinstance(self.selected_node, mixedtree.MixedTree):
       node = self.selected_node.parent
     else:
       node = self.selected_node    
@@ -675,11 +658,11 @@
     return
 
   def on_paste(self, widget=None):
-
-    widget = self._get_focus_widget(self.main_window)
-    if widget is not self.treeview and gobject.signal_lookup("paste-clipboard", widget):
-      widget.emit("paste-clipboard")
-      return
+    if not isinstance(widget, gtk.MenuItem):
+      widget = self._get_focus_widget(self.main_window)
+      if widget is not self.treeview and gobject.signal_lookup("paste-clipboard", widget):
+        widget.emit("paste-clipboard")
+        return
 
     clipboard = gtk.clipboard_get()
     ios = StringIO.StringIO(clipboard.wait_for_text())
@@ -732,6 +715,19 @@
 
     return
 
+  def on_slice(self, widget = None):
+    if not self.selected_node.is_sliceable():
+      self.statusbar.set_statusbar("Cannot slice on this element.")
+      return
+
+    window = sliceview.SliceView(self.main_window)
+    window.geometry_dim_tree = self.geometry_dim_tree
+    window.update(self.selected_node, self.tree)
+    window.connect("destroy", self._slice_destroy)
+    return
+
+  def _slice_destroy(self, widget):
+    self.on_select_row()
 
   ## LHS ###
 
@@ -747,6 +743,7 @@
       l = self.s.valid_children(":start")
 
       self.tree = l[0]
+      self.signals = {}
       self.set_treestore(None, l)
 
     root_iter = self.treestore.get_iter_first()
@@ -764,18 +761,17 @@
     """
 
     self.treeview = optionsTree = self.gui.get_widget("optionsTree")
-    self.treeview.connect("row-collapsed", self.on_treeview_row_collapsed)
     self.treeview.connect("key_press_event", self.on_treeview_key_press)
     self.treeview.connect("button_press_event", self.on_treeview_button_press)
+    self.treeview.connect("row-activated", self.on_activate_row)
     self.treeview.connect("popup_menu", self.on_treeview_popup)
-    try:  # allow for possibility of no tooltips (like elsewhere)
-      self.treeview.connect("query-tooltip", self.on_tooltip)
-      self.treeview.set_property("has-tooltip", False)
-    except:
-      pass
 
     self.treeview.set_property("rules-hint", True)
+
     self.treeview.get_selection().set_mode(gtk.SELECTION_SINGLE)
+    self.treeview.get_selection().connect("changed", self.on_select_row)
+    self.treeview.get_selection().set_select_function(self.options_tree_select_func)
+    self.options_tree_select_func_enabled = True
 
     model = gtk.ListStore(str, str, gobject.TYPE_PYOBJECT)
     self.cellcombo = cellCombo = gtk.CellRendererCombo()
@@ -783,6 +779,7 @@
     cellCombo.set_property("text-column", 0)
     cellCombo.set_property("editable", True)
     cellCombo.set_property("has-entry", False)
+    cellCombo.connect("edited", self.cellcombo_edited)
 
     # Node column
     column = gtk.TreeViewColumn("Node", cellCombo, text=0)
@@ -803,54 +800,31 @@
     imgcolumn.set_cell_data_func(cellPicture, self.set_cellpicture_cardinality)
     optionsTree.append_column(imgcolumn)
 
-    # mtw07 - add column for quick preview of data.
-    self.data_renderer = gtk.CellRendererText()
-    self.data_renderer.set_property("editable", True)
-    self.data_renderer.connect("edited", self.on_cell_edit)
-    self.data_renderer.connect("editing-started", self.on_cell_edit_start)
-
-#    self.data_col = data_col = gtk.TreeViewColumn("Data", self.data_renderer, text=4)
-#    data_col.set_property("expand", True)
-#    data_col.set_property("sizing", gtk.TREE_VIEW_COLUMN_AUTOSIZE)
-#    optionsTree.append_column(data_col)
-
-    # display name, gtk.ListStore containing the display names of possible choices, pointer to node in self.tree -- a choice or a tree, pointer to currently active tree and its data.
-    self.treestore = gtk.TreeStore(str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, str)
+    # 0: display name, 
+    # 1: gtk.ListStore containing the display names of possible choices
+    # 2: pointer to node in self.tree -- a choice or a tree
+    # 3: pointer to currently active tree
+
+    self.treestore = gtk.TreeStore(str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)
     self.treeview.set_model(self.treestore)
-#    self.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_VERTICAL)
-
-    optionsTree.get_selection().connect("changed", self.on_select_row)
-    self.treeview.get_selection().set_select_function(self.options_tree_select_func)
-    self.options_tree_select_func_enabled = True
-    optionsTree.connect("button_press_event", self.on_treeview_clicked)
-    optionsTree.connect("row-activated", self.on_activate_row)
-    cellCombo.connect("edited", self.cellcombo_edited)
-
     self.treeview.set_enable_search(False)
 
     return
 
-  def create_liststore(self, l):
+  def create_liststore(self, choice_or_tree):
     """
     Given a list of possible choices, create the liststore for the
     gtk.CellRendererCombo that contains the names of possible choices.
     """
 
     liststore = gtk.ListStore(str, gobject.TYPE_PYOBJECT)
-    if l.__class__ is choice.Choice:
-      l = l.l # I'm really sorry about this, blame dham
-
-    if not isinstance(l, list):
-      l = [l]
-
-    # Ignoring the numerous l's involved in getting the choices,
-    # l is now a list of possible names.
-    for t in l:
-      name = self.get_display_name(t)
+
+    for t in choice_or_tree.get_choices():
+      name = t.get_display_name()
       liststore.append([name, t])
 
     return liststore
-
+  
   def set_treestore(self, iter=None, new_tree=[], recurse=False, replace=False):
     """
     Given a list of children of a node in a treestore, stuff them in the treestore.
@@ -861,39 +835,50 @@
       iter = self.treestore.iter_parent(replacediter)
     else:
       self.remove_children(iter)
-    
+  
     for t in new_tree:
-      if t.__class__ is tree.Tree:
-        if self.choice_or_tree_is_hidden(t):
+      if t is not None and t in self.signals:
+        t.disconnect(self.signals[t][0])
+        t.disconnect(self.signals[t][1])
+
+      if isinstance(t, tree.Tree):
+        if t.is_hidden():
+          attrid = t.connect("on-set-attr", self.on_set_attr, self.treestore.get_path(iter))
+          dataid = t.connect("on-set-data", self.on_set_data, self.treestore.get_path(iter))
+          self.signals[t] = (attrid, dataid)
           continue
 
         liststore = self.create_liststore(t)
 
-        # Convert node data, if it exists, to a string
-        data = ""
-        node_data = t.data
-        if node_data is not None:
-#          if t.__class__ is str:
-#            if len(t) > 4: # Trim the string if it's long
-#              node_data = t[:4] + ".."
-          
-          data = str(node_data)
- 
         if replace:
-          child_iter = self.treestore.insert_before(iter, replacediter, [self.get_display_name(t), liststore, t, t, data])
+          child_iter = self.treestore.insert_before(iter, replacediter, [t.get_display_name(), liststore, t, t])
         else:
-          child_iter = self.treestore.append(iter, [self.get_display_name(t), liststore, t, t, data])
-        
+          child_iter = self.treestore.append(iter, [t.get_display_name(), liststore, t, t])
+
+        attrid = t.connect("on-set-attr", self.on_set_attr, self.treestore.get_path(child_iter))
+        dataid = t.connect("on-set-data", self.on_set_data, self.treestore.get_path(child_iter))
+        self.signals[t] = (attrid, dataid)
+ 
         if recurse and t.active: self.set_treestore(child_iter, t.children, recurse)
-      elif t.__class__ is choice.Choice:
+
+      elif isinstance(t, choice.Choice):
         liststore = self.create_liststore(t)
         ts_choice = t.get_current_tree()
-        if self.choice_or_tree_is_hidden(ts_choice):
+        if ts_choice.is_hidden():
+          attrid = t.connect("on-set-attr", self.on_set_attr, self.treestore.get_path(iter))
+          dataid = t.connect("on-set-data", self.on_set_data, self.treestore.get_path(iter))
+          self.signals[t] = (attrid, dataid)
           continue
+
         if replace:
-          child_iter = self.treestore.insert_before(iter, replacediter, [self.get_display_name(ts_choice), liststore, t, ts_choice, ""])
+          child_iter = self.treestore.insert_before(iter, replacediter, [ts_choice.get_display_name(), liststore, t, ts_choice])
         else:
-          child_iter = self.treestore.append(iter, [self.get_display_name(ts_choice), liststore, t, ts_choice, ""])
+          child_iter = self.treestore.append(iter, [ts_choice.get_display_name(), liststore, t, ts_choice])
+
+        attrid = t.connect("on-set-attr", self.on_set_attr, self.treestore.get_path(child_iter))
+        dataid = t.connect("on-set-data", self.on_set_data, self.treestore.get_path(child_iter))
+        self.signals[t] = (attrid, dataid)
+
         if recurse and t.active: self.set_treestore(child_iter, ts_choice.children, recurse)
 
     if replace:
@@ -976,10 +961,7 @@
     foreground colour.
     """
 
-    liststore = self.treestore.get_value(iter, 1)
-    choice_or_tree = self.treestore.get_value(iter, 2)
-    active_tree = self.treestore.get_value(iter, 3)
-    data = self.treestore.get_value(iter, 4)
+    liststore, choice_or_tree, active_tree = self.treestore.get(iter, 1, 2, 3)
 
     # set the model for the cellcombo, where it gets the possible choices for the name
     cellCombo.set_property("model", liststore)
@@ -1007,9 +989,9 @@
     """
 
     choice_or_tree = self.treestore.get_value(iter, 2)
-    if choice_or_tree.__class__ is tree.Tree:
+    if isinstance(choice_or_tree, tree.Tree):
       cell.set_property("stock-id", None)
-    elif choice_or_tree.__class__ is choice.Choice:
+    elif isinstance(choice_or_tree, choice.Choice):
       cell.set_property("stock-id", gtk.STOCK_GO_DOWN)
 
     return
@@ -1042,132 +1024,6 @@
 
     return
 
-  def on_treeview_row_collapsed(self, treeview, iter, path):
-    """
-    Called when a row in the LHS treeview is collapsed.
-    """
-
-    #self.treeview.get_column(0).queue_resize()
-    #self.treeview.get_column(1).queue_resize()
-
-    return
-
-  def on_tooltip(self, widget, x, y, keyboard_mode, tooltip):
-    y-=25 # It's hardcoded. Gtk doesn't offer a way to get at the column height without a lot more code.
-    (tx, ty) = self.treeview.convert_bin_window_to_tree_coords(x, y)
-    pathinfo = self.treeview.get_path_at_pos(x, y)
-
-    if pathinfo is None:
-      return False
-
-    path = pathinfo[0]
-    column = pathinfo[1]
-
-    if path is None:
-      return
-
-    ctitle = column.get_title()
-
-    iter = self.treestore.get_iter(path)
-
-    # Get the tree or choice pointed to by the iterator.
-    tree = self.treestore.get_value(iter, 2)
-
-    if tree.__class__ is choice.Choice:
-      tree = tree.get_current_tree()
-
-    if ctitle == "Node":
-      if tree.doc is None:
-        text = "(No documentation)"
-      else:
-        text = self.render_whitespace(tree.doc)
-    elif ctitle == "Data":
-      comment_tree = self.get_comment(tree)
-
-      if comment_tree is None:
-        text = "(No comment)"
-      else:
-        text = comment_tree.data
-    else:
-      return False
-
-    tooltip.set_text(text)    
-    return True
-
-  def on_cell_edit(self, cellr, path, new_text):
-    iter = self.treestore.get_iter(path)
-    node = self.selected_node
-
-    if new_text == "":
-      return
-
-    # mtw07 - Check whether the data is valid or not. If so, update the treeview
-    # and internal model. GTK automatically clears the text field if we don't
-    # add the new data to the treestore.
-    (invalid, data) = node.valid_data(node.datatype, new_text)
-
-    if invalid:
-      try:
-        name = node.datatype.__name__
-        dialogs.error(self.main_window, "Invalid data type. A %s is required." % name)
-      except:
-        pass
-      return
-
-    self.treestore.set_value(iter, 4, new_text)
-    node.data = new_text
-
-    # Update the node data box.
-    self.node_data.get_buffer().set_text(new_text)
-
-    # Update the validation errors list.
-    if self.scherror.errlist_is_open():
-      if self.scherror.errlist_type == 0:
-         self.scherror.on_validate_schematron()
-      else:
-         self.scherror.on_validate()
-
-    return
-
-  def on_cell_edit_start(self, cellrenderer, editable, path):
-    iter = self.treestore.get_iter(path)
-    node = self.selected_node
-
-    # If the cell has (<type>) in it, clear it for the user to enter data.
-    if node.datatype is not None and node.data is None:
-      editable.set_text("")
-
-    return True
-
-  def on_treeview_clicked(self, treeview, event):
-    """
-    This routine is called every time the mouse is clicked on the treeview on the
-    left-hand side. It processes the "buttons" gtk.STOCK_ADD and gtk.STOCK_REMOVE
-    in the right-hand column, activating, adding and removing tree nodes as
-    necessary.
-    """
-
-    if event.button != 1:
-      return
-
-    pathinfo = treeview.get_path_at_pos(int(event.x), int(event.y))
-
-    if pathinfo is None:
-      return
-
-    path = pathinfo[0]
-    col = pathinfo[1]
-
-    iter = self.treestore.get_iter(path)
-    self.update_data_column(self.treestore, iter)
-
-    if col is not self.imgcolumn:
-      return
-
-    self.toggle_tree(iter)
-
-    return
-
   def toggle_tree(self, iter):
     """
     Toggles the state of part of the tree.
@@ -1285,7 +1141,10 @@
       self.expand_treestore(iter)
       iter = self.treestore.insert_after(
         parent=parent_iter, sibling=iter, 
-        row=[self.get_display_name(new_tree), liststore, new_tree, new_tree.get_current_tree(), ""])
+        row=[new_tree.get_display_name(), liststore, new_tree, new_tree.get_current_tree()])
+      attrid = new_tree.connect("on-set-attr", self.on_set_attr, self.treestore.get_path(iter))
+      dataid = new_tree.connect("on-set-data", self.on_set_data, self.treestore.get_path(iter))
+      self.signals[new_tree] = (attrid, dataid)
       self.set_saved(False)
 
     parent_tree.recompute_validity()
@@ -1301,10 +1160,13 @@
       self.options_tree_select_func_enabled = True
       return False
 
-    if not self.node_data_store():
+    if not self.data.store():
       return False
 
-    if isinstance(self.selected_node, MixedTree) and self.geometry_dim_tree is not None and self.selected_node.parent is self.geometry_dim_tree.parent and self.selected_node.data is not None:
+    if isinstance(self.selected_node, mixedtree.MixedTree) \
+       and self.geometry_dim_tree is not None \
+       and self.selected_node.parent is self.geometry_dim_tree.parent \
+       and self.selected_node.data is not None:
       self.geometry_dim_tree.set_data(self.selected_node.data)
 
     return True
@@ -1327,15 +1189,29 @@
     return
 
   def on_treeview_button_press(self, treeview, event):
-    if event.button == 3:
-      x = int(event.x)
-      y = int(event.y)
-      path = treeview.get_path_at_pos(x, y)[0]
-      if path is not None:
-        treeview.get_selection().select_path(path)
+    """
+    This routine is called every time the mouse is clicked on the treeview on the
+    left-hand side. It processes the "buttons" gtk.STOCK_ADD and gtk.STOCK_REMOVE
+    in the right-hand column, activating, adding and removing tree nodes as
+    necessary.
+    """
+    pathinfo = treeview.get_path_at_pos(int(event.x), int(event.y))
+
+    if event.button == 1:
+
+      if pathinfo is not None:
+        path = pathinfo[0]
+        col = pathinfo[1]
+
+        if col is self.imgcolumn:
+          iter = self.treestore.get_iter(path)
+          self.toggle_tree(iter)
+
+    elif event.button == 3:
+      if pathinfo is not None:
+        treeview.get_selection().select_path(pathinfo[0])
         self.show_popup(None, event.button, event.time)
         return True
-    return False
 
   def popup_location(self, widget, user_data):
     column = self.treeview.get_column(0)
@@ -1358,28 +1234,22 @@
     Called when a row is selected. Update the options frame.
     """
 
-    path = self.get_selected_row(selection)
+    if isinstance(selection, str) or isinstance(selection, tuple):
+      path = selection
+    else:
+      path = self.get_selected_row(selection)
+
     if path is None:
       return  
+
     self.selected_iter = iter = self.treestore.get_iter(path)
-
-    choice_or_tree = self.treestore.get_value(iter, 2)
-
-    active_tree = self.treestore.get_value(iter, 3)
+    choice_or_tree, active_tree = self.treestore.get(iter, 2, 3)
+
     debug.dprint(active_tree)
 
     self.selected_node = self.get_painted_tree(iter)
     self.update_options_frame()
 
-    node = self.selected_node
-
-    if isinstance(node, MixedTree):
-      node = node.child
-
-    # TODO: Handle tuple datatypes. Is it possible in a Gtk treeview column?
-    if not isinstance(node.datatype, tuple):
-      self.data_renderer.set_property("editable", not (node.not_editable()))
-
     name = self.get_spudpath(active_tree)
     self.statusbar.set_statusbar(name)
     self.current_spudpath = name
@@ -1477,18 +1347,6 @@
     else:
       return None
 
-  def update_data_column(self, model, itParent):
-    """
-    Update the data column in the treeview. Used when a user expands a row.
-    """
-
-    iter = model.iter_children(itParent)
-
-    while iter is not None:
-      self.set_cell_node(iter)
-      iter = model.iter_next(iter)
-   
-
   def on_activate_row(self, treeview, path, view_column):
     """
     Called when you double click or press Enter on a row.
@@ -1507,10 +1365,6 @@
     else:
       treeview.expand_row(path, False)
 
-      # Update the data column for the newly expanded row.
-      (model, itParent) = self.treeview.get_selection().get_selected()
-      self.update_data_column(model, itParent)
-
     return
 
   def cellcombo_edited(self, cellrenderertext, path, new_text):
@@ -1561,53 +1415,6 @@
 
     return
 
-  def paint_validity(self):
-    """
-    Walk up the parental line, repainting the colour for their validity
-    appropriately. This is called when a validity-changing event occurs.
-    Repaint the whole tree if there is no selection.
-    """
-
-    def paint_iter_validity(iter):
-      while iter is not None:
-        active_tree = self.treestore.get_value(iter, 3)
-        if active_tree.valid:
-          self.cellcombo.set_property("foreground", "black")
-        else:
-          self.cellcombo.set_property("foreground", "blue")
-        iter = self.treestore.iter_next(iter)
-
-      return
-
-    selection = self.treeview.get_selection()
-    path = self.get_selected_row(selection)
-    if path is None:
-      paint_iter_validity(self.treestore.get_iter_first())
-    else:
-      paint_iter_validity(self.treestore.get_iter(path))
-
-    self.treeview.queue_draw()
-
-    return
-
-  def get_display_name(self, active_tree):
-    """
-    This is a fluidity hack, allowing the name displayed in the treeview on the
-    left to be different to the element name. If it has an attribute name="xxx",
-    element_tag (xxx) is displayed.
-    """
-
-    if active_tree.__class__ is tree.Tree:
-      displayname = active_tree.name
-      if "name" in active_tree.attrs.keys():
-        attrname = active_tree.attrs["name"][1]
-        if attrname is not None:
-          displayname = displayname + " (" + attrname + ")"
-    elif active_tree.__class__ is choice.Choice:
-      displayname = self.get_display_name(active_tree.get_current_tree())
-
-    return displayname
-
   def get_treeview_iter(self, selection):
     """
     Get a treeview iterator object, given a selection.
@@ -1619,19 +1426,19 @@
 
     return self.treestore.get_iter(path)
 
-  def update_painted_name(self):
-    """
-    This updates the treestore (and the liststore for the gtk.CellRendererCombo)
-    with a new name, when the name="xxx" attribute is changed.
-    """
+  def on_set_data(self, node, data, path):
+    self.set_saved(False)
+    self.treeview.queue_draw()
+    #self.on_select_row(path)
 
-    iter = self.get_treeview_iter(self.treeview.get_selection())
-    if iter is None:
+  def on_set_attr(self, node, attr, value, path):
+    if attr != "name":
       return
 
+    iter = self.treestore.get_iter(path)
     liststore = self.treestore.get_value(iter, 1)
     active_tree = self.treestore.get_value(iter, 3)
-    new_name = self.get_display_name(active_tree)
+    new_name = active_tree.get_display_name()
     self.treestore.set_value(iter, 0, new_name)
 
     # find the liststore iter corresponding to the painted choice
@@ -1642,9 +1449,7 @@
         liststore.set_value(list_iter, 0, new_name)
       list_iter = liststore.iter_next(list_iter)
 
-    self.treeview.get_column(0).queue_resize()
-
-    return
+    self.treeview.queue_resize()
 
   def get_painted_tree(self, iter_or_tree, lock_geometry_dim = True):
     """
@@ -1662,25 +1467,7 @@
     else:
       active_tree = self.treestore.get_value(iter_or_tree, 3)
 
-    integers = [child for child in active_tree.children if child.name == "integer_value"]
-    reals    = [child for child in active_tree.children if child.name == "real_value"]
-    logicals = [child for child in active_tree.children if child.name == "logical_value"]
-    strings  = [child for child in active_tree.children if child.name == "string_value"]
-
-    child = None
-    if len(integers) > 0:
-      child = integers[0]
-    if len(reals) > 0:
-      child = reals[0]
-    if len(logicals) > 0:
-      child = logicals[0]
-    if len(strings) > 0:
-      child = strings[0]
-
-    if child is None:
-      painted_tree = active_tree
-    else:
-      painted_tree = MixedTree(active_tree, child)
+    painted_tree = active_tree.get_mixed_data()
 
     if not isinstance(iter_or_tree, tree.Tree) and not self.treestore_iter_is_active(iter_or_tree):
       painted_tree = tree.Tree(painted_tree.name, painted_tree.schemaname, painted_tree.attrs, doc = painted_tree.doc)
@@ -1690,10 +1477,10 @@
         data_tree = tree.Tree(painted_tree.name, painted_tree.schemaname, datatype = "fixed")
         data_tree.data = painted_tree.data
         painted_tree = MixedTree(painted_tree, data_tree)
-      elif isinstance(self.geometry_dim_tree, MixedTree) and active_tree is self.geometry_dim_tree.parent:
+      elif isinstance(self.geometry_dim_tree, mixedtree.MixedTree) and active_tree is self.geometry_dim_tree.parent:
         data_tree = tree.Tree(painted_tree.child.name, painted_tree.child.schemaname, datatype = "fixed")
         data_tree.data = painted_tree.data
-        painted_tree = MixedTree(painted_tree, data_tree)
+        painted_tree = mixedtree.MixedTree(painted_tree, data_tree)
 
     return painted_tree
 
@@ -1724,20 +1511,19 @@
     Find the iter into the treestore corresponding to the geometry dimension, and
     perform checks to test that the geometry dimension node is valid.
     """
-
+    
+    self.geometry_dim_tree = self.data.geometry_dim_tree = None
     # The tree must exist
     if self.tree is None:
-      self.geometry_dim_tree = None
       return
 
     # A geometry dimension element must exist
     iter = self.get_treestore_iter_from_xmlpath("/" + self.tree.name + self.data_paths["dim"])
     if iter is None:
-      self.geometry_dim_tree = None
       return
 
     painted_tree = self.get_painted_tree(iter, False)
-    if isinstance(painted_tree, MixedTree):
+    if isinstance(painted_tree, mixedtree.MixedTree):
        # If the geometry dimension element has a hidden data element, it must
        # have datatype tuple or fixed
        if not isinstance(painted_tree.datatype, tuple) and painted_tree.datatype != "fixed":
@@ -1745,7 +1531,6 @@
          return
     elif painted_tree.datatype != "fixed":
       # Otherwise, only fixed datatype is permitted
-      self.geometry_dim_tree = None
       return
 
     # All parents of the geometry dimension element must have cardinality ""
@@ -1763,18 +1548,16 @@
     elif painted_tree.datatype == "fixed":
       possible_dims = [painted_tree.data]
     else:
-      self.geometry_dim_tree = None
       return
     for opt in possible_dims:
       try:
         test = int(opt)
         assert test > 0
       except:
-        self.geometry_dim_tree = None
         return
       
     # A valid geometry dimension element has been located
-    self.geometry_dim_tree = painted_tree
+    self.geometry_dim_tree = self.data.geometry_dim_tree = painted_tree
     
     return
 
@@ -1792,55 +1575,6 @@
 
     return True
 
-  def choice_or_tree_is_hidden(self, choice_or_tree):
-    """
-    Tests whether the supplied choice or tree should be hidden from the LHS.
-    """
-
-    return self.choice_or_tree_is_comment(choice_or_tree) or choice_or_tree.name in ["integer_value", "real_value", "string_value", "logical_value"]
-
-  def choice_or_tree_is_comment(self, choice_or_tree):
-    """
-    Test whether the given node is a comment node.
-    """
-
-    if not isinstance(choice_or_tree, tree.Tree):
-      return False
-
-    if not choice_or_tree.name == "comment":
-      return False
-
-    if not choice_or_tree.attrs == {}:
-      return False
-
-    if not choice_or_tree.children == []:
-      return False
-
-    if not choice_or_tree.datatype is str:
-      return False
-
-    if not choice_or_tree.cardinality == "?":
-      return False
-
-    return True
-
-  def get_comment(self, choice_or_tree):
-    """
-    Return the first comment found as a child of the supplied node, or None if
-    none found.
-    """
-
-    if choice_or_tree is None or isinstance(choice_or_tree, choice.Choice):
-      return None
-
-    for child in choice_or_tree.children:
-      if self.choice_or_tree_is_comment(child):
-        return child
-
-    return None
-
-    return
-
   def choice_or_tree_matches(self, text, choice_or_tree, recurse, search_active_subtrees = False):
     """
     See if the supplied node matches a given piece of text. If recurse is True,
@@ -1849,7 +1583,7 @@
     choice match.
     """
 
-    if self.choice_or_tree_is_hidden(choice_or_tree):
+    if choice_or_tree.is_hidden():
       return False
     elif isinstance(choice_or_tree, choice.Choice):
       if self.choice_or_tree_matches(text, choice_or_tree.get_current_tree(), False):
@@ -1870,7 +1604,7 @@
           text_re = re.compile(text)
         else:
           text_re = re.compile(text, re.IGNORECASE)
-        comment = self.get_comment(choice_or_tree)
+        comment = choice_or_tree.get_comment()
         if comment is not None and comment.data is not None and text_re.search(comment.data) is not None:
           return True
         elif recurse:
@@ -1909,1279 +1643,58 @@
     return
 
   ### RHS ###
-  
-  def render_whitespace(self, desc):
-    ''' Render the line wrapping in desc as follows:
-    
-    * Newlines followed by 0-1 spaces are ignored.
-    * Blank lines start new paragraphs.
-    * Newlines followed by more than 1 space are honoured.
-    '''
-
-    prev_line_literal=False
-    prev_line_new_para=False
-    newdesc=""
-
-    for line in desc.split("\n"):
-
-        if (line[:1]==" "):
-            # Literal line with leading blanks.
-            newdesc=newdesc+"\n"+line
-            prev_line_literal=True
-            prev_line_new_para=False
-            continue
-
-        if (line.strip()==""):
-            # New paragraph.
-
-            # Collapse multiple new paragraphs into one, except when
-            # following a literal line.
-            if (prev_line_new_para and not prev_line_literal):
-                continue
-
-            newdesc=newdesc+"\n"
-            prev_line_new_para=True                
-            continue
-
-        if prev_line_literal:
-            newdesc=newdesc+"\n"
-            prev_line_literal=False
-            prev_line_new_para=False
-            
-        if prev_line_new_para:
-            newdesc=newdesc+"   "
-            prev_line_new_para=False
-        
-        # Default case
-        newdesc=newdesc+line+" "
-    
-    return newdesc
-
-  def link_bounds(self, text):
-    """
-    Return a list of tuples corresponding to the start and end points of links in
-    the supplied string.
-    """
-
-    bounds = []
-
-    text_split = text.lower().split("http://")
-    if len(text_split) > 1:
-      lbound = -7
-      for i in range(len(text_split))[1:]:
-        lbound += len(text_split[i - 1]) + 7
-        ubound = lbound + len(text_split[i].split(" ")[0].split("\n")[0]) + 7
-        while text[ubound - 1:ubound] in [".", ",", ":", ";", "\"", "'", ")", "]", "}"]:
-          ubound -= 1
-        bounds.append((lbound, ubound))
-
-    return bounds
-
-  def type_name(self, datatype):
-    """
-    Return a human readable version of datatype.
-    """
-
-    def familiar_type(type_as_printable):
-      """
-      Convert some type names to more familiar equivalents.
-      """
-
-      if type_as_printable == "decim":
-        return "float"
-      elif type_as_printable == "int":
-        return "integer"
-      elif type_as_printable == "str":
-        return "string"
-      else:
-        return type_as_printable
-
-    datatype_string = str(datatype)
-
-    if datatype_string[:7] == "<type '" and datatype_string[len(datatype_string) - 2:] == "'>":
-      value_type_split = datatype_string.split("'")
-      return familiar_type(value_type_split[1])
-
-    value_type_split1 = datatype_string.split(".")
-    value_type_split2 = value_type_split1[len(value_type_split1) - 1].split(" ")
-    if len(value_type_split2) == 1:
-      return familiar_type(value_type_split2[0][0:len(value_type_split2[0]) - 6])
-    else:
-      return familiar_type(value_type_split2[0])
-
-  def printable_type(self, datatype, bracket = True):
-    """
-    Create a string to be displayed in place of empty data / attributes.
-    """
-
-    if isinstance(datatype, plist.List):
-      if (isinstance(datatype.cardinality, int) and datatype.cardinality == 1) or datatype.cardinality == "":
-        type_as_printable = self.type_name(datatype.datatype).lower()
-      else:
-        type_as_printable = self.type_name(datatype).lower() + " of "
-        list_type_as_printable = self.type_name(datatype.datatype).lower()
-        if isinstance(datatype.cardinality, int):
-          type_as_printable += str(datatype.cardinality) + " " + list_type_as_printable + "s"
-        else:
-          type_as_printable += list_type_as_printable + "s"
-    else:
-      type_as_printable = self.type_name(datatype).lower()
-
-    if bracket:
-      type_as_printable = "(" + type_as_printable + ")"
-
-    return type_as_printable
-
-  def init_options_frame(self):
-    """
-    Initialise the RHS.
-    """
-
-    # mtw07 - TODO: set the visibility of the options frame, depending on the value in the schema file.
-    self.options_frame = self.gui.get_widget("optionsFrame")
-
-    # Display the right hand side by default.
-    self.options_frame.set_property("visible", True)
-
-    self.node_desc = self.gui.get_widget("nodeDescription")
-    self.node_desc.set_buffer(TextBufferMarkup.PangoBuffer())
-    self.node_desc.connect("button-release-event", self.node_desc_mouse_button_release)
-    self.node_desc.connect("motion-notify-event", self.node_desc_mouse_over)
-
-    self.node_attrs = self.gui.get_widget("nodeAttributes")
-    attrs_model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
-    self.node_attrs.set_model(attrs_model)
-    self.node_attrs.connect("motion-notify-event", self.node_attrs_mouse_over)
-    key_renderer = gtk.CellRendererText()
-    key_renderer.set_property("editable", False)
-    attrs_col1 = gtk.TreeViewColumn("Name", key_renderer, text = 0)
-    attrs_col1.set_cell_data_func(key_renderer, self.node_attrs_key_data_func)
-    attrs_col1.set_property("min-width", 75)
-    attrs_val_entry_renderer = gtk.CellRendererText()
-    attrs_val_entry_renderer.connect("edited", self.node_attrs_edited)
-    attrs_val_entry_renderer.connect("editing-started", self.node_attrs_entry_edit_start)
-    attrs_val_combo_renderer = gtk.CellRendererCombo()
-    attrs_val_combo_renderer.set_property("text-column", 0)
-    attrs_val_combo_renderer.connect("edited", self.node_attrs_selected)
-    attrs_val_combo_renderer.connect("editing-started", self.node_attrs_combo_edit_start)
-    attrs_col2 = gtk.TreeViewColumn("Value", attrs_val_entry_renderer, text = 1)
-    attrs_col2.pack_start(attrs_val_combo_renderer)
-    attrs_col2.set_attributes(attrs_val_combo_renderer, text = 1)
-    attrs_col2.set_cell_data_func(attrs_val_entry_renderer, self.node_attrs_entry_data_func)
-    attrs_col2.set_cell_data_func(attrs_val_combo_renderer, self.node_attrs_combo_data_func)
-    attrs_col2.set_property("expand", True)
-    attrs_col2.set_property("min-width", 75)
-    attrs_icon_renderer = gtk.CellRendererPixbuf()
-    attrs_col3 = gtk.TreeViewColumn("", attrs_icon_renderer)
-    attrs_col3.set_cell_data_func(attrs_icon_renderer, self.node_attrs_icon_data_func)
-    self.node_attrs.append_column(attrs_col1)
-    self.node_attrs.append_column(attrs_col2)
-    self.node_attrs.append_column(attrs_col3)
-
-    self.node_data_frame = self.gui.get_widget("dataFrame")
-
-    self.node_data_buttons_hbox = self.gui.get_widget("dataButtonsHBox")
-
-    data_revert_button = self.gui.get_widget("dataRevertButton")
-    data_revert_button.connect("clicked", self.node_data_revert)
-
-    data_store_button = self.gui.get_widget("dataStoreButton")
-    data_store_button.connect("clicked", self.node_data_store)
-
-    self.node_comment = self.gui.get_widget("nodeComment")
-    self.node_comment.get_buffer().create_tag("comment_buffer_tag")
-    self.node_comment.connect("focus-in-event", self.node_comment_focus_in)
-    self.node_comment.connect("expose-event", self.node_comment_expose)
-
-    return
-
+
+  def add_custom_widgets(self):
+    """
+    Adds custom python widgets that aren't easily handeled by glade.
+    """
+    
+    optionsFrame = self.gui.get_widget("optionsFrame")
+
+    vpane1 = gtk.VPaned()
+    vpane2 = gtk.VPaned()
+    vbox = gtk.VBox()
+    
+    vpane1.pack2(vpane2, True, False)
+    vpane2.pack1(vbox, True, False)
+    optionsFrame.add(vpane1)
+
+    self.description = descriptionwidget.DescriptionWidget()
+    vpane1.pack1(self.description, True, False)
+
+    self.attributes = attributewidget.AttributeWidget()
+    vbox.pack_start(self.attributes, True, True)
+
+    databuttons = databuttonswidget.DataButtonsWidget()
+    vbox.pack_end(databuttons, False)
+    
+    self.data = datawidget.DataWidget()
+    self.data.set_buttons(databuttons)
+    vbox.pack_end(self.data, True, True)
+
+    self.comment = commentwidget.CommentWidget()
+    vpane2.pack2(self.comment, True, False)
+
+    optionsFrame.show_all()
+    return 
+ 
   def update_options_frame(self):
     """
     Update the RHS.
     """
-
-    if self.selected_node is None:
-      self.set_node_desc("<span foreground=\"grey\">No node selected</span>")
-    elif self.selected_node.doc is None:
-      self.set_node_desc("<span foreground=\"red\">No documentation</span>")
-    else:
-      self.set_node_desc(self.selected_node.doc)
-
-    self.update_node_attrs()
-
-    if self.selected_node is None or not self.selected_node.active:
-      self.set_node_data_entry()
-    elif self.node_data_is_tensor() and self.geometry_dim_tree.data is not None:
-      self.set_node_data_tensor()
-    elif isinstance(self.selected_node.datatype, tuple):
-      self.set_node_data_combo()
-    else:
-      self.set_node_data_entry()
-
-    self.update_node_comment()
+    
+    self.description.update(self.selected_node)
+
+    self.attributes.update(self.selected_node)
+
+    self.data.update(self.selected_node)
+
+    self.comment.update(self.selected_node)
 
     self.gui.get_widget("optionsFrame").queue_resize()
     
     return
 
-  def node_desc_mouse_over(self, widget, event):
-    """
-    Called when the mouse moves over the node description widget. Sets the cursor
-    to a hand if the mouse hovers over a link.
-
-    Based on code from HyperTextDemo class in hypertext.py from PyGTK 2.12 demos
-    """
-
-    if self.selected_node is None or self.selected_node.doc is None:
-      return
-
-    buffer_pos = self.node_desc.window_to_buffer_coords(gtk.TEXT_WINDOW_TEXT, int(event.x), int(event.y))
-    char_offset = self.node_desc.get_iter_at_location(buffer_pos[0], buffer_pos[1]).get_offset()
-
-    for bounds in self.node_desc_link_bounds:
-      if char_offset >= bounds[0] and char_offset <= bounds[1]:
-        self.node_desc.get_window(gtk.TEXT_WINDOW_TEXT).set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
-        return
-
-    self.node_desc.get_window(gtk.TEXT_WINDOW_TEXT).set_cursor(gtk.gdk.Cursor(gtk.gdk.XTERM))
-
-    return
-
-  def node_desc_mouse_button_release(self, widget, event):
-    """
-    Called when a mouse button is released over the node description widget.
-    Launches a browser if the mouse release was over a link, the left mouse button
-    was released and no text was selected.
-
-    Based on code from HyperTextDemo class in hypertext.py from PyGTK 2.12 demos
-    """
-
-    if self.selected_node is None or self.selected_node.doc is None or event.button != 1:
-      return
-
-    selection_bounds = self.node_desc.get_buffer().get_selection_bounds()
-    if selection_bounds:
-      return
-
-    buffer_pos = self.node_desc.window_to_buffer_coords(gtk.TEXT_WINDOW_TEXT, int(event.x), int(event.y))
-    char_offset = self.node_desc.get_iter_at_location(buffer_pos[0], buffer_pos[1]).get_offset()
-
-    for bounds in self.node_desc_link_bounds:
-      if char_offset >= bounds[0] and char_offset <= bounds[1]:
-        webbrowser.open(self.selected_node.doc[bounds[0]:bounds[1]])
-        return
-
-    return
-
-  def set_node_desc(self, desc):
-    """
-    Set the node description.
-    """
-
-    self.node_desc_link_bounds = self.link_bounds(desc)
-
-    desc = self.render_whitespace(desc)
-
-    if self.node_desc_link_bounds:
-      new_desc = ""
-      for i in range(len(self.node_desc_link_bounds)):
-        if i == 0:
-          new_desc += desc[:self.node_desc_link_bounds[i][0]]
-        else:
-          new_desc += desc[self.node_desc_link_bounds[i - 1][1]:self.node_desc_link_bounds[i][0]]
-        new_desc += "<span foreground=\"blue\" underline=\"single\">" + desc[self.node_desc_link_bounds[i][0]:self.node_desc_link_bounds[i][1]] + "</span>"
-      new_desc += desc[self.node_desc_link_bounds[len(self.node_desc_link_bounds) - 1][1]:]
-      if self.node_desc_link_bounds[len(self.node_desc_link_bounds) - 1][1] == len(desc):
-        new_desc += " "
-      desc = new_desc
-
-    self.node_desc.get_buffer().set_text(desc)
-
-    return
-
-  def update_node_attrs(self):
-    """
-    Update the RHS attributes widget.
-    """
-
-    self.node_attrs.get_model().clear()
-
-    if self.selected_node is None:
-      self.node_attrs.get_column(2).set_property("visible", False)
-      self.node_attrs.get_column(0).queue_resize()
-      self.node_attrs.get_column(1).queue_resize()
-    elif len(self.selected_node.attrs.keys()) == 0:
-      self.gui.get_widget("attributeFrame").set_property("visible", False)
-    else:
-      self.gui.get_widget("attributeFrame").set_property("visible", True)
-      for key in self.selected_node.attrs.keys():
-        iter = self.node_attrs.get_model().append()
-        self.node_attrs.get_model().set_value(iter, 0, key)
-        cell_model = gtk.ListStore(gobject.TYPE_STRING)
-        self.node_attrs.get_model().set_value(iter, 2, cell_model)
-        if isinstance(self.selected_node.attrs[key][0], tuple):
-          if self.selected_node.attrs[key][1] is None:
-            if isinstance(self.selected_node.attrs[key][0][0], tuple):
-              self.node_attrs.get_model().set_value(iter, 1, "Select " + self.printable_type(self.selected_node.attrs[key][0][1]) + "...")
-            else:
-              self.node_attrs.get_model().set_value(iter, 1, "Select...")
-          else:
-            self.node_attrs.get_model().set_value(iter, 1, self.selected_node.attrs[key][1])
-          if isinstance(self.selected_node.attrs[key][0][0], tuple):
-            opts = self.selected_node.attrs[key][0][0]
-          else:
-            opts = self.selected_node.attrs[key][0]
-          for opt in opts:
-            cell_iter = cell_model.append()
-            cell_model.set_value(cell_iter, 0, opt)
-          self.node_attrs.get_column(2).set_property("visible", True)
-        elif self.selected_node.attrs[key][0] is None:
-          self.node_attrs.get_model().set_value(iter, 1, "No data")
-        elif self.selected_node.attrs[key][1] is None:
-          self.node_attrs.get_model().set_value(iter, 1, self.printable_type(self.selected_node.attrs[key][0]))
-        else:
-          self.node_attrs.get_model().set_value(iter, 1, self.selected_node.attrs[key][1])
-      self.node_attrs.get_column(0).queue_resize()
-      self.node_attrs.get_column(1).queue_resize()
-      self.node_attrs.get_column(2).queue_resize()
-
-    return
-
-  def node_attrs_mouse_over(self, widget, event):
-    """
-    Called when the mouse moves over the node attributes widget. Sets the
-    appropriate attribute widget tooltip.
-    """
-
-    path_info = self.node_attrs.get_path_at_pos(int(event.x), int(event.y))
-    if path_info is None:
-      try:
-        self.node_attrs.set_tooltip_text("")
-        self.node_attrs.set_property("has-tooltip", False)
-      except:
-        pass
-      return
-
-    path = path_info[0]
-    col = path_info[1]
-    if col is not self.node_attrs.get_column(1):
-      try:
-        self.node_attrs.set_tooltip_text("")
-        self.node_attrs.set_property("has-tooltip", False)
-      except:
-        pass
-      return
-
-    iter = self.node_attrs.get_model().get_iter(path)
-    iter_key = self.node_attrs.get_model().get_value(iter, 0)
-
-    return
-
-  def node_attrs_key_data_func(self, col, cell_renderer, model, iter):
-    """
-    Attribute name data function. Sets the cell renderer text colours.
-    """
-
-    iter_key = model.get_value(iter, 0)
-
-    if not self.selected_node.active or self.selected_node.attrs[iter_key][0] is None or self.selected_node.attrs[iter_key][0] == "fixed":
-      cell_renderer.set_property("foreground", "grey")
-    elif self.selected_node.attrs[iter_key][1] is None:
-      cell_renderer.set_property("foreground", "blue")
-    else:
-      cell_renderer.set_property("foreground", "black")
-
-    return
-
-  def node_attrs_entry_data_func(self, col, cell_renderer, model, iter):
-    """
-    Attribute text data function. Hides the renderer if a combo box is required,
-    and sets colours and editability otherwise.
-    """
-
-    iter_key = model.get_value(iter, 0)
-
-    if not self.selected_node.active or self.selected_node.attrs[iter_key][0] is None or self.selected_node.attrs[iter_key][0] == "fixed":
-      cell_renderer.set_property("editable", False)
-      cell_renderer.set_property("foreground", "grey")
-      cell_renderer.set_property("visible", True)
-    elif not isinstance(self.selected_node.attrs[iter_key][0], tuple):
-      cell_renderer.set_property("editable", True)
-      cell_renderer.set_property("visible", True)
-      if self.selected_node.attrs[iter_key][1] is None:
-        cell_renderer.set_property("foreground", "blue")
-      else:
-        cell_renderer.set_property("foreground", "black")
-    else:
-      cell_renderer.set_property("editable", False)
-      cell_renderer.set_property("visible", False)
-
-    return
-
-  def node_attrs_combo_data_func(self, col, cell_renderer, model, iter):
-    """
-    Attribute combo box data function. Hides the renderer if a combo box is not
-    required, and sets the combo box options otherwise. Adds an entry if required.
-    """
-
-    iter_key = model.get_value(iter, 0)
-
-    if self.selected_node.active and isinstance(self.selected_node.attrs[iter_key][0], tuple):
-      cell_renderer.set_property("editable", True)
-      cell_renderer.set_property("visible", True)
-      if isinstance(self.selected_node.attrs[iter_key][0][0], tuple):
-        cell_renderer.set_property("has-entry", True)
-      else:
-        cell_renderer.set_property("has-entry", False)
-      if self.selected_node.attrs[iter_key][1] is None:
-        cell_renderer.set_property("foreground", "blue")
-      else:
-        cell_renderer.set_property("foreground", "black")
-    else:
-      cell_renderer.set_property("visible", False)
-      cell_renderer.set_property("editable", False)
-    cell_renderer.set_property("model", model.get_value(iter, 2))
-
-    return
-
-  def node_attrs_icon_data_func(self, col, cell_renderer, model, iter):
-    """
-    Attribute icon data function. Used to add downward pointing arrows for combo
-    attributes, for consistency with the LHS.
-    """
-
-    iter_key = model.get_value(iter, 0)
-
-    if self.selected_node.active and isinstance(self.selected_node.attrs[iter_key][0], tuple):
-      cell_renderer.set_property("stock-id", gtk.STOCK_GO_DOWN)
-    else:
-      cell_renderer.set_property("stock-id", None)
-
-    return
-
-  def node_attrs_entry_edit_start(self, cell_renderer, editable, path):
-    """
-    Called when editing is started on an attribute text cell. Used to delete the
-    printable_type placeholder.
-    """
-
-    iter = self.node_attrs.get_model().get_iter(path)
-    iter_key = self.node_attrs.get_model().get_value(iter, 0)
-
-    if self.selected_node.attrs[iter_key][1] is None:
-      editable.set_text("")
-
-    return
-
-  def node_attrs_combo_edit_start(self, cell_renderer, editable, path):
-    """
-    Called when editing is started on an attribute combo cell. Used to delete the
-    select placeholder for mixed entry / combo attributes.
-    """
-
-    iter = self.node_attrs.get_model().get_iter(path)
-    iter_key = self.node_attrs.get_model().get_value(iter, 0)
-
-    if isinstance(self.selected_node.attrs[iter_key][0][0], tuple) and self.selected_node.attrs[iter_key][1] is None:
-      editable.child.set_text("")
-
-    return
-
-  def node_attrs_edited(self, cell_renderer, path, new_text):
-    """
-    Called when editing is finished on an attribute text cell. Updates data in the
-    treestore.
-    """
-
-    iter = self.node_attrs.get_model().get_iter(path)
-    iter_key = self.node_attrs.get_model().get_value(iter, 0)
-
-    if self.selected_node.get_attr(iter_key) is None and new_text == "":
-      return
-
-    value_check = self.validity_check(new_text, self.selected_node.attrs[iter_key][0])
-
-    if not value_check is None and not value_check == self.selected_node.attrs[iter_key][1]:
-      if iter_key == "name" and not self.name_check(value_check):
-        return
-
-      self.node_attrs.get_model().set_value(iter, 1, value_check)
-      self.selected_node.set_attr(iter_key, value_check)
-      self.paint_validity()
-      if iter_key == "name":
-        self.update_painted_name()
-        self.on_select_row()
-      self.set_saved(False)
-
-    return
-
-  def node_attrs_selected(self, cell_renderer, path, new_text):
-    """
-    Called when an attribute combo box element is selected, or combo box entry
-    element entry is edited. Updates data in the treestore.
-    """
-
-    iter = self.node_attrs.get_model().get_iter(path)
-    iter_key = self.node_attrs.get_model().get_value(iter, 0)
-
-    if new_text is None:
-      return
-
-    if isinstance(self.selected_node.attrs[iter_key][0][0], tuple) and not new_text in self.selected_node.attrs[iter_key][0][0]:
-      if self.selected_node.get_attr(iter_key) is None and new_text == "":
-        return
-        
-      new_text = self.validity_check(new_text, self.selected_node.attrs[iter_key][0][1])
-      if iter_key == "name" and not self.name_check(new_text):
-        return False
-    if not new_text == self.selected_node.attrs[iter_key][1]:
-      self.node_attrs.get_model().set_value(iter, 1, new_text)
-      self.selected_node.set_attr(iter_key, new_text)
-      self.paint_validity()
-      if iter_key == "name":
-        self.update_painted_name()
-      self.set_saved(False)
-
-    return
-
-  def set_node_data_empty(self):
-    """
-    Empty the node data frame.
-    """
-
-    if len(self.node_data_frame.get_children()) > 1:
-      if isinstance(self.node_data, gtk.TextView):
-        self.node_data.handler_block_by_func(self.node_data_entry_focus_in)
-      elif isinstance(self.node_data, gtk.ComboBox):
-        self.node_data.handler_block_by_func(self.node_data_combo_focus_child)
-      self.node_data_frame.remove(self.node_data_frame.child)
-
-    self.node_data_interacted = False
-
-    return
-
-  def set_node_data_entry(self):
-    """
-    Create a text view for data entry in the node data frame.
-    """
-
-    self.set_node_data_empty()
-
-    data_scrolled_window = gtk.ScrolledWindow()
-    self.node_data_frame.add(data_scrolled_window)
-    data_scrolled_window.show()
-
-    try:
-      import gtksourceview2
-      buf = gtksourceview2.Buffer()
-      lang_manager = gtksourceview2.LanguageManager()
-      buf.set_highlight_matching_brackets(True)
-      if self.node_data_is_python_code():
-        python = lang_manager.get_language("python")
-        buf.set_language(python)
-        buf.set_highlight_syntax(True)
-      self.node_data = gtksourceview2.View(buffer=buf)
-      self.node_data.set_auto_indent(True)
-      #self.node_data.set_highlight_current_line(True)
-      self.node_data.set_insert_spaces_instead_of_tabs(True)
-      self.node_data.set_tab_width(2)
-      if self.node_data_is_python_code():
-        self.node_data.set_show_line_numbers(True)
-        font_desc = pango.FontDescription("monospace")
-        if font_desc:
-          self.node_data.modify_font(font_desc)
-    except ImportError:
-      self.node_data = gtk.TextView()
-
-    data_scrolled_window.add(self.node_data)
-    self.node_data.show()
-
-    data_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-
-    self.node_data.set_pixels_above_lines(2)
-    self.node_data.set_pixels_below_lines(2)
-    self.node_data.set_wrap_mode(gtk.WRAP_WORD)
-
-    self.node_data.connect("focus-in-event", self.node_data_entry_focus_in)
-
-    data_frame_packing = self.node_data_frame.get_property("parent").query_child_packing(self.node_data_frame)
-    self.node_data_frame.get_property("parent").set_child_packing(self.node_data_frame, True, data_frame_packing[1], data_frame_packing[2], data_frame_packing[3])
-
-    self.node_data.get_buffer().create_tag("node_data_buffer_tag")
-    text_tag = self.node_data.get_buffer().get_tag_table().lookup("node_data_buffer_tag")
-    if self.selected_node is None:
-      self.node_data.set_cursor_visible(False)
-      self.node_data.set_editable(False)
-      self.node_data_buttons_hbox.hide()
-      self.node_data.get_buffer().set_text("")
-      text_tag.set_property("foreground", "grey")
-    elif not self.selected_node.active:
-      self.node_data.set_cursor_visible(False)
-      self.node_data.set_editable(False)
-      self.node_data_buttons_hbox.hide()
-      self.node_data.get_buffer().set_text("Inactive node")
-      text_tag.set_property("foreground", "grey")
-    elif self.selected_node.datatype is None:
-      self.node_data.set_cursor_visible(False)
-      self.node_data.set_editable(False)
-      self.node_data_buttons_hbox.hide()
-      self.node_data.get_buffer().set_text("No data")
-      text_tag.set_property("foreground", "grey")
-    elif self.node_data_is_tensor():
-      self.node_data.set_cursor_visible(False)
-      self.node_data.set_editable(False)
-      self.node_data_buttons_hbox.hide()
-      self.node_data.get_buffer().set_text("Dimension not set")
-      text_tag.set_property("foreground", "grey")
-    elif self.selected_node.data is None:
-      self.node_data.set_cursor_visible(True)
-      self.node_data.set_editable(True)
-      self.node_data_buttons_hbox.show()
-      self.node_data.get_buffer().set_text(self.printable_type(self.selected_node.datatype))
-      text_tag.set_property("foreground", "blue")
-    else:
-      self.node_data.get_buffer().set_text(self.selected_node.data)
-      if self.selected_node.datatype == "fixed":
-        self.node_data.set_cursor_visible(False)
-        self.node_data.set_editable(False)
-        self.node_data_buttons_hbox.hide()
-        text_tag.set_property("foreground", "grey")
-      else:
-        self.node_data.set_cursor_visible(True)
-        self.node_data.set_editable(True)
-        self.node_data_buttons_hbox.show()
-        #text_tag.set_property("foreground", "black")
-    buffer_bounds = self.node_data.get_buffer().get_bounds()
-    self.node_data.get_buffer().apply_tag(text_tag, buffer_bounds[0], buffer_bounds[1])
-
-    return
-
-  def set_node_data_tensor(self):
-    """
-    Create a table container packed with appropriate widgets for tensor data entry
-    in the node data frame.
-    """
-
-    self.set_node_data_empty()
-
-    data_scrolled_window = gtk.ScrolledWindow()
-    self.node_data_frame.add(data_scrolled_window)
-    data_scrolled_window.show()
-
-    data_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-
-    dim1, dim2 = self.node_data_tensor_shape()
-    self.node_data = gtk.Table(dim1, dim2)
-    data_scrolled_window.add_with_viewport(self.node_data)
-    self.node_data.show()
-
-    data_scrolled_window.child.set_property("shadow-type", gtk.SHADOW_NONE)
-
-    data_frame_packing = self.node_data_frame.get_property("parent").query_child_packing(self.node_data_frame)
-    self.node_data_frame.get_property("parent").set_child_packing(self.node_data_frame, True, data_frame_packing[1], data_frame_packing[2], data_frame_packing[3])
-
-    self.node_data_buttons_hbox.show()
-
-    is_symmetric = self.node_data_is_symmetric_tensor()
-    for i in range(dim1):
-      for j in range(dim2):
-        entry = gtk.Entry()
-        self.node_data.attach(entry, dim2 - j - 1, dim2 - j, dim1 - i - 1, dim1 - i)
-        if not is_symmetric or i >= j:
-          entry.show()
-
-          entry.connect("focus-in-event", self.node_data_tensor_element_focus_in, dim2 - j - 1, dim1 - i - 1)
-
-          if self.selected_node.data is None:
-            entry.set_text(self.printable_type(self.selected_node.datatype.datatype))
-            entry.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
-          else:
-            entry.set_text(self.selected_node.data.split(" ")[(dim2 - j - 1) + (dim1 - i - 1) * dim2])
-
-    self.node_data_interacted = [False for i in range(dim1 * dim2)]
-
-    return
-
-  def set_node_data_combo(self):
-    """
-    Create a combo box for node data selection in the node data frame. Add an
-    entry if required.
-    """
-
-    self.set_node_data_empty()
-
-    if isinstance(self.selected_node.datatype[0], tuple):
-      self.node_data = gtk.combo_box_entry_new_text()
-    else:
-      self.node_data = gtk.combo_box_new_text()
-    self.node_data_frame.add(self.node_data)
-    self.node_data.show()
-
-    self.node_data.connect("set-focus-child", self.node_data_combo_focus_child)
-    self.node_data.connect("scroll-event", self.node_data_combo_scroll)
-
-    data_frame_packing = self.node_data_frame.get_property("parent").query_child_packing(self.node_data_frame)
-    self.node_data_frame.get_property("parent").set_child_packing(self.node_data_frame, False, data_frame_packing[1], data_frame_packing[2], data_frame_packing[3])
-
-    if isinstance(self.selected_node.datatype[0], tuple):
-      self.node_data_buttons_hbox.show()
-    else:
-      self.node_data_buttons_hbox.hide()
-
-    if self.selected_node.data is None:
-      if isinstance(self.selected_node.datatype[0], tuple):
-        self.node_data.child.set_text("Select " + self.printable_type(self.selected_node.datatype[1]) + "...")
-      else:
-        self.node_data.append_text("Select...")
-        self.node_data.set_active(0)
-      self.node_data.child.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
-      self.node_data.child.modify_text(gtk.STATE_PRELIGHT, gtk.gdk.color_parse("blue"))
-
-    if isinstance(self.selected_node.datatype[0], tuple):
-      options = self.selected_node.datatype[0]
-    else:
-      options = self.selected_node.datatype
-    for i in range(len(options)):
-      opt = options[i]
-      self.node_data.append_text(opt)
-      if self.selected_node.data == opt:
-        self.node_data.set_active(i)
-
-    if isinstance(self.selected_node.datatype[0], tuple) and not self.selected_node.data is None and not self.selected_node.data in self.selected_node.datatype[0]:
-      self.node_data.child.set_text(self.selected_node.data)
-
-    self.node_data.connect("changed", self.node_data_combo_changed)
-
-    return
-
-  def node_data_entry_focus_in(self, widget, event):
-    """
-    Called when a text view data entry widget gains focus. Used to delete the
-    printable_type placeholder.
-    """
-
-    if not self.selected_node is None and not self.selected_node.datatype is None and not self.node_data_is_tensor() and self.selected_node.data is None and not self.node_data_interacted:
-      self.node_data.get_buffer().set_text("")
-
-    self.node_data_interacted = True
-
-    return
-
-  def node_data_tensor_element_focus_in(self, widget, event, row, col):
-    """
-    Called when a tensor data entry widget gains focus. Used to delete the
-    printable_type placeholder.
-    """
-
-    dim1, dim2 = self.node_data_tensor_shape()
-    if not self.node_data_interacted[col + row * dim2]:
-      self.node_data_interacted[col + row * dim2] = True
-      if self.node_data_is_symmetric_tensor():
-        self.node_data_interacted[row + col * dim1] = True
-      if self.selected_node.data is None:
-        widget.set_text("")
-        widget.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
-
-    return
-
-  def node_data_combo_focus_child(self, container, widget):
-    """
-    Called when a data selection widget gains focus. Used to delete the select
-    placeholder.
-    """
-
-    if not self.node_data_interacted:
-      self.node_data_interacted = True
-      if self.selected_node.data is None:
-        self.node_data_interacted = True
-        if isinstance(self.selected_node.datatype[0], tuple):
-          self.node_data.handler_block_by_func(self.node_data_combo_changed)
-          self.node_data.child.set_text("")
-          self.node_data.handler_unblock_by_func(self.node_data_combo_changed)
-        else:
-          self.node_data.set_active(1)
-          self.node_data.remove_text(0)
-        self.node_data.child.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
-        self.node_data.child.modify_text(gtk.STATE_PRELIGHT, gtk.gdk.color_parse("black"))
-
-    return
-
-  def node_data_combo_changed(self, combo_box):
-    """
-    Called when a data combo box element is selected. Updates data in the
-    treestore.
-    """
-
-    if not isinstance(self.selected_node.datatype[0], tuple) or not self.node_data.child.get_property("has-focus"):
-      self.selected_node.set_data(self.node_data.get_active_text())
-      self.paint_validity()
-      self.set_saved(False)
-      self.node_data_interacted = False
-      iter = self.get_treeview_iter(self.treeview.get_selection())
-      self.treestore.set_value(iter, 4, self.node_data.get_active_text())
-
-    return
-
-  def node_data_combo_scroll(self, widget, event):
-    """
-    Called when the data combo box is scrolled with the mouse wheel. Removes the
-    select placeholder and updates data in the treestore.
-    """
-
-    self.node_data_combo_focus_child(self.node_data_frame, self.node_data)
-    if not isinstance(self.selected_node.datatype[0], tuple) or not self.selected_node.data is None:
-      self.node_data_combo_changed(self.node_data)
-
-    return
-
-  def node_data_revert(self, button = None):
-    """
-    "Revert Data" button click signal handler. Reverts data in the node data frame.
-    """
-
-    if self.node_data_is_tensor() and not self.geometry_dim_tree.data is None:
-      self.set_node_data_tensor()
-    elif not self.selected_node is None and isinstance(self.selected_node.datatype, tuple):
-      self.set_node_data_combo()
-    else:
-      self.set_node_data_entry()
-
-    return
-
-  def node_data_store(self, button = None):
-    """
-    "Store Data" button click signal handler. Stores data from the node data frame
-    in the treestore.
-    """
-
-    if self.node_data_is_tensor() and not self.geometry_dim_tree.data is None:
-      store_success = self.node_data_tensor_store()
-    elif not self.selected_node is None and isinstance(self.selected_node.datatype, tuple):
-      store_success = self.node_data_combo_store()
-    else:
-      store_success = self.node_data_entry_store()
-
-    if self.scherror.errlist_is_open():
-      if self.scherror.errlist_type == 0:
-         self.scherror.on_validate_schematron()
-      else:
-         self.scherror.on_validate()
-
-    return store_success
-
-  def node_data_entry_store(self):
-    """
-    Attempt to store data read from a textview packed in the node data frame.
-    """
-
-    if self.selected_node is None or self.selected_node.datatype in ["fixed", None] or self.node_data_is_tensor():
-      return True
-
-    data_buffer_bounds = self.node_data.get_buffer().get_bounds()
-    new_data = self.node_data.get_buffer().get_text(data_buffer_bounds[0], data_buffer_bounds[1])
-
-    if new_data == "":
-      return True
-
-    if self.selected_node.data is None and not self.node_data_interacted:
-      return True
-    else:
-      value_check = self.validity_check(new_data, self.selected_node.datatype)
-      if value_check is None:
-        return False
-      elif not value_check == self.selected_node.data:
-        self.selected_node.set_data(value_check)
-        if isinstance(self.selected_node, MixedTree) and "shape" in self.selected_node.child.attrs.keys() and self.selected_node.child.attrs["shape"][0] is int and isinstance(self.selected_node.datatype, plist.List) and self.selected_node.datatype.cardinality == "+":
-          self.selected_node.child.set_attr("shape", str(len(value_check.split(" "))))
-        self.paint_validity()
-        
-        iter = self.selected_iter
-        self.treestore.set_value(iter, 4, new_data)
-        self.set_saved(False)
-        self.node_data_interacted = False
-
-    return True
-
-  def node_data_combo_store(self):
-    """
-    Attempt to store data read from a combo box entry packed in the node data
-    frame.
-    """
-
-    if not isinstance(self.selected_node.datatype[0], tuple):
-      return True
-
-    new_data = self.node_data.child.get_text()
-
-    if self.selected_node.data is None and not self.node_data_interacted:
-      return True
-    elif not new_data in self.selected_node.datatype[0]:
-      new_data = self.validity_check(new_data, self.selected_node.datatype[1])
-      if new_data is None:
-        return False
-
-    if not new_data == self.selected_node.data:
-      self.selected_node.set_data(new_data)
-      self.paint_validity()
-      self.set_saved(False)
-      self.node_data_interacted = False
-
-    return True
-
-  def node_data_tensor_store(self):
-    """
-    Attempt to store data read from tensor data entry widgets packed in the node
-    data frame.
-    """
-
-    dim1, dim2 = self.node_data_tensor_shape()
-    is_symmetric = self.node_data_is_symmetric_tensor()
-
-    if not True in self.node_data_interacted:
-      return True
-
-    entry_values = []
-    for i in range(dim1):
-      for j in range(dim2):
-        if is_symmetric and i > j:
-          entry_values.append(self.node_data.get_children()[i + j * dim1].get_text())
-        else:
-          entry_values.append(self.node_data.get_children()[j + i * dim2].get_text())
-
-    changed = False
-    for i in range(dim1):
-      for j in range(dim2):
-        if self.node_data_interacted[j + i * dim2] and not entry_values[j + i * dim2] == "" and (self.selected_node.data is None or not self.selected_node.data.split(" ")[j + i * dim2] == entry_values[j + i * dim2]):
-          changed = True
-    if not changed:
-      return True
-    elif (self.selected_node.data is None and False in self.node_data_interacted) or "" in entry_values:
-      dialogs.error(self.main_window, "Invalid value entered")
-      return False
-
-    new_data = ""
-    for i in range(dim1):
-      for j in range(dim2):
-        new_data += " " + entry_values[j + i * dim2]
-
-    value_check = self.validity_check(new_data, self.selected_node.datatype)
-    if value_check is None:
-      return False
-    elif not value_check == self.selected_node.data:
-      self.selected_node.set_data(value_check)
-
-      dim1, dim2 = self.node_data_tensor_shape()
-      if int(self.selected_node.child.attrs["rank"][1]) == 1:
-        self.selected_node.child.set_attr("shape", str(dim1))
-      else:
-        self.selected_node.child.set_attr("shape", str(dim1) + " " + str(dim2))
-
-      self.paint_validity()
-      self.set_saved(False)
-      self.node_data_interacted = [False for i in range(dim1 * dim2)]
-
-    return True
-
-  def update_node_comment(self):
-    """
-    Update the comment widget.
-    """
-
-    if self.selected_node is None or not self.selected_node.active:
-      self.node_comment.get_buffer().set_text("")
-      self.node_comment.set_cursor_visible(False)
-      self.node_comment.set_editable(False)
-      try:
-        self.node_comment.set_tooltip_text("")
-        self.node_comment.set_property("has-tooltip", False)
-      except:
-        pass
-
-      return
-
-    comment_tree = self.get_comment(self.selected_node)
-    text_tag = self.node_comment.get_buffer().get_tag_table().lookup("comment_buffer_tag")
-    if comment_tree is None:
-      self.node_comment.get_buffer().set_text("No comment")
-      self.node_comment.set_cursor_visible(False)
-      self.node_comment.set_editable(False)
-      text_tag.set_property("foreground", "grey")
-      try:
-        self.node_comment.set_tooltip_text("")
-        self.node_comment.set_property("has-tooltip", False)
-      except:
-        pass
-    else:
-      if comment_tree.data is None:
-        self.node_comment.get_buffer().set_text("(string)")
-      else:
-        self.node_comment.get_buffer().set_text(comment_tree.data)
-      if self.selected_node.active:
-        self.node_comment.set_cursor_visible(True)
-        self.node_comment.set_editable(True)
-        text_tag.set_property("foreground", "black")
-      else:
-        self.node_comment.set_cursor_visible(False)
-        self.node_comment.set_editable(False)
-        text_tag.set_property("foreground", "grey")
-
-    buffer_bounds = self.node_comment.get_buffer().get_bounds()
-    self.node_comment.get_buffer().apply_tag(text_tag, buffer_bounds[0], buffer_bounds[1])
-
-    self.node_comment_interacted = False
-
-    return
-
-  def node_comment_focus_in(self, widget, event):
-    """
-    Called when the comment widget gains focus. Removes the printable_type
-    placeholder.
-    """
-
-    comment_tree = self.get_comment(self.selected_node)
-    if not comment_tree is None and not self.node_comment_interacted:
-      self.node_comment_interacted = True
-      if comment_tree.data is None:
-        self.node_comment.get_buffer().set_text("")
-
-    return
-
-  def node_comment_expose(self, widget, event):
-    """
-    Called when the comment widget is repainted. Stores the comment if required.
-    """
-
-    self.node_comment_store()
-
-    return
-
-  def node_comment_store(self):
-    """
-    Store data in the node comment.
-    """
-
-    comment_tree = self.get_comment(self.selected_node)
-    if comment_tree is None or not self.node_comment_interacted:
-      return
-
-    data_buffer_bounds = self.node_comment.get_buffer().get_bounds()
-    new_comment = self.node_comment.get_buffer().get_text(data_buffer_bounds[0], data_buffer_bounds[1])
-
-    if not new_comment == comment_tree.data:
-      if new_comment == "":
-        comment_tree.data = None
-        comment_tree.active = False
-      else:
-        comment_tree.set_data(new_comment)
-        comment_tree.active = True
-        self.set_saved(False)
-
-    return
-
-  def validity_check(self, val, val_type):
-    """
-    Check to see if the supplied data with supplied type can be stored in a
-    tree.Tree.
-    """
-
-    (invalid, data) = self.selected_node.valid_data(val_type, val)
-    if not invalid and isinstance(data, str) and not data == "":
-      if not data == val and self.validity_check(data, val_type) is None:
-        return None
-      else:
-        return data
-    else:
-      dialogs.error(self.main_window, "Invalid value entered")
-      return None
-
-  def name_check(self, val):
-    """
-    Check to see if the supplied data is a valid tree name.
-    """
-
-    valid_chars = "_:[]1234567890qwertyuioplkjhgfdsazxcvbnmMNBVCXZASDFGHJKLPOIUYTREWQ"
-    for char in val:
-      if not char in valid_chars:
-        dialogs.error(self.main_window, "Invalid value entered")
-        return False
-
-    return True
-
-  def node_data_is_python_code(self):
-    """
-    Perform a series of tests on the current tree.Tree / MixedTree, to determine if
-    it is intended to be used to store python code data.
-    """
-
-    try:
-       lang = self.selected_node.get_attr("language")
-       if lang == "python":
-         return True
-    except:
-      pass
-    
-    if not isinstance(self.selected_node, MixedTree):
-      return False
-      
-    if self.selected_node.datatype is not str:
-      return False
-  
-    if "type" in self.selected_node.child.attrs.keys():
-      return self.selected_node.child.attrs["type"][1] == "python"
-    else:
-      return False
-
-  def node_data_is_tensor(self):
-    """
-    Perform a series of tests on the current tree.Tree / MixedTree, to determine if
-    it is intended to be used to store tensor or vector data.
-    """
-
-    # Check that a geometry is defined
-    if self.geometry_dim_tree is None:
-      return False
-
-    # Check that this element has calculable and positive dimensions
-    if isinstance(self.geometry_dim_tree.datatype, tuple):
-      possible_dims = self.geometry_dim_tree.datatype
-    else:
-      possible_dims = [self.geometry_dim_tree.data]
-    for opt in possible_dims:
-      try:
-        dim1, dim2 = self.node_data_tensor_shape(int(opt))
-        assert dim1 > 0
-        assert dim2 > 0
-      except:
-        return False
-
-    # All tensor elements must be of MixedTree type
-    if not isinstance(self.selected_node, MixedTree):
-      return False
-
-    # The element must have dim1, rank and shape attributes
-    if not "dim1" in self.selected_node.child.attrs.keys() or not "rank" in self.selected_node.child.attrs.keys() or not "shape" in self.selected_node.child.attrs.keys():
-      return False
-    # The dim1 and rank attributes must be of fixed type
-    if not self.selected_node.child.attrs["dim1"][0] == "fixed" or not self.selected_node.child.attrs["rank"][0] == "fixed":
-      return False
-
-    if "dim2" in self.selected_node.child.attrs.keys():
-      # If a dim2 attribute is specified, it must be of fixed type and the rank must be 2
-      # Also, the shape attribute must be a list of integers with cardinality equal to the rank
-      if not self.selected_node.child.attrs["dim2"][0] == "fixed" or not self.selected_node.child.attrs["rank"][1] == "2" or not isinstance(self.selected_node.child.attrs["shape"][0], plist.List) or not self.selected_node.child.attrs["shape"][0].datatype is int or not str(self.selected_node.child.attrs["shape"][0].cardinality) == self.selected_node.child.attrs["rank"][1]:
-        return False
-    # Otherwise, the rank must be one and the shape an integer
-    elif not self.selected_node.child.attrs["rank"][1] == "1" or not self.selected_node.child.attrs["shape"][0] is int: 
-      return False
-
-    # The data for the element must be a list of one or more
-    if not isinstance(self.selected_node.datatype, plist.List) or not self.selected_node.datatype.cardinality == "+":
-      return False
-
-    # If the shape has been set, check that it has a valid value
-    if not self.selected_node.child.attrs["shape"][1] == None:
-      if self.geometry_dim_tree.data is None:
-        return False
-
-      dim1, dim2 = self.node_data_tensor_shape()
-      if "dim2" in self.selected_node.child.attrs.keys():
-        if not self.selected_node.child.attrs["shape"][1] == str(dim1) + " " + str(dim2):
-          return False
-      elif not self.selected_node.child.attrs["shape"][1] == str(dim1):
-        return False
-
-    return True
-
-  def node_data_tensor_shape(self, geometry_dim = None):
-    """
-    Read the tensor shape for tensor or vector data in the current MixedTree.
-    """
-
-    if geometry_dim == None:
-      geometry_dim = int(self.geometry_dim_tree.data)
-
-    dim1 = 1
-    dim2 = 1
-    if "dim1" in self.selected_node.child.attrs.keys():
-      dim1 = int(eval(self.selected_node.child.attrs["dim1"][1], {"dim":geometry_dim}))
-      if "dim2" in self.selected_node.child.attrs.keys():
-        dim2 = int(eval(self.selected_node.child.attrs["dim2"][1], {"dim":geometry_dim}))
-
-    return (dim1, dim2)
-
-  def node_data_is_symmetric_tensor(self):
-    """
-    Read if the tensor data in the current MixedTree is symmetric.
-    """
-
-    dim1, dim2 = self.node_data_tensor_shape()
-    if not dim1 == dim2:
-      return False
-
-    if "symmetric" in self.selected_node.child.attrs.keys() and self.selected_node.child.attrs["symmetric"][1] == "true":
-      return True
-    else:
-      return False
-
-class MixedTree:
-  def __init__(self, parent, child):
-    """
-    The .doc and .attrs comes from parent, and the .data comes from child. This
-    is used to hide integer_value etc. from the left hand side, but for its data
-    entry to show up on the right.
-    """
-
-    self.parent = parent
-    self.child = child
-
-    self.name = parent.name
-    self.schemaname = parent.schemaname
-    self.attrs = self.parent.attrs
-    self.children = parent.children
-    self.datatype = child.datatype
-    self.data = child.data
-    self.doc = parent.doc
-    self.active = parent.active
-
-    return
-
-  def set_attr(self, attr, val):
-    self.parent.set_attr(attr, val)
-
-    return
-
-  def get_attr(self, attr):
-    return self.parent.get_attr(attr)
-
-  def set_data(self, data):
-    self.child.set_data(data)
-    self.datatype = self.child.datatype
-    self.data = self.child.data
-
-    return
-
-  def valid_data(self, datatype, data):
-    return self.parent.valid_data(datatype, data)
-
-  def matches(self, text, case_sensitive = False):
-    old_parent_data = self.parent.data
-    self.parent.data = None
-    parent_matches = self.parent.matches(text, case_sensitive)
-    self.parent.data = old_parent_data
-
-    if parent_matches:
-      return True
-
-    if case_sensitive:
-      text_re = re.compile(text)
-    else:
-      text_re = re.compile(text, re.IGNORECASE)
-
-    if not self.child.data is None and not text_re.search(self.child.data) is None:
-      return True
-    else:
-      return False
-
 class DiamondFindDialog:
   def __init__(self, parent, gladefile):
     self.parent = parent

=== added file 'diamond/diamond/mixedtree.py'
--- diamond/diamond/mixedtree.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/mixedtree.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import plist
+
+class MixedTree:
+  def __init__(self, parent, child):
+    """
+    The .doc and .attrs comes from parent, and the .data comes from child. This
+    is used to hide integer_value etc. from the left hand side, but for its data
+    entry to show up on the right.
+    """
+
+    self.parent = parent
+    self.child = child
+
+    self.name = parent.name
+    self.schemaname = parent.schemaname
+    self.attrs = self.parent.attrs
+    self.children = parent.children
+    self.datatype = child.datatype
+    self.data = child.data
+    self.doc = parent.doc
+    self.active = parent.active
+
+    return
+
+  def set_attr(self, attr, val):
+    self.parent.set_attr(attr, val)
+
+    return
+
+  def get_attr(self, attr):
+    return self.parent.get_attr(attr)
+
+  def set_data(self, data):
+    self.child.set_data(data)
+    self.datatype = self.child.datatype
+    self.data = self.child.data
+
+    return
+
+  def valid_data(self, datatype, data):
+    return self.parent.valid_data(datatype, data)
+
+  def validity_check(self, datatype, data):
+    return self.parent.validity_check(datatype, data)
+
+  def matches(self, text, case_sensitive = False):
+    old_parent_data = self.parent.data
+    self.parent.data = None
+    parent_matches = self.parent.matches(text, case_sensitive)
+    self.parent.data = old_parent_data
+
+    if parent_matches:
+      return True
+
+    if case_sensitive:
+      text_re = re.compile(text)
+    else:
+      text_re = re.compile(text, re.IGNORECASE)
+
+    if not self.child.data is None and not text_re.search(self.child.data) is None:
+      return True
+    else:
+      return False
+
+  def is_comment(self):
+    return self.parent.is_comment()
+
+  def get_comment(self):
+    return self.parent.get_comment()
+
+  def is_tensor(self, geometry_dim_tree):
+    """
+    Perform a series of tests on the current MixedTree, to determine if
+    it is intended to be used to store tensor or vector data.
+    """
+
+    # Check that a geometry is defined
+    if geometry_dim_tree is None:
+      return False
+
+    # Check that this element has calculable and positive dimensions
+    if isinstance(geometry_dim_tree.datatype, tuple):
+      possible_dims = geometry_dim_tree.datatype
+    else:
+      possible_dims = [geometry_dim_tree.data]
+    for opt in possible_dims:
+      try:
+        dim1, dim2 = self.tensor_shape(int(opt))
+        assert dim1 > 0
+        assert dim2 > 0
+      except:
+        return False
+
+    # The element must have dim1, rank and shape attributes
+    if "dim1" not in self.child.attrs.keys() \
+       or "rank" not in self.child.attrs.keys() \
+       or "shape" not in self.child.attrs.keys():
+      return False
+
+    # The dim1 and rank attributes must be of fixed type
+    if self.child.attrs["dim1"][0] != "fixed" or self.child.attrs["rank"][0] != "fixed":
+      return False
+
+    if "dim2" in self.child.attrs.keys():
+      # If a dim2 attribute is specified, it must be of fixed type and the rank must be 2
+      # Also, the shape attribute must be a list of integers with cardinality equal to the rank
+      if self.child.attrs["dim2"][0] != "fixed" \
+         or self.child.attrs["rank"][1] != "2" \
+         or not isinstance(self.child.attrs["shape"][0], plist.List) \
+         or self.child.attrs["shape"][0].datatype is not int \
+         or str(self.child.attrs["shape"][0].cardinality) != self.child.attrs["rank"][1]:
+        return False
+
+    # Otherwise, the rank must be one and the shape an integer
+    elif self.child.attrs["rank"][1] != "1" or self.child.attrs["shape"][0] is not int:
+      return False
+
+    # The data for the element must be a list of one or more
+    if not isinstance(self.datatype, plist.List) or self.datatype.cardinality != "+":
+      return False
+
+    # If the shape has been set, check that it has a valid value
+    if self.child.attrs["shape"][1] != None:
+      if geometry_dim_tree.data is None:
+        return False
+
+      dim1, dim2 = self.tensor_shape()
+      if "dim2" in self.child.attrs.keys():
+        if self.child.attrs["shape"][1] != str(dim1) + " " + str(dim2):
+          return False
+      elif self.child.attrs["shape"][1] != str(dim1):
+        return False
+
+    return True
+
+  def tensor_shape(self, dimension):
+    """
+    Read the tensor shape for tensor or vector data in the current MixedTree.
+    """
+
+    if not isinstance(dimension, int):
+      dimension = int(dimension.data)
+
+    dim1 = 1
+    dim2 = 1
+    if "dim1" in self.child.attrs.keys():
+      dim1 = int(eval(self.child.attrs["dim1"][1], {"dim":dimension}))
+      if "dim2" in self.child.attrs.keys():
+        dim2 = int(eval(self.child.attrs["dim2"][1], {"dim":dimension}))
+
+    return (dim1, dim2)
+
+  def is_symmetric_tensor(self, geometry):
+    """
+    Read if the tensor data in the current MixedTree is symmetric.
+    """
+
+    dim1, dim2 = self.tensor_shape(geometry)
+
+    return dim1 == dim2 and "symmetric" in self.child.attrs.keys() and self.child.attrs["symmetric"][1] == "true"
+
+  def is_python_code(self):
+    """
+    Perform a series of tests on the current MixedTree, to determine if
+    it is intended to be used to store python code data.
+    """
+
+    try:
+       lang = self.get_attr("language")
+       if lang == "python":
+         return True
+    except:
+      pass
+
+    if self.datatype is not str:
+      return False
+
+    if "type" in self.child.attrs.keys():
+      return self.child.attrs["type"][1] == "python"
+    
+    return False
+
+  def get_name_path(self, leaf = True):
+    return self.parent.get_name_path(leaf)
+
+  def is_sliceable(self):
+    return True

=== modified file 'diamond/diamond/schema.py'
--- diamond/diamond/schema.py	2011-07-08 17:15:57 +0000
+++ diamond/diamond/schema.py	2011-07-25 13:56:22 +0000
@@ -160,7 +160,7 @@
       node = xpath[0]
 
     node = self.to_tree(node)
-    
+  
     if eidtree is not None:
       if eidtree.parent is not None:
         eidtree.parent.children.append(node)

=== added file 'diamond/diamond/sliceview.py'
--- diamond/diamond/sliceview.py	1970-01-01 00:00:00 +0000
+++ diamond/diamond/sliceview.py	2011-07-25 13:56:22 +0000
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+
+#    This file is part of Diamond.
+#
+#    Diamond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Diamond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Diamond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gobject
+import gtk
+
+import attributewidget
+import databuttonswidget
+import datawidget
+import mixedtree
+
+class SliceView(gtk.Window):
+  
+  __gsignals__ = { "on-store" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
+                   "update-name"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())}
+
+  def __init__(self, parent):
+    gtk.Window.__init__(self)
+    
+    self.set_default_size(800, 600)
+    self.set_title("Slice View")
+    self.set_modal(True)
+    self.set_transient_for(parent)
+
+    mainvbox = gtk.VBox()
+    self.vbox = gtk.VBox()
+
+    scrolledWindow = gtk.ScrolledWindow()
+    scrolledWindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+    scrolledWindow.add_with_viewport(self.vbox)
+
+    self.databuttons = databuttonswidget.DataButtonsWidget()
+
+    self.statusbar = gtk.Statusbar()
+
+    mainvbox.pack_start(scrolledWindow, True)
+    mainvbox.pack_start(self.databuttons, False)
+    mainvbox.pack_start(self.statusbar, False)
+
+    self.add(mainvbox)
+    self.show_all()
+
+  def update(self, node, tree):
+    nodes = self.get_nodes(node, tree)
+    if not nodes:
+      self.destroy()
+
+    for n in nodes:
+      self.vbox.pack_start(self.control(n))
+
+    maxwidth = 0
+    for child in self.vbox.get_children():
+      width, height = child.label.get_size_request()
+      maxwidth = max(maxwidth, width)
+    
+    for child in self.vbox.get_children():
+      child.label.set_size_request(maxwidth, -1)
+
+    self.check_resize()
+
+  def get_nodes(self, node, tree):
+   nodes = []
+
+   for child in tree.get_children():
+     if child.active:
+       if child.name == node.name and child.is_sliceable():
+         nodes.append(child.get_mixed_data())
+       nodes += self.get_nodes(node, child)
+   
+   return nodes
+
+  def control(self, node):
+    hbox = gtk.HBox()
+
+    label = gtk.Label(node.get_name_path())
+    hbox.label = label
+
+    data = datawidget.DataWidget()
+    data.geometry_dim_tree = self.geometry_dim_tree
+    data.connect("on-store", self.on_store)
+    data.set_buttons(self.databuttons)
+    data.update(node)
+
+    attributes = attributewidget.AttributeWidget()
+    attributes.connect("on-store", self.on_store)
+    attributes.connect("update-name", self.update_name)
+    attributes.update(node)
+
+    hbox.pack_start(label)
+    hbox.pack_start(data)
+    hbox.pack_start(attributes)
+    
+    hbox.show_all()
+
+    return hbox
+
+  def on_store(self, widget = None):
+    self.emit("on-store")
+
+  def update_name(self, widget = None):
+    self.emit("update-name") 
+
+gobject.type_register(SliceView)

=== modified file 'diamond/diamond/tree.py'
--- diamond/diamond/tree.py	2011-07-07 12:38:32 +0000
+++ diamond/diamond/tree.py	2011-07-25 13:56:22 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#/usr/bin/env python
 
 #    This file is part of Diamond.
 #
@@ -25,18 +25,26 @@
 from lxml import etree
 import sys
 
+import gobject
+
 import debug
 import choice
+import mixedtree
 
-class Tree:
+class Tree(gobject.GObject):
   """This class maps pretty much 1-to-1 with an xml tree.
      It is used to represent the options in-core."""
 
+  __gsignals__ = { "on-set-data" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (str,)),
+                   "on-set-attr"  : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (str, str))}
+  
   def __init__(self, name="", schemaname="", attrs={}, children=None, cardinality='', datatype=None, doc=None):
+    gobject.GObject.__init__(self)
+
     # name: the element name in the options XML
     # e.g. "fluidity_options"
     self.name = name
-
+    
     # schemaname: the label given to it in the Xvif parsing of the schema
     # this is necessary to walk the tree to see what possible valid
     # children this node could have
@@ -99,6 +107,7 @@
       raise Exception, "invalid data: (%s, %s)" % (datatype, val)
     self.attrs[attr] = (datatype, newdata)
     self.recompute_validity()
+    self.emit("on-set-attr", attr, val)
 
   def get_attr(self, attr):
     """Get an attribute."""
@@ -111,6 +120,7 @@
       raise Exception, "invalid data: (%s, %s)" % (str(self.datatype), data)
     self.data = data
     self.recompute_validity()
+    self.emit("on-set-data", data)
 
   def valid_data(self, datatype, data):
     if datatype is None:
@@ -146,19 +156,31 @@
 
     return (True, data)
 
+  def validity_check(self, datatype, data):
+    """
+    Check to see if the supplied data with supplied type can be stored in a
+    tree.Tree.
+    """
+
+    (invalid, new_data) = self.valid_data(datatype, data)
+    if not invalid and isinstance(new_data, str) and not new_data == "":
+      if new_data != data and self.validity_check(new_data, datatype) is None:
+        return None
+      else:
+        return new_data
+    else:
+      return None
+
   def copy(self):
     new_copy = Tree()
-    for attr in ["attrs", "name", "schemaname", "doc", "cardinality", "datatype", "parent", "active", "valid"]:
+    for attr in ["attrs", "name", "schemaname", "doc", "cardinality", "datatype", "data", "active", "valid"]:
       setattr(new_copy, attr, copy.copy(getattr(self, attr)))
 
-    new_copy.data = self.data
-    new_copy.children = copy.copy([])
+    new_copy.parent = self.parent
+    new_copy.children = []
 
     return new_copy
 
-  def not_editable(self):
-    return not self.active or self.datatype is None or self.datatype == "fixed"
-
   def recompute_validity(self):
 
     new_valid = True
@@ -330,7 +352,7 @@
     for i in range(len(self.children)):
       if isinstance(self.children[i], Tree):
         self.children[i].print_recursively(indent + ">>")
-      elif isinstance(self.children[i], Choice):
+      elif isinstance(self.children[i], choice.Choice):
         ref = self.children[i].get_current_tree()
         ref.print_recursively(indent + ">>")
       if i < len(self.children) - 1:
@@ -387,3 +409,135 @@
 
   def choices(self):
     return [self]
+
+  def is_comment(self):
+    """
+    Test whether the given node is a comment node.
+    """
+
+    if not self.name == "comment":
+      return False
+
+    if not self.attrs == {}:
+      return False
+
+    if not self.children == []:
+      return False
+
+    if not self.datatype is str:
+      return False
+
+    if not self.cardinality == "?":
+      return False
+
+    return True
+
+  def get_comment(self):
+    """
+    Return the first comment found as a child of the supplied node, or None if
+    none found.
+    """
+
+    for child in self.children:
+      if child.is_comment():
+        return child
+
+    return None
+
+  def is_tensor(self, geometry_dim_tree):
+    return False
+
+  def is_python_code(self):
+    """
+    Perform a series of tests on the current Tree, to determine if
+    it is intended to be used to store python code data.
+    """
+
+    try:
+       lang = self.selected_node.get_attr("language")
+       if lang == "python":
+         return True
+    except:
+      pass
+
+    return False
+
+  def get_display_name(self):
+    """
+    This is a fluidity hack, allowing the name displayed in the treeview on the
+    left to be different to the element name. If it has an attribute name="xxx",
+    element_tag (xxx) is displayed.
+    """
+    
+    name = self.get_name()
+
+    if name is None:
+      return self.name
+    else:
+      return self.name + " (" + name + ")"
+
+  def get_name(self):
+    if "name" in self.attrs:
+      name = self.attrs["name"][1]
+      return name
+
+    return None
+
+  def get_children(self):
+    return self.children
+  
+  def get_choices(self):
+    return [self]
+
+  def is_hidden(self):
+    """
+    Tests whether the supplied tree should be hidden in view.
+    """
+    return self.is_comment() or self.name in ["integer_value", "real_value", "string_value", "logical_value"]
+
+  def get_name_path(self, leaf = True):
+    name = self.get_display_name() if leaf else self.get_name()
+
+    if self.parent is None:
+      return name                            
+    else:
+
+      pname = self.parent.get_name_path(False)
+
+      if name is None:
+        return pname
+      elif pname is None:
+        return name
+      else:
+        return pname + "/" + name
+
+  def get_mixed_data(self):
+    integers = [child for child in self.children if child.name == "integer_value"]
+    reals    = [child for child in self.children if child.name == "real_value"]
+    logicals = [child for child in self.children if child.name == "logical_value"]
+    strings  = [child for child in self.children if child.name == "string_value"]
+
+    child = None
+    if len(integers) > 0:
+      child = integers[0]
+    if len(reals) > 0:
+      child = reals[0]
+    if len(logicals) > 0:
+      child = logicals[0]
+    if len(strings) > 0:
+      child = strings[0]
+
+    if child is None:
+      return self
+    else:
+      return mixedtree.MixedTree(self, child)
+
+  def is_sliceable(self):
+    mixed = self.get_mixed_data()
+    if isinstance(mixed, mixedtree.MixedTree):
+      return True
+    
+    return (self.datatype is not None and self.datatype != "fixed") or self.attrs
+   
+gobject.type_register(Tree)
+

=== modified file 'diamond/gui/gui.glade'
--- diamond/gui/gui.glade	2011-07-20 17:19:44 +0000
+++ diamond/gui/gui.glade	2011-07-25 13:56:22 +0000
@@ -290,225 +290,6 @@
                 <property name="label_xalign">0</property>
                 <property name="shadow_type">none</property>
                 <child>
-                  <widget class="GtkAlignment" id="optionsFrameAlignment">
-                    <property name="visible">True</property>
-                    <property name="xalign">0</property>
-                    <property name="yalign">0</property>
-                    <property name="top_padding">6</property>
-                    <property name="left_padding">12</property>
-                    <child>
-                      <widget class="GtkVPaned" id="optionsFrameVPanes1">
-                        <property name="visible">True</property>
-                        <property name="can_focus">True</property>
-                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                        <child>
-                          <widget class="GtkFrame" id="descriptionFrame">
-                            <property name="visible">True</property>
-                            <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                            <property name="label_xalign">0</property>
-                            <property name="shadow_type">none</property>
-                            <child>
-                              <widget class="GtkScrolledWindow" id="descriptionFrameScrolledWindow">
-                                <property name="visible">True</property>
-                                <property name="can_focus">True</property>
-                                <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                <property name="hscrollbar_policy">automatic</property>
-                                <property name="vscrollbar_policy">automatic</property>
-                                <child>
-                                  <widget class="GtkTextView" id="nodeDescription">
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                    <property name="editable">False</property>
-                                    <property name="wrap_mode">word</property>
-                                    <property name="cursor_visible">False</property>
-                                  </widget>
-                                </child>
-                              </widget>
-                            </child>
-                            <child>
-                              <widget class="GtkLabel" id="descriptionFrameLabel">
-                                <property name="visible">True</property>
-                                <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                <property name="label" translatable="yes">&lt;b&gt;Description&lt;/b&gt;</property>
-                                <property name="use_markup">True</property>
-                              </widget>
-                              <packing>
-                                <property name="type">label_item</property>
-                              </packing>
-                            </child>
-                          </widget>
-                          <packing>
-                            <property name="resize">True</property>
-                            <property name="shrink">False</property>
-                          </packing>
-                        </child>
-                        <child>
-                          <widget class="GtkVPaned" id="optionsFrameVPanes2">
-                            <property name="visible">True</property>
-                            <property name="can_focus">True</property>
-                            <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                            <child>
-                              <widget class="GtkVBox" id="attributeDataVBox">
-                                <property name="visible">True</property>
-                                <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                <child>
-                                  <widget class="GtkFrame" id="attributeFrame">
-                                    <property name="visible">True</property>
-                                    <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                    <property name="label_xalign">0</property>
-                                    <property name="shadow_type">none</property>
-                                    <child>
-                                      <widget class="GtkScrolledWindow" id="attributeFrameScrolledWindow">
-                                        <property name="visible">True</property>
-                                        <property name="can_focus">True</property>
-                                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                        <property name="hscrollbar_policy">automatic</property>
-                                        <property name="vscrollbar_policy">automatic</property>
-                                        <child>
-                                          <widget class="GtkTreeView" id="nodeAttributes">
-                                            <property name="visible">True</property>
-                                            <property name="can_focus">True</property>
-                                            <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                          </widget>
-                                        </child>
-                                      </widget>
-                                    </child>
-                                    <child>
-                                      <widget class="GtkLabel" id="attributeFrameLabel">
-                                        <property name="visible">True</property>
-                                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                        <property name="label" translatable="yes">&lt;b&gt;Attributes&lt;/b&gt;</property>
-                                        <property name="use_markup">True</property>
-                                      </widget>
-                                      <packing>
-                                        <property name="type">label_item</property>
-                                      </packing>
-                                    </child>
-                                  </widget>
-                                  <packing>
-                                    <property name="expand">False</property>
-                                    <property name="fill">False</property>
-                                    <property name="padding">2</property>
-                                    <property name="position">0</property>
-                                  </packing>
-                                </child>
-                                <child>
-                                  <widget class="GtkFrame" id="dataFrame">
-                                    <property name="visible">True</property>
-                                    <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                    <property name="label_xalign">0</property>
-                                    <property name="shadow_type">none</property>
-                                    <child>
-                                      <widget class="GtkLabel" id="dataFrameLabel">
-                                        <property name="visible">True</property>
-                                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                        <property name="label" translatable="yes">&lt;b&gt;Data&lt;/b&gt;</property>
-                                        <property name="use_markup">True</property>
-                                      </widget>
-                                      <packing>
-                                        <property name="type">label_item</property>
-                                      </packing>
-                                    </child>
-                                  </widget>
-                                  <packing>
-                                    <property name="padding">2</property>
-                                    <property name="position">1</property>
-                                  </packing>
-                                </child>
-                                <child>
-                                  <widget class="GtkHBox" id="dataButtonsHBox">
-                                    <property name="visible">True</property>
-                                    <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                    <child>
-                                      <widget class="GtkButton" id="dataRevertButton">
-                                        <property name="label" translatable="yes">Revert Data</property>
-                                        <property name="visible">True</property>
-                                        <property name="can_focus">True</property>
-                                        <property name="receives_default">True</property>
-                                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                      </widget>
-                                      <packing>
-                                        <property name="position">0</property>
-                                      </packing>
-                                    </child>
-                                    <child>
-                                      <widget class="GtkButton" id="dataStoreButton">
-                                        <property name="label" translatable="yes">Store Data</property>
-                                        <property name="visible">True</property>
-                                        <property name="can_focus">True</property>
-                                        <property name="receives_default">True</property>
-                                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                      </widget>
-                                      <packing>
-                                        <property name="position">1</property>
-                                      </packing>
-                                    </child>
-                                  </widget>
-                                  <packing>
-                                    <property name="expand">False</property>
-                                    <property name="position">2</property>
-                                  </packing>
-                                </child>
-                              </widget>
-                              <packing>
-                                <property name="resize">True</property>
-                                <property name="shrink">False</property>
-                              </packing>
-                            </child>
-                            <child>
-                              <widget class="GtkFrame" id="commentFrame">
-                                <property name="visible">True</property>
-                                <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                <property name="label_xalign">0</property>
-                                <property name="shadow_type">none</property>
-                                <child>
-                                  <widget class="GtkScrolledWindow" id="commentFrameScrolledWindow">
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                    <property name="hscrollbar_policy">automatic</property>
-                                    <property name="vscrollbar_policy">automatic</property>
-                                    <child>
-                                      <widget class="GtkTextView" id="nodeComment">
-                                        <property name="visible">True</property>
-                                        <property name="can_focus">True</property>
-                                        <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                        <property name="editable">False</property>
-                                        <property name="wrap_mode">word</property>
-                                        <property name="cursor_visible">False</property>
-                                      </widget>
-                                    </child>
-                                  </widget>
-                                </child>
-                                <child>
-                                  <widget class="GtkLabel" id="commentFrameLabel">
-                                    <property name="visible">True</property>
-                                    <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
-                                    <property name="label" translatable="yes">&lt;b&gt;Comment&lt;/b&gt;</property>
-                                    <property name="use_markup">True</property>
-                                  </widget>
-                                  <packing>
-                                    <property name="type">label_item</property>
-                                  </packing>
-                                </child>
-                              </widget>
-                              <packing>
-                                <property name="resize">False</property>
-                                <property name="shrink">False</property>
-                              </packing>
-                            </child>
-                          </widget>
-                          <packing>
-                            <property name="resize">True</property>
-                            <property name="shrink">False</property>
-                          </packing>
-                        </child>
-                      </widget>
-                    </child>
-                  </widget>
-                </child>
-                <child>
                   <widget class="GtkLabel" id="optionsFrameLabel">
                     <property name="visible">True</property>
                     <property name="label" translatable="yes">&lt;b&gt;Option Properties&lt;/b&gt;</property>
@@ -706,7 +487,6 @@
   </widget>
   <widget class="GtkMenu" id="popupmenu">
     <property name="visible">True</property>
-    <property name="ubuntu_local">True</property>
     <child>
       <widget class="GtkMenuItem" id="menuitemCopy">
         <property name="visible">True</property>
@@ -723,5 +503,13 @@
         <signal name="activate" handler="on_paste"/>
       </widget>
     </child>
+    <child>
+      <widget class="GtkMenuItem" id="menuitemSlice">
+        <property name="visible">True</property>
+        <property name="label" translatable="yes">Slice</property>
+        <property name="use_underline">True</property>
+        <signal name="activate" handler="on_slice"/>
+      </widget>
+    </child>
   </widget>
 </glade-interface>