/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 olive/commit.py

  • Committer: Jelmer Vernooij
  • Date: 2007-01-30 17:26:34 UTC
  • Revision ID: jelmer@samba.org-20070130172634-ov7ucauynnp5vso6
Warn about incompatible versions (taken from bzrtools, thanks Aaron).

Update version to 0.14.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/commit.py
21
21
    pass
22
22
 
23
23
import gtk
 
24
import gtk.glade
24
25
import gobject
25
26
import pango
26
27
 
27
 
import os.path
28
 
import re
29
 
 
30
 
from bzrlib import errors, osutils
31
 
from bzrlib.trace import mutter
32
 
from bzrlib.util import bencode
33
 
 
34
 
from bzrlib.plugins.gtk import _i18n
 
28
import bzrlib.errors as errors
 
29
from bzrlib import osutils
 
30
 
35
31
from dialog import error_dialog, question_dialog
36
32
from errors import show_bzr_error
37
 
 
38
 
try:
39
 
    import dbus
40
 
    import dbus.glib
41
 
    have_dbus = True
42
 
except ImportError:
43
 
    have_dbus = False
44
 
 
45
 
 
46
 
def pending_revisions(wt):
47
 
    """Return a list of pending merges or None if there are none of them.
48
 
 
49
 
    Arguably this should be a core function, and
50
 
    ``bzrlib.status.show_pending_merges`` should be built on top of it.
51
 
 
52
 
    :return: [(rev, [children])]
53
 
    """
54
 
    parents = wt.get_parent_ids()
55
 
    if len(parents) < 2:
56
 
        return None
57
 
 
58
 
    # The basic pending merge algorithm uses the same algorithm as
59
 
    # bzrlib.status.show_pending_merges
60
 
    pending = parents[1:]
61
 
    branch = wt.branch
62
 
    last_revision = parents[0]
63
 
 
64
 
    if last_revision is not None:
65
 
        try:
66
 
            ignore = set(branch.repository.get_ancestry(last_revision,
67
 
                                                        topo_sorted=False))
68
 
        except errors.NoSuchRevision:
69
 
            # the last revision is a ghost : assume everything is new
70
 
            # except for it
71
 
            ignore = set([None, last_revision])
72
 
    else:
73
 
        ignore = set([None])
74
 
 
75
 
    pm = []
76
 
    for merge in pending:
77
 
        ignore.add(merge)
78
 
        try:
79
 
            rev = branch.repository.get_revision(merge)
80
 
            children = []
81
 
            pm.append((rev, children))
82
 
 
83
 
            # This does need to be topo sorted, so we search backwards
84
 
            inner_merges = branch.repository.get_ancestry(merge)
85
 
            assert inner_merges[0] is None
86
 
            inner_merges.pop(0)
87
 
            for mmerge in reversed(inner_merges):
88
 
                if mmerge in ignore:
89
 
                    continue
90
 
                rev = branch.repository.get_revision(mmerge)
91
 
                children.append(rev)
92
 
 
93
 
                ignore.add(mmerge)
94
 
        except errors.NoSuchRevision:
95
 
            print "DEBUG: NoSuchRevision:", merge
96
 
 
97
 
    return pm
98
 
 
 
33
from guifiles import GLADEFILENAME
99
34
 
100
35
class CommitDialog(gtk.Dialog):
101
 
    """Implementation of Commit."""
102
 
 
103
 
    def __init__(self, wt, selected=None, parent=None):
 
36
    """ New implementation of the Commit dialog. """
 
37
    def __init__(self, wt, wtpath, notbranch, selected=None, parent=None):
 
38
        """ Initialize the Commit Dialog. """
104
39
        gtk.Dialog.__init__(self, title="Commit - Olive",
105
40
                                  parent=parent,
106
41
                                  flags=0,
107
42
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
108
 
        self._question_dialog = question_dialog
109
 
 
110
 
        self._wt = wt
111
 
        # TODO: Do something with this value, it is used by Olive
112
 
        #       It used to set all changes but this one to False
113
 
        self._selected = selected
114
 
        self._enable_per_file_commits = True
115
 
        self._commit_all_changes = True
116
 
        self.committed_revision_id = None # Nothing has been committed yet
117
 
 
118
 
        self.setup_params()
119
 
        self.construct()
120
 
        self.fill_in_data()
121
 
 
122
 
    def setup_params(self):
123
 
        """Setup the member variables for state."""
124
 
        self._basis_tree = self._wt.basis_tree()
125
 
        self._delta = None
126
 
        self._pending = pending_revisions(self._wt)
127
 
 
128
 
        self._is_checkout = (self._wt.branch.get_bound_location() is not None)
129
 
 
130
 
    def fill_in_data(self):
131
 
        # Now that we are built, handle changes to the view based on the state
132
 
        self._fill_in_pending()
133
 
        self._fill_in_diff()
134
 
        self._fill_in_files()
135
 
        self._fill_in_checkout()
136
 
        self._fill_in_per_file_info()
137
 
 
138
 
    def _fill_in_pending(self):
139
 
        if not self._pending:
140
 
            self._pending_box.hide()
141
 
            return
142
 
 
143
 
        # TODO: We'd really prefer this to be a nested list
144
 
        for rev, children in self._pending:
145
 
            rev_info = self._rev_to_pending_info(rev)
146
 
            self._pending_store.append([
147
 
                rev_info['revision_id'],
148
 
                rev_info['date'],
149
 
                rev_info['committer'],
150
 
                rev_info['summary'],
151
 
                ])
152
 
            for child in children:
153
 
                rev_info = self._rev_to_pending_info(child)
154
 
                self._pending_store.append([
155
 
                    rev_info['revision_id'],
156
 
                    rev_info['date'],
157
 
                    rev_info['committer'],
158
 
                    rev_info['summary'],
159
 
                    ])
160
 
        self._pending_box.show()
161
 
 
162
 
    def _fill_in_files(self):
163
 
        # We should really use add a progress bar of some kind.
164
 
        # While we fill in the view, hide the store
165
 
        store = self._files_store
166
 
        self._treeview_files.set_model(None)
167
 
 
168
 
        added = _i18n('added')
169
 
        removed = _i18n('removed')
170
 
        renamed = _i18n('renamed')
171
 
        renamed_and_modified = _i18n('renamed and modified')
172
 
        modified = _i18n('modified')
173
 
        kind_changed = _i18n('kind changed')
174
 
 
175
 
        # The store holds:
176
 
        # [file_id, real path, checkbox, display path, changes type, message]
177
 
        # iter_changes returns:
178
 
        # (file_id, (path_in_source, path_in_target),
179
 
        #  changed_content, versioned, parent, name, kind,
180
 
        #  executable)
181
 
 
182
 
        all_enabled = (self._selected is None)
183
 
        # The first entry is always the 'whole tree'
184
 
        all_iter = store.append([None, None, all_enabled, 'All Files', '', ''])
185
 
        initial_cursor = store.get_path(all_iter)
186
 
        # should we pass specific_files?
187
 
        self._wt.lock_read()
188
 
        self._basis_tree.lock_read()
189
 
        try:
190
 
            from diff import iter_changes_to_status
191
 
            for (file_id, real_path, change_type, display_path
192
 
                ) in iter_changes_to_status(self._basis_tree, self._wt):
193
 
                if self._selected and real_path != self._selected:
194
 
                    enabled = False
195
 
                else:
196
 
                    enabled = True
197
 
                item_iter = store.append([
198
 
                    file_id,
199
 
                    real_path.encode('UTF-8'),
200
 
                    enabled,
201
 
                    display_path.encode('UTF-8'),
202
 
                    change_type,
203
 
                    '', # Initial comment
204
 
                    ])
205
 
                if self._selected and enabled:
206
 
                    initial_cursor = store.get_path(item_iter)
207
 
        finally:
208
 
            self._basis_tree.unlock()
209
 
            self._wt.unlock()
210
 
 
211
 
        self._treeview_files.set_model(store)
212
 
        self._last_selected_file = None
213
 
        # This sets the cursor, which causes the expander to close, which
214
 
        # causes the _file_message_text_view to never get realized. So we have
215
 
        # to give it a little kick, or it warns when we try to grab the focus
216
 
        self._treeview_files.set_cursor(initial_cursor)
217
 
 
218
 
        def _realize_file_message_tree_view(*args):
219
 
            self._file_message_text_view.realize()
220
 
        self.connect_after('realize', _realize_file_message_tree_view)
221
 
 
222
 
    def _fill_in_diff(self):
223
 
        self._diff_view.set_trees(self._wt, self._basis_tree)
224
 
 
225
 
    def _fill_in_checkout(self):
226
 
        if not self._is_checkout:
227
 
            self._check_local.hide()
228
 
            return
229
 
        if have_dbus:
230
 
            bus = dbus.SystemBus()
231
 
            try:
232
 
                proxy_obj = bus.get_object('org.freedesktop.NetworkManager',
233
 
                                           '/org/freedesktop/NetworkManager')
234
 
            except dbus.DBusException:
235
 
                mutter("networkmanager not available.")
236
 
                self._check_local.show()
237
 
                return
 
43
        
 
44
        # Get arguments
 
45
        self.wt = wt
 
46
        self.wtpath = wtpath
 
47
        self.notbranch = notbranch
 
48
        self.selected = selected
 
49
        
 
50
        # Set the delta
 
51
        self.old_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
 
52
        self.delta = self.wt.changes_from(self.old_tree)
 
53
        
 
54
        # Get pending merges
 
55
        self.pending = self._pending_merges(self.wt)
 
56
        
 
57
        # Do some preliminary checks
 
58
        self._is_checkout = False
 
59
        self._is_pending = False
 
60
        if self.wt is None and not self.notbranch:
 
61
            error_dialog(_('Directory does not have a working tree'),
 
62
                         _('Operation aborted.'))
 
63
            self.close()
 
64
            return
 
65
 
 
66
        if self.notbranch:
 
67
            error_dialog(_('Directory is not a branch'),
 
68
                         _('You can perform this action only in a branch.'))
 
69
            self.close()
 
70
            return
 
71
        else:
 
72
            if self.wt.branch.get_bound_location() is not None:
 
73
                # we have a checkout, so the local commit checkbox must appear
 
74
                self._is_checkout = True
238
75
            
239
 
            dbus_iface = dbus.Interface(proxy_obj,
240
 
                                        'org.freedesktop.NetworkManager')
241
 
            try:
242
 
                # 3 is the enum value for STATE_CONNECTED
243
 
                self._check_local.set_active(dbus_iface.state() != 3)
244
 
            except dbus.DBusException, e:
245
 
                # Silently drop errors. While DBus may be
246
 
                # available, NetworkManager doesn't necessarily have to be
247
 
                mutter("unable to get networkmanager state: %r" % e)
248
 
        self._check_local.show()
249
 
 
250
 
    def _fill_in_per_file_info(self):
251
 
        config = self._wt.branch.get_config()
252
 
        enable_per_file_commits = config.get_user_option('per_file_commits')
253
 
        if (enable_per_file_commits is None
254
 
            or enable_per_file_commits.lower()
255
 
                not in ('y', 'yes', 'on', 'enable', '1', 't', 'true')):
256
 
            self._enable_per_file_commits = False
257
 
        else:
258
 
            self._enable_per_file_commits = True
259
 
        if not self._enable_per_file_commits:
260
 
            self._file_message_expander.hide()
261
 
            self._global_message_label.set_markup(_i18n('<b>Commit Message</b>'))
262
 
 
263
 
    def _compute_delta(self):
264
 
        self._delta = self._wt.changes_from(self._basis_tree)
265
 
 
266
 
    def construct(self):
267
 
        """Build up the dialog widgets."""
268
 
        # The primary pane which splits it into left and right (adjustable)
269
 
        # sections.
270
 
        self._hpane = gtk.HPaned()
271
 
 
272
 
        self._construct_left_pane()
273
 
        self._construct_right_pane()
274
 
        self._construct_action_pane()
275
 
 
276
 
        self.vbox.pack_start(self._hpane)
277
 
        self._hpane.show()
278
 
        self.set_focus(self._global_message_text_view)
279
 
 
280
 
        self._construct_accelerators()
281
 
        self._set_sizes()
282
 
 
283
 
    def _set_sizes(self):
284
 
        # This seems like a reasonable default, we might like it to
285
 
        # be a bit wider, so that by default we can fit an 80-line diff in the
286
 
        # diff window.
287
 
        # Alternatively, we should be saving the last position/size rather than
288
 
        # setting it to a fixed value every time we start up.
289
 
        screen = self.get_screen()
290
 
        monitor = 0 # We would like it to be the monitor we are going to
291
 
                    # display on, but I don't know how to figure that out
292
 
                    # Only really useful for freaks like me that run dual
293
 
                    # monitor, with different sizes on the monitors
294
 
        monitor_rect = screen.get_monitor_geometry(monitor)
295
 
        width = int(monitor_rect.width * 0.66)
296
 
        height = int(monitor_rect.height * 0.66)
297
 
        self.set_default_size(width, height)
298
 
        self._hpane.set_position(300)
299
 
 
300
 
    def _construct_accelerators(self):
301
 
        group = gtk.AccelGroup()
302
 
        group.connect_group(gtk.gdk.keyval_from_name('N'),
303
 
                            gtk.gdk.CONTROL_MASK, 0, self._on_accel_next)
304
 
        self.add_accel_group(group)
305
 
 
306
 
        # ignore the escape key (avoid closing the window)
307
 
        self.connect_object('close', self.emit_stop_by_name, 'close')
308
 
 
309
 
    def _construct_left_pane(self):
310
 
        self._left_pane_box = gtk.VBox(homogeneous=False, spacing=5)
311
 
        self._construct_file_list()
312
 
        self._construct_pending_list()
313
 
 
314
 
        self._check_local = gtk.CheckButton(_i18n("_Only commit locally"),
315
 
                                            use_underline=True)
316
 
        self._left_pane_box.pack_end(self._check_local, False, False)
317
 
        self._check_local.set_active(False)
318
 
 
319
 
        self._hpane.pack1(self._left_pane_box, resize=False, shrink=False)
320
 
        self._left_pane_box.show()
321
 
 
322
 
    def _construct_right_pane(self):
323
 
        # TODO: I really want to make it so the diff view gets more space than
324
 
        # the global commit message, and the per-file commit message gets even
325
 
        # less. When I did it with wxGlade, I set it to 4 for diff, 2 for
326
 
        # commit, and 1 for file commit, and it looked good. But I don't seem
327
 
        # to have a way to do that with the gtk boxes... :( (Which is extra
328
 
        # weird since wx uses gtk on Linux...)
329
 
        self._right_pane_table = gtk.Table(rows=10, columns=1, homogeneous=False)
330
 
        self._right_pane_table.set_row_spacings(5)
331
 
        self._right_pane_table.set_col_spacings(5)
332
 
        self._right_pane_table_row = 0
333
 
        self._construct_diff_view()
334
 
        self._construct_file_message()
335
 
        self._construct_global_message()
336
 
 
337
 
        self._right_pane_table.show()
338
 
        self._hpane.pack2(self._right_pane_table, resize=True, shrink=True)
339
 
 
340
 
    def _construct_action_pane(self):
341
 
        self._button_commit = gtk.Button(_i18n("Comm_it"), use_underline=True)
 
76
            if self.pending:
 
77
                # There are pending merges, file selection not supported
 
78
                self._is_pending = True
 
79
        
 
80
        # Create the widgets
 
81
        self._button_commit = gtk.Button(_("Comm_it"), use_underline=True)
 
82
        if self._is_checkout:
 
83
            self._check_local = gtk.CheckButton(_("_Local only commit (works in checkouts)"),
 
84
                                                use_underline=True)
 
85
        self._check_strict = gtk.CheckButton(_("_Strict commit (fails if unknown files are present)"),
 
86
                                             use_underline=True)
 
87
        self._expander_files = gtk.Expander(_("Please select the file(s) to commit"))
 
88
        self._vpaned_main = gtk.VPaned()
 
89
        self._scrolledwindow_files = gtk.ScrolledWindow()
 
90
        self._scrolledwindow_message = gtk.ScrolledWindow()
 
91
        self._treeview_files = gtk.TreeView()
 
92
        self._vbox_message = gtk.VBox()
 
93
        self._label_message = gtk.Label(_("Please specify a commit message:"))
 
94
        self._textview_message = gtk.TextView()
 
95
        
 
96
        if self._is_pending:
 
97
            self._expander_merges = gtk.Expander(_("Pending merges"))
 
98
            self._vpaned_list = gtk.VPaned()
 
99
            self._scrolledwindow_merges = gtk.ScrolledWindow()
 
100
            self._treeview_merges = gtk.TreeView()
 
101
 
 
102
        # Set callbacks
342
103
        self._button_commit.connect('clicked', self._on_commit_clicked)
343
 
        self._button_commit.set_flags(gtk.CAN_DEFAULT)
344
 
        self._button_commit.show()
 
104
        self._treeview_files.connect('row_activated', self._on_treeview_files_row_activated)
 
105
        
 
106
        # Set properties
 
107
        self._scrolledwindow_files.set_policy(gtk.POLICY_AUTOMATIC,
 
108
                                              gtk.POLICY_AUTOMATIC)
 
109
        self._scrolledwindow_message.set_policy(gtk.POLICY_AUTOMATIC,
 
110
                                                gtk.POLICY_AUTOMATIC)
 
111
        self._textview_message.modify_font(pango.FontDescription("Monospace"))
 
112
        self.set_default_size(500, 500)
 
113
        self._vpaned_main.set_position(200)
 
114
 
 
115
        if self._is_pending:
 
116
            self._scrolledwindow_merges.set_policy(gtk.POLICY_AUTOMATIC,
 
117
                                                   gtk.POLICY_AUTOMATIC)
 
118
            self._treeview_files.set_sensitive(False)
 
119
        
 
120
        # Construct the dialog
345
121
        self.action_area.pack_end(self._button_commit)
346
 
        self._button_commit.grab_default()
347
 
 
348
 
    def _add_to_right_table(self, widget, weight, expanding=False):
349
 
        """Add another widget to the table
350
 
 
351
 
        :param widget: The object to add
352
 
        :param weight: How many rows does this widget get to request
353
 
        :param expanding: Should expand|fill|shrink be set?
354
 
        """
355
 
        end_row = self._right_pane_table_row + weight
356
 
        options = 0
357
 
        expand_opts = gtk.EXPAND | gtk.FILL | gtk.SHRINK
358
 
        if expanding:
359
 
            options = expand_opts
360
 
        self._right_pane_table.attach(widget, 0, 1,
361
 
                                      self._right_pane_table_row, end_row,
362
 
                                      xoptions=expand_opts, yoptions=options)
363
 
        self._right_pane_table_row = end_row
364
 
 
365
 
    def _construct_file_list(self):
366
 
        self._files_box = gtk.VBox(homogeneous=False, spacing=0)
367
 
        file_label = gtk.Label(_i18n('Files'))
368
 
        # file_label.show()
369
 
        self._files_box.pack_start(file_label, expand=False)
370
 
 
371
 
        self._commit_all_files_radio = gtk.RadioButton(
372
 
            None, _i18n("Commit all changes"))
373
 
        self._files_box.pack_start(self._commit_all_files_radio, expand=False)
374
 
        self._commit_all_files_radio.show()
375
 
        self._commit_all_files_radio.connect('toggled',
376
 
            self._toggle_commit_selection)
377
 
        self._commit_selected_radio = gtk.RadioButton(
378
 
            self._commit_all_files_radio, _i18n("Only commit selected changes"))
379
 
        self._files_box.pack_start(self._commit_selected_radio, expand=False)
380
 
        self._commit_selected_radio.show()
381
 
        self._commit_selected_radio.connect('toggled',
382
 
            self._toggle_commit_selection)
383
 
        if self._pending:
384
 
            self._commit_all_files_radio.set_label(_i18n('Commit all changes*'))
385
 
            self._commit_all_files_radio.set_sensitive(False)
386
 
            self._commit_selected_radio.set_sensitive(False)
387
 
 
388
 
        scroller = gtk.ScrolledWindow()
389
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
390
 
        self._treeview_files = gtk.TreeView()
391
 
        self._treeview_files.show()
392
 
        scroller.add(self._treeview_files)
393
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
394
 
        scroller.show()
395
 
        self._files_box.pack_start(scroller,
396
 
                                   expand=True, fill=True)
397
 
        self._files_box.show()
398
 
        self._left_pane_box.pack_start(self._files_box)
399
 
 
400
 
        # Keep note that all strings stored in a ListStore must be UTF-8
401
 
        # strings. GTK does not support directly setting and restoring Unicode
402
 
        # objects.
403
 
        liststore = gtk.ListStore(
404
 
            gobject.TYPE_STRING,  # [0] file_id
405
 
            gobject.TYPE_STRING,  # [1] real path
406
 
            gobject.TYPE_BOOLEAN, # [2] checkbox
407
 
            gobject.TYPE_STRING,  # [3] display path
408
 
            gobject.TYPE_STRING,  # [4] changes type
409
 
            gobject.TYPE_STRING,  # [5] commit message
410
 
            )
411
 
        self._files_store = liststore
412
 
        self._treeview_files.set_model(liststore)
413
 
        crt = gtk.CellRendererToggle()
414
 
        crt.set_property('activatable', not bool(self._pending))
415
 
        crt.connect("toggled", self._toggle_commit, self._files_store)
416
 
        if self._pending:
417
 
            name = _i18n('Commit*')
418
 
        else:
419
 
            name = _i18n('Commit')
420
 
        commit_col = gtk.TreeViewColumn(name, crt, active=2)
421
 
        commit_col.set_visible(False)
422
 
        self._treeview_files.append_column(commit_col)
423
 
        self._treeview_files.append_column(gtk.TreeViewColumn(_i18n('Path'),
424
 
                                           gtk.CellRendererText(), text=3))
425
 
        self._treeview_files.append_column(gtk.TreeViewColumn(_i18n('Type'),
426
 
                                           gtk.CellRendererText(), text=4))
427
 
        self._treeview_files.connect('cursor-changed',
428
 
                                     self._on_treeview_files_cursor_changed)
429
 
 
430
 
    def _toggle_commit(self, cell, path, model):
431
 
        if model[path][0] is None: # No file_id means 'All Files'
432
 
            new_val = not model[path][2]
433
 
            for node in model:
434
 
                node[2] = new_val
435
 
        else:
436
 
            model[path][2] = not model[path][2]
437
 
 
438
 
    def _toggle_commit_selection(self, button):
439
 
        all_files = self._commit_all_files_radio.get_active()
440
 
        if self._commit_all_changes != all_files:
441
 
            checked_col = self._treeview_files.get_column(0)
442
 
            self._commit_all_changes = all_files
443
 
            if all_files:
444
 
                checked_col.set_visible(False)
445
 
            else:
446
 
                checked_col.set_visible(True)
447
 
            renderer = checked_col.get_cell_renderers()[0]
448
 
            renderer.set_property('activatable', not all_files)
449
 
 
450
 
    def _construct_pending_list(self):
451
 
        # Pending information defaults to hidden, we put it all in 1 box, so
452
 
        # that we can show/hide all of them at once
453
 
        self._pending_box = gtk.VBox()
454
 
        self._pending_box.hide()
455
 
 
456
 
        pending_message = gtk.Label()
457
 
        pending_message.set_markup(
458
 
            _i18n('<i>* Cannot select specific files when merging</i>'))
459
 
        self._pending_box.pack_start(pending_message, expand=False, padding=5)
460
 
        pending_message.show()
461
 
 
462
 
        pending_label = gtk.Label(_i18n('Pending Revisions'))
463
 
        self._pending_box.pack_start(pending_label, expand=False, padding=0)
464
 
        pending_label.show()
465
 
 
466
 
        scroller = gtk.ScrolledWindow()
467
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
468
 
        self._treeview_pending = gtk.TreeView()
469
 
        scroller.add(self._treeview_pending)
470
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
471
 
        scroller.show()
472
 
        self._pending_box.pack_start(scroller,
473
 
                                     expand=True, fill=True, padding=5)
474
 
        self._treeview_pending.show()
475
 
        self._left_pane_box.pack_start(self._pending_box)
476
 
 
477
 
        liststore = gtk.ListStore(gobject.TYPE_STRING, # revision_id
478
 
                                  gobject.TYPE_STRING, # date
479
 
                                  gobject.TYPE_STRING, # committer
480
 
                                  gobject.TYPE_STRING, # summary
481
 
                                 )
482
 
        self._pending_store = liststore
483
 
        self._treeview_pending.set_model(liststore)
484
 
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Date'),
485
 
                                             gtk.CellRendererText(), text=1))
486
 
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Committer'),
487
 
                                             gtk.CellRendererText(), text=2))
488
 
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Summary'),
489
 
                                             gtk.CellRendererText(), text=3))
490
 
 
491
 
    def _construct_diff_view(self):
492
 
        from diff import DiffView
493
 
 
494
 
        # TODO: jam 2007-10-30 The diff label is currently disabled. If we
495
 
        #       decide that we really don't ever want to display it, we should
496
 
        #       actually remove it, and other references to it, along with the
497
 
        #       tests that it is set properly.
498
 
        self._diff_label = gtk.Label(_i18n('Diff for whole tree'))
499
 
        self._diff_label.set_alignment(0, 0)
500
 
        self._right_pane_table.set_row_spacing(self._right_pane_table_row, 0)
501
 
        self._add_to_right_table(self._diff_label, 1, False)
502
 
        # self._diff_label.show()
503
 
 
504
 
        self._diff_view = DiffView()
505
 
        self._add_to_right_table(self._diff_view, 4, True)
506
 
        self._diff_view.show()
507
 
 
508
 
    def _construct_file_message(self):
509
 
        scroller = gtk.ScrolledWindow()
510
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
511
 
 
512
 
        self._file_message_text_view = gtk.TextView()
513
 
        scroller.add(self._file_message_text_view)
514
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
515
 
        scroller.show()
516
 
 
517
 
        self._file_message_text_view.modify_font(pango.FontDescription("Monospace"))
518
 
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
519
 
        self._file_message_text_view.set_accepts_tab(False)
520
 
        self._file_message_text_view.show()
521
 
 
522
 
        self._file_message_expander = gtk.Expander(_i18n('File commit message'))
523
 
        self._file_message_expander.set_expanded(True)
524
 
        self._file_message_expander.add(scroller)
525
 
        self._add_to_right_table(self._file_message_expander, 1, False)
526
 
        self._file_message_expander.show()
527
 
 
528
 
    def _construct_global_message(self):
529
 
        self._global_message_label = gtk.Label(_i18n('Global Commit Message'))
530
 
        self._global_message_label.set_markup(
531
 
            _i18n('<b>Global Commit Message</b>'))
532
 
        self._global_message_label.set_alignment(0, 0)
533
 
        self._right_pane_table.set_row_spacing(self._right_pane_table_row, 0)
534
 
        self._add_to_right_table(self._global_message_label, 1, False)
535
 
        # Can we remove the spacing between the label and the box?
536
 
        self._global_message_label.show()
537
 
 
538
 
        scroller = gtk.ScrolledWindow()
539
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
540
 
 
541
 
        self._global_message_text_view = gtk.TextView()
542
 
        self._global_message_text_view.modify_font(pango.FontDescription("Monospace"))
543
 
        scroller.add(self._global_message_text_view)
544
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
545
 
        scroller.show()
546
 
        self._add_to_right_table(scroller, 2, True)
547
 
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
548
 
        self._file_message_text_view.set_accepts_tab(False)
549
 
        self._global_message_text_view.show()
550
 
 
551
 
    def _on_treeview_files_cursor_changed(self, treeview):
 
122
        
 
123
        self._scrolledwindow_files.add(self._treeview_files)
 
124
        self._scrolledwindow_message.add(self._textview_message)
 
125
        
 
126
        self._expander_files.add(self._scrolledwindow_files)
 
127
        
 
128
        self._vbox_message.pack_start(self._label_message, False, False)
 
129
        self._vbox_message.pack_start(self._scrolledwindow_message, True, True)
 
130
        
 
131
        if self._is_pending:        
 
132
            self._expander_merges.add(self._scrolledwindow_merges)
 
133
            self._scrolledwindow_merges.add(self._treeview_merges)
 
134
            self._vpaned_list.add1(self._expander_files)
 
135
            self._vpaned_list.add2(self._expander_merges)
 
136
            self._vpaned_main.add1(self._vpaned_list)
 
137
        else:
 
138
            self._vpaned_main.add1(self._expander_files)
 
139
 
 
140
        self._vpaned_main.add2(self._vbox_message)
 
141
        
 
142
        self.vbox.pack_start(self._vpaned_main, True, True)
 
143
        if self._is_checkout:
 
144
            self.vbox.pack_start(self._check_local, False, False)
 
145
        self.vbox.pack_start(self._check_strict, False, False)
 
146
        
 
147
        # Create the file list
 
148
        self._create_file_view()
 
149
        # Create the pending merges
 
150
        self._create_pending_merges()
 
151
        
 
152
        # Expand the corresponding expander
 
153
        if self._is_pending:
 
154
            self._expander_merges.set_expanded(True)
 
155
        else:
 
156
            self._expander_files.set_expanded(True)
 
157
        
 
158
        # Display dialog
 
159
        self.vbox.show_all()
 
160
    
 
161
    def _on_treeview_files_row_activated(self, treeview, path, view_column):
 
162
        # FIXME: the diff window freezes for some reason
552
163
        treeselection = treeview.get_selection()
553
 
        (model, selection) = treeselection.get_selected()
554
 
 
555
 
        if selection is not None:
556
 
            path, display_path = model.get(selection, 1, 3)
557
 
            self._diff_label.set_text(_i18n('Diff for ') + display_path)
558
 
            if path is None:
559
 
                self._diff_view.show_diff(None)
560
 
            else:
561
 
                self._diff_view.show_diff([path.decode('UTF-8')])
562
 
            self._update_per_file_info(selection)
563
 
 
564
 
    def _on_accel_next(self, accel_group, window, keyval, modifier):
565
 
        # We don't really care about any of the parameters, because we know
566
 
        # where this message came from
567
 
        tree_selection = self._treeview_files.get_selection()
568
 
        (model, selection) = tree_selection.get_selected()
569
 
        if selection is None:
570
 
            next = None
571
 
        else:
572
 
            next = model.iter_next(selection)
573
 
 
574
 
        if next is None:
575
 
            # We have either made it to the end of the list, or nothing was
576
 
            # selected. Either way, select All Files, and jump to the global
577
 
            # commit message.
578
 
            self._treeview_files.set_cursor((0,))
579
 
            self._global_message_text_view.grab_focus()
580
 
        else:
581
 
            # Set the cursor to this entry, and jump to the per-file commit
582
 
            # message
583
 
            self._treeview_files.set_cursor(model.get_path(next))
584
 
            self._file_message_text_view.grab_focus()
585
 
 
586
 
    def _save_current_file_message(self):
587
 
        if self._last_selected_file is None:
588
 
            return # Nothing to save
589
 
        text_buffer = self._file_message_text_view.get_buffer()
590
 
        cur_text = text_buffer.get_text(text_buffer.get_start_iter(),
591
 
                                        text_buffer.get_end_iter())
592
 
        last_selected = self._files_store.get_iter(self._last_selected_file)
593
 
        self._files_store.set_value(last_selected, 5, cur_text)
594
 
 
595
 
    def _update_per_file_info(self, selection):
596
 
        # The node is changing, so cache the current message
597
 
        if not self._enable_per_file_commits:
598
 
            return
599
 
 
600
 
        self._save_current_file_message()
601
 
        text_buffer = self._file_message_text_view.get_buffer()
602
 
        file_id, display_path, message = self._files_store.get(selection, 0, 3, 5)
603
 
        if file_id is None: # Whole tree
604
 
            self._file_message_expander.set_label(_i18n('File commit message'))
605
 
            self._file_message_expander.set_expanded(False)
606
 
            self._file_message_expander.set_sensitive(False)
607
 
            text_buffer.set_text('')
608
 
            self._last_selected_file = None
609
 
        else:
610
 
            self._file_message_expander.set_label(_i18n('Commit message for ')
611
 
                                                  + display_path)
612
 
            self._file_message_expander.set_expanded(True)
613
 
            self._file_message_expander.set_sensitive(True)
614
 
            text_buffer.set_text(message)
615
 
            self._last_selected_file = self._files_store.get_path(selection)
616
 
 
617
 
    def _get_specific_files(self):
618
 
        """Return the list of selected paths, and file info.
619
 
 
620
 
        :return: ([unicode paths], [{utf-8 file info}]
621
 
        """
622
 
        self._save_current_file_message()
623
 
        files = []
624
 
        records = iter(self._files_store)
625
 
        rec = records.next() # Skip the All Files record
626
 
        assert rec[0] is None, "Are we skipping the wrong record?"
627
 
 
628
 
        file_info = []
629
 
        for record in records:
630
 
            if self._commit_all_changes or record[2]:# [2] checkbox
631
 
                file_id = record[0] # [0] file_id
632
 
                path = record[1]    # [1] real path
633
 
                file_message = record[5] # [5] commit message
634
 
                files.append(path.decode('UTF-8'))
635
 
                if self._enable_per_file_commits and file_message:
636
 
                    # All of this needs to be utf-8 information
637
 
                    file_info.append({'path':path, 'file_id':file_id,
638
 
                                     'message':file_message})
639
 
        file_info.sort(key=lambda x:(x['path'], x['file_id']))
640
 
        if self._enable_per_file_commits:
641
 
            return files, file_info
642
 
        else:
643
 
            return files, []
644
 
 
 
164
        (model, iter) = treeselection.get_selected()
 
165
        
 
166
        if iter is not None:
 
167
            from olive import DiffWindow
 
168
            
 
169
            _selected = model.get_value(iter, 1)
 
170
            
 
171
            diff = DiffWindow()
 
172
            parent_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
 
173
            diff.set_diff(self.wt.branch.nick, self.wt, parent_tree)
 
174
            try:
 
175
                diff.set_file(_selected)
 
176
            except errors.NoSuchFile:
 
177
                pass
 
178
            diff.show()
 
179
    
645
180
    @show_bzr_error
646
181
    def _on_commit_clicked(self, button):
647
182
        """ Commit button clicked handler. """
648
 
        self._do_commit()
649
 
 
650
 
    def _do_commit(self):
651
 
        message = self._get_global_commit_message()
 
183
        textbuffer = self._textview_message.get_buffer()
 
184
        start, end = textbuffer.get_bounds()
 
185
        message = textbuffer.get_text(start, end).decode('utf-8')
 
186
        
 
187
        if not self.pending:
 
188
            specific_files = self._get_specific_files()
 
189
        else:
 
190
            specific_files = None
652
191
 
653
192
        if message == '':
654
 
            response = self._question_dialog(
655
 
                _i18n('Commit with an empty message?'),
656
 
                _i18n('You can describe your commit intent in the message.'))
 
193
            response = question_dialog(_('Commit with an empty message?'),
 
194
                                       _('You can describe your commit intent in the message.'))
657
195
            if response == gtk.RESPONSE_NO:
658
196
                # Kindly give focus to message area
659
 
                self._global_message_text_view.grab_focus()
660
 
                return
661
 
 
662
 
        specific_files, file_info = self._get_specific_files()
663
 
        if self._pending:
664
 
            specific_files = None
665
 
 
666
 
        local = self._check_local.get_active()
667
 
 
668
 
        # All we care about is if there is a single unknown, so if this loop is
669
 
        # entered, then there are unknown files.
670
 
        # TODO: jam 20071002 It seems like this should cancel the dialog
671
 
        #       entirely, since there isn't a way for them to add the unknown
672
 
        #       files at this point.
673
 
        for path in self._wt.unknowns():
674
 
            response = self._question_dialog(
675
 
                _i18n("Commit with unknowns?"),
676
 
                _i18n("Unknown files exist in the working tree. Commit anyway?"))
677
 
            if response == gtk.RESPONSE_NO:
678
 
                return
679
 
            break
680
 
 
681
 
        rev_id = None
682
 
        revprops = {}
683
 
        if file_info:
684
 
            revprops['file-info'] = bencode.bencode(file_info).decode('UTF-8')
 
197
                self._textview_message.grab_focus()
 
198
                return
 
199
 
 
200
        if self._is_checkout:
 
201
            local = self._check_local.get_active()
 
202
        else:
 
203
            local = False
 
204
        
685
205
        try:
686
 
            rev_id = self._wt.commit(message,
 
206
            self.wt.commit(message,
687
207
                       allow_pointless=False,
688
 
                       strict=False,
 
208
                       strict=self._check_strict.get_active(),
689
209
                       local=local,
690
 
                       specific_files=specific_files,
691
 
                       revprops=revprops)
 
210
                       specific_files=specific_files)
692
211
        except errors.PointlessCommit:
693
 
            response = self._question_dialog(
694
 
                _i18n('Commit with no changes?'),
695
 
                _i18n('There are no changes in the working tree.'
696
 
                      ' Do you want to commit anyway?'))
 
212
            response = question_dialog(_('Commit with no changes?'),
 
213
                                       _('There are no changes in the working tree.'))
697
214
            if response == gtk.RESPONSE_YES:
698
 
                rev_id = self._wt.commit(message,
 
215
                self.wt.commit(message,
699
216
                               allow_pointless=True,
700
 
                               strict=False,
 
217
                               strict=self._check_strict.get_active(),
701
218
                               local=local,
702
 
                               specific_files=specific_files,
703
 
                               revprops=revprops)
704
 
        self.committed_revision_id = rev_id
 
219
                               specific_files=specific_files)
705
220
        self.response(gtk.RESPONSE_OK)
706
221
 
707
 
    def _get_global_commit_message(self):
708
 
        buf = self._global_message_text_view.get_buffer()
709
 
        start, end = buf.get_bounds()
710
 
        return buf.get_text(start, end).decode('utf-8')
711
 
 
712
 
    def _set_global_commit_message(self, message):
713
 
        """Just a helper for the test suite."""
714
 
        if isinstance(message, unicode):
715
 
            message = message.encode('UTF-8')
716
 
        self._global_message_text_view.get_buffer().set_text(message)
717
 
 
718
 
    def _set_file_commit_message(self, message):
719
 
        """Helper for the test suite."""
720
 
        if isinstance(message, unicode):
721
 
            message = message.encode('UTF-8')
722
 
        self._file_message_text_view.get_buffer().set_text(message)
723
 
 
724
 
    @staticmethod
725
 
    def _rev_to_pending_info(rev):
726
 
        """Get the information from a pending merge."""
 
222
    def _pending_merges(self, wt):
 
223
        """ Return a list of pending merges or None if there are none of them. """
 
224
        parents = wt.get_parent_ids()
 
225
        if len(parents) < 2:
 
226
            return None
 
227
        
 
228
        import re
727
229
        from bzrlib.osutils import format_date
728
 
        rev_dict = {}
729
 
        rev_dict['committer'] = re.sub('<.*@.*>', '', rev.committer).strip(' ')
730
 
        rev_dict['summary'] = rev.get_summary()
731
 
        rev_dict['date'] = format_date(rev.timestamp,
732
 
                                       rev.timezone or 0,
733
 
                                       'original', date_fmt="%Y-%m-%d",
734
 
                                       show_offset=False)
735
 
        rev_dict['revision_id'] = rev.revision_id
736
 
        return rev_dict
 
230
        
 
231
        pending = parents[1:]
 
232
        branch = wt.branch
 
233
        last_revision = parents[0]
 
234
        
 
235
        if last_revision is not None:
 
236
            try:
 
237
                ignore = set(branch.repository.get_ancestry(last_revision))
 
238
            except errors.NoSuchRevision:
 
239
                # the last revision is a ghost : assume everything is new 
 
240
                # except for it
 
241
                ignore = set([None, last_revision])
 
242
        else:
 
243
            ignore = set([None])
 
244
        
 
245
        pm = []
 
246
        for merge in pending:
 
247
            ignore.add(merge)
 
248
            try:
 
249
                m_revision = branch.repository.get_revision(merge)
 
250
                
 
251
                rev = {}
 
252
                rev['committer'] = re.sub('<.*@.*>', '', m_revision.committer).strip(' ')
 
253
                rev['summary'] = m_revision.get_summary()
 
254
                rev['date'] = format_date(m_revision.timestamp,
 
255
                                          m_revision.timezone or 0, 
 
256
                                          'original', date_fmt="%Y-%m-%d",
 
257
                                          show_offset=False)
 
258
                
 
259
                pm.append(rev)
 
260
                
 
261
                inner_merges = branch.repository.get_ancestry(merge)
 
262
                assert inner_merges[0] is None
 
263
                inner_merges.pop(0)
 
264
                inner_merges.reverse()
 
265
                for mmerge in inner_merges:
 
266
                    if mmerge in ignore:
 
267
                        continue
 
268
                    mm_revision = branch.repository.get_revision(mmerge)
 
269
                    
 
270
                    rev = {}
 
271
                    rev['committer'] = re.sub('<.*@.*>', '', mm_revision.committer).strip(' ')
 
272
                    rev['summary'] = mm_revision.get_summary()
 
273
                    rev['date'] = format_date(mm_revision.timestamp,
 
274
                                              mm_revision.timezone or 0, 
 
275
                                              'original', date_fmt="%Y-%m-%d",
 
276
                                              show_offset=False)
 
277
                
 
278
                    pm.append(rev)
 
279
                    
 
280
                    ignore.add(mmerge)
 
281
            except errors.NoSuchRevision:
 
282
                print "DEBUG: NoSuchRevision:", merge
 
283
        
 
284
        return pm
 
285
 
 
286
    def _create_file_view(self):
 
287
        self._file_store = gtk.ListStore(gobject.TYPE_BOOLEAN,   # [0] checkbox
 
288
                                         gobject.TYPE_STRING,    # [1] path to display
 
289
                                         gobject.TYPE_STRING,    # [2] changes type
 
290
                                         gobject.TYPE_STRING)    # [3] real path
 
291
        self._treeview_files.set_model(self._file_store)
 
292
        crt = gtk.CellRendererToggle()
 
293
        crt.set_property("activatable", True)
 
294
        crt.connect("toggled", self._toggle_commit, self._file_store)
 
295
        self._treeview_files.append_column(gtk.TreeViewColumn(_('Commit'),
 
296
                                     crt, active=0))
 
297
        self._treeview_files.append_column(gtk.TreeViewColumn(_('Path'),
 
298
                                     gtk.CellRendererText(), text=1))
 
299
        self._treeview_files.append_column(gtk.TreeViewColumn(_('Type'),
 
300
                                     gtk.CellRendererText(), text=2))
 
301
 
 
302
        for path, id, kind in self.delta.added:
 
303
            marker = osutils.kind_marker(kind)
 
304
            self._file_store.append([ True, path+marker, _('added'), path ])
 
305
 
 
306
        for path, id, kind in self.delta.removed:
 
307
            marker = osutils.kind_marker(kind)
 
308
            self._file_store.append([ True, path+marker, _('removed'), path ])
 
309
 
 
310
        for oldpath, newpath, id, kind, text_modified, meta_modified in self.delta.renamed:
 
311
            marker = osutils.kind_marker(kind)
 
312
            if text_modified or meta_modified:
 
313
                changes = _('renamed and modified')
 
314
            else:
 
315
                changes = _('renamed')
 
316
            self._file_store.append([ True,
 
317
                                      oldpath+marker + '  =>  ' + newpath+marker,
 
318
                                      changes,
 
319
                                      newpath
 
320
                                    ])
 
321
 
 
322
        for path, id, kind, text_modified, meta_modified in self.delta.modified:
 
323
            marker = osutils.kind_marker(kind)
 
324
            self._file_store.append([ True, path+marker, _('modified'), path ])
 
325
    
 
326
    def _create_pending_merges(self):
 
327
        if not self.pending:
 
328
            return
 
329
        
 
330
        liststore = gtk.ListStore(gobject.TYPE_STRING,
 
331
                                  gobject.TYPE_STRING,
 
332
                                  gobject.TYPE_STRING)
 
333
        self._treeview_merges.set_model(liststore)
 
334
        
 
335
        self._treeview_merges.append_column(gtk.TreeViewColumn(_('Date'),
 
336
                                            gtk.CellRendererText(), text=0))
 
337
        self._treeview_merges.append_column(gtk.TreeViewColumn(_('Committer'),
 
338
                                            gtk.CellRendererText(), text=1))
 
339
        self._treeview_merges.append_column(gtk.TreeViewColumn(_('Summary'),
 
340
                                            gtk.CellRendererText(), text=2))
 
341
        
 
342
        for item in self.pending:
 
343
            liststore.append([ item['date'],
 
344
                               item['committer'],
 
345
                               item['summary'] ])
 
346
    
 
347
    def _get_specific_files(self):
 
348
        ret = []
 
349
        it = self._file_store.get_iter_first()
 
350
        while it:
 
351
            if self._file_store.get_value(it, 0):
 
352
                # get real path from hidden column 3
 
353
                ret.append(self._file_store.get_value(it, 3))
 
354
            it = self._file_store.iter_next(it)
 
355
 
 
356
        return ret
 
357
    
 
358
    def _toggle_commit(self, cell, path, model):
 
359
        model[path][0] = not model[path][0]
 
360
        return