/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: Vincent Ladeuil
  • Date: 2008-11-06 15:45:24 UTC
  • mto: This revision was merged to the branch mainline in revision 625.
  • Revision ID: v.ladeuil+lp@free.fr-20081106154524-n9al5n1pome2xo0u
Fix bug #289220 by using the right parameter order.

* status.py:
(StatusWindow.row_diff): One can argue that the parameters are in
the wrong order or just respect their meaning :) Thanks to Anne
Mohsen for noticing and proposing the fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/treeview.py
6
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
12
 
 
 
9
import sys
 
10
import string
 
11
import gtk
 
12
import gobject
 
13
import pango
 
14
import re
 
15
import treemodel
13
16
from bzrlib import ui
 
17
 
 
18
from bzrlib.plugins.gtk import _i18n
 
19
from bzrlib.plugins.gtk.ui import GtkProgressBar, ProgressPanel
 
20
from linegraph import linegraph, same_branch
 
21
from graphcell import CellRendererGraph
 
22
from treemodel import TreeModel
14
23
from bzrlib.revision import NULL_REVISION
15
24
 
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):
 
25
 
 
26
class TreeView(gtk.VBox):
24
27
 
25
28
    __gproperties__ = {
26
 
        'branch': (GObject.TYPE_PYOBJECT,
 
29
        'branch': (gobject.TYPE_PYOBJECT,
27
30
                   'Branch',
28
31
                   'The Bazaar branch being visualized',
29
 
                   GObject.PARAM_CONSTRUCT_ONLY | GObject.PARAM_WRITABLE),
 
32
                   gobject.PARAM_CONSTRUCT_ONLY | gobject.PARAM_WRITABLE),
30
33
 
31
 
        'revision': (GObject.TYPE_PYOBJECT,
 
34
        'revision': (gobject.TYPE_PYOBJECT,
32
35
                     'Revision',
33
36
                     'The currently selected revision',
34
 
                     GObject.PARAM_READWRITE),
 
37
                     gobject.PARAM_READWRITE),
35
38
 
36
 
        'revision-number': (GObject.TYPE_STRING,
 
39
        'revision-number': (gobject.TYPE_STRING,
37
40
                            'Revision number',
38
41
                            'The number of the selected revision',
39
42
                            '',
40
 
                            GObject.PARAM_READABLE),
 
43
                            gobject.PARAM_READABLE),
41
44
 
42
 
        'children': (GObject.TYPE_PYOBJECT,
 
45
        'children': (gobject.TYPE_PYOBJECT,
43
46
                     'Child revisions',
44
47
                     'Children of the currently selected revision',
45
 
                     GObject.PARAM_READABLE),
 
48
                     gobject.PARAM_READABLE),
46
49
 
47
 
        'parents': (GObject.TYPE_PYOBJECT,
 
50
        'parents': (gobject.TYPE_PYOBJECT,
48
51
                    'Parent revisions',
49
52
                    'Parents to the currently selected revision',
50
 
                    GObject.PARAM_READABLE),
 
53
                    gobject.PARAM_READABLE),
51
54
 
52
 
        'revno-column-visible': (GObject.TYPE_BOOLEAN,
 
55
        'revno-column-visible': (gobject.TYPE_BOOLEAN,
53
56
                                 'Revision number column',
54
57
                                 'Show revision number column',
55
58
                                 True,
56
 
                                 GObject.PARAM_READWRITE),
 
59
                                 gobject.PARAM_READWRITE),
57
60
 
58
 
        'graph-column-visible': (GObject.TYPE_BOOLEAN,
 
61
        'graph-column-visible': (gobject.TYPE_BOOLEAN,
59
62
                                 'Graph column',
60
63
                                 'Show graph column',
61
64
                                 True,
62
 
                                 GObject.PARAM_READWRITE),
 
65
                                 gobject.PARAM_READWRITE),
63
66
 
64
 
        'date-column-visible': (GObject.TYPE_BOOLEAN,
 
67
        'date-column-visible': (gobject.TYPE_BOOLEAN,
65
68
                                 'Date',
66
69
                                 'Show date column',
67
70
                                 False,
68
 
                                 GObject.PARAM_READWRITE),
 
71
                                 gobject.PARAM_READWRITE),
69
72
 
70
 
        'compact': (GObject.TYPE_BOOLEAN,
 
73
        'compact': (gobject.TYPE_BOOLEAN,
71
74
                    'Compact view',
72
75
                    'Break ancestry lines to save space',
73
76
                    True,
74
 
                    GObject.PARAM_CONSTRUCT | GObject.PARAM_READWRITE),
 
77
                    gobject.PARAM_CONSTRUCT | gobject.PARAM_READWRITE),
75
78
 
76
 
        'mainline-only': (GObject.TYPE_BOOLEAN,
 
79
        'mainline-only': (gobject.TYPE_BOOLEAN,
77
80
                    'Mainline only',
78
81
                    'Only show the mainline history.',
79
82
                    False,
80
 
                    GObject.PARAM_CONSTRUCT | GObject.PARAM_READWRITE),
 
83
                    gobject.PARAM_CONSTRUCT | gobject.PARAM_READWRITE),
81
84
 
82
85
    }
83
86
 
84
87
    __gsignals__ = {
85
 
        'revision-selected': (GObject.SignalFlags.RUN_FIRST,
86
 
                              None,
 
88
        'revision-selected': (gobject.SIGNAL_RUN_FIRST,
 
89
                              gobject.TYPE_NONE,
87
90
                              ()),
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,
 
91
        'revision-activated': (gobject.SIGNAL_RUN_FIRST,
 
92
                              gobject.TYPE_NONE,
 
93
                              (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)),
 
94
        'tag-added': (gobject.SIGNAL_RUN_FIRST,
 
95
                              gobject.TYPE_NONE,
 
96
                              (gobject.TYPE_STRING, gobject.TYPE_STRING)),
 
97
        'refreshed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
95
98
                              ())
96
99
    }
97
100
 
105
108
        :param broken_line_length: After how much lines to break 
106
109
                                   branches.
107
110
        """
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)
 
111
        gtk.VBox.__init__(self, spacing=0)
 
112
 
 
113
        loading_msg_widget = ProgressPanel()
 
114
        if getattr(ui.ui_factory, "set_nested_progress_bar_widget", None) is not None:
 
115
            ui.ui_factory.set_nested_progress_bar_widget(loading_msg_widget.get_progress_bar)
 
116
        self.pack_start(loading_msg_widget, expand=False, fill=True)
 
117
 
 
118
        self.scrolled_window = gtk.ScrolledWindow()
 
119
        self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
 
120
                                        gtk.POLICY_AUTOMATIC)
 
121
        self.scrolled_window.set_shadow_type(gtk.SHADOW_IN)
120
122
        self.scrolled_window.show()
121
 
        self.pack_start(self.scrolled_window, True, True, 0)
 
123
        self.pack_start(self.scrolled_window, expand=True, fill=True)
122
124
 
123
125
        self.scrolled_window.add(self.construct_treeview())
124
126
 
125
 
        self.path = None
 
127
        self.iter = None
126
128
        self.branch = branch
127
129
        self.revision = None
128
130
        self.index = {}
131
133
        self.maxnum = maxnum
132
134
        self.compact = compact
133
135
 
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)
 
136
        gobject.idle_add(self.populate)
 
137
 
 
138
        self.connect("destroy", lambda x: self.branch.unlock())
144
139
 
145
140
    def do_get_property(self, property):
146
141
        if property.name == 'revno-column-visible':
156
151
        elif property.name == 'branch':
157
152
            return self.branch
158
153
        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)
 
154
            return self.model.get_value(self.iter, treemodel.REVISION)
163
155
        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)
 
156
            return self.model.get_value(self.iter, treemodel.REVNO)
168
157
        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)
 
158
            return self.model.get_value(self.iter, treemodel.CHILDREN)
173
159
        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)
 
160
            return self.model.get_value(self.iter, treemodel.PARENTS)
178
161
        else:
179
162
            raise AttributeError, 'unknown property %s' % property.name
180
163
 
211
194
 
212
195
        :param revid: Revision id of revision to display.
213
196
        """
214
 
        self.treeview.set_cursor(
215
 
            Gtk.TreePath(path=self.index[revid]), None, False)
 
197
        self.treeview.set_cursor(self.index[revid])
216
198
        self.treeview.grab_focus()
217
199
 
218
200
    def get_children(self):
232
214
    def add_tag(self, tag, revid=None):
233
215
        if revid is None: revid = self.revision.revision_id
234
216
 
235
 
        if lock.release(self.branch):
 
217
        try:
 
218
            self.branch.unlock()
 
219
 
236
220
            try:
237
 
                lock.acquire(self.branch, lock.WRITE)
 
221
                self.branch.lock_write()
238
222
                self.model.add_tag(tag, revid)
239
223
            finally:
240
 
                lock.release(self.branch)
241
 
 
242
 
            lock.acquire(self.branch, lock.READ)
243
 
 
244
 
            self.emit('tag-added', tag, revid)
245
 
 
 
224
                self.branch.unlock()
 
225
 
 
226
        finally:
 
227
            self.branch.lock_read()
 
228
 
 
229
        self.emit('tag-added', tag, revid)
 
230
        
246
231
    def refresh(self):
247
 
        GObject.idle_add(self.populate, self.get_revision())
 
232
        gobject.idle_add(self.populate, self.get_revision())
248
233
 
249
234
    def update(self):
250
235
        try:
260
245
    def back(self):
261
246
        """Signal handler for the Back button."""
262
247
        parents = self.get_parents()
263
 
        if not parents:
 
248
        if not len(parents):
264
249
            return
265
250
 
266
251
        for parent_id in parents:
275
260
    def forward(self):
276
261
        """Signal handler for the Forward button."""
277
262
        children = self.get_children()
278
 
        if not children:
 
263
        if not len(children):
279
264
            return
280
265
 
281
266
        for child_id in children:
297
282
                       should be broken.
298
283
        """
299
284
 
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
285
        self.progress_bar = ui.ui_factory.nested_progress_bar()
304
286
        self.progress_bar.update("Loading ancestry graph", 0, 5)
305
287
 
308
290
                broken_line_length = 32
309
291
            else:
310
292
                broken_line_length = None
311
 
 
 
293
            
312
294
            show_graph = self.graph_column.get_visible()
313
295
 
314
296
            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)
 
297
            (linegraphdata, index, columns_len) = linegraph(self.branch.repository.get_graph(),
 
298
                                                            self.start,
 
299
                                                            self.maxnum, 
 
300
                                                            broken_line_length,
 
301
                                                            show_graph,
 
302
                                                            self.mainline_only,
 
303
                                                            self.progress_bar)
323
304
 
324
 
            self.model.set_line_graph_data(linegraphdata)
 
305
            self.model = TreeModel(self.branch, linegraphdata)
325
306
            self.graph_cell.columns_len = columns_len
326
 
            width = self.graph_cell.get_preferred_width(self.treeview)[1]
 
307
            width = self.graph_cell.get_size(self.treeview)[2]
327
308
            if width > 500:
328
309
                width = 500
329
 
            elif width == 0:
330
 
                # The get_preferred_width() call got an insane value.
331
 
                width = 200
332
310
            self.graph_column.set_fixed_width(width)
333
311
            self.graph_column.set_max_width(width)
334
312
            self.index = index
335
313
            self.treeview.set_model(self.model)
336
314
 
337
315
            if not revision or revision == NULL_REVISION:
338
 
                self.treeview.set_cursor(Gtk.TreePath(path=0), None, False)
 
316
                self.treeview.set_cursor(0)
339
317
            else:
340
318
                self.set_revision(revision)
341
319
 
345
323
            self.progress_bar.finished()
346
324
 
347
325
    def construct_treeview(self):
348
 
        self.treeview = Gtk.TreeView()
 
326
        self.treeview = gtk.TreeView()
349
327
 
350
328
        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, ignored):
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)
 
329
        self.treeview.set_search_column(treemodel.REVNO)
 
330
        
 
331
        # Fix old PyGTK bug - by JAM
 
332
        set_tooltip = getattr(self.treeview, 'set_tooltip_column', None)
 
333
        if set_tooltip is not None:
 
334
            set_tooltip(treemodel.MESSAGE)
366
335
 
367
336
        self._prev_cursor_path = None
368
337
        self.treeview.connect("cursor-changed",
378
347
 
379
348
        self.treeview.show()
380
349
 
381
 
        cell = Gtk.CellRendererText()
 
350
        cell = gtk.CellRendererText()
382
351
        cell.set_property("width-chars", 15)
383
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
384
 
        self.revno_column = Gtk.TreeViewColumn("Revision No")
385
 
        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)
 
352
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
353
        self.revno_column = gtk.TreeViewColumn("Revision No")
 
354
        self.revno_column.set_resizable(False)
 
355
        self.revno_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
356
        self.revno_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
357
        self.revno_column.pack_start(cell, expand=True)
390
358
        self.revno_column.add_attribute(cell, "text", treemodel.REVNO)
391
359
        self.treeview.append_column(self.revno_column)
392
360
 
393
361
        self.graph_cell = CellRendererGraph()
394
 
        self.graph_column = Gtk.TreeViewColumn()
395
 
        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)
 
362
        self.graph_column = gtk.TreeViewColumn()
 
363
        self.graph_column.set_resizable(False)
 
364
        self.graph_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
365
        self.graph_column.pack_start(self.graph_cell, expand=True)
 
366
        self.graph_column.add_attribute(self.graph_cell, "node", treemodel.NODE)
 
367
        self.graph_column.add_attribute(self.graph_cell, "tags", treemodel.TAGS)
 
368
        self.graph_column.add_attribute(self.graph_cell, "in-lines", treemodel.LAST_LINES)
 
369
        self.graph_column.add_attribute(self.graph_cell, "out-lines", treemodel.LINES)
406
370
        self.treeview.append_column(self.graph_column)
407
371
 
408
 
        cell = Gtk.CellRendererText()
 
372
        cell = gtk.CellRendererText()
409
373
        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)
 
374
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
375
        self.summary_column = gtk.TreeViewColumn("Summary")
 
376
        self.summary_column.set_resizable(False)
413
377
        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)
 
378
        self.summary_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
379
        self.summary_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
380
        self.summary_column.pack_start(cell, expand=True)
418
381
        self.summary_column.add_attribute(cell, "markup", treemodel.SUMMARY)
419
382
        self.treeview.append_column(self.summary_column)
420
383
 
421
 
        cell = Gtk.CellRendererText()
 
384
        cell = gtk.CellRendererText()
422
385
        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)
 
386
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
387
        self.committer_column = gtk.TreeViewColumn("Committer")
 
388
        self.committer_column.set_resizable(False)
 
389
        self.committer_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
390
        self.committer_column.set_fixed_width(200)
 
391
        self.committer_column.pack_start(cell, expand=True)
 
392
        self.committer_column.add_attribute(cell, "text", treemodel.COMMITTER)
 
393
        self.treeview.append_column(self.committer_column)
431
394
 
432
 
        cell = Gtk.CellRendererText()
 
395
        cell = gtk.CellRendererText()
433
396
        cell.set_property("width-chars", 20)
434
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
435
 
        self.date_column = Gtk.TreeViewColumn("Date")
 
397
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
398
        self.date_column = gtk.TreeViewColumn("Date")
436
399
        self.date_column.set_visible(False)
437
 
        self.date_column.set_resizable(True)
438
 
        self.date_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
 
400
        self.date_column.set_resizable(False)
 
401
        self.date_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
439
402
        self.date_column.set_fixed_width(130)
440
 
        self.date_column.pack_start(cell, True)
 
403
        self.date_column.pack_start(cell, expand=True)
441
404
        self.date_column.add_attribute(cell, "text", treemodel.TIMESTAMP)
442
405
        self.treeview.append_column(self.date_column)
443
 
 
 
406
        
444
407
        return self.treeview
445
 
 
 
408
    
446
409
    def _on_selection_changed(self, treeview):
447
410
        """callback for when the treeview changes."""
448
411
        (path, focus) = treeview.get_cursor()
449
412
        if (path is not None) and (path != self._prev_cursor_path):
450
413
            self._prev_cursor_path = path # avoid emitting twice per click
451
 
            self.path = path
 
414
            self.iter = self.model.get_iter(path)
452
415
            self.emit('revision-selected')
453
416
 
454
417
    def _on_revision_selected(self, widget, event):
455
418
        from bzrlib.plugins.gtk.revisionmenu import RevisionMenu
456
419
        if event.button == 3:
457
 
            revs = []
458
 
            rev = self.get_revision()
459
 
            if rev is not None:
460
 
                revs.append(rev.revision_id)
461
 
            menu = RevisionMenu(self.branch.repository, revs, self.branch)
 
420
            menu = RevisionMenu(self.branch.repository, 
 
421
                [self.get_revision().revision_id],
 
422
                self.branch)
462
423
            menu.connect('tag-added', lambda w, t, r: self.add_tag(t, r))
463
 
            menu.popup(None, None, None, None, event.button, event.get_time())
 
424
            menu.popup(None, None, None, event.button, event.get_time())
464
425
 
465
426
    def _on_revision_activated(self, widget, path, col):
466
427
        self.emit('revision-activated', path, col)