/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: Curtis Hovey
  • Date: 2011-08-01 14:46:23 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110801144623-ldjf0bu7kyi5bxzu
Updated commit to gtk3.

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
 
try:
18
 
    import pygtk
19
 
    pygtk.require("2.0")
20
 
except:
21
 
    pass
22
 
 
23
 
import gtk
24
 
import gobject
25
 
import pango
26
 
 
27
 
import os.path
28
17
import re
29
18
 
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
35
 
from dialog import error_dialog, question_dialog
36
 
from errors import show_bzr_error
 
19
from gi.repository import Gdk
 
20
from gi.repository import Gtk
 
21
from gi.repository import GObject
 
22
from gi.repository import Pango
 
23
 
 
24
from bzrlib import (
 
25
    errors,
 
26
    osutils,
 
27
    trace,
 
28
    )
 
29
try:
 
30
    from bzrlib import bencode
 
31
except ImportError:
 
32
    from bzrlib.util import bencode
 
33
 
 
34
from bzrlib.plugins.gtk.dialog import question_dialog
 
35
from bzrlib.plugins.gtk.errors import show_bzr_error
 
36
from bzrlib.plugins.gtk.i18n import _i18n
37
37
 
38
38
try:
39
39
    import dbus
97
97
    return pm
98
98
 
99
99
 
100
 
class CommitDialog(gtk.Dialog):
 
100
_newline_variants_re = re.compile(r'\r\n?')
 
101
def _sanitize_and_decode_message(utf8_message):
 
102
    """Turn a utf-8 message into a sanitized Unicode message."""
 
103
    fixed_newline = _newline_variants_re.sub('\n', utf8_message)
 
104
    return fixed_newline.decode('utf-8')
 
105
 
 
106
 
 
107
class CommitDialog(Gtk.Dialog):
101
108
    """Implementation of Commit."""
102
109
 
103
110
    def __init__(self, wt, selected=None, parent=None):
104
 
        gtk.Dialog.__init__(self, title="Commit - Olive",
105
 
                                  parent=parent,
106
 
                                  flags=0,
107
 
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
111
        Gtk.Dialog.__init__(self, title="Commit to %s" % wt.basedir,
 
112
                            parent=parent, flags=0,)
 
113
        self.connect('delete-event', self._on_delete_window)
108
114
        self._question_dialog = question_dialog
109
115
 
 
116
        self.set_type_hint(Gdk.WindowTypeHint.NORMAL)
 
117
 
110
118
        self._wt = wt
111
119
        # TODO: Do something with this value, it is used by Olive
112
120
        #       It used to set all changes but this one to False
114
122
        self._enable_per_file_commits = True
115
123
        self._commit_all_changes = True
116
124
        self.committed_revision_id = None # Nothing has been committed yet
 
125
        self._saved_commit_messages_manager = SavedCommitMessagesManager(
 
126
            self._wt, self._wt.branch)
117
127
 
118
128
        self.setup_params()
119
129
        self.construct()
188
198
        self._basis_tree.lock_read()
189
199
        try:
190
200
            from diff import iter_changes_to_status
 
201
            saved_file_messages = self._saved_commit_messages_manager.get()[1]
191
202
            for (file_id, real_path, change_type, display_path
192
203
                ) in iter_changes_to_status(self._basis_tree, self._wt):
193
204
                if self._selected and real_path != self._selected:
194
205
                    enabled = False
195
206
                else:
196
207
                    enabled = True
 
208
                try:
 
209
                    default_message = saved_file_messages[file_id]
 
210
                except KeyError:
 
211
                    default_message = ''
197
212
                item_iter = store.append([
198
213
                    file_id,
199
214
                    real_path.encode('UTF-8'),
200
215
                    enabled,
201
216
                    display_path.encode('UTF-8'),
202
217
                    change_type,
203
 
                    '', # Initial comment
 
218
                    default_message, # Initial comment
204
219
                    ])
205
220
                if self._selected and enabled:
206
221
                    initial_cursor = store.get_path(item_iter)
213
228
        # This sets the cursor, which causes the expander to close, which
214
229
        # causes the _file_message_text_view to never get realized. So we have
215
230
        # to give it a little kick, or it warns when we try to grab the focus
216
 
        self._treeview_files.set_cursor(initial_cursor)
 
231
        self._treeview_files.set_cursor(initial_cursor, None, None)
217
232
 
218
233
        def _realize_file_message_tree_view(*args):
219
234
            self._file_message_text_view.realize()
232
247
                proxy_obj = bus.get_object('org.freedesktop.NetworkManager',
233
248
                                           '/org/freedesktop/NetworkManager')
234
249
            except dbus.DBusException:
235
 
                mutter("networkmanager not available.")
 
250
                trace.mutter("networkmanager not available.")
236
251
                self._check_local.show()
237
252
                return
238
253
            
244
259
            except dbus.DBusException, e:
245
260
                # Silently drop errors. While DBus may be
246
261
                # available, NetworkManager doesn't necessarily have to be
247
 
                mutter("unable to get networkmanager state: %r" % e)
 
262
                trace.mutter("unable to get networkmanager state: %r" % e)
248
263
        self._check_local.show()
249
264
 
250
265
    def _fill_in_per_file_info(self):
267
282
        """Build up the dialog widgets."""
268
283
        # The primary pane which splits it into left and right (adjustable)
269
284
        # sections.
270
 
        self._hpane = gtk.HPaned()
 
285
        self._hpane = Gtk.HPaned()
271
286
 
272
287
        self._construct_left_pane()
273
288
        self._construct_right_pane()
274
289
        self._construct_action_pane()
275
290
 
276
 
        self.vbox.pack_start(self._hpane)
 
291
        self.get_content_area().pack_start(self._hpane, True, True, 0)
277
292
        self._hpane.show()
278
293
        self.set_focus(self._global_message_text_view)
279
294
 
298
313
        self._hpane.set_position(300)
299
314
 
300
315
    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)
 
316
        group = Gtk.AccelGroup()
 
317
        group.connect(Gdk.keyval_from_name('N'),
 
318
                      Gdk.ModifierType.CONTROL_MASK, 0, self._on_accel_next)
304
319
        self.add_accel_group(group)
305
320
 
306
321
        # ignore the escape key (avoid closing the window)
307
322
        self.connect_object('close', self.emit_stop_by_name, 'close')
308
323
 
309
324
    def _construct_left_pane(self):
310
 
        self._left_pane_box = gtk.VBox(homogeneous=False, spacing=5)
 
325
        self._left_pane_box = Gtk.VBox(homogeneous=False, spacing=5)
311
326
        self._construct_file_list()
312
327
        self._construct_pending_list()
313
328
 
314
 
        self._check_local = gtk.CheckButton(_i18n("_Only commit locally"),
 
329
        self._check_local = Gtk.CheckButton(_i18n("_Only commit locally"),
315
330
                                            use_underline=True)
316
 
        self._left_pane_box.pack_end(self._check_local, False, False)
 
331
        self._left_pane_box.pack_end(self._check_local, False, False, 0)
317
332
        self._check_local.set_active(False)
318
333
 
319
334
        self._hpane.pack1(self._left_pane_box, resize=False, shrink=False)
326
341
        # commit, and 1 for file commit, and it looked good. But I don't seem
327
342
        # to have a way to do that with the gtk boxes... :( (Which is extra
328
343
        # weird since wx uses gtk on Linux...)
329
 
        self._right_pane_table = gtk.Table(rows=10, columns=1, homogeneous=False)
 
344
        self._right_pane_table = Gtk.Table(rows=10, columns=1, homogeneous=False)
330
345
        self._right_pane_table.set_row_spacings(5)
331
346
        self._right_pane_table.set_col_spacings(5)
332
347
        self._right_pane_table_row = 0
338
353
        self._hpane.pack2(self._right_pane_table, resize=True, shrink=True)
339
354
 
340
355
    def _construct_action_pane(self):
341
 
        self._button_commit = gtk.Button(_i18n("Comm_it"), use_underline=True)
 
356
        self._button_cancel = Gtk.Button(stock=Gtk.STOCK_CANCEL)
 
357
        self._button_cancel.connect('clicked', self._on_cancel_clicked)
 
358
        self._button_cancel.show()
 
359
        self.get_action_area().pack_end(
 
360
            self._button_cancel, True, True, 0)
 
361
        self._button_commit = Gtk.Button(_i18n("Comm_it"), use_underline=True)
342
362
        self._button_commit.connect('clicked', self._on_commit_clicked)
343
 
        self._button_commit.set_flags(gtk.CAN_DEFAULT)
 
363
        self._button_commit.set_can_default(True)
344
364
        self._button_commit.show()
345
 
        self.action_area.pack_end(self._button_commit)
 
365
        self.get_action_area().pack_end(
 
366
            self._button_commit, True, True, 0)
346
367
        self._button_commit.grab_default()
347
368
 
348
369
    def _add_to_right_table(self, widget, weight, expanding=False):
354
375
        """
355
376
        end_row = self._right_pane_table_row + weight
356
377
        options = 0
357
 
        expand_opts = gtk.EXPAND | gtk.FILL | gtk.SHRINK
 
378
        expand_opts = Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK
358
379
        if expanding:
359
380
            options = expand_opts
360
381
        self._right_pane_table.attach(widget, 0, 1,
363
384
        self._right_pane_table_row = end_row
364
385
 
365
386
    def _construct_file_list(self):
366
 
        self._files_box = gtk.VBox(homogeneous=False, spacing=0)
367
 
        file_label = gtk.Label(_i18n('Files'))
 
387
        self._files_box = Gtk.VBox(homogeneous=False, spacing=0)
 
388
        file_label = Gtk.Label(label=_i18n('Files'))
368
389
        # file_label.show()
369
 
        self._files_box.pack_start(file_label, expand=False)
 
390
        self._files_box.pack_start(file_label, False, True, 0)
370
391
 
371
 
        self._commit_all_files_radio = gtk.RadioButton(
 
392
        self._commit_all_files_radio = Gtk.RadioButton(
372
393
            None, _i18n("Commit all changes"))
373
 
        self._files_box.pack_start(self._commit_all_files_radio, expand=False)
 
394
        self._files_box.pack_start(self._commit_all_files_radio, False, True, 0)
374
395
        self._commit_all_files_radio.show()
375
396
        self._commit_all_files_radio.connect('toggled',
376
397
            self._toggle_commit_selection)
377
 
        self._commit_selected_radio = gtk.RadioButton(
 
398
        self._commit_selected_radio = Gtk.RadioButton(
378
399
            self._commit_all_files_radio, _i18n("Only commit selected changes"))
379
 
        self._files_box.pack_start(self._commit_selected_radio, expand=False)
 
400
        self._files_box.pack_start(self._commit_selected_radio, False, True, 0)
380
401
        self._commit_selected_radio.show()
381
402
        self._commit_selected_radio.connect('toggled',
382
403
            self._toggle_commit_selection)
385
406
            self._commit_all_files_radio.set_sensitive(False)
386
407
            self._commit_selected_radio.set_sensitive(False)
387
408
 
388
 
        scroller = gtk.ScrolledWindow()
389
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
390
 
        self._treeview_files = gtk.TreeView()
 
409
        scroller = Gtk.ScrolledWindow()
 
410
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
411
        self._treeview_files = Gtk.TreeView()
391
412
        self._treeview_files.show()
392
413
        scroller.add(self._treeview_files)
393
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
414
        scroller.set_shadow_type(Gtk.ShadowType.IN)
394
415
        scroller.show()
395
 
        self._files_box.pack_start(scroller,
396
 
                                   expand=True, fill=True)
 
416
        self._files_box.pack_start(scroller, True, True, 0)
397
417
        self._files_box.show()
398
 
        self._left_pane_box.pack_start(self._files_box)
 
418
        self._left_pane_box.pack_start(self._files_box, True, True, 0)
399
419
 
400
420
        # Keep note that all strings stored in a ListStore must be UTF-8
401
421
        # strings. GTK does not support directly setting and restoring Unicode
402
422
        # 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
 
423
        liststore = Gtk.ListStore(
 
424
            GObject.TYPE_STRING,  # [0] file_id
 
425
            GObject.TYPE_STRING,  # [1] real path
 
426
            GObject.TYPE_BOOLEAN, # [2] checkbox
 
427
            GObject.TYPE_STRING,  # [3] display path
 
428
            GObject.TYPE_STRING,  # [4] changes type
 
429
            GObject.TYPE_STRING,  # [5] commit message
410
430
            )
411
431
        self._files_store = liststore
412
432
        self._treeview_files.set_model(liststore)
413
 
        crt = gtk.CellRendererToggle()
 
433
        crt = Gtk.CellRendererToggle()
414
434
        crt.set_property('activatable', not bool(self._pending))
415
435
        crt.connect("toggled", self._toggle_commit, self._files_store)
416
436
        if self._pending:
417
437
            name = _i18n('Commit*')
418
438
        else:
419
439
            name = _i18n('Commit')
420
 
        commit_col = gtk.TreeViewColumn(name, crt, active=2)
 
440
        commit_col = Gtk.TreeViewColumn(name, crt, active=2)
421
441
        commit_col.set_visible(False)
422
442
        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))
 
443
        self._treeview_files.append_column(Gtk.TreeViewColumn(_i18n('Path'),
 
444
                                           Gtk.CellRendererText(), text=3))
 
445
        self._treeview_files.append_column(Gtk.TreeViewColumn(_i18n('Type'),
 
446
                                           Gtk.CellRendererText(), text=4))
427
447
        self._treeview_files.connect('cursor-changed',
428
448
                                     self._on_treeview_files_cursor_changed)
429
449
 
450
470
    def _construct_pending_list(self):
451
471
        # Pending information defaults to hidden, we put it all in 1 box, so
452
472
        # that we can show/hide all of them at once
453
 
        self._pending_box = gtk.VBox()
 
473
        self._pending_box = Gtk.VBox()
454
474
        self._pending_box.hide()
455
475
 
456
 
        pending_message = gtk.Label()
 
476
        pending_message = Gtk.Label()
457
477
        pending_message.set_markup(
458
478
            _i18n('<i>* Cannot select specific files when merging</i>'))
459
 
        self._pending_box.pack_start(pending_message, expand=False, padding=5)
 
479
        self._pending_box.pack_start(pending_message, False, True, 5)
460
480
        pending_message.show()
461
481
 
462
 
        pending_label = gtk.Label(_i18n('Pending Revisions'))
463
 
        self._pending_box.pack_start(pending_label, expand=False, padding=0)
 
482
        pending_label = Gtk.Label(label=_i18n('Pending Revisions'))
 
483
        self._pending_box.pack_start(pending_label, False, True, 0)
464
484
        pending_label.show()
465
485
 
466
 
        scroller = gtk.ScrolledWindow()
467
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
468
 
        self._treeview_pending = gtk.TreeView()
 
486
        scroller = Gtk.ScrolledWindow()
 
487
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
488
        self._treeview_pending = Gtk.TreeView()
469
489
        scroller.add(self._treeview_pending)
470
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
490
        scroller.set_shadow_type(Gtk.ShadowType.IN)
471
491
        scroller.show()
472
 
        self._pending_box.pack_start(scroller,
473
 
                                     expand=True, fill=True, padding=5)
 
492
        self._pending_box.pack_start(scroller, True, True, 5)
474
493
        self._treeview_pending.show()
475
 
        self._left_pane_box.pack_start(self._pending_box)
 
494
        self._left_pane_box.pack_start(self._pending_box, True, True, 0)
476
495
 
477
 
        liststore = gtk.ListStore(gobject.TYPE_STRING, # revision_id
478
 
                                  gobject.TYPE_STRING, # date
479
 
                                  gobject.TYPE_STRING, # committer
480
 
                                  gobject.TYPE_STRING, # summary
 
496
        liststore = Gtk.ListStore(GObject.TYPE_STRING, # revision_id
 
497
                                  GObject.TYPE_STRING, # date
 
498
                                  GObject.TYPE_STRING, # committer
 
499
                                  GObject.TYPE_STRING, # summary
481
500
                                 )
482
501
        self._pending_store = liststore
483
502
        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))
 
503
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Date'),
 
504
                                             Gtk.CellRendererText(), text=1))
 
505
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Committer'),
 
506
                                             Gtk.CellRendererText(), text=2))
 
507
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Summary'),
 
508
                                             Gtk.CellRendererText(), text=3))
490
509
 
491
510
    def _construct_diff_view(self):
492
 
        from diff import DiffView
 
511
        from bzrlib.plugins.gtk.diff import DiffView
493
512
 
494
513
        # TODO: jam 2007-10-30 The diff label is currently disabled. If we
495
514
        #       decide that we really don't ever want to display it, we should
496
515
        #       actually remove it, and other references to it, along with the
497
516
        #       tests that it is set properly.
498
 
        self._diff_label = gtk.Label(_i18n('Diff for whole tree'))
 
517
        self._diff_label = Gtk.Label(label=_i18n('Diff for whole tree'))
499
518
        self._diff_label.set_alignment(0, 0)
500
519
        self._right_pane_table.set_row_spacing(self._right_pane_table_row, 0)
501
520
        self._add_to_right_table(self._diff_label, 1, False)
506
525
        self._diff_view.show()
507
526
 
508
527
    def _construct_file_message(self):
509
 
        scroller = gtk.ScrolledWindow()
510
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
528
        scroller = Gtk.ScrolledWindow()
 
529
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
511
530
 
512
 
        self._file_message_text_view = gtk.TextView()
 
531
        self._file_message_text_view = Gtk.TextView()
513
532
        scroller.add(self._file_message_text_view)
514
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
533
        scroller.set_shadow_type(Gtk.ShadowType.IN)
515
534
        scroller.show()
516
535
 
517
 
        self._file_message_text_view.modify_font(pango.FontDescription("Monospace"))
518
 
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
 
536
        self._file_message_text_view.modify_font(Pango.FontDescription("Monospace"))
 
537
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
519
538
        self._file_message_text_view.set_accepts_tab(False)
520
539
        self._file_message_text_view.show()
521
540
 
522
 
        self._file_message_expander = gtk.Expander(_i18n('File commit message'))
 
541
        self._file_message_expander = Gtk.Expander(
 
542
            label=_i18n('File commit message'))
523
543
        self._file_message_expander.set_expanded(True)
524
544
        self._file_message_expander.add(scroller)
525
545
        self._add_to_right_table(self._file_message_expander, 1, False)
526
546
        self._file_message_expander.show()
527
547
 
528
548
    def _construct_global_message(self):
529
 
        self._global_message_label = gtk.Label(_i18n('Global Commit Message'))
 
549
        self._global_message_label = Gtk.Label(label=_i18n('Global Commit Message'))
530
550
        self._global_message_label.set_markup(
531
551
            _i18n('<b>Global Commit Message</b>'))
532
552
        self._global_message_label.set_alignment(0, 0)
535
555
        # Can we remove the spacing between the label and the box?
536
556
        self._global_message_label.show()
537
557
 
538
 
        scroller = gtk.ScrolledWindow()
539
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
558
        scroller = Gtk.ScrolledWindow()
 
559
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
540
560
 
541
 
        self._global_message_text_view = gtk.TextView()
542
 
        self._global_message_text_view.modify_font(pango.FontDescription("Monospace"))
 
561
        self._global_message_text_view = Gtk.TextView()
 
562
        self._set_global_commit_message(self._saved_commit_messages_manager.get()[0])
 
563
        self._global_message_text_view.modify_font(Pango.FontDescription("Monospace"))
543
564
        scroller.add(self._global_message_text_view)
544
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
565
        scroller.set_shadow_type(Gtk.ShadowType.IN)
545
566
        scroller.show()
546
567
        self._add_to_right_table(scroller, 2, True)
547
 
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
 
568
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
548
569
        self._file_message_text_view.set_accepts_tab(False)
549
570
        self._global_message_text_view.show()
550
571
 
588
609
            return # Nothing to save
589
610
        text_buffer = self._file_message_text_view.get_buffer()
590
611
        cur_text = text_buffer.get_text(text_buffer.get_start_iter(),
591
 
                                        text_buffer.get_end_iter())
 
612
                                        text_buffer.get_end_iter(), True)
592
613
        last_selected = self._files_store.get_iter(self._last_selected_file)
593
614
        self._files_store.set_value(last_selected, 5, cur_text)
594
615
 
630
651
            if self._commit_all_changes or record[2]:# [2] checkbox
631
652
                file_id = record[0] # [0] file_id
632
653
                path = record[1]    # [1] real path
633
 
                file_message = record[5] # [5] commit message
 
654
                # [5] commit message
 
655
                file_message = _sanitize_and_decode_message(record[5])
634
656
                files.append(path.decode('UTF-8'))
635
657
                if self._enable_per_file_commits and file_message:
636
658
                    # All of this needs to be utf-8 information
 
659
                    file_message = file_message.encode('UTF-8')
637
660
                    file_info.append({'path':path, 'file_id':file_id,
638
661
                                     'message':file_message})
639
662
        file_info.sort(key=lambda x:(x['path'], x['file_id']))
643
666
            return files, []
644
667
 
645
668
    @show_bzr_error
 
669
    def _on_cancel_clicked(self, button):
 
670
        """ Cancel button clicked handler. """
 
671
        self._do_cancel()
 
672
 
 
673
    @show_bzr_error
 
674
    def _on_delete_window(self, source, event):
 
675
        """ Delete window handler. """
 
676
        self._do_cancel()
 
677
 
 
678
    def _do_cancel(self):
 
679
        """If requested, saves commit messages when cancelling gcommit; they are re-used by a next gcommit"""
 
680
        mgr = SavedCommitMessagesManager()
 
681
        self._saved_commit_messages_manager = mgr
 
682
        mgr.insert(self._get_global_commit_message(),
 
683
                   self._get_specific_files()[1])
 
684
        if mgr.is_not_empty(): # maybe worth saving
 
685
            response = self._question_dialog(
 
686
                _i18n('Commit cancelled'),
 
687
                _i18n('Do you want to save your commit messages ?'),
 
688
                parent=self)
 
689
            if response == Gtk.ResponseType.NO:
 
690
                 # save nothing and destroy old comments if any
 
691
                mgr = SavedCommitMessagesManager()
 
692
        mgr.save(self._wt, self._wt.branch)
 
693
        self.response(Gtk.ResponseType.CANCEL) # close window
 
694
 
 
695
    @show_bzr_error
646
696
    def _on_commit_clicked(self, button):
647
697
        """ Commit button clicked handler. """
648
698
        self._do_commit()
653
703
        if message == '':
654
704
            response = self._question_dialog(
655
705
                _i18n('Commit with an empty message?'),
656
 
                _i18n('You can describe your commit intent in the message.'))
657
 
            if response == gtk.RESPONSE_NO:
 
706
                _i18n('You can describe your commit intent in the message.'),
 
707
                parent=self)
 
708
            if response == Gtk.ResponseType.NO:
658
709
                # Kindly give focus to message area
659
710
                self._global_message_text_view.grab_focus()
660
711
                return
673
724
        for path in self._wt.unknowns():
674
725
            response = self._question_dialog(
675
726
                _i18n("Commit with unknowns?"),
676
 
                _i18n("Unknown files exist in the working tree. Commit anyway?"))
677
 
            if response == gtk.RESPONSE_NO:
 
727
                _i18n("Unknown files exist in the working tree. Commit anyway?"),
 
728
                parent=self)
 
729
                # Doesn't set a parent for the dialog..
 
730
            if response == Gtk.ResponseType.NO:
678
731
                return
679
732
            break
680
733
 
693
746
            response = self._question_dialog(
694
747
                _i18n('Commit with no changes?'),
695
748
                _i18n('There are no changes in the working tree.'
696
 
                      ' Do you want to commit anyway?'))
697
 
            if response == gtk.RESPONSE_YES:
 
749
                      ' Do you want to commit anyway?'),
 
750
                parent=self)
 
751
            if response == Gtk.ResponseType.YES:
698
752
                rev_id = self._wt.commit(message,
699
753
                               allow_pointless=True,
700
754
                               strict=False,
702
756
                               specific_files=specific_files,
703
757
                               revprops=revprops)
704
758
        self.committed_revision_id = rev_id
705
 
        self.response(gtk.RESPONSE_OK)
 
759
        # destroy old comments if any
 
760
        SavedCommitMessagesManager().save(self._wt, self._wt.branch)
 
761
        self.response(Gtk.ResponseType.OK)
706
762
 
707
763
    def _get_global_commit_message(self):
708
764
        buf = self._global_message_text_view.get_buffer()
709
765
        start, end = buf.get_bounds()
710
 
        return buf.get_text(start, end).decode('utf-8')
 
766
        text = buf.get_text(start, end, True)
 
767
        return _sanitize_and_decode_message(text)
711
768
 
712
769
    def _set_global_commit_message(self, message):
713
770
        """Just a helper for the test suite."""
734
791
                                       show_offset=False)
735
792
        rev_dict['revision_id'] = rev.revision_id
736
793
        return rev_dict
 
794
 
 
795
 
 
796
class SavedCommitMessagesManager:
 
797
    """Save glogal and per-file commit messages.
 
798
 
 
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
    """
 
802
 
 
803
    def __init__(self, tree=None, branch=None):
 
804
        """If branch is None, builds empty messages, otherwise reads them
 
805
        from branch's disk storage. 'tree' argument is for the future."""
 
806
        if branch is None:
 
807
            self.global_message = u''
 
808
            self.file_messages = {}
 
809
        else:
 
810
            config = branch.get_config()
 
811
            self.global_message = config.get_user_option(
 
812
                'gtk_global_commit_message')
 
813
            if self.global_message is None:
 
814
                self.global_message = u''
 
815
            file_messages = config.get_user_option('gtk_file_commit_messages')
 
816
            if file_messages: # unicode and B-encoded:
 
817
                self.file_messages = bencode.bdecode(
 
818
                    file_messages.encode('UTF-8'))
 
819
            else:
 
820
                self.file_messages = {}
 
821
 
 
822
    def get(self):
 
823
        return self.global_message, self.file_messages
 
824
 
 
825
    def is_not_empty(self):
 
826
        return bool(self.global_message or self.file_messages)
 
827
 
 
828
    def insert(self, global_message, file_info):
 
829
        """Formats per-file commit messages (list of dictionaries, one per file)
 
830
        into one utf-8 file_id->message dictionary and merges this with
 
831
        previously existing dictionary. Merges global commit message too."""
 
832
        file_messages = {}
 
833
        for fi in file_info:
 
834
            file_message = fi['message']
 
835
            if file_message:
 
836
                file_messages[fi['file_id']] = file_message # utf-8 strings
 
837
        for k,v in file_messages.iteritems():
 
838
            try:
 
839
                self.file_messages[k] = v + '\n******\n' + self.file_messages[k]
 
840
            except KeyError:
 
841
                self.file_messages[k] = v
 
842
        if self.global_message:
 
843
            self.global_message = global_message + '\n******\n' \
 
844
                + self.global_message
 
845
        else:
 
846
            self.global_message = global_message
 
847
 
 
848
    def save(self, tree, branch):
 
849
        # We store in branch's config, which can be a problem if two gcommit
 
850
        # are done in two checkouts of one single branch (comments overwrite
 
851
        # each other). Ideally should be in working tree. But uncommit does
 
852
        # not always have a working tree, though it always has a branch.
 
853
        # 'tree' argument is for the future
 
854
        config = branch.get_config()
 
855
        # should it be named "gtk_" or some more neutral name ("gui_" ?) to
 
856
        # be compatible with qbzr in the future?
 
857
        config.set_user_option('gtk_global_commit_message', self.global_message)
 
858
        # bencode() does not know unicode objects but set_user_option()
 
859
        # requires one:
 
860
        config.set_user_option(
 
861
            'gtk_file_commit_messages',
 
862
            bencode.bencode(self.file_messages).decode('UTF-8'))
 
863
 
 
864
 
 
865
def save_commit_messages(local, master, old_revno, old_revid,
 
866
                         new_revno, new_revid):
 
867
    b = local
 
868
    if b is None:
 
869
        b = master
 
870
    mgr = SavedCommitMessagesManager(None, b)
 
871
    revid_iterator = b.repository.iter_reverse_revision_history(old_revid)
 
872
    cur_revno = old_revno
 
873
    new_revision_id = old_revid
 
874
    graph = b.repository.get_graph()
 
875
    for rev_id in revid_iterator:
 
876
        if cur_revno == new_revno:
 
877
            break
 
878
        cur_revno -= 1
 
879
        rev = b.repository.get_revision(rev_id)
 
880
        file_info = rev.properties.get('file-info', None)
 
881
        if file_info is None:
 
882
            file_info = {}
 
883
        else:
 
884
            file_info = bencode.bdecode(file_info.encode('UTF-8'))
 
885
        global_message = osutils.safe_unicode(rev.message)
 
886
        # Concatenate comment of the uncommitted revision
 
887
        mgr.insert(global_message, file_info)
 
888
 
 
889
        parents = graph.get_parent_map([rev_id]).get(rev_id, None)
 
890
        if not parents:
 
891
            continue
 
892
    mgr.save(None, b)