/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 16:20:15 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629162015-amhe7xj4cdmup4id
Rename GtkProgressBarStack to GtkWindowProgressBarStack

Show diffs side-by-side

added added

removed removed

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