/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/branchwin.py

  • Committer: Tarmac
  • Author(s): Andrew Starr-Bochicchio
  • Date: 2011-02-15 00:38:36 UTC
  • mfrom: (699.2.8 panel-icon)
  • Revision ID: tarmac-20110215003836-6b9kqkx7n8xyyb4z
Allow themeable/mono icon for bzr-notify.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/branchwin.py
1
 
# -*- coding: UTF-8 -*-
2
1
"""Branch window.
3
2
 
4
3
This module contains the code to manage the branch information window,
5
4
which contains both the revision graph and details panes.
6
5
"""
7
6
 
8
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
 
7
__copyright__ = "Copyright (c) 2005 Canonical Ltd."
9
8
__author__    = "Scott James Remnant <scott@ubuntu.com>"
10
9
 
11
10
 
13
12
import gobject
14
13
import pango
15
14
 
16
 
from bzrlib.plugins.gtk.window import Window
17
15
from bzrlib.plugins.gtk import icon_path
 
16
from bzrlib.plugins.gtk.branchview import TreeView, treemodel
18
17
from bzrlib.plugins.gtk.tags import AddTagDialog
19
18
from bzrlib.plugins.gtk.preferences import PreferencesWindow
20
 
from bzrlib.plugins.gtk.branchview import TreeView, treemodel
 
19
from bzrlib.plugins.gtk.revisionmenu import RevisionMenu
 
20
from bzrlib.plugins.gtk.window import Window
 
21
 
 
22
from bzrlib.config import BranchConfig, GlobalConfig
21
23
from bzrlib.revision import Revision, NULL_REVISION
22
 
from bzrlib.config import BranchConfig
23
 
from bzrlib.config import GlobalConfig
 
24
from bzrlib.trace import mutter
24
25
 
25
26
class BranchWindow(Window):
26
27
    """Branch window.
51
52
        else:
52
53
            self.compact_view = False
53
54
 
54
 
        self.set_title(branch.nick + " - revision history")
 
55
        self.set_title(branch._get_nick(local=True) + " - revision history")
55
56
 
56
 
        # Use three-quarters of the screen by default
57
 
        screen = self.get_screen()
58
 
        monitor = screen.get_monitor_geometry(0)
59
 
        width = int(monitor.width * 0.75)
60
 
        height = int(monitor.height * 0.75)
 
57
        # user-configured window size
 
58
        size = self._load_size('viz-window-size')
 
59
        if size:
 
60
            width, height = size
 
61
        else:
 
62
            # Use three-quarters of the screen by default
 
63
            screen = self.get_screen()
 
64
            monitor = screen.get_monitor_geometry(0)
 
65
            width = int(monitor.width * 0.75)
 
66
            height = int(monitor.height * 0.75)
61
67
        self.set_default_size(width, height)
 
68
        self.set_size_request(width/3, height/3)
 
69
        self._save_size_on_destroy(self, 'viz-window-size')
62
70
 
63
71
        # FIXME AndyFitz!
64
72
        icon = self.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
71
79
        self.accel_group = gtk.AccelGroup()
72
80
        self.add_accel_group(self.accel_group)
73
81
 
74
 
        gtk.Action.set_tool_item_type(gtk.MenuToolButton)
 
82
        if getattr(gtk.Action, 'set_tool_item_type', None) is not None:
 
83
            # Not available before PyGtk-2.10
 
84
            gtk.Action.set_tool_item_type(gtk.MenuToolButton)
75
85
 
76
86
        self.prev_rev_action = gtk.Action("prev-rev", "_Previous Revision", "Go to the previous revision", gtk.STOCK_GO_DOWN)
77
87
        self.prev_rev_action.set_accel_path("<viz>/Go/Previous Revision")
93
103
 
94
104
        self.construct()
95
105
 
 
106
    def _save_size_on_destroy(self, widget, config_name):
 
107
        """Creates a hook that saves the size of widget to config option 
 
108
           config_name when the window is destroyed/closed."""
 
109
        def save_size(src):
 
110
            width, height = widget.allocation.width, widget.allocation.height
 
111
            value = '%sx%s' % (width, height)
 
112
            self.config.set_user_option(config_name, value)
 
113
        self.connect("destroy", save_size)
 
114
 
96
115
    def set_revision(self, revid):
97
116
        self.treeview.set_revision_id(revid)
98
117
 
102
121
        self.add(vbox)
103
122
 
104
123
        self.paned = gtk.VPaned()
105
 
        self.paned.pack1(self.construct_top(), resize=True, shrink=False)
106
 
        self.paned.pack2(self.construct_bottom(), resize=False, shrink=True)
 
124
        self.paned.pack1(self.construct_top(), resize=False, shrink=True)
 
125
        self.paned.pack2(self.construct_bottom(), resize=True, shrink=False)
107
126
        self.paned.show()
108
127
 
109
 
        vbox.pack_start(self.construct_menubar(), expand=False, fill=True)
110
 
        vbox.pack_start(self.construct_navigation(), expand=False, fill=True)
111
 
        
 
128
        nav = self.construct_navigation()
 
129
        menubar = self.construct_menubar()
 
130
        vbox.pack_start(menubar, expand=False, fill=True)
 
131
        vbox.pack_start(nav, expand=False, fill=True)
 
132
 
112
133
        vbox.pack_start(self.paned, expand=True, fill=True)
113
134
        vbox.set_focus_child(self.paned)
114
135
 
 
136
        self.treeview.connect('revision-selected',
 
137
                self._treeselection_changed_cb)
 
138
        self.treeview.connect('revision-activated',
 
139
                self._tree_revision_activated)
 
140
 
 
141
        self.treeview.connect('tag-added', lambda w, t, r: self._update_tags())
115
142
        vbox.show()
116
 
 
 
143
    
117
144
    def construct_menubar(self):
118
145
        menubar = gtk.MenuBar()
119
146
 
135
162
        edit_menuitem = gtk.MenuItem("_Edit")
136
163
        edit_menuitem.set_submenu(edit_menu)
137
164
 
138
 
        edit_menu_find = gtk.ImageMenuItem(gtk.STOCK_FIND)
139
 
 
140
165
        edit_menu_branchopts = gtk.MenuItem("Branch Settings")
141
166
        edit_menu_branchopts.connect('activate', lambda x: PreferencesWindow(self.branch.get_config()).show())
142
167
 
143
168
        edit_menu_globopts = gtk.MenuItem("Global Settings")
144
169
        edit_menu_globopts.connect('activate', lambda x: PreferencesWindow().show())
145
170
 
146
 
        edit_menu.add(edit_menu_find)
147
171
        edit_menu.add(edit_menu_branchopts)
148
172
        edit_menu.add(edit_menu_globopts)
149
173
 
159
183
 
160
184
        view_menu_toolbar = gtk.CheckMenuItem("Show Toolbar")
161
185
        view_menu_toolbar.set_active(True)
 
186
        if self.config.get_user_option('viz-toolbar-visible') == 'False':
 
187
            view_menu_toolbar.set_active(False)
 
188
            self.toolbar.hide()
162
189
        view_menu_toolbar.connect('toggled', self._toolbar_visibility_changed)
163
190
 
164
191
        view_menu_compact = gtk.CheckMenuItem("Show Compact Graph")
165
192
        view_menu_compact.set_active(self.compact_view)
166
193
        view_menu_compact.connect('activate', self._brokenlines_toggled_cb)
167
 
 
 
194
        
 
195
        view_menu_diffs = gtk.CheckMenuItem("Show Diffs")
 
196
        view_menu_diffs.set_active(False)
 
197
        if self.config.get_user_option('viz-show-diffs') == 'True':
 
198
            view_menu_diffs.set_active(True)
 
199
        view_menu_diffs.connect('toggled', self._diff_visibility_changed)
 
200
        
 
201
        view_menu_wide_diffs = gtk.CheckMenuItem("Wide Diffs")
 
202
        view_menu_wide_diffs.set_active(False)
 
203
        if self.config.get_user_option('viz-wide-diffs') == 'True':
 
204
            view_menu_wide_diffs.set_active(True)
 
205
        view_menu_wide_diffs.connect('toggled', self._diff_placement_changed)
 
206
        
 
207
        view_menu_wrap_diffs = gtk.CheckMenuItem("Wrap _Long Lines in Diffs")
 
208
        view_menu_wrap_diffs.set_active(False)
 
209
        if self.config.get_user_option('viz-wrap-diffs') == 'True':
 
210
            view_menu_wrap_diffs.set_active(True)
 
211
        view_menu_wrap_diffs.connect('toggled', self._diff_wrap_changed)
 
212
                
168
213
        view_menu.add(view_menu_toolbar)
169
214
        view_menu.add(view_menu_compact)
170
215
        view_menu.add(gtk.SeparatorMenuItem())
 
216
        view_menu.add(view_menu_diffs)
 
217
        view_menu.add(view_menu_wide_diffs)
 
218
        view_menu.add(view_menu_wrap_diffs)
 
219
        view_menu.add(gtk.SeparatorMenuItem())
171
220
 
172
221
        self.mnu_show_revno_column = gtk.CheckMenuItem("Show Revision _Number Column")
173
222
        self.mnu_show_date_column = gtk.CheckMenuItem("Show _Date Column")
195
244
        tag_image.set_from_file(icon_path("tag-16.png"))
196
245
        self.go_menu_tags = gtk.ImageMenuItem("_Tags")
197
246
        self.go_menu_tags.set_image(tag_image)
198
 
        self._update_tags()
 
247
        self.treeview.connect('refreshed', lambda w: self._update_tags())
199
248
 
200
249
        go_menu.add(go_menu_next)
201
250
        go_menu.add(go_menu_prev)
202
251
        go_menu.add(gtk.SeparatorMenuItem())
203
252
        go_menu.add(self.go_menu_tags)
204
253
 
205
 
        revision_menu = gtk.Menu()
 
254
        self.revision_menu = RevisionMenu(self.branch.repository, [], self.branch, parent=self)
206
255
        revision_menuitem = gtk.MenuItem("_Revision")
207
 
        revision_menuitem.set_submenu(revision_menu)
208
 
 
209
 
        revision_menu_diff = gtk.MenuItem("View Changes")
210
 
        revision_menu_diff.connect('activate', 
211
 
                self._menu_diff_cb)
212
 
        
213
 
        revision_menu_compare = gtk.MenuItem("Compare with...")
214
 
        revision_menu_compare.connect('activate',
215
 
                self._compare_with_cb)
216
 
 
217
 
        revision_menu_tag = gtk.MenuItem("Tag Revision")
218
 
        revision_menu_tag.connect('activate', self._tag_revision_cb)
219
 
 
220
 
        revision_menu.add(revision_menu_tag)
221
 
        revision_menu.add(revision_menu_diff)
222
 
        revision_menu.add(revision_menu_compare)
 
256
        revision_menuitem.set_submenu(self.revision_menu)
223
257
 
224
258
        branch_menu = gtk.Menu()
225
259
        branch_menuitem = gtk.MenuItem("_Branch")
228
262
        branch_menu.add(gtk.MenuItem("Pu_ll Revisions"))
229
263
        branch_menu.add(gtk.MenuItem("Pu_sh Revisions"))
230
264
 
 
265
        try:
 
266
            from bzrlib.plugins import search
 
267
        except ImportError:
 
268
            mutter("Didn't find search plugin")
 
269
        else:
 
270
            branch_menu.add(gtk.SeparatorMenuItem())
 
271
 
 
272
            branch_index_menuitem = gtk.MenuItem("_Index")
 
273
            branch_index_menuitem.connect('activate', self._branch_index_cb)
 
274
            branch_menu.add(branch_index_menuitem)
 
275
 
 
276
            branch_search_menuitem = gtk.MenuItem("_Search")
 
277
            branch_search_menuitem.connect('activate', self._branch_search_cb)
 
278
            branch_menu.add(branch_search_menuitem)
 
279
 
231
280
        help_menu = gtk.Menu()
232
281
        help_menuitem = gtk.MenuItem("_Help")
233
282
        help_menuitem.set_submenu(help_menu)
254
303
 
255
304
        self.treeview = TreeView(self.branch, self.start_revs, self.maxnum, self.compact_view)
256
305
 
257
 
        self.treeview.connect('revision-selected',
258
 
                self._treeselection_changed_cb)
259
 
        self.treeview.connect('revision-activated',
260
 
                self._tree_revision_activated)
261
 
 
262
 
        self.treeview.connect('tag-added', lambda w, t, r: self._update_tags())
263
 
 
264
306
        for col in ["revno", "date"]:
265
307
            option = self.config.get_user_option(col + '-column-visible')
266
308
            if option is not None:
273
315
        align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
274
316
        align.set_padding(5, 0, 0, 0)
275
317
        align.add(self.treeview)
 
318
        # user-configured size
 
319
        size = self._load_size('viz-graph-size')
 
320
        if size:
 
321
            width, height = size
 
322
            align.set_size_request(width, height)
 
323
        else:
 
324
            (width, height) = self.get_size()
 
325
            align.set_size_request(width, int(height / 2.5))
 
326
        self._save_size_on_destroy(align, 'viz-graph-size')
276
327
        align.show()
277
328
 
278
329
        return align
300
351
 
301
352
    def construct_bottom(self):
302
353
        """Construct the bottom half of the window."""
 
354
        if self.config.get_user_option('viz-wide-diffs') == 'True':
 
355
            self.diff_paned = gtk.VPaned()
 
356
        else:
 
357
            self.diff_paned = gtk.HPaned()
 
358
        (width, height) = self.get_size()
 
359
        self.diff_paned.set_size_request(20, 20) # shrinkable
 
360
 
303
361
        from bzrlib.plugins.gtk.revisionview import RevisionView
304
362
        self.revisionview = RevisionView(branch=self.branch)
305
 
        (width, height) = self.get_size()
306
 
        self.revisionview.set_size_request(width, int(height / 2.5))
 
363
        self.revisionview.set_size_request(width/3, int(height / 2.5))
 
364
        # user-configured size
 
365
        size = self._load_size('viz-revisionview-size')
 
366
        if size:
 
367
            width, height = size
 
368
            self.revisionview.set_size_request(width, height)
 
369
        self._save_size_on_destroy(self.revisionview, 'viz-revisionview-size')
307
370
        self.revisionview.show()
308
371
        self.revisionview.set_show_callback(self._show_clicked_cb)
309
372
        self.revisionview.connect('notify::revision', self._go_clicked_cb)
310
373
        self.treeview.connect('tag-added', lambda w, t, r: self.revisionview.update_tags())
311
 
        return self.revisionview
 
374
        self.diff_paned.pack1(self.revisionview)
 
375
 
 
376
        from bzrlib.plugins.gtk.diff import DiffWidget
 
377
        self.diff = DiffWidget()
 
378
        self.diff_paned.pack2(self.diff)
 
379
 
 
380
        self.diff_paned.show_all()
 
381
        if self.config.get_user_option('viz-show-diffs') != 'True':
 
382
            self.diff.hide()
 
383
 
 
384
        return self.diff_paned
312
385
 
313
386
    def _tag_selected_cb(self, menuitem, revid):
314
387
        self.treeview.set_revision_id(revid)
319
392
        parents  = self.treeview.get_parents()
320
393
        children = self.treeview.get_children()
321
394
 
 
395
        self.revision_menu.set_revision_ids([revision.revision_id])
 
396
 
322
397
        if revision and revision != NULL_REVISION:
323
398
            prev_menu = gtk.Menu()
324
399
            if len(parents) > 0:
339
414
                self.prev_rev_action.set_sensitive(False)
340
415
                prev_menu.hide()
341
416
 
342
 
            self.prev_button.set_menu(prev_menu)
 
417
            if getattr(self.prev_button, 'set_menu', None) is not None:
 
418
                self.prev_button.set_menu(prev_menu)
343
419
 
344
420
            next_menu = gtk.Menu()
345
421
            if len(children) > 0:
359
435
                self.next_rev_action.set_sensitive(False)
360
436
                next_menu.hide()
361
437
 
362
 
            self.next_button.set_menu(next_menu)
 
438
            if getattr(self.next_button, 'set_menu', None) is not None:
 
439
                self.next_button.set_menu(next_menu)
363
440
 
364
441
            self.revisionview.set_revision(revision)
365
442
            self.revisionview.set_children(children)
366
 
    
 
443
            self.update_diff_panel(revision, parents)
 
444
 
367
445
    def _tree_revision_activated(self, widget, path, col):
368
446
        # TODO: more than one parent
369
447
        """Callback for when a treeview row gets activated."""
371
449
        parents  = self.treeview.get_parents()
372
450
 
373
451
        if len(parents) == 0:
374
 
            parent_id = None
 
452
            parent_id = NULL_REVISION
375
453
        else:
376
454
            parent_id = parents[0]
377
455
 
378
456
        self.show_diff(revision.revision_id, parent_id)
379
457
        self.treeview.grab_focus()
380
458
        
381
 
    def _menu_diff_cb(self,w):
382
 
        (path, focus) = self.treeview.treeview.get_cursor()
383
 
        revid = self.treeview.model[path][treemodel.REVID]
384
 
        
385
 
        parentids = self.branch.repository.revision_parents(revid)
386
 
 
387
 
        if len(parentids) == 0:
388
 
            parentid = NULL_REVISION
389
 
        else:
390
 
            parentid = parentids[0]
391
 
        
392
 
        self.show_diff(revid,parentid)    
393
 
 
394
459
    def _back_clicked_cb(self, *args):
395
460
        """Callback for when the back button is clicked."""
396
461
        self.treeview.back()
409
474
        self.show_diff(revid, parentid)
410
475
        self.treeview.grab_focus()
411
476
 
412
 
    def _compare_with_cb(self,w):
413
 
        """Callback for revision 'compare with' menu. Will show a small
414
 
            dialog with branch revisions to compare with selected revision in TreeView"""
415
 
        
416
 
        from bzrlib.plugins.gtk.revbrowser import RevisionBrowser
417
 
        
418
 
        rb = RevisionBrowser(self.branch,self)
419
 
        ret = rb.run()
420
 
        
421
 
        if ret == gtk.RESPONSE_OK:          
422
 
            (path, focus) = self.treeview.treeview.get_cursor()
423
 
            revid = self.treeview.model[path][treemodel.REVID]
424
 
            self.show_diff(revid, rb.selected_revid)
425
 
            
426
 
        rb.destroy()
427
 
            
428
477
    def _set_revision_cb(self, w, revision_id):
429
478
        self.treeview.set_revision_id(revision_id)
430
479
 
440
489
        self.treeview.set_property('compact', self.compact_view)
441
490
        self.treeview.refresh()
442
491
 
443
 
    def _tag_revision_cb(self, w):
 
492
    def _branch_index_cb(self, w):
 
493
        from bzrlib.plugins.search import index as _mod_index
 
494
        _mod_index.index_url(self.branch.base)
 
495
 
 
496
    def _branch_search_cb(self, w):
 
497
        from bzrlib.plugins.search import index as _mod_index
 
498
        from bzrlib.plugins.gtk.search import SearchDialog
 
499
        from bzrlib.plugins.search import errors as search_errors
 
500
 
444
501
        try:
445
 
            self.treeview.set_sensitive(False)
446
 
            dialog = AddTagDialog(self.branch.repository, self.treeview.get_revision().revision_id, self.branch)
447
 
            response = dialog.run()
448
 
            if response != gtk.RESPONSE_NONE:
449
 
                dialog.hide()
450
 
            
451
 
                if response == gtk.RESPONSE_OK:
452
 
                    self.treeview.add_tag(dialog.tagname, dialog._revid)
453
 
                
454
 
                dialog.destroy()
455
 
 
456
 
        finally:
457
 
            self.treeview.set_sensitive(True)
 
502
            index = _mod_index.open_index_url(self.branch.base)
 
503
        except search_errors.NoSearchIndex:
 
504
            dialog = gtk.MessageDialog(self, type=gtk.MESSAGE_QUESTION, 
 
505
                buttons=gtk.BUTTONS_OK_CANCEL, 
 
506
                message_format="This branch has not been indexed yet. "
 
507
                               "Index now?")
 
508
            if dialog.run() == gtk.RESPONSE_OK:
 
509
                dialog.destroy()
 
510
                index = _mod_index.index_url(self.branch.base)
 
511
            else:
 
512
                dialog.destroy()
 
513
                return
 
514
 
 
515
        dialog = SearchDialog(index)
 
516
        
 
517
        if dialog.run() == gtk.RESPONSE_OK:
 
518
            self.set_revision(dialog.get_revision())
 
519
 
 
520
        dialog.destroy()
458
521
 
459
522
    def _about_dialog_cb(self, w):
460
523
        from bzrlib.plugins.gtk.about import AboutDialog
467
530
 
468
531
    def _toolbar_visibility_changed(self, col):
469
532
        if col.get_active():
470
 
            self.toolbar.show() 
 
533
            self.toolbar.show()
471
534
        else:
472
535
            self.toolbar.hide()
473
 
 
 
536
        self.config.set_user_option('viz-toolbar-visible', col.get_active())
 
537
 
 
538
    def _make_diff_nonzero_size(self):
 
539
        """make sure the diff isn't zero-width or zero-height"""
 
540
        alloc = self.diff.get_allocation()
 
541
        if (alloc.width < 10) or (alloc.height < 10):
 
542
            width, height = self.get_size()
 
543
            self.revisionview.set_size_request(width/3, int(height / 2.5))
 
544
 
 
545
    def _diff_visibility_changed(self, col):
 
546
        """Hide or show the diff panel."""
 
547
        if col.get_active():
 
548
            self.diff.show()
 
549
            self._make_diff_nonzero_size()
 
550
        else:
 
551
            self.diff.hide()
 
552
        self.config.set_user_option('viz-show-diffs', str(col.get_active()))
 
553
        self.update_diff_panel()
 
554
 
 
555
    def _diff_placement_changed(self, col):
 
556
        """Toggle the diff panel's position."""
 
557
        self.config.set_user_option('viz-wide-diffs', str(col.get_active()))
 
558
 
 
559
        old = self.paned.get_child2()
 
560
        self.paned.remove(old)
 
561
        self.paned.pack2(self.construct_bottom(), resize=True, shrink=False)
 
562
        self._make_diff_nonzero_size()
 
563
 
 
564
        self.treeview.emit('revision-selected')
 
565
    
 
566
    def _diff_wrap_changed(self, widget):
 
567
        """Toggle word wrap in the diff widget."""
 
568
        self.config.set_user_option('viz-wrap-diffs', widget.get_active())
 
569
        self.diff._on_wraplines_toggled(widget)
 
570
    
474
571
    def _show_about_cb(self, w):
475
572
        dialog = AboutDialog()
476
573
        dialog.connect('response', lambda d,r: d.destroy())
484
581
 
485
582
        if self.branch.supports_tags():
486
583
            tags = self.branch.tags.get_tag_dict().items()
487
 
            tags.sort()
488
 
            tags.reverse()
 
584
            tags.sort(reverse=True)
489
585
            for tag, revid in tags:
490
586
                tag_image = gtk.Image()
491
587
                tag_image.set_from_file(icon_path('tag-16.png'))
492
588
                tag_item = gtk.ImageMenuItem(tag.replace('_', '__'))
493
589
                tag_item.set_image(tag_image)
494
590
                tag_item.connect('activate', self._tag_selected_cb, revid)
 
591
                tag_item.set_sensitive(self.treeview.has_revision_id(revid))
495
592
                menu.add(tag_item)
496
593
            self.go_menu_tags.set_submenu(menu)
497
594
 
501
598
 
502
599
        self.go_menu_tags.show_all()
503
600
 
504
 
    def show_diff(self, revid=None, parentid=None):
 
601
    def _load_size(self, name):
 
602
        """Read and parse 'name' from self.config.
 
603
        The value is a string, formatted as WIDTHxHEIGHT
 
604
        Returns None, or (width, height)
 
605
        """
 
606
        size = self.config.get_user_option(name)
 
607
        if size:
 
608
            width, height = [int(num) for num in size.split('x')]
 
609
            # avoid writing config every time we start
 
610
            return width, height
 
611
        return None
 
612
 
 
613
    def show_diff(self, revid=None, parentid=NULL_REVISION):
505
614
        """Open a new window to show a diff between the given revisions."""
506
615
        from bzrlib.plugins.gtk.diff import DiffWindow
507
616
        window = DiffWindow(parent=self)
508
617
 
509
 
        if parentid is None:
510
 
            parentid = NULL_REVISION
511
 
 
512
618
        rev_tree    = self.branch.repository.revision_tree(revid)
513
619
        parent_tree = self.branch.repository.revision_tree(parentid)
514
620
 
515
 
        description = revid + " - " + self.branch.nick
 
621
        description = revid + " - " + self.branch._get_nick(local=True)
516
622
        window.set_diff(description, rev_tree, parent_tree)
517
623
        window.show()
518
624
 
519
 
 
 
625
    def update_diff_panel(self, revision=None, parents=None):
 
626
        """Show the current revision in the diff panel."""
 
627
        if self.config.get_user_option('viz-show-diffs') != 'True':
 
628
            return
 
629
 
 
630
        if not revision: # default to selected row
 
631
            revision = self.treeview.get_revision()
 
632
        if revision == NULL_REVISION:
 
633
            return
 
634
 
 
635
        if not parents: # default to selected row's parents
 
636
            parents  = self.treeview.get_parents()
 
637
        if len(parents) == 0:
 
638
            parent_id = NULL_REVISION
 
639
        else:
 
640
            parent_id = parents[0]
 
641
 
 
642
        rev_tree    = self.branch.repository.revision_tree(revision.revision_id)
 
643
        parent_tree = self.branch.repository.revision_tree(parent_id)
 
644
 
 
645
        self.diff.set_diff(rev_tree, parent_tree)
 
646
        if self.config.get_user_option('viz-wrap-diffs') == 'True':
 
647
            self.diff._on_wraplines_toggled(wrap=True)
 
648
        self.diff.show_all()