/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: Curtis Hovey
  • Date: 2011-08-27 18:35:08 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110827183508-ugqbp58na4mtt1no
Updated the pixbuf calls to gtk3.

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