/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: John Arbash Meinel
  • Date: 2007-10-30 21:15:13 UTC
  • mfrom: (326 trunk)
  • mto: (330.3.3 trunk)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: john@arbash-meinel.com-20071030211513-l8ukdfa81g1y74mi
Merge the latest trunk 326

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