/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-03-28 19:26:53 UTC
  • mto: (450.1.13 trunk)
  • mto: This revision was merged to the branch mainline in revision 458.
  • Revision ID: jelmer@samba.org-20080328192653-trzptkwahx1tulz9
Add module for preferences code.

Show diffs side-by-side

added added

removed removed

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