/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-02-18 11:53:18 UTC
  • mfrom: (452.5.2 viz-locks)
  • Revision ID: jelmer@samba.org-20110218115318-xgsxhn13fd3m6nj9
https://launchpad.net/bugs/93652
Add lock dialog. (Daniel Schierbeck)

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