/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to viz/treemodel.py

  • Committer: Gary van der Merwe
  • Date: 2007-09-17 21:30:47 UTC
  • mto: (256.2.54 gtk)
  • mto: This revision was merged to the branch mainline in revision 289.
  • Revision ID: garyvdm@gmail.com-20070917213047-c642vy6m4cx28yqy
Revert back to GenericTreeModel and implement on_ref_node

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/treemodel.py
25
25
PARENTS = 9
26
26
CHILDREN = 10
27
27
 
28
 
class TreeModel(gtk.TreeModel):
 
28
class TreeModel(gtk.GenericTreeModel):
29
29
 
30
30
    
31
31
    def __init__ (self, branch, line_graph_data):
 
32
        gtk.GenericTreeModel.__init__(self)
32
33
        self.revisions = {}
33
34
        self.branch = branch
34
35
        self.line_graph_data = line_graph_data
35
36
    
36
 
    def get_flags(self):
 
37
    def on_get_flags(self):
37
38
        return gtk.TREE_MODEL_LIST_ONLY
38
39
    
39
 
    def get_n_columns(self):
 
40
    def on_get_n_columns(self):
40
41
        return 11
41
42
    
42
 
    def get_column_type(self, index):
 
43
    def on_get_column_type(self, index):
43
44
        if index == REVID: return gobject.TYPE_STRING
44
45
        if index == NODE: return gobject.TYPE_PYOBJECT
45
46
        if index == LINES: return gobject.TYPE_PYOBJECT
52
53
        if index == PARENTS: return gobject.TYPE_PYOBJECT
53
54
        if index == CHILDREN: return gobject.TYPE_PYOBJECT
54
55
        
55
 
    def get_iter(self, path):
 
56
    def on_get_iter(self, path):
56
57
        return path[0]
57
58
    
58
 
    def get_iter_from_string(self, path_string):
59
 
        raise NotImplementedError
60
 
    
61
 
    def get_string_from_iter(self, iter):
62
 
        raise NotImplementedError
63
 
 
64
 
    def get_iter_root(self):
65
 
        if len(self.line_graph_data) == 0: return None
66
 
        return 0
67
 
    
68
 
    def get_iter_first(self):
69
 
        if len(self.line_graph_data) == 0: return None
70
 
        return 0
71
 
 
72
 
    def get_path(self, iter):
73
 
        return iter
74
 
    
75
 
    def get_value(self, iter, column):
 
59
    def on_get_path(self, rowref):
 
60
        return rowref
 
61
    
 
62
    def on_get_value(self, rowref, column):
76
63
        (revid, node, lines, parents,
77
 
         children, revno_sequence) = self.line_graph_data[iter]
 
64
         children, revno_sequence) = self.line_graph_data[rowref]
78
65
        if column == REVID: return revid
79
66
        if column == NODE: return node
80
67
        if column == LINES: return lines
81
68
        if column == PARENTS: return parents
82
69
        if column == CHILDREN: return children
83
70
        if column == LAST_LINES:
84
 
            if iter>0:
85
 
                return self.line_graph_data[iter-1][2]
 
71
            if rowref>0:
 
72
                return self.line_graph_data[rowref-1][2]
86
73
            return []
87
74
        if column == REVNO: return ".".join(["%d" % (revno)
88
75
                                      for revno in revno_sequence])
95
82
            if column == COMMITER: return revision.committer
96
83
            if column == TIMESTAMP: return format_date(revision.timestamp,
97
84
                                                       revision.timezone)
98
 
        return None
99
 
    
100
 
    def iter_next(self, iter):
101
 
        if iter < len(self.line_graph_data) - 1:
102
 
            return iter+1
103
 
        return None
104
 
    
105
 
    def iter_children(self, parent):
 
85
        else:
 
86
            return None
 
87
    
 
88
    def on_iter_next(self, rowref):
 
89
        if rowref < len(self.line_graph_data) - 1:
 
90
            return rowref+1
 
91
        return None
 
92
    
 
93
    def on_iter_children(self, parent):
106
94
        if parent is None: return 0
107
95
        return None
108
96
    
109
 
    def iter_has_child(self, iter):
 
97
    def on_iter_has_child(self, rowref):
110
98
        return False
111
99
    
112
 
    def iter_n_children(self, iter):
113
 
        if iter is None: return len(self.line_graph_data)
 
100
    def on_iter_n_children(self, rowref):
 
101
        if rowref is None: return len(self.line_graph_data)
114
102
        return 0
115
103
    
116
 
    def iter_nth_child(self, parent, n):
 
104
    def on_iter_nth_child(self, parent, n):
117
105
        if parent is None: return n
118
106
        return None
119
107
    
120
 
    def iter_parent(self, child):
 
108
    def on_iter_parent(self, child):
121
109
        return None
122
110
    
123
 
    def ref_node(self, iter):
 
111
    def on_ref_node(self, iter):
124
112
        revid = self.line_graph_data[iter][0]
125
113
        if revid not in self.revisions:
126
114
            revision = self.branch.repository.get_revisions([revid])[0]
127
115
            self.revisions[revid] = revision        
128
116
 
129
 
    def unref_node(self,iter):
130
 
        pass
131
 
    
132
 
    def get(self, iter, *column):
133
 
        raise NotImplementedError
134
 
    
135
 
    def foreach(self, func, user_data):
136
 
        raise NotImplementedError        
137
 
 
138
 
    def row_changed(self, path, iter):
139
 
        raise NotImplementedError
140
 
 
141
 
    def row_inserted(self, path, iter):
142
 
        raise NotImplementedError
143
 
 
144
 
    def row_has_child_toggled(self, path, iter):
145
 
        raise NotImplementedError
146
 
 
147
 
    def row_deleted(self, path):
148
 
        raise NotImplementedError
149
 
 
150
 
    def rows_reordered(self, path, iter, new_order):
151
 
        raise NotImplementedError
152
 
 
153
 
    def filter_new(self, root=None):
154
 
        raise NotImplementedError