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

  • Committer: Jelmer Vernooij
  • Date: 2012-07-09 15:23:26 UTC
  • mto: This revision was merged to the branch mainline in revision 794.
  • Revision ID: jelmer@samba.org-20120709152326-dzxb8zoz0btull7n
https://launchpad.net/bugs/714767
https://launchpad.net/bugs/949798
https://launchpad.net/bugs/998994
https://launchpad.net/bugs/342135
https://launchpad.net/bugs/342136
https://launchpad.net/bugs/394536
Remove bzr-notify.

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
5
5
"""
6
6
 
7
7
__copyright__ = "Copyright 2005 Canonical Ltd."
8
 
__author__    = "Scott James Remnant <scott@ubuntu.com>"
 
8
__author__ = "Scott James Remnant <scott@ubuntu.com>"
9
9
 
10
10
 
11
11
from cStringIO import StringIO
12
12
 
13
 
import pygtk
14
 
pygtk.require("2.0")
15
 
import gtk
16
 
import pango
17
 
import os
18
 
import re
19
13
import sys
 
14
import inspect
20
15
 
 
16
from gi.repository import Gtk
 
17
from gi.repository import Pango
21
18
try:
22
 
    import gtksourceview
 
19
    from gi.repository import GtkSource
23
20
    have_gtksourceview = True
24
21
except ImportError:
25
22
    have_gtksourceview = False
26
 
try:
27
 
    import gconf
28
 
    have_gconf = True
29
 
except ImportError:
30
 
    have_gconf = False
31
23
 
32
24
from bzrlib import (
 
25
    errors,
33
26
    merge as _mod_merge,
34
27
    osutils,
35
 
    progress,
36
28
    urlutils,
37
29
    workingtree,
38
 
)
39
 
from bzrlib.diff import show_diff_trees, internal_diff
40
 
from bzrlib.errors import NoSuchFile
 
30
    )
 
31
from bzrlib.diff import show_diff_trees
41
32
from bzrlib.patches import parse_patches
42
 
from bzrlib.trace import warning
43
 
from bzrlib.plugins.gtk import _i18n
 
33
from bzrlib.plugins.gtk.dialog import (
 
34
    error_dialog,
 
35
    info_dialog,
 
36
    warning_dialog,
 
37
    )
 
38
from bzrlib.plugins.gtk.i18n import _i18n
44
39
from bzrlib.plugins.gtk.window import Window
45
 
from dialog import error_dialog, info_dialog, warning_dialog
 
40
 
 
41
 
 
42
def fallback_guess_language(slm, content_type):
 
43
    for lang_id in slm.get_language_ids():
 
44
        lang = slm.get_language(lang_id)
 
45
        if "text/x-patch" in lang.get_mime_types():
 
46
            return lang
 
47
    return None
46
48
 
47
49
 
48
50
class SelectCancelled(Exception):
50
52
    pass
51
53
 
52
54
 
53
 
class DiffFileView(gtk.ScrolledWindow):
 
55
class DiffFileView(Gtk.ScrolledWindow):
54
56
    """Window for displaying diffs from a diff file"""
55
57
 
 
58
    SHOW_WIDGETS = True
 
59
 
56
60
    def __init__(self):
57
 
        gtk.ScrolledWindow.__init__(self)
 
61
        super(DiffFileView, self).__init__()
58
62
        self.construct()
59
63
        self._diffs = {}
60
64
 
61
65
    def construct(self):
62
 
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
63
 
        self.set_shadow_type(gtk.SHADOW_IN)
 
66
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
67
        self.set_shadow_type(Gtk.ShadowType.IN)
64
68
 
65
69
        if have_gtksourceview:
66
 
            self.buffer = gtksourceview.SourceBuffer()
67
 
            slm = gtksourceview.SourceLanguagesManager()
68
 
            gsl = slm.get_language_from_mime_type("text/x-patch")
69
 
            if have_gconf:
70
 
                self.apply_gedit_colors(gsl)
71
 
            self.apply_colordiff_colors(gsl)
72
 
            self.buffer.set_language(gsl)
73
 
            self.buffer.set_highlight(True)
74
 
 
75
 
            self.sourceview = gtksourceview.SourceView(self.buffer)
 
70
            self.buffer = GtkSource.Buffer()
 
71
            lang_manager = GtkSource.LanguageManager.get_default()
 
72
            language = lang_manager.guess_language(None, "text/x-patch")
 
73
            self.buffer.set_language(language)
 
74
            self.buffer.set_highlight_syntax(True)
 
75
            self.sourceview = GtkSource.View(buffer=self.buffer)
76
76
        else:
77
 
            self.buffer = gtk.TextBuffer()
78
 
            self.sourceview = gtk.TextView(self.buffer)
 
77
            self.buffer = Gtk.TextBuffer()
 
78
            self.sourceview = Gtk.TextView(self.buffer)
79
79
 
80
80
        self.sourceview.set_editable(False)
81
 
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
81
        self.sourceview.override_font(Pango.FontDescription("Monospace"))
82
82
        self.add(self.sourceview)
83
 
        self.sourceview.show()
84
 
 
85
 
    @staticmethod
86
 
    def apply_gedit_colors(lang):
87
 
        """Set style for lang to that specified in gedit configuration.
88
 
 
89
 
        This method needs the gconf module.
90
 
 
91
 
        :param lang: a gtksourceview.SourceLanguage object.
92
 
        """
93
 
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
94
 
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
95
 
 
96
 
        client = gconf.client_get_default()
97
 
        client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
98
 
 
99
 
        for tag in lang.get_tags():
100
 
            tag_id = tag.get_id()
101
 
            gconf_key = GEDIT_LANG_PATH + '/' + tag_id
102
 
            style_string = client.get_string(gconf_key)
103
 
 
104
 
            if style_string is None:
105
 
                continue
106
 
 
107
 
            # function to get a bool from a string that's either '0' or '1'
108
 
            string_bool = lambda x: bool(int(x))
109
 
 
110
 
            # style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
111
 
            # values are: mask, fg, bg, italic, bold, underline, strike
112
 
            # this packs them into (str_value, attr_name, conv_func) tuples
113
 
            items = zip(style_string.split('/'), ['mask', 'foreground',
114
 
                'background', 'italic', 'bold', 'underline', 'strikethrough' ],
115
 
                [ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
116
 
                    string_bool, string_bool, string_bool ]
117
 
            )
118
 
 
119
 
            style = gtksourceview.SourceTagStyle()
120
 
 
121
 
            # XXX The mask attribute controls whether the present values of
122
 
            # foreground and background color should in fact be used. Ideally
123
 
            # (and that's what gedit does), one could set all three attributes,
124
 
            # and let the TagStyle object figure out which colors to use.
125
 
            # However, in the GtkSourceview python bindings, the mask attribute
126
 
            # is read-only, and it's derived instead from the colors being
127
 
            # set or not. This means that we have to sometimes refrain from
128
 
            # setting fg or bg colors, depending on the value of the mask.
129
 
            # This code could go away if mask were writable.
130
 
            mask = int(items[0][0])
131
 
            if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
132
 
                items[2:3] = []
133
 
            if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
134
 
                items[1:2] = []
135
 
            items[0:1] = [] # skip the mask unconditionally
136
 
 
137
 
            for value, attr, func in items:
138
 
                try:
139
 
                    value = func(value)
140
 
                except ValueError:
141
 
                    warning('gconf key %s contains an invalid value: %s'
142
 
                            % gconf_key, value)
143
 
                else:
144
 
                    setattr(style, attr, value)
145
 
 
146
 
            lang.set_tag_style(tag_id, style)
147
 
 
148
 
    @classmethod
149
 
    def apply_colordiff_colors(klass, lang):
150
 
        """Set style colors for lang using the colordiff configuration file.
151
 
 
152
 
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
153
 
 
154
 
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
155
 
        """
156
 
        colors = {}
157
 
 
158
 
        for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
159
 
            f = os.path.expanduser(f)
160
 
            if os.path.exists(f):
161
 
                try:
162
 
                    f = file(f)
163
 
                except IOError, e:
164
 
                    warning('could not open file %s: %s' % (f, str(e)))
165
 
                else:
166
 
                    colors.update(klass.parse_colordiffrc(f))
167
 
                    f.close()
168
 
 
169
 
        if not colors:
170
 
            # ~/.colordiffrc does not exist
171
 
            return
172
 
 
173
 
        mapping = {
174
 
                # map GtkSourceView tags to colordiff names
175
 
                # since GSV is richer, accept new names for extra bits,
176
 
                # defaulting to old names if they're not present
177
 
                'Added@32@line': ['newtext'],
178
 
                'Removed@32@line': ['oldtext'],
179
 
                'Location': ['location', 'diffstuff'],
180
 
                'Diff@32@file': ['file', 'diffstuff'],
181
 
                'Special@32@case': ['specialcase', 'diffstuff'],
182
 
        }
183
 
 
184
 
        for tag in lang.get_tags():
185
 
            tag_id = tag.get_id()
186
 
            keys = mapping.get(tag_id, [])
187
 
            color = None
188
 
 
189
 
            for key in keys:
190
 
                color = colors.get(key, None)
191
 
                if color is not None:
192
 
                    break
193
 
 
194
 
            if color is None:
195
 
                continue
196
 
 
197
 
            style = gtksourceview.SourceTagStyle()
198
 
            try:
199
 
                style.foreground = gtk.gdk.color_parse(color)
200
 
            except ValueError:
201
 
                warning('not a valid color: %s' % color)
202
 
            else:
203
 
                lang.set_tag_style(tag_id, style)
204
 
 
205
 
    @staticmethod
206
 
    def parse_colordiffrc(fileobj):
207
 
        """Parse fileobj as a colordiff configuration file.
208
 
 
209
 
        :return: A dict with the key -> value pairs.
210
 
        """
211
 
        colors = {}
212
 
        for line in fileobj:
213
 
            if re.match(r'^\s*#', line):
214
 
                continue
215
 
            if '=' not in line:
216
 
                continue
217
 
            key, val = line.split('=', 1)
218
 
            colors[key.strip()] = val.strip()
219
 
        return colors
 
83
        if self.SHOW_WIDGETS:
 
84
            self.sourceview.show()
220
85
 
221
86
    def set_trees(self, rev_tree, parent_tree):
222
87
        self.rev_tree = rev_tree
227
92
#        self.parent_tree.lock_read()
228
93
#        self.rev_tree.lock_read()
229
94
#        try:
230
 
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
95
#            self.delta = iter_changes_to_status(
 
96
#               self.parent_tree, self.rev_tree)
231
97
#            self.path_to_status = {}
232
98
#            self.path_to_diff = {}
233
99
#            source_inv = self.parent_tree.inventory
234
100
#            target_inv = self.rev_tree.inventory
235
101
#            for (file_id, real_path, change_type, display_path) in self.delta:
236
 
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
102
#                self.path_to_status[real_path] = u'=== %s %s' % (
 
103
#                    change_type, display_path)
237
104
#                if change_type in ('modified', 'renamed and modified'):
238
105
#                    source_ie = source_inv[file_id]
239
106
#                    target_ie = target_inv[file_id]
241
108
#                    source_ie.diff(internal_diff, *old path, *old_tree,
242
109
#                                   *new_path, target_ie, self.rev_tree,
243
110
#                                   sio)
244
 
#                    self.path_to_diff[real_path] = 
 
111
#                    self.path_to_diff[real_path] =
245
112
#
246
113
#        finally:
247
114
#            self.rev_tree.unlock()
261
128
    """This is the soft and chewy filling for a DiffWindow."""
262
129
 
263
130
    def __init__(self):
264
 
        DiffFileView.__init__(self)
 
131
        super(DiffView, self).__init__()
265
132
        self.rev_tree = None
266
133
        self.parent_tree = None
267
134
 
291
158
        self.buffer.set_text(decoded.encode('UTF-8'))
292
159
 
293
160
 
294
 
class DiffWidget(gtk.HPaned):
 
161
class DiffWidget(Gtk.HPaned):
295
162
    """Diff widget
296
163
 
297
164
    """
 
165
 
 
166
    SHOW_WIDGETS = True
 
167
 
298
168
    def __init__(self):
299
169
        super(DiffWidget, self).__init__()
300
170
 
301
171
        # The file hierarchy: a scrollable treeview
302
 
        scrollwin = gtk.ScrolledWindow()
303
 
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
304
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
 
172
        scrollwin = Gtk.ScrolledWindow()
 
173
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
 
174
        scrollwin.set_shadow_type(Gtk.ShadowType.IN)
305
175
        self.pack1(scrollwin)
306
 
        scrollwin.show()
307
 
        
308
 
        self.model = gtk.TreeStore(str, str)
309
 
        self.treeview = gtk.TreeView(self.model)
 
176
        if self.SHOW_WIDGETS:
 
177
            scrollwin.show()
 
178
 
 
179
        self.model = Gtk.TreeStore(str, str)
 
180
        self.treeview = Gtk.TreeView(model=self.model)
310
181
        self.treeview.set_headers_visible(False)
311
182
        self.treeview.set_search_column(1)
312
183
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
313
184
        scrollwin.add(self.treeview)
314
 
        self.treeview.show()
 
185
        if self.SHOW_WIDGETS:
 
186
            self.treeview.show()
315
187
 
316
 
        cell = gtk.CellRendererText()
 
188
        cell = Gtk.CellRendererText()
317
189
        cell.set_property("width-chars", 20)
318
 
        column = gtk.TreeViewColumn()
319
 
        column.pack_start(cell, expand=True)
 
190
        column = Gtk.TreeViewColumn()
 
191
        column.pack_start(cell, True)
320
192
        column.add_attribute(cell, "text", 0)
321
193
        self.treeview.append_column(column)
322
194
 
332
204
        if getattr(self, 'diff_view', None) is None:
333
205
            self.diff_view = DiffFileView()
334
206
            self.pack2(self.diff_view)
335
 
        self.diff_view.show()
 
207
        if self.SHOW_WIDGETS:
 
208
            self.diff_view.show()
336
209
        for oldname, newname, patch in sections:
337
210
            self.diff_view._diffs[newname] = str(patch)
338
211
            if newname is None:
349
222
        if getattr(self, 'diff_view', None) is None:
350
223
            self.diff_view = DiffView()
351
224
            self.pack2(self.diff_view)
352
 
        self.diff_view.show()
 
225
        if self.SHOW_WIDGETS:
 
226
            self.diff_view.show()
353
227
        self.diff_view.set_trees(rev_tree, parent_tree)
354
228
        self.rev_tree = rev_tree
355
229
        self.parent_tree = parent_tree
357
231
        self.model.clear()
358
232
        delta = self.rev_tree.changes_from(self.parent_tree)
359
233
 
360
 
        self.model.append(None, [ "Complete Diff", "" ])
 
234
        self.model.append(None, ["Complete Diff", ""])
361
235
 
362
236
        if len(delta.added):
363
 
            titer = self.model.append(None, [ "Added", None ])
 
237
            titer = self.model.append(None, ["Added", None])
364
238
            for path, id, kind in delta.added:
365
 
                self.model.append(titer, [ path, path ])
 
239
                self.model.append(titer, [path, path])
366
240
 
367
241
        if len(delta.removed):
368
 
            titer = self.model.append(None, [ "Removed", None ])
 
242
            titer = self.model.append(None, ["Removed", None])
369
243
            for path, id, kind in delta.removed:
370
 
                self.model.append(titer, [ path, path ])
 
244
                self.model.append(titer, [path, path])
371
245
 
372
246
        if len(delta.renamed):
373
 
            titer = self.model.append(None, [ "Renamed", None ])
 
247
            titer = self.model.append(None, ["Renamed", None])
374
248
            for oldpath, newpath, id, kind, text_modified, meta_modified \
375
249
                    in delta.renamed:
376
 
                self.model.append(titer, [ oldpath, newpath ])
 
250
                self.model.append(titer, [oldpath, newpath])
377
251
 
378
252
        if len(delta.modified):
379
 
            titer = self.model.append(None, [ "Modified", None ])
 
253
            titer = self.model.append(None, ["Modified", None])
380
254
            for path, id, kind, text_modified, meta_modified in delta.modified:
381
 
                self.model.append(titer, [ path, path ])
 
255
                self.model.append(titer, [path, path])
382
256
 
383
257
        self.treeview.expand_all()
384
258
        self.diff_view.show_diff(None)
392
266
                    tv_path = child.path
393
267
                    break
394
268
        if tv_path is None:
395
 
            raise NoSuchFile(file_path)
396
 
        self.treeview.set_cursor(tv_path)
 
269
            raise errors.NoSuchFile(file_path)
 
270
        self.treeview.set_cursor(tv_path, None, False)
397
271
        self.treeview.scroll_to_cell(tv_path)
398
272
 
399
273
    def _treeview_cursor_cb(self, *args):
400
274
        """Callback for when the treeview cursor changes."""
401
275
        (path, col) = self.treeview.get_cursor()
402
 
        specific_files = [ self.model[path][1] ]
403
 
        if specific_files == [ None ]:
404
 
            return
405
 
        elif specific_files == [ "" ]:
 
276
        if path is None:
 
277
            return
 
278
        specific_files = [self.model[path][1]]
 
279
        if specific_files == [None]:
 
280
            return
 
281
        elif specific_files == [""]:
406
282
            specific_files = None
407
 
        
 
283
 
408
284
        self.diff_view.show_diff(specific_files)
409
 
    
 
285
 
410
286
    def _on_wraplines_toggled(self, widget=None, wrap=False):
411
287
        """Callback for when the wrap lines checkbutton is toggled"""
412
288
        if wrap or widget.get_active():
413
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
 
289
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
414
290
        else:
415
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
 
291
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
 
292
 
416
293
 
417
294
class DiffWindow(Window):
418
295
    """Diff window.
421
298
    differences between two revisions on a branch.
422
299
    """
423
300
 
 
301
    SHOW_WIDGETS = True
 
302
 
424
303
    def __init__(self, parent=None, operations=None):
425
 
        Window.__init__(self, parent)
 
304
        super(DiffWindow, self).__init__(parent=parent)
426
305
        self.set_border_width(0)
427
 
        self.set_title("bzrk diff")
 
306
        self.set_title("bzr diff")
428
307
 
429
308
        # Use two thirds of the screen by default
430
309
        screen = self.get_screen()
436
315
 
437
316
    def construct(self, operations):
438
317
        """Construct the window contents."""
439
 
        self.vbox = gtk.VBox()
 
318
        self.vbox = Gtk.VBox()
440
319
        self.add(self.vbox)
441
 
        self.vbox.show()
 
320
        if self.SHOW_WIDGETS:
 
321
            self.vbox.show()
442
322
        self.diff = DiffWidget()
443
323
        self.vbox.pack_end(self.diff, True, True, 0)
444
 
        self.diff.show_all()
 
324
        if self.SHOW_WIDGETS:
 
325
            self.diff.show_all()
445
326
        # Build after DiffWidget to connect signals
446
327
        menubar = self._get_menu_bar()
447
328
        self.vbox.pack_start(menubar, False, False, 0)
448
329
        hbox = self._get_button_bar(operations)
449
330
        if hbox is not None:
450
331
            self.vbox.pack_start(hbox, False, True, 0)
451
 
        
452
 
    
 
332
 
453
333
    def _get_menu_bar(self):
454
 
        menubar = gtk.MenuBar()
 
334
        menubar = Gtk.MenuBar()
455
335
        # View menu
456
 
        mb_view = gtk.MenuItem(_i18n("_View"))
457
 
        mb_view_menu = gtk.Menu()
458
 
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
 
336
        mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
 
337
        mb_view_menu = Gtk.Menu()
 
338
        mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
 
339
            _i18n("Wrap _Long Lines"))
459
340
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
460
 
        mb_view_wrapsource.show()
461
341
        mb_view_menu.append(mb_view_wrapsource)
462
 
        mb_view.show()
463
342
        mb_view.set_submenu(mb_view_menu)
464
 
        mb_view.show()
465
343
        menubar.append(mb_view)
466
 
        menubar.show()
 
344
        if self.SHOW_WIDGETS:
 
345
            menubar.show_all()
467
346
        return menubar
468
 
    
 
347
 
469
348
    def _get_button_bar(self, operations):
470
349
        """Return a button bar to use.
471
350
 
473
352
        """
474
353
        if operations is None:
475
354
            return None
476
 
        hbox = gtk.HButtonBox()
477
 
        hbox.set_layout(gtk.BUTTONBOX_START)
 
355
        hbox = Gtk.HButtonBox()
 
356
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
478
357
        for title, method in operations:
479
 
            merge_button = gtk.Button(title)
480
 
            merge_button.show()
481
 
            merge_button.set_relief(gtk.RELIEF_NONE)
 
358
            merge_button = Gtk.Button(title)
 
359
            if self.SHOW_WIDGETS:
 
360
                merge_button.show()
 
361
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
482
362
            merge_button.connect("clicked", method)
483
 
            hbox.pack_start(merge_button, expand=False, fill=True)
484
 
        hbox.show()
 
363
            hbox.pack_start(merge_button, False, True, 0)
 
364
        if self.SHOW_WIDGETS:
 
365
            hbox.show()
485
366
        return hbox
486
367
 
487
368
    def _get_merge_target(self):
488
 
        d = gtk.FileChooserDialog('Merge branch', self,
489
 
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
490
 
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
491
 
                                           gtk.STOCK_CANCEL,
492
 
                                           gtk.RESPONSE_CANCEL,))
 
369
        d = Gtk.FileChooserDialog('Merge branch', self,
 
370
                                  Gtk.FileChooserAction.SELECT_FOLDER,
 
371
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
 
372
                                           Gtk.STOCK_CANCEL,
 
373
                                           Gtk.ResponseType.CANCEL,))
493
374
        try:
494
375
            result = d.run()
495
 
            if result != gtk.RESPONSE_OK:
 
376
            if result != Gtk.ResponseType.OK:
496
377
                raise SelectCancelled()
497
378
            return d.get_current_folder_uri()
498
379
        finally:
512
393
        error_dialog('Error', str(e))
513
394
 
514
395
    def _get_save_path(self, basename):
515
 
        d = gtk.FileChooserDialog('Save As', self,
516
 
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
517
 
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
518
 
                                           gtk.STOCK_CANCEL,
519
 
                                           gtk.RESPONSE_CANCEL,))
 
396
        d = Gtk.FileChooserDialog('Save As', self,
 
397
                                  Gtk.FileChooserAction.SAVE,
 
398
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
 
399
                                           Gtk.STOCK_CANCEL,
 
400
                                           Gtk.ResponseType.CANCEL,))
520
401
        d.set_current_name(basename)
521
402
        try:
522
403
            result = d.run()
523
 
            if result != gtk.RESPONSE_OK:
 
404
            if result != Gtk.ResponseType.OK:
524
405
                raise SelectCancelled()
525
406
            return urlutils.local_path_from_url(d.get_uri())
526
407
        finally:
541
422
 
542
423
class DiffController(object):
543
424
 
544
 
    def __init__(self, path, patch, window=None):
 
425
    def __init__(self, path, patch, window=None, allow_dirty=False):
545
426
        self.path = path
546
427
        self.patch = patch
 
428
        self.allow_dirty = allow_dirty
547
429
        if window is None:
548
430
            window = DiffWindow(operations=self._provide_operations())
549
431
            self.initialize_window(window)
555
437
 
556
438
    def get_diff_sections(self):
557
439
        yield "Complete Diff", None, ''.join(self.patch)
558
 
        for patch in parse_patches(self.patch):
 
440
        # allow_dirty was added to parse_patches in bzrlib 2.2b1
 
441
        if 'allow_dirty' in inspect.getargspec(parse_patches).args:
 
442
            patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
 
443
        else:
 
444
            patches = parse_patches(self.patch)
 
445
        for patch in patches:
559
446
            oldname = patch.oldname.split('\t')[0]
560
447
            newname = patch.newname.split('\t')[0]
561
448
            yield oldname, newname, str(patch)
582
469
class MergeDirectiveController(DiffController):
583
470
 
584
471
    def __init__(self, path, directive, window=None):
585
 
        DiffController.__init__(self, path, directive.patch.splitlines(True),
586
 
                                window)
 
472
        super(MergeDirectiveController, self).__init__(
 
473
            path, directive.patch.splitlines(True), window)
587
474
        self.directive = directive
588
475
        self.merge_target = None
589
476
 
600
487
        tree.lock_write()
601
488
        try:
602
489
            try:
603
 
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
604
 
                    self.directive, progress.DummyProgress())
605
 
                merger.check_basis(True)
 
490
                if tree.has_changes():
 
491
                    raise errors.UncommittedChanges(tree)
 
492
                merger, verified = _mod_merge.Merger.from_mergeable(
 
493
                    tree, self.directive, pb=None)
606
494
                merger.merge_type = _mod_merge.Merge3Merger
607
495
                conflict_count = merger.do_merge()
608
496
                merger.set_pending()