/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: 2012-03-29 13:15:14 UTC
  • mfrom: (786.1.1 register-lazy)
  • Revision ID: jelmer@samba.org-20120329131514-knrl1w2wzntx89rv
Use lazy registration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/branchwin.py
8
8
__author__    = "Scott James Remnant <scott@ubuntu.com>"
9
9
 
10
10
 
11
 
import gtk
 
11
from gi.repository import Gdk
 
12
from gi.repository import Gtk
12
13
 
13
14
from bzrlib.plugins.gtk import icon_path
14
15
from bzrlib.plugins.gtk.branchview import TreeView
20
21
from bzrlib.revision import NULL_REVISION
21
22
from bzrlib.trace import mutter
22
23
 
 
24
 
23
25
class BranchWindow(Window):
24
26
    """Branch window.
25
27
 
36
38
                       None for no limit.
37
39
        """
38
40
 
39
 
        Window.__init__(self, parent=parent)
 
41
        super(BranchWindow, self).__init__(parent=parent)
40
42
        self.set_border_width(0)
41
43
 
42
44
        self.branch      = branch
66
68
        self._save_size_on_destroy(self, 'viz-window-size')
67
69
 
68
70
        # FIXME AndyFitz!
69
 
        icon = self.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
 
71
        icon = self.render_icon_pixbuf(Gtk.STOCK_INDEX, Gtk.IconSize.BUTTON)
70
72
        self.set_icon(icon)
71
73
 
72
 
        gtk.accel_map_add_entry("<viz>/Go/Next Revision", gtk.keysyms.Up, gtk.gdk.MOD1_MASK)
73
 
        gtk.accel_map_add_entry("<viz>/Go/Previous Revision", gtk.keysyms.Down, gtk.gdk.MOD1_MASK)
74
 
        gtk.accel_map_add_entry("<viz>/View/Refresh", gtk.keysyms.F5, 0)
 
74
        Gtk.AccelMap.add_entry("<viz>/Go/Next Revision", Gdk.KEY_Up, Gdk.ModifierType.MOD1_MASK)
 
75
        Gtk.AccelMap.add_entry("<viz>/Go/Previous Revision", Gdk.KEY_Down, Gdk.ModifierType.MOD1_MASK)
 
76
        Gtk.AccelMap.add_entry("<viz>/View/Refresh", Gdk.KEY_F5, 0)
75
77
 
76
 
        self.accel_group = gtk.AccelGroup()
 
78
        self.accel_group = Gtk.AccelGroup()
77
79
        self.add_accel_group(self.accel_group)
78
80
 
79
 
        if getattr(gtk.Action, 'set_tool_item_type', None) is not None:
80
 
            # Not available before PyGtk-2.10
81
 
            gtk.Action.set_tool_item_type(gtk.MenuToolButton)
82
 
 
83
 
        self.prev_rev_action = gtk.Action("prev-rev", "_Previous Revision", "Go to the previous revision", gtk.STOCK_GO_DOWN)
 
81
        self.prev_rev_action = Gtk.Action("prev-rev", "_Previous Revision", "Go to the previous revision", Gtk.STOCK_GO_DOWN)
84
82
        self.prev_rev_action.set_accel_path("<viz>/Go/Previous Revision")
85
83
        self.prev_rev_action.set_accel_group(self.accel_group)
86
84
        self.prev_rev_action.connect("activate", self._back_clicked_cb)
87
85
        self.prev_rev_action.connect_accelerator()
88
86
 
89
 
        self.next_rev_action = gtk.Action("next-rev", "_Next Revision", "Go to the next revision", gtk.STOCK_GO_UP)
 
87
        self.next_rev_action = Gtk.Action("next-rev", "_Next Revision", "Go to the next revision", Gtk.STOCK_GO_UP)
90
88
        self.next_rev_action.set_accel_path("<viz>/Go/Next Revision")
91
89
        self.next_rev_action.set_accel_group(self.accel_group)
92
90
        self.next_rev_action.connect("activate", self._fwd_clicked_cb)
93
91
        self.next_rev_action.connect_accelerator()
94
92
 
95
 
        self.refresh_action = gtk.Action("refresh", "_Refresh", "Refresh view", gtk.STOCK_REFRESH)
 
93
        self.refresh_action = Gtk.Action("refresh", "_Refresh", "Refresh view", Gtk.STOCK_REFRESH)
96
94
        self.refresh_action.set_accel_path("<viz>/View/Refresh")
97
95
        self.refresh_action.set_accel_group(self.accel_group)
98
96
        self.refresh_action.connect("activate", self._refresh_clicked)
99
97
        self.refresh_action.connect_accelerator()
100
98
 
101
 
        self.construct()
 
99
        self.vbox = self.construct()
102
100
 
103
101
    def _save_size_on_destroy(self, widget, config_name):
104
102
        """Creates a hook that saves the size of widget to config option 
105
103
           config_name when the window is destroyed/closed."""
106
104
        def save_size(src):
107
 
            width, height = widget.allocation.width, widget.allocation.height
 
105
            allocation = widget.get_allocation()
 
106
            width, height = allocation.width, allocation.height
108
107
            value = '%sx%s' % (width, height)
109
108
            self.config.set_user_option(config_name, value)
110
109
        self.connect("destroy", save_size)
114
113
 
115
114
    def construct(self):
116
115
        """Construct the window contents."""
117
 
        vbox = gtk.VBox(spacing=0)
 
116
        vbox = Gtk.VBox(spacing=0)
118
117
        self.add(vbox)
119
118
 
120
 
        self.paned = gtk.VPaned()
121
 
        self.paned.pack1(self.construct_top(), resize=False, shrink=True)
122
 
        self.paned.pack2(self.construct_bottom(), resize=True, shrink=False)
123
 
        self.paned.show()
124
 
 
 
119
        # order is important here
 
120
        paned = self.construct_paned()
125
121
        nav = self.construct_navigation()
126
122
        menubar = self.construct_menubar()
127
 
        vbox.pack_start(menubar, expand=False, fill=True)
128
 
        vbox.pack_start(nav, expand=False, fill=True)
129
 
 
130
 
        vbox.pack_start(self.paned, expand=True, fill=True)
131
 
        vbox.set_focus_child(self.paned)
132
 
 
133
 
        self.treeview.connect('revision-selected',
134
 
                self._treeselection_changed_cb)
135
 
        self.treeview.connect('revision-activated',
136
 
                self._tree_revision_activated)
137
 
 
138
 
        self.treeview.connect('tag-added', lambda w, t, r: self._update_tags())
 
123
 
 
124
        vbox.pack_start(menubar, False, True, 0)
 
125
        vbox.pack_start(nav, False, True, 0)
 
126
        vbox.pack_start(paned, True, True, 0)
 
127
        vbox.set_focus_child(paned)
 
128
 
 
129
 
139
130
        vbox.show()
140
131
 
 
132
        return vbox
 
133
 
 
134
    def construct_paned(self):
 
135
        """Construct the main HPaned/VPaned contents."""
 
136
        if self.config.get_user_option('viz-vertical') == 'True':
 
137
            self.paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
 
138
        else:
 
139
            self.paned = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
 
140
 
 
141
        self.paned.pack1(self.construct_top(), resize=False, shrink=True)
 
142
        self.paned.pack2(self.construct_bottom(), resize=True, shrink=False)
 
143
        self.paned.show()
 
144
 
 
145
        return self.paned
 
146
 
141
147
    def construct_menubar(self):
142
 
        menubar = gtk.MenuBar()
 
148
        menubar = Gtk.MenuBar()
143
149
 
144
 
        file_menu = gtk.Menu()
145
 
        file_menuitem = gtk.MenuItem("_File")
 
150
        file_menu = Gtk.Menu()
 
151
        file_menuitem = Gtk.MenuItem.new_with_mnemonic("_File")
146
152
        file_menuitem.set_submenu(file_menu)
147
153
 
148
 
        file_menu_close = gtk.ImageMenuItem(gtk.STOCK_CLOSE, self.accel_group)
 
154
        file_menu_close = Gtk.ImageMenuItem.new_from_stock(
 
155
            Gtk.STOCK_CLOSE, self.accel_group)
149
156
        file_menu_close.connect('activate', lambda x: self.destroy())
150
157
 
151
 
        file_menu_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, self.accel_group)
152
 
        file_menu_quit.connect('activate', lambda x: gtk.main_quit())
 
158
        file_menu_quit = Gtk.ImageMenuItem.new_from_stock(
 
159
            Gtk.STOCK_QUIT, self.accel_group)
 
160
        file_menu_quit.connect('activate', lambda x: Gtk.main_quit())
153
161
 
154
162
        if self._parent is not None:
155
163
            file_menu.add(file_menu_close)
156
164
        file_menu.add(file_menu_quit)
157
165
 
158
 
        edit_menu = gtk.Menu()
159
 
        edit_menuitem = gtk.MenuItem("_Edit")
 
166
        edit_menu = Gtk.Menu()
 
167
        edit_menuitem = Gtk.MenuItem.new_with_mnemonic("_Edit")
160
168
        edit_menuitem.set_submenu(edit_menu)
161
169
 
162
 
        edit_menu_branchopts = gtk.MenuItem("Branch Settings")
 
170
        edit_menu_branchopts = Gtk.MenuItem(label="Branch Settings")
163
171
        edit_menu_branchopts.connect('activate', lambda x: PreferencesWindow(self.branch.get_config()).show())
164
172
 
165
 
        edit_menu_globopts = gtk.MenuItem("Global Settings")
 
173
        edit_menu_globopts = Gtk.MenuItem(label="Global Settings")
166
174
        edit_menu_globopts.connect('activate', lambda x: PreferencesWindow().show())
167
175
 
168
176
        edit_menu.add(edit_menu_branchopts)
169
177
        edit_menu.add(edit_menu_globopts)
170
178
 
171
 
        view_menu = gtk.Menu()
172
 
        view_menuitem = gtk.MenuItem("_View")
 
179
        view_menu = Gtk.Menu()
 
180
        view_menuitem = Gtk.MenuItem.new_with_mnemonic("_View")
173
181
        view_menuitem.set_submenu(view_menu)
174
182
 
175
183
        view_menu_refresh = self.refresh_action.create_menu_item()
176
184
        view_menu_refresh.connect('activate', self._refresh_clicked)
177
185
 
178
186
        view_menu.add(view_menu_refresh)
179
 
        view_menu.add(gtk.SeparatorMenuItem())
 
187
        view_menu.add(Gtk.SeparatorMenuItem())
180
188
 
181
 
        view_menu_toolbar = gtk.CheckMenuItem("Show Toolbar")
 
189
        view_menu_toolbar = Gtk.CheckMenuItem(label="Show Toolbar")
182
190
        view_menu_toolbar.set_active(True)
183
191
        if self.config.get_user_option('viz-toolbar-visible') == 'False':
184
192
            view_menu_toolbar.set_active(False)
185
193
            self.toolbar.hide()
186
194
        view_menu_toolbar.connect('toggled', self._toolbar_visibility_changed)
187
195
 
188
 
        view_menu_compact = gtk.CheckMenuItem("Show Compact Graph")
 
196
        view_menu_compact = Gtk.CheckMenuItem(label="Show Compact Graph")
189
197
        view_menu_compact.set_active(self.compact_view)
190
198
        view_menu_compact.connect('activate', self._brokenlines_toggled_cb)
191
199
 
192
 
        view_menu_diffs = gtk.CheckMenuItem("Show Diffs")
 
200
        view_menu_vertical = Gtk.CheckMenuItem(label="Side-by-side Layout")
 
201
        view_menu_vertical.set_active(False)
 
202
        if self.config.get_user_option('viz-vertical') == 'True':
 
203
            view_menu_vertical.set_active(True)
 
204
        view_menu_vertical.connect('toggled', self._vertical_layout)
 
205
 
 
206
        view_menu_diffs = Gtk.CheckMenuItem(label="Show Diffs")
193
207
        view_menu_diffs.set_active(False)
194
208
        if self.config.get_user_option('viz-show-diffs') == 'True':
195
209
            view_menu_diffs.set_active(True)
196
210
        view_menu_diffs.connect('toggled', self._diff_visibility_changed)
197
211
 
198
 
        view_menu_wide_diffs = gtk.CheckMenuItem("Wide Diffs")
 
212
        view_menu_wide_diffs = Gtk.CheckMenuItem(label="Wide Diffs")
199
213
        view_menu_wide_diffs.set_active(False)
200
214
        if self.config.get_user_option('viz-wide-diffs') == 'True':
201
215
            view_menu_wide_diffs.set_active(True)
202
216
        view_menu_wide_diffs.connect('toggled', self._diff_placement_changed)
203
217
 
204
 
        view_menu_wrap_diffs = gtk.CheckMenuItem("Wrap _Long Lines in Diffs")
 
218
        view_menu_wrap_diffs = Gtk.CheckMenuItem.new_with_mnemonic(
 
219
            "Wrap _Long Lines in Diffs")
205
220
        view_menu_wrap_diffs.set_active(False)
206
221
        if self.config.get_user_option('viz-wrap-diffs') == 'True':
207
222
            view_menu_wrap_diffs.set_active(True)
209
224
 
210
225
        view_menu.add(view_menu_toolbar)
211
226
        view_menu.add(view_menu_compact)
212
 
        view_menu.add(gtk.SeparatorMenuItem())
 
227
        view_menu.add(view_menu_vertical)
 
228
        view_menu.add(Gtk.SeparatorMenuItem())
213
229
        view_menu.add(view_menu_diffs)
214
230
        view_menu.add(view_menu_wide_diffs)
215
231
        view_menu.add(view_menu_wrap_diffs)
216
 
        view_menu.add(gtk.SeparatorMenuItem())
 
232
        view_menu.add(Gtk.SeparatorMenuItem())
217
233
 
218
 
        self.mnu_show_revno_column = gtk.CheckMenuItem("Show Revision _Number Column")
219
 
        self.mnu_show_date_column = gtk.CheckMenuItem("Show _Date Column")
 
234
        self.mnu_show_revno_column = Gtk.CheckMenuItem.new_with_mnemonic(
 
235
            "Show Revision _Number Column")
 
236
        self.mnu_show_date_column = Gtk.CheckMenuItem.new_with_mnemonic(
 
237
            "Show _Date Column")
220
238
 
221
239
        # Revision numbers are pointless if there are multiple branches
222
240
        if len(self.start_revs) > 1:
229
247
            col.connect('toggled', self._col_visibility_changed, name)
230
248
            view_menu.add(col)
231
249
 
232
 
        go_menu = gtk.Menu()
 
250
        go_menu = Gtk.Menu()
233
251
        go_menu.set_accel_group(self.accel_group)
234
 
        go_menuitem = gtk.MenuItem("_Go")
 
252
        go_menuitem = Gtk.MenuItem.new_with_mnemonic("_Go")
235
253
        go_menuitem.set_submenu(go_menu)
236
254
 
237
255
        go_menu_next = self.next_rev_action.create_menu_item()
238
256
        go_menu_prev = self.prev_rev_action.create_menu_item()
239
257
 
240
 
        tag_image = gtk.Image()
 
258
        tag_image = Gtk.Image()
241
259
        tag_image.set_from_file(icon_path("tag-16.png"))
242
 
        self.go_menu_tags = gtk.ImageMenuItem("_Tags")
 
260
        self.go_menu_tags = Gtk.ImageMenuItem.new_with_mnemonic("_Tags")
243
261
        self.go_menu_tags.set_image(tag_image)
244
262
        self.treeview.connect('refreshed', lambda w: self._update_tags())
245
263
 
246
264
        go_menu.add(go_menu_next)
247
265
        go_menu.add(go_menu_prev)
248
 
        go_menu.add(gtk.SeparatorMenuItem())
 
266
        go_menu.add(Gtk.SeparatorMenuItem())
249
267
        go_menu.add(self.go_menu_tags)
250
268
 
251
 
        self.revision_menu = RevisionMenu(self.branch.repository, [], self.branch, parent=self)
252
 
        revision_menuitem = gtk.MenuItem("_Revision")
 
269
        self.revision_menu = RevisionMenu(self.branch.repository, [],
 
270
            self.branch, parent=self)
 
271
        revision_menuitem = Gtk.MenuItem.new_with_mnemonic("_Revision")
253
272
        revision_menuitem.set_submenu(self.revision_menu)
254
273
 
255
 
        branch_menu = gtk.Menu()
256
 
        branch_menuitem = gtk.MenuItem("_Branch")
 
274
        branch_menu = Gtk.Menu()
 
275
        branch_menuitem = Gtk.MenuItem.new_with_mnemonic("_Branch")
257
276
        branch_menuitem.set_submenu(branch_menu)
258
277
 
259
 
        branch_menu.add(gtk.MenuItem("Pu_ll Revisions"))
260
 
        branch_menu.add(gtk.MenuItem("Pu_sh Revisions"))
 
278
        branch_menu.add(Gtk.MenuItem.new_with_mnemonic("Pu_ll Revisions"))
 
279
        branch_menu.add(Gtk.MenuItem.new_with_mnemonic("Pu_sh Revisions"))
261
280
 
262
281
        try:
263
282
            from bzrlib.plugins import search
264
283
        except ImportError:
265
284
            mutter("Didn't find search plugin")
266
285
        else:
267
 
            branch_menu.add(gtk.SeparatorMenuItem())
 
286
            branch_menu.add(Gtk.SeparatorMenuItem())
268
287
 
269
 
            branch_index_menuitem = gtk.MenuItem("_Index")
 
288
            branch_index_menuitem = Gtk.MenuItem.new_with_mnemonic("_Index")
270
289
            branch_index_menuitem.connect('activate', self._branch_index_cb)
271
290
            branch_menu.add(branch_index_menuitem)
272
291
 
273
 
            branch_search_menuitem = gtk.MenuItem("_Search")
 
292
            branch_search_menuitem = Gtk.MenuItem.new_with_mnemonic("_Search")
274
293
            branch_search_menuitem.connect('activate', self._branch_search_cb)
275
294
            branch_menu.add(branch_search_menuitem)
276
295
 
277
 
        help_menu = gtk.Menu()
278
 
        help_menuitem = gtk.MenuItem("_Help")
 
296
        help_menu = Gtk.Menu()
 
297
        help_menuitem = Gtk.MenuItem.new_with_mnemonic("_Help")
279
298
        help_menuitem.set_submenu(help_menu)
280
299
 
281
 
        help_about_menuitem = gtk.ImageMenuItem(gtk.STOCK_ABOUT, self.accel_group)
 
300
        help_about_menuitem = Gtk.ImageMenuItem.new_from_stock(
 
301
            Gtk.STOCK_ABOUT, self.accel_group)
282
302
        help_about_menuitem.connect('activate', self._about_dialog_cb)
283
303
 
284
304
        help_menu.add(help_about_menuitem)
298
318
        """Construct the top-half of the window."""
299
319
        # FIXME: Make broken_line_length configurable
300
320
 
301
 
        self.treeview = TreeView(self.branch, self.start_revs, self.maxnum, self.compact_view)
 
321
        self.treeview = TreeView(self.branch, self.start_revs, self.maxnum,
 
322
            self.compact_view)
302
323
 
303
324
        for col in ["revno", "date"]:
304
325
            option = self.config.get_user_option(col + '-column-visible')
305
326
            if option is not None:
306
 
                self.treeview.set_property(col + '-column-visible', option == 'True')
 
327
                self.treeview.set_property(col + '-column-visible',
 
328
                    option == 'True')
307
329
            else:
308
330
                self.treeview.set_property(col + '-column-visible', False)
309
331
 
310
332
        self.treeview.show()
311
333
 
312
 
        align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
 
334
        align = Gtk.Alignment.new(0.0, 0.0, 1.0, 1.0)
313
335
        align.set_padding(5, 0, 0, 0)
314
336
        align.add(self.treeview)
315
337
        # user-configured size
327
349
 
328
350
    def construct_navigation(self):
329
351
        """Construct the navigation buttons."""
330
 
        self.toolbar = gtk.Toolbar()
331
 
        self.toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
 
352
        self.toolbar = Gtk.Toolbar()
 
353
        self.toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
332
354
 
333
355
        self.prev_button = self.prev_rev_action.create_tool_item()
334
356
        self.toolbar.insert(self.prev_button, -1)
336
358
        self.next_button = self.next_rev_action.create_tool_item()
337
359
        self.toolbar.insert(self.next_button, -1)
338
360
 
339
 
        self.toolbar.insert(gtk.SeparatorToolItem(), -1)
 
361
        self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
340
362
 
341
 
        refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
 
363
        refresh_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_REFRESH)
342
364
        refresh_button.connect('clicked', self._refresh_clicked)
343
365
        self.toolbar.insert(refresh_button, -1)
344
366
 
349
371
    def construct_bottom(self):
350
372
        """Construct the bottom half of the window."""
351
373
        if self.config.get_user_option('viz-wide-diffs') == 'True':
352
 
            self.diff_paned = gtk.VPaned()
 
374
            self.diff_paned = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
353
375
        else:
354
 
            self.diff_paned = gtk.HPaned()
 
376
            self.diff_paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
355
377
        (width, height) = self.get_size()
356
378
        self.diff_paned.set_size_request(20, 20) # shrinkable
357
379
 
367
389
        self.revisionview.show()
368
390
        self.revisionview.set_show_callback(self._show_clicked_cb)
369
391
        self.revisionview.connect('notify::revision', self._go_clicked_cb)
370
 
        self.treeview.connect('tag-added', lambda w, t, r: self.revisionview.update_tags())
 
392
        self.treeview.connect('tag-added',
 
393
            lambda w, t, r: self.revisionview.update_tags())
 
394
        self.treeview.connect('revision-selected',
 
395
                self._treeselection_changed_cb)
 
396
        self.treeview.connect('revision-activated',
 
397
                self._tree_revision_activated)
371
398
        self.diff_paned.pack1(self.revisionview)
372
399
 
373
400
        from bzrlib.plugins.gtk.diff import DiffWidget
389
416
        parents  = self.treeview.get_parents()
390
417
        children = self.treeview.get_children()
391
418
 
392
 
        self.revision_menu.set_revision_ids([revision.revision_id])
393
 
 
394
 
        if revision and revision != NULL_REVISION:
395
 
            prev_menu = gtk.Menu()
 
419
        if revision and revision.revision_id != NULL_REVISION:
 
420
            self.revision_menu.set_revision_ids([revision.revision_id])
 
421
            prev_menu = Gtk.Menu()
396
422
            if len(parents) > 0:
397
423
                self.prev_rev_action.set_sensitive(True)
398
424
                for parent_id in parents:
399
425
                    if parent_id and parent_id != NULL_REVISION:
400
426
                        parent = self.branch.repository.get_revision(parent_id)
401
427
                        try:
402
 
                            str = ' (' + parent.properties['branch-nick'] + ')'
 
428
                            str = ' (%s)' % parent.properties['branch-nick']
403
429
                        except KeyError:
404
430
                            str = ""
405
431
 
406
 
                        item = gtk.MenuItem(parent.message.split("\n")[0] + str)
 
432
                        item = Gtk.MenuItem(
 
433
                            label=parent.message.split("\n")[0] + str)
407
434
                        item.connect('activate', self._set_revision_cb, parent_id)
408
435
                        prev_menu.add(item)
409
436
                prev_menu.show_all()
412
439
                prev_menu.hide()
413
440
 
414
441
            if getattr(self.prev_button, 'set_menu', None) is not None:
415
 
                self.prev_button.set_menu(prev_menu)
 
442
                self.prev_button.set_menu(prev_menu)
416
443
 
417
 
            next_menu = gtk.Menu()
 
444
            next_menu = Gtk.Menu()
418
445
            if len(children) > 0:
419
446
                self.next_rev_action.set_sensitive(True)
420
447
                for child_id in children:
421
448
                    child = self.branch.repository.get_revision(child_id)
422
449
                    try:
423
 
                        str = ' (' + child.properties['branch-nick'] + ')'
 
450
                        str = ' (%s)' % child.properties['branch-nick']
424
451
                    except KeyError:
425
452
                        str = ""
426
453
 
427
 
                    item = gtk.MenuItem(child.message.split("\n")[0] + str)
 
454
                    item = Gtk.MenuItem(
 
455
                        label=child.message.split("\n")[0] + str)
428
456
                    item.connect('activate', self._set_revision_cb, child_id)
429
457
                    next_menu.add(item)
430
458
                next_menu.show_all()
433
461
                next_menu.hide()
434
462
 
435
463
            if getattr(self.next_button, 'set_menu', None) is not None:
436
 
                self.next_button.set_menu(next_menu)
 
464
                self.next_button.set_menu(next_menu)
437
465
 
438
466
            self.revisionview.set_revision(revision)
439
467
            self.revisionview.set_children(children)
450
478
        else:
451
479
            parent_id = parents[0]
452
480
 
453
 
        self.show_diff(revision.revision_id, parent_id)
 
481
        if revision is not None:
 
482
            self.show_diff(revision.revision_id, parent_id)
 
483
        else:
 
484
            self.show_diff(NULL_REVISION)
454
485
        self.treeview.grab_focus()
455
486
 
456
487
    def _back_clicked_cb(self, *args):
491
522
        _mod_index.index_url(self.branch.base)
492
523
 
493
524
    def _branch_search_cb(self, w):
494
 
        from bzrlib.plugins.search import index as _mod_index
 
525
        from bzrlib.plugins.search import (
 
526
            index as _mod_index,
 
527
            errors as search_errors,
 
528
            )
495
529
        from bzrlib.plugins.gtk.search import SearchDialog
496
 
        from bzrlib.plugins.search import errors as search_errors
497
530
 
498
531
        try:
499
532
            index = _mod_index.open_index_url(self.branch.base)
500
533
        except search_errors.NoSearchIndex:
501
 
            dialog = gtk.MessageDialog(self, type=gtk.MESSAGE_QUESTION, 
502
 
                buttons=gtk.BUTTONS_OK_CANCEL, 
 
534
            dialog = Gtk.MessageDialog(self, type=Gtk.MessageType.QUESTION, 
 
535
                buttons=Gtk.ButtonsType.OK_CANCEL, 
503
536
                message_format="This branch has not been indexed yet. "
504
537
                               "Index now?")
505
 
            if dialog.run() == gtk.RESPONSE_OK:
 
538
            if dialog.run() == Gtk.ResponseType.OK:
506
539
                dialog.destroy()
507
540
                index = _mod_index.index_url(self.branch.base)
508
541
            else:
511
544
 
512
545
        dialog = SearchDialog(index)
513
546
 
514
 
        if dialog.run() == gtk.RESPONSE_OK:
515
 
            self.set_revision(dialog.get_revision())
 
547
        if dialog.run() == Gtk.ResponseType.OK:
 
548
            revid = dialog.get_revision()
 
549
            if revid is not None:
 
550
                self.set_revision(revid)
516
551
 
517
552
        dialog.destroy()
518
553
 
531
566
            self.toolbar.hide()
532
567
        self.config.set_user_option('viz-toolbar-visible', col.get_active())
533
568
 
 
569
    def _vertical_layout(self, col):
 
570
        """Toggle the layout vertical/horizontal"""
 
571
        self.config.set_user_option('viz-vertical', str(col.get_active()))
 
572
 
 
573
        old = self.paned
 
574
        self.vbox.remove(old)
 
575
        self.vbox.pack_start(
 
576
            self.construct_paned(), True, True, 0)
 
577
        self._make_diff_paned_nonzero_size()
 
578
        self._make_diff_nonzero_size()
 
579
 
 
580
        self.treeview.emit('revision-selected')
 
581
 
 
582
    def _make_diff_paned_nonzero_size(self):
 
583
        """make sure the diff/revision pane isn't zero-width or zero-height"""
 
584
        alloc = self.diff_paned.get_allocation()
 
585
        if (alloc.width < 10) or (alloc.height < 10):
 
586
            width, height = self.get_size()
 
587
            self.diff_paned.set_size_request(width/3, int(height / 2.5))
 
588
 
534
589
    def _make_diff_nonzero_size(self):
535
590
        """make sure the diff isn't zero-width or zero-height"""
536
591
        alloc = self.diff.get_allocation()
568
623
        self.treeview.refresh()
569
624
 
570
625
    def _update_tags(self):
571
 
        menu = gtk.Menu()
 
626
        menu = Gtk.Menu()
572
627
 
573
628
        if self.branch.supports_tags():
574
629
            tags = self.branch.tags.get_tag_dict().items()
575
630
            tags.sort(reverse=True)
576
631
            for tag, revid in tags:
577
 
                tag_image = gtk.Image()
 
632
                tag_image = Gtk.Image()
578
633
                tag_image.set_from_file(icon_path('tag-16.png'))
579
 
                tag_item = gtk.ImageMenuItem(tag.replace('_', '__'))
 
634
                tag_item = Gtk.ImageMenuItem.new_with_mnemonic(
 
635
                    tag.replace('_', '__'))
580
636
                tag_item.set_image(tag_image)
581
637
                tag_item.connect('activate', self._tag_selected_cb, revid)
582
638
                tag_item.set_sensitive(self.treeview.has_revision_id(revid))
601
657
            return width, height
602
658
        return None
603
659
 
604
 
    def show_diff(self, revid=None, parentid=NULL_REVISION):
 
660
    def show_diff(self, revid, parentid=NULL_REVISION):
605
661
        """Open a new window to show a diff between the given revisions."""
606
662
        from bzrlib.plugins.gtk.diff import DiffWindow
607
663
        window = DiffWindow(parent=self)