/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: Daniel Schierbeck
  • Date: 2007-11-05 17:03:57 UTC
  • Revision ID: daniel.schierbeck@gmail.com-20071105170357-wz4ivbsmlaalzsa0
Added support for showing the date column in the viz.

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
18
 
from bzrlib.plugins.gtk.tags import AddTagDialog
19
17
from bzrlib.plugins.gtk.preferences import PreferencesWindow
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
 
18
from bzrlib.revision import Revision
 
19
from treeview import TreeView
25
20
 
26
21
class BranchWindow(Window):
27
22
    """Branch window.
30
25
    for a particular branch.
31
26
    """
32
27
 
33
 
    def __init__(self, branch, start_revs, maxnum, parent=None):
 
28
    def __init__(self, branch, start, maxnum, parent=None):
34
29
        """Create a new BranchWindow.
35
30
 
36
31
        :param branch: Branch object for branch to show.
37
 
        :param start_revs: Revision ids of top revisions.
 
32
        :param start: Revision id of top revision.
38
33
        :param maxnum: Maximum number of revisions to display, 
39
34
                       None for no limit.
40
35
        """
42
37
        Window.__init__(self, parent=parent)
43
38
        self.set_border_width(0)
44
39
 
45
 
        self.branch      = branch
46
 
        self.start_revs  = start_revs
47
 
        self.maxnum      = maxnum
48
 
        self.config      = GlobalConfig()
49
 
 
50
 
        if self.config.get_user_option('viz-compact-view') == 'yes':
51
 
            self.compact_view = True
52
 
        else:
53
 
            self.compact_view = False
 
40
        self.branch = branch
 
41
        self.start  = start
 
42
        self.maxnum = maxnum
54
43
 
55
44
        self.set_title(branch.nick + " - revision history")
56
45
 
65
54
        icon = self.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
66
55
        self.set_icon(icon)
67
56
 
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
 
 
72
57
        self.accel_group = gtk.AccelGroup()
73
58
        self.add_accel_group(self.accel_group)
74
59
 
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
 
 
95
60
        self.construct()
96
61
 
97
 
    def set_revision(self, revid):
98
 
        self.treeview.set_revision_id(revid)
99
 
 
100
62
    def construct(self):
101
63
        """Construct the window contents."""
102
64
        vbox = gtk.VBox(spacing=0)
103
65
        self.add(vbox)
104
66
 
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()
109
 
 
110
67
        vbox.pack_start(self.construct_menubar(), expand=False, fill=True)
111
68
        vbox.pack_start(self.construct_navigation(), expand=False, fill=True)
 
69
        vbox.pack_start(self.construct_loading_msg(), expand=False, fill=True)
112
70
        
113
 
        vbox.pack_start(self.paned, expand=True, fill=True)
114
 
        vbox.set_focus_child(self.paned)
 
71
        paned = gtk.VPaned()
 
72
        paned.pack1(self.construct_top(), resize=True, shrink=False)
 
73
        paned.pack2(self.construct_bottom(), resize=False, shrink=True)
 
74
        paned.show()
 
75
        vbox.pack_start(paned, expand=True, fill=True)
 
76
        vbox.set_focus_child(paned)
115
77
 
116
78
        vbox.show()
117
79
 
122
84
        file_menuitem = gtk.MenuItem("_File")
123
85
        file_menuitem.set_submenu(file_menu)
124
86
 
125
 
        file_menu_close = gtk.ImageMenuItem(gtk.STOCK_CLOSE, self.accel_group)
 
87
        file_menu_close = gtk.ImageMenuItem(gtk.STOCK_CLOSE)
126
88
        file_menu_close.connect('activate', lambda x: self.destroy())
127
89
        
128
 
        file_menu_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, self.accel_group)
129
 
        file_menu_quit.connect('activate', lambda x: gtk.main_quit())
130
 
        
131
 
        if self._parent is not None:
132
 
            file_menu.add(file_menu_close)
133
 
        file_menu.add(file_menu_quit)
 
90
        file_menu.add(file_menu_close)
134
91
 
135
92
        edit_menu = gtk.Menu()
136
93
        edit_menuitem = gtk.MenuItem("_Edit")
138
95
 
139
96
        edit_menu_find = gtk.ImageMenuItem(gtk.STOCK_FIND)
140
97
 
141
 
        edit_menu_branchopts = gtk.MenuItem("Branch Settings")
142
 
        edit_menu_branchopts.connect('activate', lambda x: PreferencesWindow(self.branch.get_config()).show())
143
 
 
144
 
        edit_menu_globopts = gtk.MenuItem("Global Settings")
145
 
        edit_menu_globopts.connect('activate', lambda x: PreferencesWindow().show())
 
98
        edit_menu_prefs = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
 
99
        edit_menu_prefs.connect('activate', lambda x: PreferencesWindow(self.branch.get_config()).show())
146
100
 
147
101
        edit_menu.add(edit_menu_find)
148
 
        edit_menu.add(edit_menu_branchopts)
149
 
        edit_menu.add(edit_menu_globopts)
 
102
        edit_menu.add(edit_menu_prefs)
150
103
 
151
104
        view_menu = gtk.Menu()
152
105
        view_menuitem = gtk.MenuItem("_View")
153
106
        view_menuitem.set_submenu(view_menu)
154
107
 
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
 
 
161
108
        view_menu_toolbar = gtk.CheckMenuItem("Show Toolbar")
162
109
        view_menu_toolbar.set_active(True)
163
110
        view_menu_toolbar.connect('toggled', self._toolbar_visibility_changed)
164
111
 
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)
 
112
        view_menu_revno_col = gtk.CheckMenuItem("Show Revision _Number Column")
 
113
        view_menu_revno_col.set_active(True)
 
114
        view_menu_revno_col.connect('toggled', self._col_visibility_changed, 'revno')
 
115
 
 
116
        view_menu_date_col = gtk.CheckMenuItem("Show _Date Column")
 
117
        view_menu_date_col.set_active(False)
 
118
        view_menu_date_col.connect('toggled', self._col_visibility_changed, 'date')
168
119
 
169
120
        view_menu.add(view_menu_toolbar)
170
 
        view_menu.add(view_menu_compact)
171
121
        view_menu.add(gtk.SeparatorMenuItem())
172
 
 
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")]:
183
 
            col.set_active(self.treeview.get_property(name + "-column-visible"))
184
 
            col.connect('toggled', self._col_visibility_changed, name)
185
 
            view_menu.add(col)
 
122
        view_menu.add(view_menu_revno_col)
 
123
        view_menu.add(view_menu_date_col)
186
124
 
187
125
        go_menu = gtk.Menu()
188
 
        go_menu.set_accel_group(self.accel_group)
189
126
        go_menuitem = gtk.MenuItem("_Go")
190
127
        go_menuitem.set_submenu(go_menu)
191
128
        
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)
 
129
        go_menu_back = gtk.ImageMenuItem(gtk.STOCK_GO_DOWN)
 
130
        go_menu_back.connect("activate", self._back_clicked_cb)
 
131
 
 
132
        go_menu_forward = gtk.ImageMenuItem(gtk.STOCK_GO_UP)
 
133
        go_menu_forward.connect("activate", self._fwd_clicked_cb)
 
134
 
 
135
        tags_menu = gtk.Menu()
 
136
        go_menu_tags = gtk.MenuItem("_Tags")
 
137
        go_menu_tags.set_submenu(tags_menu)
 
138
 
 
139
        for (tag, revid) in self.branch.tags.get_tag_dict().items():
 
140
            tag_item = gtk.MenuItem(tag)
 
141
            tag_item.connect('activate', self._tag_selected_cb, revid)
 
142
            tags_menu.add(tag_item)
 
143
 
 
144
        go_menu.add(go_menu_back)
 
145
        go_menu.add(go_menu_forward)
203
146
        go_menu.add(gtk.SeparatorMenuItem())
204
 
        go_menu.add(self.go_menu_tags)
 
147
        go_menu.add(go_menu_tags)
205
148
 
206
149
        revision_menu = gtk.Menu()
207
150
        revision_menuitem = gtk.MenuItem("_Revision")
208
151
        revision_menuitem.set_submenu(revision_menu)
209
152
 
210
 
        revision_menu_diff = gtk.MenuItem("View Changes")
211
 
        revision_menu_diff.connect('activate', 
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)
217
 
 
218
 
        revision_menu_tag = gtk.MenuItem("Tag Revision")
219
 
        revision_menu_tag.connect('activate', self._tag_revision_cb)
220
 
 
221
 
        revision_menu.add(revision_menu_tag)
222
 
        revision_menu.add(revision_menu_diff)
223
 
        revision_menu.add(revision_menu_compare)
 
153
        revision_menu.add(gtk.MenuItem("Tag Revision"))
 
154
        revision_menu.add(gtk.MenuItem("View Changes"))
224
155
 
225
156
        branch_menu = gtk.Menu()
226
157
        branch_menuitem = gtk.MenuItem("_Branch")
228
159
 
229
160
        branch_menu.add(gtk.MenuItem("Pu_ll Revisions"))
230
161
        branch_menu.add(gtk.MenuItem("Pu_sh Revisions"))
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
 
 
 
162
       
250
163
        menubar.add(file_menuitem)
251
164
        menubar.add(edit_menuitem)
252
165
        menubar.add(view_menuitem)
253
166
        menubar.add(go_menuitem)
254
167
        menubar.add(revision_menuitem)
255
168
        menubar.add(branch_menuitem)
256
 
        menubar.add(help_menuitem)
257
169
        menubar.show_all()
258
170
 
259
171
        return menubar
 
172
    
 
173
    def construct_loading_msg(self):
 
174
        image_loading = gtk.image_new_from_stock(gtk.STOCK_REFRESH,
 
175
                                                 gtk.ICON_SIZE_BUTTON)
 
176
        image_loading.show()
 
177
        
 
178
        label_loading = gtk.Label(_("Please wait, loading ancestral graph..."))
 
179
        label_loading.set_alignment(0.0, 0.5)  
 
180
        label_loading.show()
 
181
        
 
182
        self.loading_msg_box = gtk.HBox()
 
183
        self.loading_msg_box.set_spacing(5)
 
184
        self.loading_msg_box.set_border_width(5)        
 
185
        self.loading_msg_box.pack_start(image_loading, False, False)
 
186
        self.loading_msg_box.pack_start(label_loading, True, True)
 
187
        self.loading_msg_box.show()
 
188
        
 
189
        return self.loading_msg_box
260
190
 
261
191
    def construct_top(self):
262
192
        """Construct the top-half of the window."""
263
193
        # FIXME: Make broken_line_length configurable
264
 
 
265
 
        self.treeview = TreeView(self.branch, self.start_revs, self.maxnum, self.compact_view)
266
 
 
267
 
        self.treeview.connect('revision-selected',
 
194
        self.treeview = TreeView(self.branch, self.start, self.maxnum, 32)
 
195
 
 
196
        self.treeview.connect("revision-selected",
268
197
                self._treeselection_changed_cb)
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)
 
198
 
 
199
        self.treeview.connect('revisions-loaded', 
 
200
                lambda x: self.loading_msg_box.hide())
280
201
 
281
202
        self.treeview.show()
282
203
 
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
 
204
        return self.treeview
289
205
 
290
206
    def construct_navigation(self):
291
207
        """Construct the navigation buttons."""
292
208
        self.toolbar = gtk.Toolbar()
293
209
        self.toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
294
210
 
295
 
        self.prev_button = self.prev_rev_action.create_tool_item()
296
 
        self.toolbar.insert(self.prev_button, -1)
297
 
 
298
 
        self.next_button = self.next_rev_action.create_tool_item()
299
 
        self.toolbar.insert(self.next_button, -1)
300
 
 
301
 
        self.toolbar.insert(gtk.SeparatorToolItem(), -1)
302
 
 
303
 
        refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
304
 
        refresh_button.connect('clicked', self._refresh_clicked)
305
 
        self.toolbar.insert(refresh_button, -1)
306
 
 
307
 
        self.toolbar.show_all()
 
211
        self.back_button = gtk.MenuToolButton(stock_id=gtk.STOCK_GO_DOWN)
 
212
        self.back_button.add_accelerator("clicked", self.accel_group, ord('['),
 
213
                                         0, 0)
 
214
        self.back_button.connect("clicked", self._back_clicked_cb)
 
215
        self.toolbar.insert(self.back_button, -1)
 
216
        self.back_button.show()
 
217
 
 
218
        self.fwd_button = gtk.MenuToolButton(stock_id=gtk.STOCK_GO_UP)
 
219
        self.fwd_button.add_accelerator("clicked", self.accel_group, ord(']'),
 
220
                                        0, 0)
 
221
        self.fwd_button.connect("clicked", self._fwd_clicked_cb)
 
222
        self.toolbar.insert(self.fwd_button, -1)
 
223
        self.fwd_button.show()
 
224
 
 
225
        self.toolbar.show()
308
226
 
309
227
        return self.toolbar
310
228
 
311
229
    def construct_bottom(self):
312
230
        """Construct the bottom half of the window."""
313
231
        from bzrlib.plugins.gtk.revisionview import RevisionView
314
 
        self.revisionview = RevisionView(branch=self.branch)
 
232
        self.revisionview = RevisionView(None, tags=[], show_children=True, branch=self.branch)
315
233
        (width, height) = self.get_size()
316
234
        self.revisionview.set_size_request(width, int(height / 2.5))
317
235
        self.revisionview.show()
318
236
        self.revisionview.set_show_callback(self._show_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())
 
237
        self.revisionview.set_go_callback(self._go_clicked_cb)
321
238
        return self.revisionview
322
239
 
323
240
    def _tag_selected_cb(self, menuitem, revid):
329
246
        parents  = self.treeview.get_parents()
330
247
        children = self.treeview.get_children()
331
248
 
332
 
        if revision and revision != NULL_REVISION:
333
 
            prev_menu = gtk.Menu()
 
249
        if revision is not None:
 
250
            back_menu = gtk.Menu()
334
251
            if len(parents) > 0:
335
 
                self.prev_rev_action.set_sensitive(True)
 
252
                self.back_button.set_sensitive(True)
336
253
                for parent_id in parents:
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 = ""
 
254
                    parent = self.branch.repository.get_revision(parent_id)
 
255
                    try:
 
256
                        str = ' (' + parent.properties['branch-nick'] + ')'
 
257
                    except KeyError:
 
258
                        str = ""
343
259
 
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()
 
260
                    item = gtk.MenuItem(parent.message.split("\n")[0] + str)
 
261
                    item.connect('activate', self._set_revision_cb, parent_id)
 
262
                    back_menu.add(item)
 
263
                back_menu.show_all()
348
264
            else:
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()
 
265
                self.back_button.set_sensitive(False)
 
266
                back_menu.hide()
 
267
 
 
268
            self.back_button.set_menu(back_menu)
 
269
 
 
270
            fwd_menu = gtk.Menu()
355
271
            if len(children) > 0:
356
 
                self.next_rev_action.set_sensitive(True)
 
272
                self.fwd_button.set_sensitive(True)
357
273
                for child_id in children:
358
274
                    child = self.branch.repository.get_revision(child_id)
359
275
                    try:
363
279
 
364
280
                    item = gtk.MenuItem(child.message.split("\n")[0] + str)
365
281
                    item.connect('activate', self._set_revision_cb, child_id)
366
 
                    next_menu.add(item)
367
 
                next_menu.show_all()
 
282
                    fwd_menu.add(item)
 
283
                fwd_menu.show_all()
368
284
            else:
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)    
 
285
                self.fwd_button.set_sensitive(False)
 
286
                fwd_menu.hide()
 
287
 
 
288
            self.fwd_button.set_menu(fwd_menu)
 
289
 
 
290
            tags = []
 
291
            if self.branch.supports_tags():
 
292
                tagdict = self.branch.tags.get_reverse_tag_dict()
 
293
                if tagdict.has_key(revision.revision_id):
 
294
                    tags = tagdict[revision.revision_id]
 
295
            self.revisionview.set_revision(revision, tags, children)
403
296
 
404
297
    def _back_clicked_cb(self, *args):
405
298
        """Callback for when the back button is clicked."""
409
302
        """Callback for when the forward button is clicked."""
410
303
        self.treeview.forward()
411
304
 
412
 
    def _go_clicked_cb(self, w, p):
 
305
    def _go_clicked_cb(self, revid):
413
306
        """Callback for when the go button for a parent is clicked."""
414
 
        if self.revisionview.get_revision() is not None:
415
 
            self.treeview.set_revision(self.revisionview.get_revision())
 
307
        self.treeview.set_revision_id(revid)
416
308
 
417
309
    def _show_clicked_cb(self, revid, parentid):
418
310
        """Callback for when the show button for a parent is clicked."""
419
 
        self.show_diff(revid, parentid)
 
311
        self.treeview.show_diff(self.branch, revid, parentid)
420
312
        self.treeview.grab_focus()
421
313
 
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
 
            
438
314
    def _set_revision_cb(self, w, revision_id):
439
315
        self.treeview.set_revision_id(revision_id)
440
316
 
441
 
    def _brokenlines_toggled_cb(self, button):
442
 
        self.compact_view = button.get_active()
443
 
 
444
 
        if self.compact_view:
445
 
            option = 'yes'
446
 
        else:
447
 
            option = 'no'
448
 
 
449
 
        self.config.set_user_option('viz-compact-view', option)
450
 
        self.treeview.set_property('compact', self.compact_view)
451
 
        self.treeview.refresh()
452
 
 
453
 
    def _tag_revision_cb(self, w):
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()
460
 
            
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()
477
 
 
478
317
    def _col_visibility_changed(self, col, property):
479
 
        self.config.set_user_option(property + '-column-visible', col.get_active())
480
318
        self.treeview.set_property(property + '-column-visible', col.get_active())
481
319
 
482
320
    def _toolbar_visibility_changed(self, col):
484
322
            self.toolbar.show() 
485
323
        else:
486
324
            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