/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 branchview/treeview.py

  • Committer: Daniel Schierbeck
  • Date: 2008-01-13 14:12:49 UTC
  • mto: (423.1.2 trunk)
  • mto: This revision was merged to the branch mainline in revision 429.
  • Revision ID: daniel.schierbeck@gmail.com-20080113141249-gd0i2lknr3yik55r
Moved branch view to its own package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/treeview.py
3
3
 
4
4
"""
5
5
 
6
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
 
6
__copyright__ = "Copyright � 2005 Canonical Ltd."
7
7
__author__    = "Daniel Schierbeck <daniel.schierbeck@gmail.com>"
8
8
 
9
 
from gi.repository import Gtk
10
 
from gi.repository import GObject
11
 
from gi.repository import Pango
 
9
import sys
 
10
import string
 
11
import gtk
 
12
import gobject
 
13
import pango
 
14
import re
 
15
import treemodel
12
16
 
13
 
from bzrlib import ui
 
17
from linegraph import linegraph, same_branch
 
18
from graphcell import CellRendererGraph
 
19
from treemodel import TreeModel
14
20
from bzrlib.revision import NULL_REVISION
15
21
 
16
 
from bzrlib.plugins.gtk import lock
17
 
from bzrlib.plugins.gtk.ui import ProgressPanel
18
 
from bzrlib.plugins.gtk.branchview import treemodel
19
 
from bzrlib.plugins.gtk.branchview.linegraph import linegraph, same_branch
20
 
from bzrlib.plugins.gtk.branchview.graphcell import CellRendererGraph
21
 
 
22
 
 
23
 
class TreeView(Gtk.VBox):
 
22
class TreeView(gtk.ScrolledWindow):
24
23
 
25
24
    __gproperties__ = {
26
 
        'branch': (GObject.TYPE_PYOBJECT,
 
25
        'branch': (gobject.TYPE_PYOBJECT,
27
26
                   'Branch',
28
27
                   'The Bazaar branch being visualized',
29
 
                   GObject.PARAM_CONSTRUCT_ONLY | GObject.PARAM_WRITABLE),
 
28
                   gobject.PARAM_CONSTRUCT_ONLY | gobject.PARAM_WRITABLE),
30
29
 
31
 
        'revision': (GObject.TYPE_PYOBJECT,
 
30
        'revision': (gobject.TYPE_PYOBJECT,
32
31
                     'Revision',
33
32
                     'The currently selected revision',
34
 
                     GObject.PARAM_READWRITE),
 
33
                     gobject.PARAM_READWRITE),
35
34
 
36
 
        'revision-number': (GObject.TYPE_STRING,
 
35
        'revision-number': (gobject.TYPE_STRING,
37
36
                            'Revision number',
38
37
                            'The number of the selected revision',
39
38
                            '',
40
 
                            GObject.PARAM_READABLE),
 
39
                            gobject.PARAM_READABLE),
41
40
 
42
 
        'children': (GObject.TYPE_PYOBJECT,
 
41
        'children': (gobject.TYPE_PYOBJECT,
43
42
                     'Child revisions',
44
43
                     'Children of the currently selected revision',
45
 
                     GObject.PARAM_READABLE),
 
44
                     gobject.PARAM_READABLE),
46
45
 
47
 
        'parents': (GObject.TYPE_PYOBJECT,
 
46
        'parents': (gobject.TYPE_PYOBJECT,
48
47
                    'Parent revisions',
49
48
                    'Parents to the currently selected revision',
50
 
                    GObject.PARAM_READABLE),
 
49
                    gobject.PARAM_READABLE),
51
50
 
52
 
        'revno-column-visible': (GObject.TYPE_BOOLEAN,
53
 
                                 'Revision number column',
 
51
        'revno-column-visible': (gobject.TYPE_BOOLEAN,
 
52
                                 'Revision number',
54
53
                                 'Show revision number column',
55
54
                                 True,
56
 
                                 GObject.PARAM_READWRITE),
57
 
 
58
 
        'graph-column-visible': (GObject.TYPE_BOOLEAN,
59
 
                                 'Graph column',
60
 
                                 'Show graph column',
61
 
                                 True,
62
 
                                 GObject.PARAM_READWRITE),
63
 
 
64
 
        'date-column-visible': (GObject.TYPE_BOOLEAN,
 
55
                                 gobject.PARAM_READWRITE),
 
56
 
 
57
        'date-column-visible': (gobject.TYPE_BOOLEAN,
65
58
                                 'Date',
66
59
                                 'Show date column',
67
60
                                 False,
68
 
                                 GObject.PARAM_READWRITE),
 
61
                                 gobject.PARAM_READWRITE),
69
62
 
70
 
        'compact': (GObject.TYPE_BOOLEAN,
 
63
        'compact': (gobject.TYPE_BOOLEAN,
71
64
                    'Compact view',
72
65
                    'Break ancestry lines to save space',
73
66
                    True,
74
 
                    GObject.PARAM_CONSTRUCT | GObject.PARAM_READWRITE),
75
 
 
76
 
        'mainline-only': (GObject.TYPE_BOOLEAN,
77
 
                    'Mainline only',
78
 
                    'Only show the mainline history.',
79
 
                    False,
80
 
                    GObject.PARAM_CONSTRUCT | GObject.PARAM_READWRITE),
 
67
                    gobject.PARAM_CONSTRUCT | gobject.PARAM_READWRITE)
81
68
 
82
69
    }
83
70
 
84
71
    __gsignals__ = {
85
 
        'revision-selected': (GObject.SignalFlags.RUN_FIRST,
86
 
                              None,
87
 
                              ()),
88
 
        'revision-activated': (GObject.SignalFlags.RUN_FIRST,
89
 
                              None,
90
 
                              (GObject.TYPE_PYOBJECT, GObject.TYPE_PYOBJECT)),
91
 
        'tag-added': (GObject.SignalFlags.RUN_FIRST,
92
 
                              None,
93
 
                              (GObject.TYPE_STRING, GObject.TYPE_STRING)),
94
 
        'refreshed': (GObject.SignalFlags.RUN_FIRST, None,
 
72
        'revisions-loaded': (gobject.SIGNAL_RUN_FIRST, 
 
73
                             gobject.TYPE_NONE,
 
74
                             ()),
 
75
        'revision-selected': (gobject.SIGNAL_RUN_FIRST,
 
76
                              gobject.TYPE_NONE,
95
77
                              ())
96
78
    }
97
79
 
105
87
        :param broken_line_length: After how much lines to break 
106
88
                                   branches.
107
89
        """
108
 
        super(TreeView, self).__init__(homogeneous=False, spacing=0)
109
 
 
110
 
        self.progress_widget = ProgressPanel()
111
 
        self.pack_start(self.progress_widget, False, True, 0)
112
 
        if getattr(ui.ui_factory, "set_progress_bar_widget", None) is not None:
113
 
            # We'are using our own ui, let's tell it to use our widget.
114
 
            ui.ui_factory.set_progress_bar_widget(self.progress_widget)
115
 
 
116
 
        self.scrolled_window = Gtk.ScrolledWindow()
117
 
        self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
118
 
                                        Gtk.PolicyType.AUTOMATIC)
119
 
        self.scrolled_window.set_shadow_type(Gtk.ShadowType.IN)
120
 
        self.scrolled_window.show()
121
 
        self.pack_start(self.scrolled_window, True, True, 0)
122
 
 
123
 
        self.scrolled_window.add(self.construct_treeview())
124
 
 
125
 
        self.path = None
 
90
        gtk.ScrolledWindow.__init__(self)
 
91
 
 
92
        self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
93
        self.set_shadow_type(gtk.SHADOW_IN)
 
94
 
 
95
        self.construct_treeview()
 
96
 
 
97
        self.iter   = None
126
98
        self.branch = branch
127
 
        self.revision = None
128
 
        self.index = {}
129
99
 
130
100
        self.start = start
131
101
        self.maxnum = maxnum
132
102
        self.compact = compact
133
103
 
134
 
        self.model = treemodel.BranchTreeModel(self.branch, [])
135
 
        GObject.idle_add(self.populate)
136
 
 
137
 
        self.connect("destroy", self._on_destroy)
138
 
 
139
 
    def _on_destroy(self, *ignored):
140
 
        self.branch.unlock()
141
 
        if getattr(ui.ui_factory, "set_progress_bar_widget", None) is not None:
142
 
            # We'are using our own ui, let's tell it to stop using our widget.
143
 
            ui.ui_factory.set_progress_bar_widget(None)
 
104
        gobject.idle_add(self.populate)
 
105
 
 
106
        self.connect("destroy", lambda x: self.branch.unlock())
144
107
 
145
108
    def do_get_property(self, property):
146
109
        if property.name == 'revno-column-visible':
147
110
            return self.revno_column.get_visible()
148
 
        elif property.name == 'graph-column-visible':
149
 
            return self.graph_column.get_visible()
150
111
        elif property.name == 'date-column-visible':
151
112
            return self.date_column.get_visible()
152
113
        elif property.name == 'compact':
153
114
            return self.compact
154
 
        elif property.name == 'mainline-only':
155
 
            return self.mainline_only
156
115
        elif property.name == 'branch':
157
116
            return self.branch
158
117
        elif property.name == 'revision':
159
 
            if self.path is None:
160
 
                return None
161
 
            return self.model.get_value(self.model.get_iter(self.path),
162
 
                                        treemodel.REVISION)
 
118
            return self.model.get_value(self.iter, treemodel.REVISION)
163
119
        elif property.name == 'revision-number':
164
 
            if self.path is None:
165
 
                return None
166
 
            return self.model.get_value(self.model.get_iter(self.path),
167
 
                                        treemodel.REVNO)
 
120
            return self.model.get_value(self.iter, treemodel.REVNO)
168
121
        elif property.name == 'children':
169
 
            if self.path is None:
170
 
                return None
171
 
            return self.model.get_value(self.model.get_iter(self.path),
172
 
                                        treemodel.CHILDREN)
 
122
            return self.model.get_value(self.iter, treemodel.CHILDREN)
173
123
        elif property.name == 'parents':
174
 
            if self.path is None:
175
 
                return None
176
 
            return self.model.get_value(self.model.get_iter(self.path),
177
 
                                        treemodel.PARENTS)
 
124
            return self.model.get_value(self.iter, treemodel.PARENTS)
178
125
        else:
179
126
            raise AttributeError, 'unknown property %s' % property.name
180
127
 
181
128
    def do_set_property(self, property, value):
182
129
        if property.name == 'revno-column-visible':
183
130
            self.revno_column.set_visible(value)
184
 
        elif property.name == 'graph-column-visible':
185
 
            self.graph_column.set_visible(value)
186
131
        elif property.name == 'date-column-visible':
187
132
            self.date_column.set_visible(value)
188
133
        elif property.name == 'compact':
189
134
            self.compact = value
190
 
        elif property.name == 'mainline-only':
191
 
            self.mainline_only = value
192
135
        elif property.name == 'branch':
193
136
            self.branch = value
194
137
        elif property.name == 'revision':
200
143
        """Return revision id of currently selected revision, or None."""
201
144
        return self.get_property('revision')
202
145
 
203
 
    def has_revision_id(self, revision_id):
204
 
        return (revision_id in self.index)
205
 
 
206
146
    def set_revision(self, revision):
207
147
        self.set_property('revision', revision)
208
148
 
211
151
 
212
152
        :param revid: Revision id of revision to display.
213
153
        """
214
 
        self.treeview.set_cursor(
215
 
            Gtk.TreePath(path=self.index[revid]), None, False)
 
154
        self.treeview.set_cursor(self.index[revid])
216
155
        self.treeview.grab_focus()
217
156
 
218
157
    def get_children(self):
228
167
        :return: list of revision ids.
229
168
        """
230
169
        return self.get_property('parents')
231
 
 
232
 
    def add_tag(self, tag, revid=None):
233
 
        if revid is None: revid = self.revision.revision_id
234
 
 
235
 
        if lock.release(self.branch):
236
 
            try:
237
 
                lock.acquire(self.branch, lock.WRITE)
238
 
                self.model.add_tag(tag, revid)
239
 
            finally:
240
 
                lock.release(self.branch)
241
 
 
242
 
            lock.acquire(self.branch, lock.READ)
243
 
 
244
 
            self.emit('tag-added', tag, revid)
245
 
 
 
170
        
246
171
    def refresh(self):
247
 
        GObject.idle_add(self.populate, self.get_revision())
 
172
        gobject.idle_add(self.populate, self.get_revision())
248
173
 
249
174
    def update(self):
250
175
        try:
260
185
    def back(self):
261
186
        """Signal handler for the Back button."""
262
187
        parents = self.get_parents()
263
 
        if not parents:
 
188
        if not len(parents):
264
189
            return
265
190
 
266
191
        for parent_id in parents:
275
200
    def forward(self):
276
201
        """Signal handler for the Forward button."""
277
202
        children = self.get_children()
278
 
        if not children:
 
203
        if not len(children):
279
204
            return
280
205
 
281
206
        for child_id in children:
297
222
                       should be broken.
298
223
        """
299
224
 
300
 
        if getattr(ui.ui_factory, "set_progress_bar_widget", None) is not None:
301
 
            # We'are using our own ui, let's tell it to use our widget.
302
 
            ui.ui_factory.set_progress_bar_widget(self.progress_widget)
303
 
        self.progress_bar = ui.ui_factory.nested_progress_bar()
304
 
        self.progress_bar.update("Loading ancestry graph", 0, 5)
305
 
 
306
 
        try:
307
 
            if self.compact:
308
 
                broken_line_length = 32
309
 
            else:
310
 
                broken_line_length = None
311
 
 
312
 
            show_graph = self.graph_column.get_visible()
313
 
 
314
 
            self.branch.lock_read()
315
 
            (linegraphdata, index, columns_len) = linegraph(
316
 
                self.branch.repository.get_graph(),
317
 
                self.start,
318
 
                self.maxnum, 
319
 
                broken_line_length,
320
 
                show_graph,
321
 
                self.mainline_only,
322
 
                self.progress_bar)
323
 
 
324
 
            self.model.set_line_graph_data(linegraphdata)
325
 
            self.graph_cell.columns_len = columns_len
326
 
            width = self.graph_cell.get_preferred_width(self.treeview)[1]
327
 
            if width > 500:
328
 
                width = 500
329
 
            elif width == 0:
330
 
                # The get_preferred_width() call got an insane value.
331
 
                width = 200
332
 
            self.graph_column.set_fixed_width(width)
333
 
            self.graph_column.set_max_width(width)
334
 
            self.index = index
335
 
            self.treeview.set_model(self.model)
336
 
 
337
 
            if not revision or revision == NULL_REVISION:
338
 
                self.treeview.set_cursor(Gtk.TreePath(path=0), None, False)
339
 
            else:
340
 
                self.set_revision(revision)
341
 
 
342
 
            self.emit('refreshed')
343
 
            return False
344
 
        finally:
345
 
            self.progress_bar.finished()
 
225
        if self.compact:
 
226
            broken_line_length = 32
 
227
        else:
 
228
            broken_line_length = None
 
229
 
 
230
        self.branch.lock_read()
 
231
        (linegraphdata, index, columns_len) = linegraph(self.branch.repository,
 
232
                                                        self.start,
 
233
                                                        self.maxnum, 
 
234
                                                        broken_line_length)
 
235
 
 
236
        self.model = TreeModel(self.branch.repository, linegraphdata)
 
237
        self.graph_cell.columns_len = columns_len
 
238
        width = self.graph_cell.get_size(self.treeview)[2]
 
239
        if width > 500:
 
240
            width = 500
 
241
        self.graph_column.set_fixed_width(width)
 
242
        self.graph_column.set_max_width(width)
 
243
        self.index = index
 
244
        self.treeview.set_model(self.model)
 
245
 
 
246
        if revision is None:
 
247
            self.treeview.set_cursor(0)
 
248
        else:
 
249
            self.set_revision(revision)
 
250
 
 
251
        self.emit('revisions-loaded')
 
252
 
 
253
        return False
 
254
 
 
255
    def show_diff(self, revid=None, parentid=None):
 
256
        """Open a new window to show a diff between the given revisions."""
 
257
        from bzrlib.plugins.gtk.diff import DiffWindow
 
258
        window = DiffWindow(parent=self)
 
259
 
 
260
        parents = self.get_parents()
 
261
 
 
262
        if revid is None:
 
263
            revid = self.get_revision().revision_id
 
264
 
 
265
            if parentid is None and len(parents) > 0:
 
266
                parentid = parents[0]
 
267
 
 
268
        if parentid is None:
 
269
            parentid = NULL_REVISION
 
270
 
 
271
        rev_tree    = self.branch.repository.revision_tree(revid)
 
272
        parent_tree = self.branch.repository.revision_tree(parentid)
 
273
 
 
274
        description = revid + " - " + self.branch.nick
 
275
        window.set_diff(description, rev_tree, parent_tree)
 
276
        window.show()
346
277
 
347
278
    def construct_treeview(self):
348
 
        self.treeview = Gtk.TreeView()
 
279
        self.treeview = gtk.TreeView()
349
280
 
350
281
        self.treeview.set_rules_hint(True)
351
 
        # combined revno/summary interactive search
352
 
        #
353
 
        # the row in a treemodel is considered "matched" if a REVNO *starts*
354
 
        # from the key (that is the key is found in a REVNO at the offset 0)
355
 
        # or if a MESSAGE *contains* the key anywhere (that is, the key is
356
 
        # found case insensitively in a MESSAGE at any offset)
357
 
        def search_equal_func(model, column, key, iter):
358
 
            return (model.get_value(iter, treemodel.REVNO).find(key) != 0
359
 
                and model.get_value(iter, treemodel.MESSAGE).lower().find(key.lower()) == -1)
360
 
 
361
 
        self.treeview.set_search_equal_func(search_equal_func, None)
362
 
        self.treeview.set_enable_search(True)
363
 
 
364
 
        self.treeview.set_tooltip_column(treemodel.MESSAGE)
365
 
        self.treeview.set_headers_visible(True)
366
 
 
367
 
        self._prev_cursor_path = None
 
282
        self.treeview.set_search_column(treemodel.REVNO)
 
283
        
 
284
        # Fix old PyGTK bug - by JAM
 
285
        set_tooltip = getattr(self.treeview, 'set_tooltip_column', None)
 
286
        if set_tooltip is not None:
 
287
            set_tooltip(treemodel.MESSAGE)
 
288
 
368
289
        self.treeview.connect("cursor-changed",
369
290
                self._on_selection_changed)
370
291
 
376
297
 
377
298
        self.treeview.set_property('fixed-height-mode', True)
378
299
 
 
300
        self.add(self.treeview)
379
301
        self.treeview.show()
380
302
 
381
 
        cell = Gtk.CellRendererText()
 
303
        cell = gtk.CellRendererText()
382
304
        cell.set_property("width-chars", 15)
383
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
384
 
        self.revno_column = Gtk.TreeViewColumn("Revision No")
 
305
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
306
        self.revno_column = gtk.TreeViewColumn("Revision No")
385
307
        self.revno_column.set_resizable(True)
386
 
        self.revno_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
387
 
        self.revno_column.set_fixed_width(
388
 
            cell.get_preferred_width(self.treeview)[1])
389
 
        self.revno_column.pack_start(cell, True)
 
308
        self.revno_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
309
        self.revno_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
310
        self.revno_column.pack_start(cell, expand=True)
390
311
        self.revno_column.add_attribute(cell, "text", treemodel.REVNO)
391
312
        self.treeview.append_column(self.revno_column)
392
313
 
393
314
        self.graph_cell = CellRendererGraph()
394
 
        self.graph_column = Gtk.TreeViewColumn()
 
315
        self.graph_column = gtk.TreeViewColumn()
395
316
        self.graph_column.set_resizable(True)
396
 
        self.graph_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
397
 
        self.graph_column.pack_start(self.graph_cell, True)
398
 
        self.graph_column.add_attribute(
399
 
            self.graph_cell, "node", treemodel.NODE)
400
 
        self.graph_column.add_attribute(
401
 
            self.graph_cell, "tags", treemodel.TAGS)
402
 
        self.graph_column.add_attribute(
403
 
            self.graph_cell, "in-lines", treemodel.LAST_LINES)
404
 
        self.graph_column.add_attribute(
405
 
            self.graph_cell, "out-lines", treemodel.LINES)
 
317
        self.graph_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
318
        self.graph_column.pack_start(self.graph_cell, expand=False)
 
319
        self.graph_column.add_attribute(self.graph_cell, "node", treemodel.NODE)
 
320
        self.graph_column.add_attribute(self.graph_cell, "in-lines", treemodel.LAST_LINES)
 
321
        self.graph_column.add_attribute(self.graph_cell, "out-lines", treemodel.LINES)
406
322
        self.treeview.append_column(self.graph_column)
407
323
 
408
 
        cell = Gtk.CellRendererText()
 
324
        cell = gtk.CellRendererText()
409
325
        cell.set_property("width-chars", 65)
410
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
411
 
        self.summary_column = Gtk.TreeViewColumn("Summary")
412
 
        self.summary_column.set_resizable(True)
413
 
        self.summary_column.set_expand(True)
414
 
        self.summary_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
415
 
        self.summary_column.set_fixed_width(
416
 
            cell.get_preferred_width(self.treeview)[1])
417
 
        self.summary_column.pack_start(cell, True)
418
 
        self.summary_column.add_attribute(cell, "markup", treemodel.SUMMARY)
419
 
        self.treeview.append_column(self.summary_column)
 
326
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
327
        self.msg_column = gtk.TreeViewColumn("Message")
 
328
        self.msg_column.set_resizable(True)
 
329
        self.msg_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
330
        self.msg_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
331
        self.msg_column.pack_start(cell, expand=True)
 
332
        self.msg_column.add_attribute(cell, "markup", treemodel.MESSAGE)
 
333
        self.treeview.append_column(self.msg_column)
420
334
 
421
 
        cell = Gtk.CellRendererText()
 
335
        cell = gtk.CellRendererText()
422
336
        cell.set_property("width-chars", 15)
423
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
424
 
        self.authors_column = Gtk.TreeViewColumn("Author(s)")
425
 
        self.authors_column.set_resizable(False)
426
 
        self.authors_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
427
 
        self.authors_column.set_fixed_width(200)
428
 
        self.authors_column.pack_start(cell, True)
429
 
        self.authors_column.add_attribute(cell, "text", treemodel.AUTHORS)
430
 
        self.treeview.append_column(self.authors_column)
 
337
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
338
        self.committer_column = gtk.TreeViewColumn("Committer")
 
339
        self.committer_column.set_resizable(True)
 
340
        self.committer_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
341
        self.committer_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
342
        self.committer_column.pack_start(cell, expand=True)
 
343
        self.committer_column.add_attribute(cell, "text", treemodel.COMMITER)
 
344
        self.treeview.append_column(self.committer_column)
431
345
 
432
 
        cell = Gtk.CellRendererText()
 
346
        cell = gtk.CellRendererText()
433
347
        cell.set_property("width-chars", 20)
434
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
435
 
        self.date_column = Gtk.TreeViewColumn("Date")
 
348
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
349
        self.date_column = gtk.TreeViewColumn("Date")
436
350
        self.date_column.set_visible(False)
437
351
        self.date_column.set_resizable(True)
438
 
        self.date_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
439
 
        self.date_column.set_fixed_width(130)
440
 
        self.date_column.pack_start(cell, True)
 
352
        self.date_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
353
        self.date_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
354
        self.date_column.pack_start(cell, expand=True)
441
355
        self.date_column.add_attribute(cell, "text", treemodel.TIMESTAMP)
442
356
        self.treeview.append_column(self.date_column)
443
357
 
444
 
        return self.treeview
445
 
 
446
358
    def _on_selection_changed(self, treeview):
447
359
        """callback for when the treeview changes."""
448
360
        (path, focus) = treeview.get_cursor()
449
 
        if (path is not None) and (path != self._prev_cursor_path):
450
 
            self._prev_cursor_path = path # avoid emitting twice per click
451
 
            self.path = path
 
361
        if path is not None:
 
362
            self.iter = self.model.get_iter(path)
452
363
            self.emit('revision-selected')
453
364
 
454
365
    def _on_revision_selected(self, widget, event):
455
 
        from bzrlib.plugins.gtk.revisionmenu import RevisionMenu
 
366
        from bzrlib.plugins.gtk.revisionmenu import RevisionPopupMenu
456
367
        if event.button == 3:
457
 
            menu = RevisionMenu(self.branch.repository, 
 
368
            menu = RevisionPopupMenu(self.branch.repository, 
458
369
                [self.get_revision().revision_id],
459
370
                self.branch)
460
 
            menu.connect('tag-added', lambda w, t, r: self.add_tag(t, r))
461
 
            menu.popup(None, None, None, None, event.button, event.get_time())
 
371
            menu.popup(None, None, None, event.button, event.get_time())
462
372
 
463
373
    def _on_revision_activated(self, widget, path, col):
464
 
        self.emit('revision-activated', path, col)
 
374
        # TODO: more than one parent
 
375
        """Callback for when a treeview row gets activated."""
 
376
        revision_id = self.model[path][treemodel.REVID]
 
377
        parents = self.model[path][treemodel.PARENTS]
 
378
 
 
379
        if len(parents) == 0:
 
380
            parent_id = None
 
381
        else:
 
382
            parent_id = parents[0]
 
383
 
 
384
        self.show_diff(revision_id, parent_id)
 
385
        self.treeview.grab_focus()