/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to olive/commit.py

  • Committer: Jelmer Vernooij
  • Date: 2006-05-19 16:56:46 UTC
  • mfrom: (0.1.25 gannotate)
  • Revision ID: jelmer@samba.org-20060519165646-0d867938fdbc9097
Merge in Dan Loda's gannotate plugin and put it in annotate/

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/commit.py
1
 
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
try:
18
 
    import pygtk
19
 
    pygtk.require("2.0")
20
 
except:
21
 
    pass
22
 
 
23
 
import gtk
24
 
import gtk.glade
25
 
import gobject
26
 
import pango
27
 
 
28
 
import bzrlib.errors as errors
29
 
from bzrlib import osutils
30
 
 
31
 
from dialog import error_dialog
32
 
from guifiles import GLADEFILENAME
33
 
 
34
 
 
35
 
class CommitDialog:
36
 
    """ Display Commit dialog and perform the needed actions. """
37
 
    def __init__(self, wt, wtpath, notbranch):
38
 
        """ Initialize the Commit dialog.
39
 
        :param  wt:         bzr working tree object
40
 
        :param  wtpath:     path to working tree root
41
 
        :param  notbranch:  flag that path is not a brach
42
 
        :type   notbranch:  bool
43
 
        """
44
 
        self.glade = gtk.glade.XML(GLADEFILENAME, 'window_commit', 'olive-gtk')
45
 
        
46
 
        self.wt = wt
47
 
        self.wtpath = wtpath
48
 
        self.notbranch = notbranch
49
 
 
50
 
        # Get some important widgets
51
 
        self.window = self.glade.get_widget('window_commit')
52
 
        self.checkbutton_local = self.glade.get_widget('checkbutton_commit_local')
53
 
        self.textview = self.glade.get_widget('textview_commit')
54
 
        self.file_view = self.glade.get_widget('treeview_commit_select')
55
 
        self.pending_label = self.glade.get_widget('label_commit_pending')
56
 
        self.pending_view = self.glade.get_widget('treeview_commit_pending')
57
 
 
58
 
        if wt is None or notbranch:
59
 
            return
60
 
        
61
 
        # Set the delta
62
 
        self.old_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
63
 
        self.delta = self.wt.changes_from(self.old_tree)
64
 
        
65
 
        # Get pending merges
66
 
        self.pending = self._pending_merges(self.wt)
67
 
        
68
 
        # Dictionary for signal_autoconnect
69
 
        dic = { "on_button_commit_commit_clicked": self.commit,
70
 
                "on_button_commit_cancel_clicked": self.close }
71
 
 
72
 
        # Connect the signals to the handlers
73
 
        self.glade.signal_autoconnect(dic)
74
 
        
75
 
        # Create the file list
76
 
        self._create_file_view()
77
 
        # Create the pending merges
78
 
        self._create_pending_merges()
79
 
    
80
 
    def display(self):
81
 
        """ Display the Push dialog.
82
 
        @return:    True if dialog is shown.
83
 
        """
84
 
        if self.wt is None and not self.notbranch:
85
 
            error_dialog(_('Directory does not have a working tree'),
86
 
                         _('Operation aborted.'))
87
 
            self.close()
88
 
            return False
89
 
        if self.notbranch:
90
 
            error_dialog(_('Directory is not a branch'),
91
 
                         _('You can perform this action only in a branch.'))
92
 
            self.close()
93
 
            return False
94
 
        else:
95
 
            if self.wt.branch.get_bound_location() is not None:
96
 
                # we have a checkout, so the local commit checkbox must appear
97
 
                self.checkbutton_local.show()
98
 
            
99
 
            if self.pending:
100
 
                # There are pending merges, file selection not supported
101
 
                self.file_view.set_sensitive(False)
102
 
            else:
103
 
                # No pending merges
104
 
                self.pending_view.set_sensitive(False)
105
 
            
106
 
            self.textview.modify_font(pango.FontDescription("Monospace"))
107
 
            self.window.show()
108
 
            return True
109
 
    
110
 
    def _create_file_view(self):
111
 
        self.file_store = gtk.ListStore(gobject.TYPE_BOOLEAN,   # [0] checkbox
112
 
                                        gobject.TYPE_STRING,    # [1] path to display
113
 
                                        gobject.TYPE_STRING,    # [2] changes type
114
 
                                        gobject.TYPE_STRING)    # [3] real path
115
 
        self.file_view.set_model(self.file_store)
116
 
        crt = gtk.CellRendererToggle()
117
 
        crt.set_property("activatable", True)
118
 
        crt.connect("toggled", self._toggle_commit, self.file_store)
119
 
        self.file_view.append_column(gtk.TreeViewColumn(_('Commit'),
120
 
                                     crt, active=0))
121
 
        self.file_view.append_column(gtk.TreeViewColumn(_('Path'),
122
 
                                     gtk.CellRendererText(), text=1))
123
 
        self.file_view.append_column(gtk.TreeViewColumn(_('Type'),
124
 
                                     gtk.CellRendererText(), text=2))
125
 
 
126
 
        for path, id, kind in self.delta.added:
127
 
            marker = osutils.kind_marker(kind)
128
 
            self.file_store.append([ True, path+marker, _('added'), path ])
129
 
 
130
 
        for path, id, kind in self.delta.removed:
131
 
            marker = osutils.kind_marker(kind)
132
 
            self.file_store.append([ True, path+marker, _('removed'), path ])
133
 
 
134
 
        for oldpath, newpath, id, kind, text_modified, meta_modified in self.delta.renamed:
135
 
            marker = osutils.kind_marker(kind)
136
 
            if text_modified or meta_modified:
137
 
                changes = _('renamed and modified')
138
 
            else:
139
 
                changes = _('renamed')
140
 
            self.file_store.append([ True,
141
 
                                     oldpath+marker + '  =>  ' + newpath+marker,
142
 
                                     changes,
143
 
                                     newpath
144
 
                                   ])
145
 
 
146
 
        for path, id, kind, text_modified, meta_modified in self.delta.modified:
147
 
            marker = osutils.kind_marker(kind)
148
 
            self.file_store.append([ True, path+marker, _('modified'), path ])
149
 
    
150
 
    def _create_pending_merges(self):
151
 
        liststore = gtk.ListStore(gobject.TYPE_STRING,
152
 
                                  gobject.TYPE_STRING,
153
 
                                  gobject.TYPE_STRING)
154
 
        self.pending_view.set_model(liststore)
155
 
        
156
 
        self.pending_view.append_column(gtk.TreeViewColumn(_('Date'),
157
 
                                        gtk.CellRendererText(), text=0))
158
 
        self.pending_view.append_column(gtk.TreeViewColumn(_('Committer'),
159
 
                                        gtk.CellRendererText(), text=1))
160
 
        self.pending_view.append_column(gtk.TreeViewColumn(_('Summary'),
161
 
                                        gtk.CellRendererText(), text=2))
162
 
        
163
 
        if not self.pending:
164
 
            return
165
 
        
166
 
        for item in self.pending:
167
 
            liststore.append([ item['date'],
168
 
                               item['committer'],
169
 
                               item['summary'] ])
170
 
    
171
 
    def _get_specific_files(self):
172
 
        ret = []
173
 
        it = self.file_store.get_iter_first()
174
 
        while it:
175
 
            if self.file_store.get_value(it, 0):
176
 
                # get real path from hidden column 3
177
 
                ret.append(self.file_store.get_value(it, 3))
178
 
            it = self.file_store.iter_next(it)
179
 
 
180
 
        return ret
181
 
    
182
 
    def _toggle_commit(self, cell, path, model):
183
 
        model[path][0] = not model[path][0]
184
 
        return
185
 
    
186
 
    def _pending_merges(self, wt):
187
 
        """ Return a list of pending merges or None if there are none of them. """
188
 
        parents = wt.get_parent_ids()
189
 
        if len(parents) < 2:
190
 
            return None
191
 
        
192
 
        import re
193
 
        from bzrlib.osutils import format_date
194
 
        
195
 
        pending = parents[1:]
196
 
        branch = wt.branch
197
 
        last_revision = parents[0]
198
 
        
199
 
        if last_revision is not None:
200
 
            try:
201
 
                ignore = set(branch.repository.get_ancestry(last_revision))
202
 
            except errors.NoSuchRevision:
203
 
                # the last revision is a ghost : assume everything is new 
204
 
                # except for it
205
 
                ignore = set([None, last_revision])
206
 
        else:
207
 
            ignore = set([None])
208
 
        
209
 
        pm = []
210
 
        for merge in pending:
211
 
            ignore.add(merge)
212
 
            try:
213
 
                m_revision = branch.repository.get_revision(merge)
214
 
                
215
 
                rev = {}
216
 
                rev['committer'] = re.sub('<.*@.*>', '', m_revision.committer).strip(' ')
217
 
                rev['summary'] = m_revision.get_summary()
218
 
                rev['date'] = format_date(m_revision.timestamp,
219
 
                                          m_revision.timezone or 0, 
220
 
                                          'original', date_fmt="%Y-%m-%d",
221
 
                                          show_offset=False)
222
 
                
223
 
                pm.append(rev)
224
 
                
225
 
                inner_merges = branch.repository.get_ancestry(merge)
226
 
                assert inner_merges[0] is None
227
 
                inner_merges.pop(0)
228
 
                inner_merges.reverse()
229
 
                for mmerge in inner_merges:
230
 
                    if mmerge in ignore:
231
 
                        continue
232
 
                    mm_revision = branch.repository.get_revision(mmerge)
233
 
                    
234
 
                    rev = {}
235
 
                    rev['committer'] = re.sub('<.*@.*>', '', mm_revision.committer).strip(' ')
236
 
                    rev['summary'] = mm_revision.get_summary()
237
 
                    rev['date'] = format_date(mm_revision.timestamp,
238
 
                                              mm_revision.timezone or 0, 
239
 
                                              'original', date_fmt="%Y-%m-%d",
240
 
                                              show_offset=False)
241
 
                
242
 
                    pm.append(rev)
243
 
                    
244
 
                    ignore.add(mmerge)
245
 
            except errors.NoSuchRevision:
246
 
                print "DEBUG: NoSuchRevision:", merge
247
 
        
248
 
        return pm
249
 
 
250
 
    def commit(self, widget):
251
 
        textbuffer = self.textview.get_buffer()
252
 
        start, end = textbuffer.get_bounds()
253
 
        message = textbuffer.get_text(start, end).decode('utf-8')
254
 
        
255
 
        checkbutton_strict = self.glade.get_widget('checkbutton_commit_strict')
256
 
        checkbutton_force = self.glade.get_widget('checkbutton_commit_force')
257
 
        
258
 
        if not self.pending:
259
 
            specific_files = self._get_specific_files()
260
 
        else:
261
 
            specific_files = None
262
 
        
263
 
        try:
264
 
            self.wt.commit(message, 
265
 
                           allow_pointless=checkbutton_force.get_active(),
266
 
                           strict=checkbutton_strict.get_active(),
267
 
                           local=self.checkbutton_local.get_active(),
268
 
                           specific_files=specific_files)
269
 
        except errors.NotBranchError:
270
 
            error_dialog(_('Directory is not a branch'),
271
 
                         _('You can perform this action only in a branch.'))
272
 
            return
273
 
        except errors.LocalRequiresBoundBranch:
274
 
            error_dialog(_('Directory is not a checkout'),
275
 
                         _('You can perform local commit only on checkouts.'))
276
 
            return
277
 
        except errors.PointlessCommit:
278
 
            error_dialog(_('No changes to commit'),
279
 
                         _('Try force commit if you want to commit anyway.'))
280
 
            return
281
 
        except errors.ConflictsInTree:
282
 
            error_dialog(_('Conflicts in tree'),
283
 
                         _('You need to resolve the conflicts before committing.'))
284
 
            return
285
 
        except errors.StrictCommitFailed:
286
 
            error_dialog(_('Strict commit failed'),
287
 
                         _('There are unknown files in the working tree.\nPlease add or delete them.'))
288
 
            return
289
 
        except errors.BoundBranchOutOfDate, errmsg:
290
 
            error_dialog(_('Bound branch is out of date'),
291
 
                         _('%s') % errmsg)
292
 
            return
293
 
        except errors.BzrError, msg:
294
 
            error_dialog(_('Unknown bzr error'), str(msg))
295
 
            return
296
 
        except Exception, msg:
297
 
            error_dialog(_('Unknown error'), str(msg))
298
 
            return
299
 
 
300
 
        self.close()
301
 
 
302
 
    def close(self, widget=None):
303
 
        self.window.destroy()