/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: Jelmer Vernooij
  • Date: 2011-04-10 18:44:39 UTC
  • mto: This revision was merged to the branch mainline in revision 730.
  • Revision ID: jelmer@samba.org-20110410184439-g7hqaacexqtviq13
Move i18n support to a separate file, so gettext files aren't loaded unless bzr-gtk is used.

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