/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: 2010-05-25 17:09:02 UTC
  • mto: This revision was merged to the branch mainline in revision 691.
  • Revision ID: jelmer@samba.org-20100525170902-3to8g5iw7ovw79kh
Split out olive into a separate directory.

Show diffs side-by-side

added added

removed removed

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