/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: Jelmer Vernooij
  • Date: 2008-06-29 19:04:44 UTC
  • mto: This revision was merged to the branch mainline in revision 515.
  • Revision ID: jelmer@samba.org-20080629190444-3hhmoc5fsoknrvet
Re-enable signature showing.

Show diffs side-by-side

added added

removed removed

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