/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: 2008-06-29 19:34:29 UTC
  • mto: This revision was merged to the branch mainline in revision 520.
  • Revision ID: jelmer@samba.org-20080629193429-ir2ilmbko6qkubg5
Add Branch/Index option if bzr-search is available.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/branchwin.py
14
14
import pango
15
15
 
16
16
from bzrlib.plugins.gtk.window import Window
 
17
from bzrlib.plugins.gtk import icon_path
17
18
from bzrlib.plugins.gtk.tags import AddTagDialog
18
19
from bzrlib.plugins.gtk.preferences import PreferencesWindow
19
 
from bzrlib.revision import Revision
20
 
from bzrlib.config import BranchConfig
21
 
from bzrlib.config import GlobalConfig
22
 
from treeview import TreeView
 
20
from bzrlib.plugins.gtk.branchview import TreeView, treemodel
 
21
 
 
22
from bzrlib.config import BranchConfig, GlobalConfig
 
23
from bzrlib.revision import Revision, NULL_REVISION
 
24
from bzrlib.trace import mutter
23
25
 
24
26
class BranchWindow(Window):
25
27
    """Branch window.
28
30
    for a particular branch.
29
31
    """
30
32
 
31
 
    def __init__(self, branch, start, maxnum, parent=None):
 
33
    def __init__(self, branch, start_revs, maxnum, parent=None):
32
34
        """Create a new BranchWindow.
33
35
 
34
36
        :param branch: Branch object for branch to show.
35
 
        :param start: Revision id of top revision.
 
37
        :param start_revs: Revision ids of top revisions.
36
38
        :param maxnum: Maximum number of revisions to display, 
37
39
                       None for no limit.
38
40
        """
41
43
        self.set_border_width(0)
42
44
 
43
45
        self.branch      = branch
44
 
        self.start       = start
 
46
        self.start_revs  = start_revs
45
47
        self.maxnum      = maxnum
46
48
        self.config      = GlobalConfig()
47
49
 
63
65
        icon = self.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
64
66
        self.set_icon(icon)
65
67
 
 
68
        gtk.accel_map_add_entry("<viz>/Go/Next Revision", gtk.keysyms.Up, gtk.gdk.MOD1_MASK)
 
69
        gtk.accel_map_add_entry("<viz>/Go/Previous Revision", gtk.keysyms.Down, gtk.gdk.MOD1_MASK)
 
70
        gtk.accel_map_add_entry("<viz>/View/Refresh", gtk.keysyms.F5, 0)
 
71
 
66
72
        self.accel_group = gtk.AccelGroup()
67
73
        self.add_accel_group(self.accel_group)
68
74
 
 
75
        gtk.Action.set_tool_item_type(gtk.MenuToolButton)
 
76
 
 
77
        self.prev_rev_action = gtk.Action("prev-rev", "_Previous Revision", "Go to the previous revision", gtk.STOCK_GO_DOWN)
 
78
        self.prev_rev_action.set_accel_path("<viz>/Go/Previous Revision")
 
79
        self.prev_rev_action.set_accel_group(self.accel_group)
 
80
        self.prev_rev_action.connect("activate", self._back_clicked_cb)
 
81
        self.prev_rev_action.connect_accelerator()
 
82
 
 
83
        self.next_rev_action = gtk.Action("next-rev", "_Next Revision", "Go to the next revision", gtk.STOCK_GO_UP)
 
84
        self.next_rev_action.set_accel_path("<viz>/Go/Next Revision")
 
85
        self.next_rev_action.set_accel_group(self.accel_group)
 
86
        self.next_rev_action.connect("activate", self._fwd_clicked_cb)
 
87
        self.next_rev_action.connect_accelerator()
 
88
 
 
89
        self.refresh_action = gtk.Action("refresh", "_Refresh", "Refresh view", gtk.STOCK_REFRESH)
 
90
        self.refresh_action.set_accel_path("<viz>/View/Refresh")
 
91
        self.refresh_action.set_accel_group(self.accel_group)
 
92
        self.refresh_action.connect("activate", self._refresh_clicked)
 
93
        self.refresh_action.connect_accelerator()
 
94
 
69
95
        self.construct()
70
96
 
71
 
    def set_revision(self, revision):
72
 
        self.treeview.set_revision(revision)
 
97
    def set_revision(self, revid):
 
98
        self.treeview.set_revision_id(revid)
73
99
 
74
100
    def construct(self):
75
101
        """Construct the window contents."""
76
102
        vbox = gtk.VBox(spacing=0)
77
103
        self.add(vbox)
78
104
 
79
 
        top = self.construct_top()
 
105
        self.paned = gtk.VPaned()
 
106
        self.paned.pack1(self.construct_top(), resize=True, shrink=False)
 
107
        self.paned.pack2(self.construct_bottom(), resize=False, shrink=True)
 
108
        self.paned.show()
80
109
 
81
110
        vbox.pack_start(self.construct_menubar(), expand=False, fill=True)
82
111
        vbox.pack_start(self.construct_navigation(), expand=False, fill=True)
83
 
        vbox.pack_start(self.construct_loading_msg(), expand=False, fill=True)
84
112
        
85
 
        paned = gtk.VPaned()
86
 
        paned.pack1(top, resize=True, shrink=False)
87
 
        paned.pack2(self.construct_bottom(), resize=False, shrink=True)
88
 
        paned.show()
89
 
        vbox.pack_start(paned, expand=True, fill=True)
90
 
        vbox.set_focus_child(paned)
 
113
        vbox.pack_start(self.paned, expand=True, fill=True)
 
114
        vbox.set_focus_child(self.paned)
91
115
 
92
116
        vbox.show()
93
117
 
104
128
        file_menu_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, self.accel_group)
105
129
        file_menu_quit.connect('activate', lambda x: gtk.main_quit())
106
130
        
107
 
        file_menu.add(file_menu_close)
 
131
        if self._parent is not None:
 
132
            file_menu.add(file_menu_close)
108
133
        file_menu.add(file_menu_quit)
109
134
 
110
135
        edit_menu = gtk.Menu()
116
141
        edit_menu_branchopts = gtk.MenuItem("Branch Settings")
117
142
        edit_menu_branchopts.connect('activate', lambda x: PreferencesWindow(self.branch.get_config()).show())
118
143
 
119
 
        edit_menu_prefs = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
120
 
        edit_menu_prefs.connect('activate', lambda x: PreferencesWindow().show())
 
144
        edit_menu_globopts = gtk.MenuItem("Global Settings")
 
145
        edit_menu_globopts.connect('activate', lambda x: PreferencesWindow().show())
121
146
 
122
147
        edit_menu.add(edit_menu_find)
123
148
        edit_menu.add(edit_menu_branchopts)
124
 
        edit_menu.add(edit_menu_prefs)
 
149
        edit_menu.add(edit_menu_globopts)
125
150
 
126
151
        view_menu = gtk.Menu()
127
152
        view_menuitem = gtk.MenuItem("_View")
128
153
        view_menuitem.set_submenu(view_menu)
129
154
 
 
155
        view_menu_refresh = self.refresh_action.create_menu_item()
 
156
        view_menu_refresh.connect('activate', self._refresh_clicked)
 
157
 
 
158
        view_menu.add(view_menu_refresh)
 
159
        view_menu.add(gtk.SeparatorMenuItem())
 
160
 
130
161
        view_menu_toolbar = gtk.CheckMenuItem("Show Toolbar")
131
162
        view_menu_toolbar.set_active(True)
132
163
        view_menu_toolbar.connect('toggled', self._toolbar_visibility_changed)
133
164
 
 
165
        view_menu_compact = gtk.CheckMenuItem("Show Compact Graph")
 
166
        view_menu_compact.set_active(self.compact_view)
 
167
        view_menu_compact.connect('activate', self._brokenlines_toggled_cb)
 
168
 
134
169
        view_menu.add(view_menu_toolbar)
 
170
        view_menu.add(view_menu_compact)
135
171
        view_menu.add(gtk.SeparatorMenuItem())
136
172
 
137
 
        for (label, name) in [("Revision _Number", "revno"), ("_Date", "date")]:
138
 
            col = gtk.CheckMenuItem("Show " + label + " Column")
 
173
        self.mnu_show_revno_column = gtk.CheckMenuItem("Show Revision _Number Column")
 
174
        self.mnu_show_date_column = gtk.CheckMenuItem("Show _Date Column")
 
175
 
 
176
        # Revision numbers are pointless if there are multiple branches
 
177
        if len(self.start_revs) > 1:
 
178
            self.mnu_show_revno_column.set_sensitive(False)
 
179
            self.treeview.set_property('revno-column-visible', False)
 
180
 
 
181
        for (col, name) in [(self.mnu_show_revno_column, "revno"), 
 
182
                            (self.mnu_show_date_column, "date")]:
139
183
            col.set_active(self.treeview.get_property(name + "-column-visible"))
140
184
            col.connect('toggled', self._col_visibility_changed, name)
141
185
            view_menu.add(col)
142
186
 
143
187
        go_menu = gtk.Menu()
 
188
        go_menu.set_accel_group(self.accel_group)
144
189
        go_menuitem = gtk.MenuItem("_Go")
145
190
        go_menuitem.set_submenu(go_menu)
146
191
        
147
 
        go_menu_back = gtk.ImageMenuItem(gtk.STOCK_GO_DOWN)
148
 
        go_menu_back.connect("activate", self._back_clicked_cb)
149
 
 
150
 
        go_menu_forward = gtk.ImageMenuItem(gtk.STOCK_GO_UP)
151
 
        go_menu_forward.connect("activate", self._fwd_clicked_cb)
152
 
 
153
 
        tags_menu = gtk.Menu()
154
 
        go_menu_tags = gtk.MenuItem("_Tags")
155
 
        go_menu_tags.set_submenu(tags_menu)
156
 
 
157
 
        if self.branch.supports_tags():
158
 
            for (tag, revid) in self.branch.tags.get_tag_dict().items():
159
 
                tag_item = gtk.MenuItem(tag)
160
 
                tag_item.connect('activate', self._tag_selected_cb, revid)
161
 
                tags_menu.add(tag_item)
162
 
 
163
 
        go_menu.add(go_menu_back)
164
 
        go_menu.add(go_menu_forward)
 
192
        go_menu_next = self.next_rev_action.create_menu_item()
 
193
        go_menu_prev = self.prev_rev_action.create_menu_item()
 
194
 
 
195
        tag_image = gtk.Image()
 
196
        tag_image.set_from_file(icon_path("tag-16.png"))
 
197
        self.go_menu_tags = gtk.ImageMenuItem("_Tags")
 
198
        self.go_menu_tags.set_image(tag_image)
 
199
        self._update_tags()
 
200
 
 
201
        go_menu.add(go_menu_next)
 
202
        go_menu.add(go_menu_prev)
165
203
        go_menu.add(gtk.SeparatorMenuItem())
166
 
        go_menu.add(go_menu_tags)
 
204
        go_menu.add(self.go_menu_tags)
167
205
 
168
206
        revision_menu = gtk.Menu()
169
207
        revision_menuitem = gtk.MenuItem("_Revision")
171
209
 
172
210
        revision_menu_diff = gtk.MenuItem("View Changes")
173
211
        revision_menu_diff.connect('activate', 
174
 
                lambda w: self.treeview.show_diff())
 
212
                self._menu_diff_cb)
 
213
        
 
214
        revision_menu_compare = gtk.MenuItem("Compare with...")
 
215
        revision_menu_compare.connect('activate',
 
216
                self._compare_with_cb)
175
217
 
176
218
        revision_menu_tag = gtk.MenuItem("Tag Revision")
177
219
        revision_menu_tag.connect('activate', self._tag_revision_cb)
178
220
 
179
221
        revision_menu.add(revision_menu_tag)
180
222
        revision_menu.add(revision_menu_diff)
 
223
        revision_menu.add(revision_menu_compare)
181
224
 
182
225
        branch_menu = gtk.Menu()
183
226
        branch_menuitem = gtk.MenuItem("_Branch")
185
228
 
186
229
        branch_menu.add(gtk.MenuItem("Pu_ll Revisions"))
187
230
        branch_menu.add(gtk.MenuItem("Pu_sh Revisions"))
188
 
       
 
231
 
 
232
        try:
 
233
            from bzrlib.plugins import search
 
234
        except ImportError:
 
235
            mutter("Didn't find search plugin")
 
236
        else:
 
237
            branch_index_menuitem = gtk.MenuItem("_Index")
 
238
            branch_index_menuitem.connect('activate', self._branch_index_cb)
 
239
            branch_menu.add(branch_index_menuitem)
 
240
 
 
241
        help_menu = gtk.Menu()
 
242
        help_menuitem = gtk.MenuItem("_Help")
 
243
        help_menuitem.set_submenu(help_menu)
 
244
 
 
245
        help_about_menuitem = gtk.ImageMenuItem(gtk.STOCK_ABOUT, self.accel_group)
 
246
        help_about_menuitem.connect('activate', self._about_dialog_cb)
 
247
 
 
248
        help_menu.add(help_about_menuitem)
 
249
 
189
250
        menubar.add(file_menuitem)
190
251
        menubar.add(edit_menuitem)
191
252
        menubar.add(view_menuitem)
192
253
        menubar.add(go_menuitem)
193
254
        menubar.add(revision_menuitem)
194
255
        menubar.add(branch_menuitem)
 
256
        menubar.add(help_menuitem)
195
257
        menubar.show_all()
196
258
 
197
259
        return menubar
198
 
    
199
 
    def construct_loading_msg(self):
200
 
        image_loading = gtk.image_new_from_stock(gtk.STOCK_REFRESH,
201
 
                                                 gtk.ICON_SIZE_BUTTON)
202
 
        image_loading.show()
203
 
        
204
 
        label_loading = gtk.Label(_("Please wait, loading ancestral graph..."))
205
 
        label_loading.set_alignment(0.0, 0.5)
206
 
        label_loading.show()
207
 
        
208
 
        self.loading_msg_box = gtk.HBox()
209
 
        self.loading_msg_box.set_spacing(5)
210
 
        self.loading_msg_box.set_border_width(5)        
211
 
        self.loading_msg_box.pack_start(image_loading, False, False)
212
 
        self.loading_msg_box.pack_start(label_loading, True, True)
213
 
        self.loading_msg_box.show()
214
 
        
215
 
        return self.loading_msg_box
216
260
 
217
261
    def construct_top(self):
218
262
        """Construct the top-half of the window."""
219
263
        # FIXME: Make broken_line_length configurable
220
 
        if self.compact_view:
221
 
            brokenlines = 32
222
 
        else:
223
 
            brokenlines = None
224
 
 
225
 
        self.treeview = TreeView(self.branch, self.start, self.maxnum, brokenlines)
226
 
 
227
 
        self.treeview.connect("revision-selected",
 
264
 
 
265
        self.treeview = TreeView(self.branch, self.start_revs, self.maxnum, self.compact_view)
 
266
 
 
267
        self.treeview.connect('revision-selected',
228
268
                self._treeselection_changed_cb)
229
 
 
230
 
        self.treeview.connect('revisions-loaded', 
231
 
                lambda x: self.loading_msg_box.hide())
 
269
        self.treeview.connect('revision-activated',
 
270
                self._tree_revision_activated)
 
271
 
 
272
        self.treeview.connect('tag-added', lambda w, t, r: self._update_tags())
 
273
 
 
274
        for col in ["revno", "date"]:
 
275
            option = self.config.get_user_option(col + '-column-visible')
 
276
            if option is not None:
 
277
                self.treeview.set_property(col + '-column-visible', option == 'True')
 
278
            else:
 
279
                self.treeview.set_property(col + '-column-visible', False)
232
280
 
233
281
        self.treeview.show()
234
282
 
235
 
        return self.treeview
 
283
        align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
 
284
        align.set_padding(5, 0, 0, 0)
 
285
        align.add(self.treeview)
 
286
        align.show()
 
287
 
 
288
        return align
236
289
 
237
290
    def construct_navigation(self):
238
291
        """Construct the navigation buttons."""
239
292
        self.toolbar = gtk.Toolbar()
240
293
        self.toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
241
294
 
242
 
        self.back_button = gtk.MenuToolButton(stock_id=gtk.STOCK_GO_DOWN)
243
 
        self.back_button.add_accelerator("clicked", self.accel_group, ord('['),
244
 
                                         0, 0)
245
 
        self.back_button.connect("clicked", self._back_clicked_cb)
246
 
        self.toolbar.insert(self.back_button, -1)
 
295
        self.prev_button = self.prev_rev_action.create_tool_item()
 
296
        self.toolbar.insert(self.prev_button, -1)
247
297
 
248
 
        self.fwd_button = gtk.MenuToolButton(stock_id=gtk.STOCK_GO_UP)
249
 
        self.fwd_button.add_accelerator("clicked", self.accel_group, ord(']'),
250
 
                                        0, 0)
251
 
        self.fwd_button.connect("clicked", self._fwd_clicked_cb)
252
 
        self.toolbar.insert(self.fwd_button, -1)
 
298
        self.next_button = self.next_rev_action.create_tool_item()
 
299
        self.toolbar.insert(self.next_button, -1)
253
300
 
254
301
        self.toolbar.insert(gtk.SeparatorToolItem(), -1)
255
302
 
256
 
        brokenlines_button = gtk.ToggleToolButton()
257
 
        brokenlines_button.set_label("Compact View")
258
 
        brokenlines_button.set_active(self.compact_view)
259
 
        brokenlines_button.set_is_important(True)
260
 
        brokenlines_button.connect('toggled', self._brokenlines_toggled_cb)
261
 
        self.toolbar.insert(brokenlines_button, -1)
 
303
        refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
 
304
        refresh_button.connect('clicked', self._refresh_clicked)
 
305
        self.toolbar.insert(refresh_button, -1)
262
306
 
263
307
        self.toolbar.show_all()
264
308
 
267
311
    def construct_bottom(self):
268
312
        """Construct the bottom half of the window."""
269
313
        from bzrlib.plugins.gtk.revisionview import RevisionView
270
 
        self.revisionview = RevisionView(None, tags=[], show_children=True, branch=self.branch)
 
314
        self.revisionview = RevisionView(branch=self.branch)
271
315
        (width, height) = self.get_size()
272
316
        self.revisionview.set_size_request(width, int(height / 2.5))
273
317
        self.revisionview.show()
274
318
        self.revisionview.set_show_callback(self._show_clicked_cb)
275
 
        self.revisionview.set_go_callback(self._go_clicked_cb)
 
319
        self.revisionview.connect('notify::revision', self._go_clicked_cb)
 
320
        self.treeview.connect('tag-added', lambda w, t, r: self.revisionview.update_tags())
276
321
        return self.revisionview
277
322
 
278
323
    def _tag_selected_cb(self, menuitem, revid):
284
329
        parents  = self.treeview.get_parents()
285
330
        children = self.treeview.get_children()
286
331
 
287
 
        if revision is not None:
288
 
            back_menu = gtk.Menu()
 
332
        if revision and revision != NULL_REVISION:
 
333
            prev_menu = gtk.Menu()
289
334
            if len(parents) > 0:
290
 
                self.back_button.set_sensitive(True)
 
335
                self.prev_rev_action.set_sensitive(True)
291
336
                for parent_id in parents:
292
 
                    parent = self.branch.repository.get_revision(parent_id)
293
 
                    try:
294
 
                        str = ' (' + parent.properties['branch-nick'] + ')'
295
 
                    except KeyError:
296
 
                        str = ""
 
337
                    if parent_id and parent_id != NULL_REVISION:
 
338
                        parent = self.branch.repository.get_revision(parent_id)
 
339
                        try:
 
340
                            str = ' (' + parent.properties['branch-nick'] + ')'
 
341
                        except KeyError:
 
342
                            str = ""
297
343
 
298
 
                    item = gtk.MenuItem(parent.message.split("\n")[0] + str)
299
 
                    item.connect('activate', self._set_revision_cb, parent_id)
300
 
                    back_menu.add(item)
301
 
                back_menu.show_all()
 
344
                        item = gtk.MenuItem(parent.message.split("\n")[0] + str)
 
345
                        item.connect('activate', self._set_revision_cb, parent_id)
 
346
                        prev_menu.add(item)
 
347
                prev_menu.show_all()
302
348
            else:
303
 
                self.back_button.set_sensitive(False)
304
 
                back_menu.hide()
305
 
 
306
 
            self.back_button.set_menu(back_menu)
307
 
 
308
 
            fwd_menu = gtk.Menu()
 
349
                self.prev_rev_action.set_sensitive(False)
 
350
                prev_menu.hide()
 
351
 
 
352
            self.prev_button.set_menu(prev_menu)
 
353
 
 
354
            next_menu = gtk.Menu()
309
355
            if len(children) > 0:
310
 
                self.fwd_button.set_sensitive(True)
 
356
                self.next_rev_action.set_sensitive(True)
311
357
                for child_id in children:
312
358
                    child = self.branch.repository.get_revision(child_id)
313
359
                    try:
317
363
 
318
364
                    item = gtk.MenuItem(child.message.split("\n")[0] + str)
319
365
                    item.connect('activate', self._set_revision_cb, child_id)
320
 
                    fwd_menu.add(item)
321
 
                fwd_menu.show_all()
 
366
                    next_menu.add(item)
 
367
                next_menu.show_all()
322
368
            else:
323
 
                self.fwd_button.set_sensitive(False)
324
 
                fwd_menu.hide()
325
 
 
326
 
            self.fwd_button.set_menu(fwd_menu)
327
 
 
328
 
            tags = []
329
 
            if self.branch.supports_tags():
330
 
                tagdict = self.branch.tags.get_reverse_tag_dict()
331
 
                if tagdict.has_key(revision.revision_id):
332
 
                    tags = tagdict[revision.revision_id]
333
 
            self.revisionview.set_revision(revision, tags, children)
 
369
                self.next_rev_action.set_sensitive(False)
 
370
                next_menu.hide()
 
371
 
 
372
            self.next_button.set_menu(next_menu)
 
373
 
 
374
            self.revisionview.set_revision(revision)
 
375
            self.revisionview.set_children(children)
 
376
    
 
377
    def _tree_revision_activated(self, widget, path, col):
 
378
        # TODO: more than one parent
 
379
        """Callback for when a treeview row gets activated."""
 
380
        revision = self.treeview.get_revision()
 
381
        parents  = self.treeview.get_parents()
 
382
 
 
383
        if len(parents) == 0:
 
384
            parent_id = None
 
385
        else:
 
386
            parent_id = parents[0]
 
387
 
 
388
        self.show_diff(revision.revision_id, parent_id)
 
389
        self.treeview.grab_focus()
 
390
        
 
391
    def _menu_diff_cb(self,w):
 
392
        (path, focus) = self.treeview.treeview.get_cursor()
 
393
        revid = self.treeview.model[path][treemodel.REVID]
 
394
        
 
395
        parentids = self.branch.repository.revision_parents(revid)
 
396
 
 
397
        if len(parentids) == 0:
 
398
            parentid = NULL_REVISION
 
399
        else:
 
400
            parentid = parentids[0]
 
401
        
 
402
        self.show_diff(revid,parentid)    
334
403
 
335
404
    def _back_clicked_cb(self, *args):
336
405
        """Callback for when the back button is clicked."""
340
409
        """Callback for when the forward button is clicked."""
341
410
        self.treeview.forward()
342
411
 
343
 
    def _go_clicked_cb(self, revid):
 
412
    def _go_clicked_cb(self, w, p):
344
413
        """Callback for when the go button for a parent is clicked."""
345
 
        self.treeview.set_revision_id(revid)
 
414
        if self.revisionview.get_revision() is not None:
 
415
            self.treeview.set_revision(self.revisionview.get_revision())
346
416
 
347
417
    def _show_clicked_cb(self, revid, parentid):
348
418
        """Callback for when the show button for a parent is clicked."""
349
 
        self.treeview.show_diff(revid, parentid)
 
419
        self.show_diff(revid, parentid)
350
420
        self.treeview.grab_focus()
351
421
 
 
422
    def _compare_with_cb(self,w):
 
423
        """Callback for revision 'compare with' menu. Will show a small
 
424
            dialog with branch revisions to compare with selected revision in TreeView"""
 
425
        
 
426
        from bzrlib.plugins.gtk.revbrowser import RevisionBrowser
 
427
        
 
428
        rb = RevisionBrowser(self.branch,self)
 
429
        ret = rb.run()
 
430
        
 
431
        if ret == gtk.RESPONSE_OK:          
 
432
            (path, focus) = self.treeview.treeview.get_cursor()
 
433
            revid = self.treeview.model[path][treemodel.REVID]
 
434
            self.show_diff(revid, rb.selected_revid)
 
435
            
 
436
        rb.destroy()
 
437
            
352
438
    def _set_revision_cb(self, w, revision_id):
353
439
        self.treeview.set_revision_id(revision_id)
354
440
 
361
447
            option = 'no'
362
448
 
363
449
        self.config.set_user_option('viz-compact-view', option)
364
 
 
365
 
        revision = self.treeview.get_revision()
366
 
 
367
 
        self.treeview.destroy()
368
 
        self.paned.pack1(self.construct_top(), resize=True, shrink=False)
369
 
 
370
 
        gobject.idle_add(self.set_revision, revision.revision_id)
 
450
        self.treeview.set_property('compact', self.compact_view)
 
451
        self.treeview.refresh()
371
452
 
372
453
    def _tag_revision_cb(self, w):
373
 
        dialog = AddTagDialog(self.branch.repository, self.treeview.get_revision().revision_id, self.branch)
374
 
        response = dialog.run()
375
 
        if response != gtk.RESPONSE_NONE:
376
 
            dialog.hide()
377
 
        
378
 
            if response == gtk.RESPONSE_OK:
379
 
                try:
380
 
                    self.branch.lock_write()
381
 
                    self.branch.tags.set_tag(dialog.tagname, dialog._revid)
382
 
                finally:
383
 
                    self.branch.unlock()
 
454
        try:
 
455
            self.treeview.set_sensitive(False)
 
456
            dialog = AddTagDialog(self.branch.repository, self.treeview.get_revision().revision_id, self.branch)
 
457
            response = dialog.run()
 
458
            if response != gtk.RESPONSE_NONE:
 
459
                dialog.hide()
384
460
            
385
 
            dialog.destroy()
 
461
                if response == gtk.RESPONSE_OK:
 
462
                    self.treeview.add_tag(dialog.tagname, dialog._revid)
 
463
                
 
464
                dialog.destroy()
 
465
 
 
466
        finally:
 
467
            self.treeview.set_sensitive(True)
 
468
 
 
469
    def _branch_index_cb(self, w):
 
470
        from bzrlib.plugins.search import index as _mod_index
 
471
        _mod_index.index_url(self.branch.base)
 
472
 
 
473
    def _about_dialog_cb(self, w):
 
474
        from bzrlib.plugins.gtk.about import AboutDialog
 
475
 
 
476
        AboutDialog().run()
386
477
 
387
478
    def _col_visibility_changed(self, col, property):
 
479
        self.config.set_user_option(property + '-column-visible', col.get_active())
388
480
        self.treeview.set_property(property + '-column-visible', col.get_active())
389
481
 
390
482
    def _toolbar_visibility_changed(self, col):
392
484
            self.toolbar.show() 
393
485
        else:
394
486
            self.toolbar.hide()
 
487
 
 
488
    def _show_about_cb(self, w):
 
489
        dialog = AboutDialog()
 
490
        dialog.connect('response', lambda d,r: d.destroy())
 
491
        dialog.run()
 
492
 
 
493
    def _refresh_clicked(self, w):
 
494
        self.treeview.refresh()
 
495
 
 
496
    def _update_tags(self):
 
497
        menu = gtk.Menu()
 
498
 
 
499
        if self.branch.supports_tags():
 
500
            tags = self.branch.tags.get_tag_dict().items()
 
501
            tags.sort()
 
502
            tags.reverse()
 
503
            for tag, revid in tags:
 
504
                tag_image = gtk.Image()
 
505
                tag_image.set_from_file(icon_path('tag-16.png'))
 
506
                tag_item = gtk.ImageMenuItem(tag.replace('_', '__'))
 
507
                tag_item.set_image(tag_image)
 
508
                tag_item.connect('activate', self._tag_selected_cb, revid)
 
509
                menu.add(tag_item)
 
510
            self.go_menu_tags.set_submenu(menu)
 
511
 
 
512
            self.go_menu_tags.set_sensitive(len(tags) != 0)
 
513
        else:
 
514
            self.go_menu_tags.set_sensitive(False)
 
515
 
 
516
        self.go_menu_tags.show_all()
 
517
 
 
518
    def show_diff(self, revid=None, parentid=None):
 
519
        """Open a new window to show a diff between the given revisions."""
 
520
        from bzrlib.plugins.gtk.diff import DiffWindow
 
521
        window = DiffWindow(parent=self)
 
522
 
 
523
        if parentid is None:
 
524
            parentid = NULL_REVISION
 
525
 
 
526
        rev_tree    = self.branch.repository.revision_tree(revid)
 
527
        parent_tree = self.branch.repository.revision_tree(parentid)
 
528
 
 
529
        description = revid + " - " + self.branch.nick
 
530
        window.set_diff(description, rev_tree, parent_tree)
 
531
        window.show()
 
532
 
 
533