root/gaphor/tags/gaphor-0.11.2/utils/gbrowseUML.py

#!/usr/bin/env python
'''This application shows a nice tree view of the UML meta model.

Somehow, this peace of code seems to crash by X server. I thinnk it's a bug in
GTK+. ... but how do I isolate the bug?
'''

import sys
sys.path.append("..")

from gaphor.UML import *
import gtk
import gobject
import types


# to create a new GtkTreeModel from python, you must derive from
# GenericTreeModel.
class TreeModel(gtk.GenericTreeModel):
    ''' The node is defined by a "name" tuple. '''

    def __init__(self, klass):
        '''constructor for the model.  Make sure you call
        PyTreeModel.__init__'''
        self.iter = None # Value used to keep track of iterations.
        self.klass = klass;
        
        gtk.GenericTreeModel.__init__(self)

    def class_from_node(self, node):
        klass = self.klass
        for n in node:
            attrdef = klass._attrdef[n]
            klass = attrdef[1]
        return klass

    # the implementations for TreeModel methods are prefixed with on_
    def on_get_flags(self):
        '''returns the GtkTreeModelFlags for this particular type of model'''
        return 0

    def on_get_n_columns(self):
        '''returns the number of columns in the model'''
        return 1

    def on_get_column_type(self, index):
        '''returns the type of a column in the model'''
        return gobject.TYPE_STRING

    def on_get_path(self, node):
        '''returns the tree path (a tuple of indices at the various
        levels) for a particular node.'''
        print "on_get_path", node
        return node

    def on_get_iter(self, path):
        '''returns the node corresponding to the given path. The patch is a
           tuple of values, like (0 1 1). We have to figure out a path that is
           easy to use by on_get_value() and can also be easely extended by
           on_iter_children() and chopped by on_iter_parent()'''
        def get_iter(klass, path):
            item = klass._attrdef.items()[path[0]]
            if len(path) == 1:
                return (item[0],)
            else:
                subklass = klass._attrdef.items()[path[0]][1][1]
                return (item[0],) + get_iter(subklass, path[1:])
        
        node = get_iter(self.klass, path)
        
        #print "on_get_iter", path, node
        return node

    def on_get_value(self, node, column):
        '''returns the value stored in a particular column for the node'''
        assert column == 0
        attr = node[-1]
        parent = self.class_from_node(node[:-1])
        attrdef = parent._attrdef[attr]
        #print "on_get_value", node, attrdef
        closing = ")"
        if attrdef[0] == Sequence:
            closing = "*)"
            
        if len(attrdef) == 3:
            return attr + " (" + attrdef[1].__name__ + "::" + attrdef[2] + closing
        else:
            return attr + " (" + attrdef[1].__name__ + closing

    def on_iter_next(self, node):
        '''returns the next node at this level of the tree'''
        attr = node[-1]
        parent = self.class_from_node(node[:-1])
        attrdef = parent._attrdef[attr]
        items = parent._attrdef.items()
        sentinel = 0
        for i in items:
            if sentinel:
                node = node[:-1] + (i[0],)
                #print "on_iter_next", node
                return node
            elif i[0] == attr:
                sentinel = 1 # Use next item
        #print "on_iter_next (None)"
        return None

    def on_iter_children(self, node):
        '''returns the first child of this node'''
        klass = self.class_from_node(node)
        if klass.__dict__.has_key("_attrdef"):
            item = klass._attrdef.items()[0][0]
            #print "on_iter_children", node, item
            return node + (item,)
        else:
            #print "on_iter_children (None)"
            return None

    def on_iter_has_child(self, node):
        '''returns true if this node has children'''
        #return 0
        klass = self.class_from_node(node)
        #print "on_iter_has_child", node
        return klass.__dict__.has_key("_attrdef") and len(klass._attrdef) > 0

    def on_iter_n_children(self, node):
        '''returns the number of children of this node'''
        klass = self.class_from_node(node)
        if klass.__dict__.has_key("_attrdef"):
            items = klass._attrdef.items()
            #print "on_iter_n_children", len(items)
            return len(items) - 1
        else:
            #print "on_iter_n_children (None)"
            return 0

    def on_iter_nth_child(self, node, n):
        '''returns the nth child of this node'''
        #print "on_iter_nth_child"
        if node == None:
            #print 'result =', n, self.klass._attrdef.items()[0][0]
            return (self.klass._attrdef.items()[0][0],)
        klass = self.class_from_node(node)
        if klass.__dict__.has_key("_attrdef") and len(node) >= n:
            item = klass._attrdef.items()[n][0]
            #print "on_iter_nth_child", node, klass.__name__, item
            #print 'result =', n, node, item
            return node + (item,)
        else:
            #print 'result =', n, None
            return None

    def on_iter_parent(self, node):
        '''returns the parent of this node'''
        #print "on_iter_parent", node
        return node[:-1]

def main():
    args = sys.argv[1:]
    
    base_class = None
    try:
        base_class = eval(args[0])
    except NameError:
        print "Invalid class name (" + args[0] + ")"
        sys.exit(1)
    except IndexError:
        print "Use gbrowseUML.py <class>, now using class ModelElement"
        base_class = ModelElement

    window = gtk.Window()
    window.connect('destroy', lambda win: gtk.main_quit())
    window.set_title('gbrowseUML -- ' + base_class.__name__)
    window.set_default_size(250, 400)

    scrolled_window = gtk.ScrolledWindow()
    scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
    window.add(scrolled_window)

    model = TreeModel(base_class)
    tree_view = gtk.TreeView(model)
    cell = gtk.CellRendererText()
    # the text in the column comes from column 0
    column = gtk.TreeViewColumn(base_class.__name__, cell, text=0)
    tree_view.append_column(column)

    scrolled_window.add(tree_view)
    window.show_all()

    gtk.main()

if __name__ == '__main__':
    main()
else:
    del main