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

  • Committer: Vincent Ladeuil
  • Date: 2009-05-28 15:14:14 UTC
  • mto: This revision was merged to the branch mainline in revision 640.
  • Revision ID: v.ladeuil+lp@free.fr-20090528151414-q5rlh8kaicx2hgqo
Implement commit message saving without modifying bzrlib.

* tests/test_commit.py:
(TestSavedCommitMessages.setUp): Install the post_uncommit hook
for all relevant tests.
(TestUncommitHook.setUp): Use explicit rev-ids to ease debugging.

* commit.py: 
Fix imports. Integrate SavedCommitMessagesManager so that we don't
need to modify bzrlib anymore.
(CommitDialog.__init__, CommitDialog._fill_in_files,
CommitDialog._construct_global_message, CommitDialog._do_cancel,
CommitDialog._do_commit): Stop testing can_save_commit_messages,
SavedCommitMessagesManager is always available now.
(SavedCommitMessagesManager): Borrowed from Anne Mohsen's patch.
(save_commit_messages): Implement the post_uncommit hook.

* __init__.py:
Install a lazy hook.

Show diffs side-by-side

added added

removed removed

Lines of Context:
commit.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import os.path
17
18
import re
18
19
 
19
 
from gi.repository import Gdk
20
 
from gi.repository import Gtk
21
 
from gi.repository import GObject
22
 
from gi.repository import Pango
 
20
try:
 
21
    import pygtk
 
22
    pygtk.require("2.0")
 
23
except:
 
24
    pass
 
25
 
 
26
import gtk
 
27
import gobject
 
28
import pango
23
29
 
24
30
from bzrlib import (
25
 
    bencode,
 
31
    branch,
26
32
    errors,
27
33
    osutils,
28
 
    revision as _mod_revision,
29
34
    trace,
30
 
    tsort,
31
35
    )
 
36
from bzrlib.util import bencode
 
37
 
 
38
from bzrlib.plugins.gtk import _i18n
32
39
from bzrlib.plugins.gtk.dialog import question_dialog
33
 
from bzrlib.plugins.gtk.diff import DiffView
34
40
from bzrlib.plugins.gtk.errors import show_bzr_error
35
 
from bzrlib.plugins.gtk.i18n import _i18n
36
 
from bzrlib.plugins.gtk.commitmsgs import SavedCommitMessagesManager
37
41
 
38
42
try:
39
43
    import dbus
43
47
    have_dbus = False
44
48
 
45
49
 
46
 
def _get_sorted_revisions(tip_revision, revision_ids, parent_map):
47
 
    """Get an iterator which will return the revisions in merge sorted order.
48
 
 
49
 
    This will build up a list of all nodes, such that only nodes in the list
50
 
    are referenced. It then uses MergeSorter to return them in 'merge-sorted'
51
 
    order.
52
 
 
53
 
    :param revision_ids: A set of revision_ids
54
 
    :param parent_map: The parent information for each node. Revisions which
55
 
        are considered ghosts should not be present in the map.
56
 
    :return: iterator from MergeSorter.iter_topo_order()
57
 
    """
58
 
    # MergeSorter requires that all nodes be present in the graph, so get rid
59
 
    # of any references pointing outside of this graph.
60
 
    parent_graph = {}
61
 
    for revision_id in revision_ids:
62
 
        if revision_id not in parent_map: # ghost
63
 
            parent_graph[revision_id] = []
64
 
        else:
65
 
            # Only include parents which are in this sub-graph
66
 
            parent_graph[revision_id] = [p for p in parent_map[revision_id]
67
 
                                            if p in revision_ids]
68
 
    sorter = tsort.MergeSorter(parent_graph, tip_revision)
69
 
    return sorter.iter_topo_order()
70
 
 
71
 
 
72
50
def pending_revisions(wt):
73
51
    """Return a list of pending merges or None if there are none of them.
74
52
 
79
57
    """
80
58
    parents = wt.get_parent_ids()
81
59
    if len(parents) < 2:
82
 
        return
 
60
        return None
83
61
 
84
62
    # The basic pending merge algorithm uses the same algorithm as
85
63
    # bzrlib.status.show_pending_merges
87
65
    branch = wt.branch
88
66
    last_revision = parents[0]
89
67
 
90
 
    graph = branch.repository.get_graph()
91
 
    other_revisions = [last_revision]
 
68
    if last_revision is not None:
 
69
        try:
 
70
            ignore = set(branch.repository.get_ancestry(last_revision,
 
71
                                                        topo_sorted=False))
 
72
        except errors.NoSuchRevision:
 
73
            # the last revision is a ghost : assume everything is new
 
74
            # except for it
 
75
            ignore = set([None, last_revision])
 
76
    else:
 
77
        ignore = set([None])
92
78
 
93
79
    pm = []
94
80
    for merge in pending:
95
 
        try:
96
 
            merge_rev = branch.repository.get_revision(merge)
97
 
        except errors.NoSuchRevision:
98
 
            # If we are missing a revision, just print out the revision id
99
 
            trace.mutter("ghost: %r", merge)
100
 
            other_revisions.append(merge)
101
 
            continue
102
 
 
103
 
        # Find all of the revisions in the merge source, which are not in the
104
 
        # last committed revision.
105
 
        merge_extra = graph.find_unique_ancestors(merge, other_revisions)
106
 
        other_revisions.append(merge)
107
 
        merge_extra.discard(_mod_revision.NULL_REVISION)
108
 
 
109
 
        # Get a handle to all of the revisions we will need
110
 
        try:
111
 
            revisions = dict((rev.revision_id, rev) for rev in
112
 
                             branch.repository.get_revisions(merge_extra))
113
 
        except errors.NoSuchRevision:
114
 
            # One of the sub nodes is a ghost, check each one
115
 
            revisions = {}
116
 
            for revision_id in merge_extra:
117
 
                try:
118
 
                    rev = branch.repository.get_revisions([revision_id])[0]
119
 
                except errors.NoSuchRevision:
120
 
                    revisions[revision_id] = None
121
 
                else:
122
 
                    revisions[revision_id] = rev
123
 
 
124
 
         # Display the revisions brought in by this merge.
125
 
        rev_id_iterator = _get_sorted_revisions(merge, merge_extra,
126
 
                            branch.repository.get_parent_map(merge_extra))
127
 
        # Skip the first node
128
 
        num, first, depth, eom = rev_id_iterator.next()
129
 
        if first != merge:
130
 
            raise AssertionError('Somehow we misunderstood how'
131
 
                ' iter_topo_order works %s != %s' % (first, merge))
132
 
        children = []
133
 
        for num, sub_merge, depth, eom in rev_id_iterator:
134
 
            rev = revisions[sub_merge]
135
 
            if rev is None:
136
 
                trace.warning("ghost: %r", sub_merge)
137
 
                continue
138
 
            children.append(rev)
139
 
        yield (merge_rev, children)
 
81
        ignore.add(merge)
 
82
        try:
 
83
            rev = branch.repository.get_revision(merge)
 
84
            children = []
 
85
            pm.append((rev, children))
 
86
 
 
87
            # This does need to be topo sorted, so we search backwards
 
88
            inner_merges = branch.repository.get_ancestry(merge)
 
89
            assert inner_merges[0] is None
 
90
            inner_merges.pop(0)
 
91
            for mmerge in reversed(inner_merges):
 
92
                if mmerge in ignore:
 
93
                    continue
 
94
                rev = branch.repository.get_revision(mmerge)
 
95
                children.append(rev)
 
96
 
 
97
                ignore.add(mmerge)
 
98
        except errors.NoSuchRevision:
 
99
            print "DEBUG: NoSuchRevision:", merge
 
100
 
 
101
    return pm
140
102
 
141
103
 
142
104
_newline_variants_re = re.compile(r'\r\n?')
143
105
def _sanitize_and_decode_message(utf8_message):
144
106
    """Turn a utf-8 message into a sanitized Unicode message."""
145
107
    fixed_newline = _newline_variants_re.sub('\n', utf8_message)
146
 
    return osutils.safe_unicode(fixed_newline)
147
 
 
148
 
 
149
 
class CommitDialog(Gtk.Dialog):
 
108
    return fixed_newline.decode('utf-8')
 
109
 
 
110
 
 
111
class CommitDialog(gtk.Dialog):
150
112
    """Implementation of Commit."""
151
113
 
152
114
    def __init__(self, wt, selected=None, parent=None):
153
 
        super(CommitDialog, self).__init__(
154
 
            title="Commit to %s" % wt.basedir, parent=parent, flags=0)
 
115
        gtk.Dialog.__init__(self, title="Commit to %s" % wt.basedir,
 
116
                            parent=parent, flags=0,)
155
117
        self.connect('delete-event', self._on_delete_window)
156
118
        self._question_dialog = question_dialog
157
119
 
158
 
        self.set_type_hint(Gdk.WindowTypeHint.NORMAL)
 
120
        self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NORMAL)
159
121
 
160
122
        self._wt = wt
161
123
        # TODO: Do something with this value, it is used by Olive
164
126
        self._enable_per_file_commits = True
165
127
        self._commit_all_changes = True
166
128
        self.committed_revision_id = None # Nothing has been committed yet
167
 
        self._last_selected_file = None
168
 
        self._saved_commit_messages_manager = SavedCommitMessagesManager(
169
 
            self._wt, self._wt.branch)
 
129
        self._saved_commit_messages_manager = SavedCommitMessagesManager(self._wt, self._wt.branch)
170
130
 
171
131
        self.setup_params()
172
132
        self.construct()
176
136
        """Setup the member variables for state."""
177
137
        self._basis_tree = self._wt.basis_tree()
178
138
        self._delta = None
179
 
        self._wt.lock_read()
180
 
        try:
181
 
            self._pending = list(pending_revisions(self._wt))
182
 
        finally:
183
 
            self._wt.unlock()
 
139
        self._pending = pending_revisions(self._wt)
184
140
 
185
141
        self._is_checkout = (self._wt.branch.get_bound_location() is not None)
186
142
 
238
194
 
239
195
        all_enabled = (self._selected is None)
240
196
        # The first entry is always the 'whole tree'
241
 
        all_iter = store.append(["", "", all_enabled, 'All Files', '', ''])
 
197
        all_iter = store.append([None, None, all_enabled, 'All Files', '', ''])
242
198
        initial_cursor = store.get_path(all_iter)
243
199
        # should we pass specific_files?
244
200
        self._wt.lock_read()
275
231
        # This sets the cursor, which causes the expander to close, which
276
232
        # causes the _file_message_text_view to never get realized. So we have
277
233
        # to give it a little kick, or it warns when we try to grab the focus
278
 
        self._treeview_files.set_cursor(initial_cursor, None, False)
 
234
        self._treeview_files.set_cursor(initial_cursor)
279
235
 
280
236
        def _realize_file_message_tree_view(*args):
281
237
            self._file_message_text_view.realize()
289
245
            self._check_local.hide()
290
246
            return
291
247
        if have_dbus:
292
 
            try:
293
 
                bus = dbus.SystemBus()
294
 
            except dbus.DBusException:
295
 
                trace.mutter("DBus system bus not available")
296
 
                self._check_local.show()
297
 
                return
 
248
            bus = dbus.SystemBus()
298
249
            try:
299
250
                proxy_obj = bus.get_object('org.freedesktop.NetworkManager',
300
251
                                           '/org/freedesktop/NetworkManager')
302
253
                trace.mutter("networkmanager not available.")
303
254
                self._check_local.show()
304
255
                return
305
 
 
 
256
            
306
257
            dbus_iface = dbus.Interface(proxy_obj,
307
258
                                        'org.freedesktop.NetworkManager')
308
259
            try:
334
285
        """Build up the dialog widgets."""
335
286
        # The primary pane which splits it into left and right (adjustable)
336
287
        # sections.
337
 
        self._hpane = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
 
288
        self._hpane = gtk.HPaned()
338
289
 
339
290
        self._construct_left_pane()
340
291
        self._construct_right_pane()
341
292
        self._construct_action_pane()
342
293
 
343
 
        self.get_content_area().pack_start(self._hpane, True, True, 0)
 
294
        self.vbox.pack_start(self._hpane)
344
295
        self._hpane.show()
345
296
        self.set_focus(self._global_message_text_view)
346
297
 
365
316
        self._hpane.set_position(300)
366
317
 
367
318
    def _construct_accelerators(self):
368
 
        group = Gtk.AccelGroup()
369
 
        group.connect(Gdk.keyval_from_name('N'),
370
 
                      Gdk.ModifierType.CONTROL_MASK, 0, self._on_accel_next)
 
319
        group = gtk.AccelGroup()
 
320
        group.connect_group(gtk.gdk.keyval_from_name('N'),
 
321
                            gtk.gdk.CONTROL_MASK, 0, self._on_accel_next)
371
322
        self.add_accel_group(group)
372
323
 
373
324
        # ignore the escape key (avoid closing the window)
374
325
        self.connect_object('close', self.emit_stop_by_name, 'close')
375
326
 
376
327
    def _construct_left_pane(self):
377
 
        self._left_pane_box = Gtk.VBox(homogeneous=False, spacing=5)
 
328
        self._left_pane_box = gtk.VBox(homogeneous=False, spacing=5)
378
329
        self._construct_file_list()
379
330
        self._construct_pending_list()
380
331
 
381
 
        self._check_local = Gtk.CheckButton(_i18n("_Only commit locally"),
 
332
        self._check_local = gtk.CheckButton(_i18n("_Only commit locally"),
382
333
                                            use_underline=True)
383
 
        self._left_pane_box.pack_end(self._check_local, False, False, 0)
 
334
        self._left_pane_box.pack_end(self._check_local, False, False)
384
335
        self._check_local.set_active(False)
385
336
 
386
337
        self._hpane.pack1(self._left_pane_box, resize=False, shrink=False)
393
344
        # commit, and 1 for file commit, and it looked good. But I don't seem
394
345
        # to have a way to do that with the gtk boxes... :( (Which is extra
395
346
        # weird since wx uses gtk on Linux...)
396
 
        self._right_pane_table = Gtk.Table(rows=10, columns=1, homogeneous=False)
 
347
        self._right_pane_table = gtk.Table(rows=10, columns=1, homogeneous=False)
397
348
        self._right_pane_table.set_row_spacings(5)
398
349
        self._right_pane_table.set_col_spacings(5)
399
350
        self._right_pane_table_row = 0
405
356
        self._hpane.pack2(self._right_pane_table, resize=True, shrink=True)
406
357
 
407
358
    def _construct_action_pane(self):
408
 
        self._button_cancel = Gtk.Button(stock=Gtk.STOCK_CANCEL)
 
359
        self._button_cancel = gtk.Button(stock=gtk.STOCK_CANCEL)
409
360
        self._button_cancel.connect('clicked', self._on_cancel_clicked)
410
361
        self._button_cancel.show()
411
 
        self.get_action_area().pack_end(
412
 
            self._button_cancel, True, True, 0)
413
 
        self._button_commit = Gtk.Button(_i18n("Comm_it"), use_underline=True)
 
362
        self.action_area.pack_end(self._button_cancel)
 
363
        self._button_commit = gtk.Button(_i18n("Comm_it"), use_underline=True)
414
364
        self._button_commit.connect('clicked', self._on_commit_clicked)
415
 
        self._button_commit.set_can_default(True)
 
365
        self._button_commit.set_flags(gtk.CAN_DEFAULT)
416
366
        self._button_commit.show()
417
 
        self.get_action_area().pack_end(
418
 
            self._button_commit, True, True, 0)
 
367
        self.action_area.pack_end(self._button_commit)
419
368
        self._button_commit.grab_default()
420
369
 
421
370
    def _add_to_right_table(self, widget, weight, expanding=False):
427
376
        """
428
377
        end_row = self._right_pane_table_row + weight
429
378
        options = 0
430
 
        expand_opts = Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK
 
379
        expand_opts = gtk.EXPAND | gtk.FILL | gtk.SHRINK
431
380
        if expanding:
432
381
            options = expand_opts
433
382
        self._right_pane_table.attach(widget, 0, 1,
436
385
        self._right_pane_table_row = end_row
437
386
 
438
387
    def _construct_file_list(self):
439
 
        self._files_box = Gtk.VBox(homogeneous=False, spacing=0)
440
 
        file_label = Gtk.Label(label=_i18n('Files'))
 
388
        self._files_box = gtk.VBox(homogeneous=False, spacing=0)
 
389
        file_label = gtk.Label(_i18n('Files'))
441
390
        # file_label.show()
442
 
        self._files_box.pack_start(file_label, False, True, 0)
 
391
        self._files_box.pack_start(file_label, expand=False)
443
392
 
444
 
        self._commit_all_files_radio = Gtk.RadioButton.new_with_label(
 
393
        self._commit_all_files_radio = gtk.RadioButton(
445
394
            None, _i18n("Commit all changes"))
446
 
        self._files_box.pack_start(self._commit_all_files_radio, False, True, 0)
 
395
        self._files_box.pack_start(self._commit_all_files_radio, expand=False)
447
396
        self._commit_all_files_radio.show()
448
397
        self._commit_all_files_radio.connect('toggled',
449
398
            self._toggle_commit_selection)
450
 
        self._commit_selected_radio = Gtk.RadioButton.new_with_label_from_widget(
 
399
        self._commit_selected_radio = gtk.RadioButton(
451
400
            self._commit_all_files_radio, _i18n("Only commit selected changes"))
452
 
        self._files_box.pack_start(self._commit_selected_radio, False, True, 0)
 
401
        self._files_box.pack_start(self._commit_selected_radio, expand=False)
453
402
        self._commit_selected_radio.show()
454
403
        self._commit_selected_radio.connect('toggled',
455
404
            self._toggle_commit_selection)
458
407
            self._commit_all_files_radio.set_sensitive(False)
459
408
            self._commit_selected_radio.set_sensitive(False)
460
409
 
461
 
        scroller = Gtk.ScrolledWindow()
462
 
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
463
 
        self._treeview_files = Gtk.TreeView()
 
410
        scroller = gtk.ScrolledWindow()
 
411
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
412
        self._treeview_files = gtk.TreeView()
464
413
        self._treeview_files.show()
465
414
        scroller.add(self._treeview_files)
466
 
        scroller.set_shadow_type(Gtk.ShadowType.IN)
 
415
        scroller.set_shadow_type(gtk.SHADOW_IN)
467
416
        scroller.show()
468
 
        self._files_box.pack_start(scroller, True, True, 0)
 
417
        self._files_box.pack_start(scroller,
 
418
                                   expand=True, fill=True)
469
419
        self._files_box.show()
470
 
        self._left_pane_box.pack_start(self._files_box, True, True, 0)
 
420
        self._left_pane_box.pack_start(self._files_box)
471
421
 
472
422
        # Keep note that all strings stored in a ListStore must be UTF-8
473
423
        # strings. GTK does not support directly setting and restoring Unicode
474
424
        # objects.
475
 
        liststore = Gtk.ListStore(
476
 
            GObject.TYPE_STRING,  # [0] file_id
477
 
            GObject.TYPE_STRING,  # [1] real path
478
 
            GObject.TYPE_BOOLEAN, # [2] checkbox
479
 
            GObject.TYPE_STRING,  # [3] display path
480
 
            GObject.TYPE_STRING,  # [4] changes type
481
 
            GObject.TYPE_STRING,  # [5] commit message
 
425
        liststore = gtk.ListStore(
 
426
            gobject.TYPE_STRING,  # [0] file_id
 
427
            gobject.TYPE_STRING,  # [1] real path
 
428
            gobject.TYPE_BOOLEAN, # [2] checkbox
 
429
            gobject.TYPE_STRING,  # [3] display path
 
430
            gobject.TYPE_STRING,  # [4] changes type
 
431
            gobject.TYPE_STRING,  # [5] commit message
482
432
            )
483
433
        self._files_store = liststore
484
434
        self._treeview_files.set_model(liststore)
485
 
        crt = Gtk.CellRendererToggle()
 
435
        crt = gtk.CellRendererToggle()
486
436
        crt.set_property('activatable', not bool(self._pending))
487
437
        crt.connect("toggled", self._toggle_commit, self._files_store)
488
438
        if self._pending:
489
439
            name = _i18n('Commit*')
490
440
        else:
491
441
            name = _i18n('Commit')
492
 
        commit_col = Gtk.TreeViewColumn(name, crt, active=2)
 
442
        commit_col = gtk.TreeViewColumn(name, crt, active=2)
493
443
        commit_col.set_visible(False)
494
444
        self._treeview_files.append_column(commit_col)
495
 
        self._treeview_files.append_column(Gtk.TreeViewColumn(_i18n('Path'),
496
 
                                           Gtk.CellRendererText(), text=3))
497
 
        self._treeview_files.append_column(Gtk.TreeViewColumn(_i18n('Type'),
498
 
                                           Gtk.CellRendererText(), text=4))
 
445
        self._treeview_files.append_column(gtk.TreeViewColumn(_i18n('Path'),
 
446
                                           gtk.CellRendererText(), text=3))
 
447
        self._treeview_files.append_column(gtk.TreeViewColumn(_i18n('Type'),
 
448
                                           gtk.CellRendererText(), text=4))
499
449
        self._treeview_files.connect('cursor-changed',
500
450
                                     self._on_treeview_files_cursor_changed)
501
451
 
502
452
    def _toggle_commit(self, cell, path, model):
503
 
        if model[path][0] == "": # No file_id means 'All Files'
 
453
        if model[path][0] is None: # No file_id means 'All Files'
504
454
            new_val = not model[path][2]
505
455
            for node in model:
506
456
                node[2] = new_val
516
466
                checked_col.set_visible(False)
517
467
            else:
518
468
                checked_col.set_visible(True)
519
 
            renderer = checked_col.get_cells()[0]
 
469
            renderer = checked_col.get_cell_renderers()[0]
520
470
            renderer.set_property('activatable', not all_files)
521
471
 
522
472
    def _construct_pending_list(self):
523
473
        # Pending information defaults to hidden, we put it all in 1 box, so
524
474
        # that we can show/hide all of them at once
525
 
        self._pending_box = Gtk.VBox()
 
475
        self._pending_box = gtk.VBox()
526
476
        self._pending_box.hide()
527
477
 
528
 
        pending_message = Gtk.Label()
 
478
        pending_message = gtk.Label()
529
479
        pending_message.set_markup(
530
480
            _i18n('<i>* Cannot select specific files when merging</i>'))
531
 
        self._pending_box.pack_start(pending_message, False, True, 5)
 
481
        self._pending_box.pack_start(pending_message, expand=False, padding=5)
532
482
        pending_message.show()
533
483
 
534
 
        pending_label = Gtk.Label(label=_i18n('Pending Revisions'))
535
 
        self._pending_box.pack_start(pending_label, False, True, 0)
 
484
        pending_label = gtk.Label(_i18n('Pending Revisions'))
 
485
        self._pending_box.pack_start(pending_label, expand=False, padding=0)
536
486
        pending_label.show()
537
487
 
538
 
        scroller = Gtk.ScrolledWindow()
539
 
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
540
 
        self._treeview_pending = Gtk.TreeView()
 
488
        scroller = gtk.ScrolledWindow()
 
489
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
490
        self._treeview_pending = gtk.TreeView()
541
491
        scroller.add(self._treeview_pending)
542
 
        scroller.set_shadow_type(Gtk.ShadowType.IN)
 
492
        scroller.set_shadow_type(gtk.SHADOW_IN)
543
493
        scroller.show()
544
 
        self._pending_box.pack_start(scroller, True, True, 5)
 
494
        self._pending_box.pack_start(scroller,
 
495
                                     expand=True, fill=True, padding=5)
545
496
        self._treeview_pending.show()
546
 
        self._left_pane_box.pack_start(self._pending_box, True, True, 0)
 
497
        self._left_pane_box.pack_start(self._pending_box)
547
498
 
548
 
        liststore = Gtk.ListStore(GObject.TYPE_STRING, # revision_id
549
 
                                  GObject.TYPE_STRING, # date
550
 
                                  GObject.TYPE_STRING, # committer
551
 
                                  GObject.TYPE_STRING, # summary
 
499
        liststore = gtk.ListStore(gobject.TYPE_STRING, # revision_id
 
500
                                  gobject.TYPE_STRING, # date
 
501
                                  gobject.TYPE_STRING, # committer
 
502
                                  gobject.TYPE_STRING, # summary
552
503
                                 )
553
504
        self._pending_store = liststore
554
505
        self._treeview_pending.set_model(liststore)
555
 
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Date'),
556
 
                                             Gtk.CellRendererText(), text=1))
557
 
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Committer'),
558
 
                                             Gtk.CellRendererText(), text=2))
559
 
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Summary'),
560
 
                                             Gtk.CellRendererText(), text=3))
 
506
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Date'),
 
507
                                             gtk.CellRendererText(), text=1))
 
508
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Committer'),
 
509
                                             gtk.CellRendererText(), text=2))
 
510
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Summary'),
 
511
                                             gtk.CellRendererText(), text=3))
561
512
 
562
513
    def _construct_diff_view(self):
 
514
        from diff import DiffView
 
515
 
563
516
        # TODO: jam 2007-10-30 The diff label is currently disabled. If we
564
517
        #       decide that we really don't ever want to display it, we should
565
518
        #       actually remove it, and other references to it, along with the
566
519
        #       tests that it is set properly.
567
 
        self._diff_label = Gtk.Label(label=_i18n('Diff for whole tree'))
 
520
        self._diff_label = gtk.Label(_i18n('Diff for whole tree'))
568
521
        self._diff_label.set_alignment(0, 0)
569
522
        self._right_pane_table.set_row_spacing(self._right_pane_table_row, 0)
570
523
        self._add_to_right_table(self._diff_label, 1, False)
574
527
        self._add_to_right_table(self._diff_view, 4, True)
575
528
        self._diff_view.show()
576
529
 
577
 
    @staticmethod
578
 
    def get_line_height(widget):
579
 
        pango_layout = widget.create_pango_layout("X");
580
 
        ink_rectangle, logical_rectangle = pango_layout.get_pixel_extents()
581
 
        return logical_rectangle.height
582
 
 
583
530
    def _construct_file_message(self):
584
 
        scroller = Gtk.ScrolledWindow()
585
 
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
531
        scroller = gtk.ScrolledWindow()
 
532
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
586
533
 
587
 
        self._file_message_text_view = Gtk.TextView()
 
534
        self._file_message_text_view = gtk.TextView()
588
535
        scroller.add(self._file_message_text_view)
589
 
        scroller.set_shadow_type(Gtk.ShadowType.IN)
 
536
        scroller.set_shadow_type(gtk.SHADOW_IN)
590
537
        scroller.show()
591
538
 
592
 
        self._file_message_text_view.modify_font(Pango.FontDescription("Monospace"))
593
 
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
 
539
        self._file_message_text_view.modify_font(pango.FontDescription("Monospace"))
 
540
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
594
541
        self._file_message_text_view.set_accepts_tab(False)
595
 
        line_height = self.get_line_height(self._file_message_text_view)
596
 
        self._file_message_text_view.set_size_request(-1, line_height * 2)
597
542
        self._file_message_text_view.show()
598
543
 
599
 
        self._file_message_expander = Gtk.Expander(
600
 
            label=_i18n('File commit message'))
 
544
        self._file_message_expander = gtk.Expander(_i18n('File commit message'))
601
545
        self._file_message_expander.set_expanded(True)
602
546
        self._file_message_expander.add(scroller)
603
547
        self._add_to_right_table(self._file_message_expander, 1, False)
604
548
        self._file_message_expander.show()
605
549
 
606
550
    def _construct_global_message(self):
607
 
        self._global_message_label = Gtk.Label(label=_i18n('Global Commit Message'))
 
551
        self._global_message_label = gtk.Label(_i18n('Global Commit Message'))
608
552
        self._global_message_label.set_markup(
609
553
            _i18n('<b>Global Commit Message</b>'))
610
554
        self._global_message_label.set_alignment(0, 0)
613
557
        # Can we remove the spacing between the label and the box?
614
558
        self._global_message_label.show()
615
559
 
616
 
        scroller = Gtk.ScrolledWindow()
617
 
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
560
        scroller = gtk.ScrolledWindow()
 
561
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
618
562
 
619
 
        self._global_message_text_view = Gtk.TextView()
 
563
        self._global_message_text_view = gtk.TextView()
620
564
        self._set_global_commit_message(self._saved_commit_messages_manager.get()[0])
621
 
        self._global_message_text_view.modify_font(Pango.FontDescription("Monospace"))
 
565
        self._global_message_text_view.modify_font(pango.FontDescription("Monospace"))
622
566
        scroller.add(self._global_message_text_view)
623
 
        scroller.set_shadow_type(Gtk.ShadowType.IN)
 
567
        scroller.set_shadow_type(gtk.SHADOW_IN)
624
568
        scroller.show()
625
569
        self._add_to_right_table(scroller, 2, True)
626
 
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
 
570
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
627
571
        self._file_message_text_view.set_accepts_tab(False)
628
572
        self._global_message_text_view.show()
629
573
 
630
574
    def _on_treeview_files_cursor_changed(self, treeview):
631
575
        treeselection = treeview.get_selection()
632
 
        if treeselection is None:
633
 
            # The treeview was probably destroyed as the dialog closes.
634
 
            return
635
576
        (model, selection) = treeselection.get_selected()
636
577
 
637
578
        if selection is not None:
638
579
            path, display_path = model.get(selection, 1, 3)
639
580
            self._diff_label.set_text(_i18n('Diff for ') + display_path)
640
 
            if path == "":
 
581
            if path is None:
641
582
                self._diff_view.show_diff(None)
642
583
            else:
643
 
                self._diff_view.show_diff([osutils.safe_unicode(path)])
 
584
                self._diff_view.show_diff([path.decode('UTF-8')])
644
585
            self._update_per_file_info(selection)
645
586
 
646
587
    def _on_accel_next(self, accel_group, window, keyval, modifier):
657
598
            # We have either made it to the end of the list, or nothing was
658
599
            # selected. Either way, select All Files, and jump to the global
659
600
            # commit message.
660
 
            self._treeview_files.set_cursor(
661
 
                Gtk.TreePath(path=0), "", False)
 
601
            self._treeview_files.set_cursor((0,))
662
602
            self._global_message_text_view.grab_focus()
663
603
        else:
664
604
            # Set the cursor to this entry, and jump to the per-file commit
665
605
            # message
666
 
            self._treeview_files.set_cursor(model.get_path(next), None, False)
 
606
            self._treeview_files.set_cursor(model.get_path(next))
667
607
            self._file_message_text_view.grab_focus()
668
608
 
669
609
    def _save_current_file_message(self):
671
611
            return # Nothing to save
672
612
        text_buffer = self._file_message_text_view.get_buffer()
673
613
        cur_text = text_buffer.get_text(text_buffer.get_start_iter(),
674
 
                                        text_buffer.get_end_iter(), True)
 
614
                                        text_buffer.get_end_iter())
675
615
        last_selected = self._files_store.get_iter(self._last_selected_file)
676
616
        self._files_store.set_value(last_selected, 5, cur_text)
677
617
 
683
623
        self._save_current_file_message()
684
624
        text_buffer = self._file_message_text_view.get_buffer()
685
625
        file_id, display_path, message = self._files_store.get(selection, 0, 3, 5)
686
 
        if file_id == "": # Whole tree
 
626
        if file_id is None: # Whole tree
687
627
            self._file_message_expander.set_label(_i18n('File commit message'))
688
628
            self._file_message_expander.set_expanded(False)
689
629
            self._file_message_expander.set_sensitive(False)
706
646
        files = []
707
647
        records = iter(self._files_store)
708
648
        rec = records.next() # Skip the All Files record
709
 
        assert rec[0] == "", "Are we skipping the wrong record?"
 
649
        assert rec[0] is None, "Are we skipping the wrong record?"
710
650
 
711
651
        file_info = []
712
652
        for record in records:
713
653
            if self._commit_all_changes or record[2]:# [2] checkbox
714
 
                file_id = osutils.safe_utf8(record[0]) # [0] file_id
715
 
                path = osutils.safe_utf8(record[1])    # [1] real path
 
654
                file_id = record[0] # [0] file_id
 
655
                path = record[1]    # [1] real path
716
656
                # [5] commit message
717
657
                file_message = _sanitize_and_decode_message(record[5])
718
658
                files.append(path.decode('UTF-8'))
748
688
                _i18n('Commit cancelled'),
749
689
                _i18n('Do you want to save your commit messages ?'),
750
690
                parent=self)
751
 
            if response == Gtk.ResponseType.NO:
 
691
            if response == gtk.RESPONSE_NO:
752
692
                 # save nothing and destroy old comments if any
753
693
                mgr = SavedCommitMessagesManager()
754
694
        mgr.save(self._wt, self._wt.branch)
755
 
        self.response(Gtk.ResponseType.CANCEL) # close window
 
695
        self.response(gtk.RESPONSE_CANCEL) # close window
756
696
 
757
697
    @show_bzr_error
758
698
    def _on_commit_clicked(self, button):
767
707
                _i18n('Commit with an empty message?'),
768
708
                _i18n('You can describe your commit intent in the message.'),
769
709
                parent=self)
770
 
            if response == Gtk.ResponseType.NO:
 
710
            if response == gtk.RESPONSE_NO:
771
711
                # Kindly give focus to message area
772
712
                self._global_message_text_view.grab_focus()
773
713
                return
789
729
                _i18n("Unknown files exist in the working tree. Commit anyway?"),
790
730
                parent=self)
791
731
                # Doesn't set a parent for the dialog..
792
 
            if response == Gtk.ResponseType.NO:
 
732
            if response == gtk.RESPONSE_NO:
793
733
                return
794
734
            break
795
735
 
810
750
                _i18n('There are no changes in the working tree.'
811
751
                      ' Do you want to commit anyway?'),
812
752
                parent=self)
813
 
            if response == Gtk.ResponseType.YES:
 
753
            if response == gtk.RESPONSE_YES:
814
754
                rev_id = self._wt.commit(message,
815
755
                               allow_pointless=True,
816
756
                               strict=False,
820
760
        self.committed_revision_id = rev_id
821
761
        # destroy old comments if any
822
762
        SavedCommitMessagesManager().save(self._wt, self._wt.branch)
823
 
        self.response(Gtk.ResponseType.OK)
 
763
        self.response(gtk.RESPONSE_OK)
824
764
 
825
765
    def _get_global_commit_message(self):
826
766
        buf = self._global_message_text_view.get_buffer()
827
767
        start, end = buf.get_bounds()
828
 
        text = buf.get_text(start, end, True)
 
768
        text = buf.get_text(start, end)
829
769
        return _sanitize_and_decode_message(text)
830
770
 
831
771
    def _set_global_commit_message(self, message):
854
794
        rev_dict['revision_id'] = rev.revision_id
855
795
        return rev_dict
856
796
 
 
797
 
 
798
class SavedCommitMessagesManager:
 
799
    """Saves global commit message and utf-8 file_id->message dictionary
 
800
    of per-file commit messages on disk. Re-reads them later for re-using."""
 
801
    def __init__(self, tree=None, branch=None):
 
802
        """If branch is None, builds empty messages, otherwise reads them
 
803
        from branch's disk storage. 'tree' argument is for the future."""
 
804
        if branch is None:
 
805
            self.global_message = u''
 
806
            self.file_messages = {}
 
807
        else:
 
808
            config = branch.get_config()._get_branch_data_config()
 
809
            self.global_message = config.get_user_option('gtk_global_commit_message')
 
810
            if self.global_message is None:
 
811
                self.global_message = u''
 
812
            file_messages = config.get_user_option('gtk_file_commit_messages')
 
813
            if file_messages: # unicode and B-encoded:
 
814
                self.file_messages = bencode.bdecode(file_messages.encode('UTF-8'))
 
815
            else:
 
816
                self.file_messages = {}
 
817
    def get(self):
 
818
        return self.global_message, self.file_messages
 
819
    def is_not_empty(self):
 
820
        return bool(self.global_message or self.file_messages)
 
821
    def insert(self, global_message, file_info):
 
822
        """Formats per-file commit messages (list of dictionaries, one per file)
 
823
        into one utf-8 file_id->message dictionary and merges this with
 
824
        previously existing dictionary. Merges global commit message too."""
 
825
        file_messages = {}
 
826
        for fi in file_info:
 
827
            file_message = fi['message']
 
828
            if file_message:
 
829
                file_messages[fi['file_id']] = file_message # utf-8 strings
 
830
        for k,v in file_messages.iteritems():
 
831
            try:
 
832
                self.file_messages[k] = v + '\n******\n' + self.file_messages[k]
 
833
            except KeyError:
 
834
                self.file_messages[k] = v
 
835
        if self.global_message:
 
836
            self.global_message = global_message + '\n******\n' + self.global_message
 
837
        else:
 
838
            self.global_message = global_message
 
839
    def save(self, tree, branch):
 
840
        # We store in branch's config, which can be a problem if two gcommit
 
841
        # are done in two checkouts of one single branch (comments overwrite
 
842
        # each other). Ideally should be in working tree. But uncommit does
 
843
        # not always have a working tree, though it always has a branch.
 
844
        # 'tree' argument is for the future
 
845
        config = branch.get_config()
 
846
        # should it be named "gtk_" or some more neutral name ("gui_" ?) to
 
847
        # be compatible with qbzr in the future?
 
848
        config.set_user_option('gtk_global_commit_message', self.global_message)
 
849
        # bencode() does not know unicode objects but set_user_option() requires one:
 
850
        config.set_user_option('gtk_file_commit_messages',
 
851
                                bencode.bencode(self.file_messages).decode('UTF-8'))
 
852
 
 
853
 
 
854
def save_commit_messages(local, master, old_revno, old_revid,
 
855
                         new_revno, new_revid):
 
856
    b = local
 
857
    if b is None:
 
858
        b = master
 
859
    mgr = SavedCommitMessagesManager(None, b)
 
860
    revid_iterator = b.repository.iter_reverse_revision_history(old_revid)
 
861
    cur_revno = old_revno
 
862
    new_revision_id = old_revid
 
863
    graph = b.repository.get_graph()
 
864
    for rev_id in revid_iterator:
 
865
        if cur_revno == new_revno:
 
866
            break
 
867
        cur_revno -= 1
 
868
        rev = b.repository.get_revision(rev_id)
 
869
        file_info = rev.properties.get('file-info', None)
 
870
        if file_info is None:
 
871
            file_info = {}
 
872
        else:
 
873
            file_info = bencode.bdecode(file_info.encode('UTF-8'))
 
874
        global_message = osutils.safe_unicode(rev.message)
 
875
        # Concatenate comment of the uncommitted revision
 
876
        mgr.insert(global_message, file_info)
 
877
 
 
878
        parents = graph.get_parent_map([rev_id]).get(rev_id, None)
 
879
        if not parents:
 
880
            continue
 
881
    mgr.save(None, b)