/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: Mark Lee
  • Date: 2009-07-10 20:07:43 UTC
  • mto: This revision was merged to the branch mainline in revision 661.
  • Revision ID: bzr@lazymalevolence.com-20090710200743-2s9x0xa8jgs9wf8s
Remove credits.pickle (generated file).

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