/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: Vincent Ladeuil
  • Date: 2008-11-06 15:45:24 UTC
  • mto: This revision was merged to the branch mainline in revision 625.
  • Revision ID: v.ladeuil+lp@free.fr-20081106154524-n9al5n1pome2xo0u
Fix bug #289220 by using the right parameter order.

* status.py:
(StatusWindow.row_diff): One can argue that the parameters are in
the wrong order or just respect their meaning :) Thanks to Anne
Mohsen for noticing and proposing the fix.

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
13
19
import sys
14
 
import inspect
15
20
 
16
 
from gi.repository import Gtk
17
 
from gi.repository import Pango
18
21
try:
19
 
    from gi.repository import GtkSource
 
22
    import gtksourceview
20
23
    have_gtksourceview = True
21
24
except ImportError:
22
25
    have_gtksourceview = False
 
26
try:
 
27
    import gconf
 
28
    have_gconf = True
 
29
except ImportError:
 
30
    have_gconf = False
23
31
 
24
32
from bzrlib import (
25
 
    errors,
26
33
    merge as _mod_merge,
27
34
    osutils,
 
35
    progress,
28
36
    urlutils,
29
37
    workingtree,
30
 
    )
31
 
from bzrlib.diff import show_diff_trees
 
38
)
 
39
from bzrlib.diff import show_diff_trees, internal_diff
 
40
from bzrlib.errors import NoSuchFile
32
41
from bzrlib.patches import parse_patches
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
 
42
from bzrlib.trace import warning
 
43
from bzrlib.plugins.gtk import _i18n
39
44
from bzrlib.plugins.gtk.window import Window
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
 
45
from dialog import error_dialog, info_dialog, warning_dialog
48
46
 
49
47
 
50
48
class SelectCancelled(Exception):
52
50
    pass
53
51
 
54
52
 
55
 
class DiffFileView(Gtk.ScrolledWindow):
 
53
class DiffFileView(gtk.ScrolledWindow):
56
54
    """Window for displaying diffs from a diff file"""
57
55
 
58
 
    SHOW_WIDGETS = True
59
 
 
60
56
    def __init__(self):
61
 
        super(DiffFileView, self).__init__()
 
57
        gtk.ScrolledWindow.__init__(self)
62
58
        self.construct()
63
59
        self._diffs = {}
64
60
 
65
61
    def construct(self):
66
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
 
        self.set_shadow_type(Gtk.ShadowType.IN)
 
62
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
63
        self.set_shadow_type(gtk.SHADOW_IN)
68
64
 
69
65
        if have_gtksourceview:
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)
 
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)
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.override_font(Pango.FontDescription("Monospace"))
 
81
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
82
82
        self.add(self.sourceview)
83
 
        if self.SHOW_WIDGETS:
84
 
            self.sourceview.show()
 
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
85
220
 
86
221
    def set_trees(self, rev_tree, parent_tree):
87
222
        self.rev_tree = rev_tree
92
227
#        self.parent_tree.lock_read()
93
228
#        self.rev_tree.lock_read()
94
229
#        try:
95
 
#            self.delta = iter_changes_to_status(
96
 
#               self.parent_tree, self.rev_tree)
 
230
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
97
231
#            self.path_to_status = {}
98
232
#            self.path_to_diff = {}
99
233
#            source_inv = self.parent_tree.inventory
100
234
#            target_inv = self.rev_tree.inventory
101
235
#            for (file_id, real_path, change_type, display_path) in self.delta:
102
 
#                self.path_to_status[real_path] = u'=== %s %s' % (
103
 
#                    change_type, display_path)
 
236
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
104
237
#                if change_type in ('modified', 'renamed and modified'):
105
238
#                    source_ie = source_inv[file_id]
106
239
#                    target_ie = target_inv[file_id]
108
241
#                    source_ie.diff(internal_diff, *old path, *old_tree,
109
242
#                                   *new_path, target_ie, self.rev_tree,
110
243
#                                   sio)
111
 
#                    self.path_to_diff[real_path] =
 
244
#                    self.path_to_diff[real_path] = 
112
245
#
113
246
#        finally:
114
247
#            self.rev_tree.unlock()
128
261
    """This is the soft and chewy filling for a DiffWindow."""
129
262
 
130
263
    def __init__(self):
131
 
        super(DiffView, self).__init__()
 
264
        DiffFileView.__init__(self)
132
265
        self.rev_tree = None
133
266
        self.parent_tree = None
134
267
 
158
291
        self.buffer.set_text(decoded.encode('UTF-8'))
159
292
 
160
293
 
161
 
class DiffWidget(Gtk.HPaned):
 
294
class DiffWidget(gtk.HPaned):
162
295
    """Diff widget
163
296
 
164
297
    """
165
 
 
166
 
    SHOW_WIDGETS = True
167
 
 
168
298
    def __init__(self):
169
299
        super(DiffWidget, self).__init__()
170
300
 
171
301
        # The file hierarchy: a scrollable treeview
172
 
        scrollwin = Gtk.ScrolledWindow()
173
 
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
174
 
        scrollwin.set_shadow_type(Gtk.ShadowType.IN)
 
302
        scrollwin = gtk.ScrolledWindow()
 
303
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
304
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
175
305
        self.pack1(scrollwin)
176
 
        if self.SHOW_WIDGETS:
177
 
            scrollwin.show()
178
 
 
179
 
        self.model = Gtk.TreeStore(str, str)
180
 
        self.treeview = Gtk.TreeView(model=self.model)
 
306
        scrollwin.show()
 
307
        
 
308
        self.model = gtk.TreeStore(str, str)
 
309
        self.treeview = gtk.TreeView(self.model)
181
310
        self.treeview.set_headers_visible(False)
182
311
        self.treeview.set_search_column(1)
183
312
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
313
        scrollwin.add(self.treeview)
185
 
        if self.SHOW_WIDGETS:
186
 
            self.treeview.show()
 
314
        self.treeview.show()
187
315
 
188
 
        cell = Gtk.CellRendererText()
 
316
        cell = gtk.CellRendererText()
189
317
        cell.set_property("width-chars", 20)
190
 
        column = Gtk.TreeViewColumn()
191
 
        column.pack_start(cell, True)
 
318
        column = gtk.TreeViewColumn()
 
319
        column.pack_start(cell, expand=True)
192
320
        column.add_attribute(cell, "text", 0)
193
321
        self.treeview.append_column(column)
194
322
 
204
332
        if getattr(self, 'diff_view', None) is None:
205
333
            self.diff_view = DiffFileView()
206
334
            self.pack2(self.diff_view)
207
 
        if self.SHOW_WIDGETS:
208
 
            self.diff_view.show()
 
335
        self.diff_view.show()
209
336
        for oldname, newname, patch in sections:
210
337
            self.diff_view._diffs[newname] = str(patch)
211
338
            if newname is None:
222
349
        if getattr(self, 'diff_view', None) is None:
223
350
            self.diff_view = DiffView()
224
351
            self.pack2(self.diff_view)
225
 
        if self.SHOW_WIDGETS:
226
 
            self.diff_view.show()
 
352
        self.diff_view.show()
227
353
        self.diff_view.set_trees(rev_tree, parent_tree)
228
354
        self.rev_tree = rev_tree
229
355
        self.parent_tree = parent_tree
231
357
        self.model.clear()
232
358
        delta = self.rev_tree.changes_from(self.parent_tree)
233
359
 
234
 
        self.model.append(None, ["Complete Diff", ""])
 
360
        self.model.append(None, [ "Complete Diff", "" ])
235
361
 
236
362
        if len(delta.added):
237
 
            titer = self.model.append(None, ["Added", None])
 
363
            titer = self.model.append(None, [ "Added", None ])
238
364
            for path, id, kind in delta.added:
239
 
                self.model.append(titer, [path, path])
 
365
                self.model.append(titer, [ path, path ])
240
366
 
241
367
        if len(delta.removed):
242
 
            titer = self.model.append(None, ["Removed", None])
 
368
            titer = self.model.append(None, [ "Removed", None ])
243
369
            for path, id, kind in delta.removed:
244
 
                self.model.append(titer, [path, path])
 
370
                self.model.append(titer, [ path, path ])
245
371
 
246
372
        if len(delta.renamed):
247
 
            titer = self.model.append(None, ["Renamed", None])
 
373
            titer = self.model.append(None, [ "Renamed", None ])
248
374
            for oldpath, newpath, id, kind, text_modified, meta_modified \
249
375
                    in delta.renamed:
250
 
                self.model.append(titer, [oldpath, newpath])
 
376
                self.model.append(titer, [ oldpath, newpath ])
251
377
 
252
378
        if len(delta.modified):
253
 
            titer = self.model.append(None, ["Modified", None])
 
379
            titer = self.model.append(None, [ "Modified", None ])
254
380
            for path, id, kind, text_modified, meta_modified in delta.modified:
255
 
                self.model.append(titer, [path, path])
 
381
                self.model.append(titer, [ path, path ])
256
382
 
257
383
        self.treeview.expand_all()
258
384
        self.diff_view.show_diff(None)
266
392
                    tv_path = child.path
267
393
                    break
268
394
        if tv_path is None:
269
 
            raise errors.NoSuchFile(file_path)
270
 
        self.treeview.set_cursor(tv_path, None, False)
 
395
            raise NoSuchFile(file_path)
 
396
        self.treeview.set_cursor(tv_path)
271
397
        self.treeview.scroll_to_cell(tv_path)
272
398
 
273
399
    def _treeview_cursor_cb(self, *args):
274
400
        """Callback for when the treeview cursor changes."""
275
401
        (path, col) = self.treeview.get_cursor()
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 == [""]:
 
402
        specific_files = [ self.model[path][1] ]
 
403
        if specific_files == [ None ]:
 
404
            return
 
405
        elif specific_files == [ "" ]:
282
406
            specific_files = None
283
 
 
 
407
        
284
408
        self.diff_view.show_diff(specific_files)
285
 
 
 
409
    
286
410
    def _on_wraplines_toggled(self, widget=None, wrap=False):
287
411
        """Callback for when the wrap lines checkbutton is toggled"""
288
412
        if wrap or widget.get_active():
289
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
 
413
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
290
414
        else:
291
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
292
 
 
 
415
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
293
416
 
294
417
class DiffWindow(Window):
295
418
    """Diff window.
298
421
    differences between two revisions on a branch.
299
422
    """
300
423
 
301
 
    SHOW_WIDGETS = True
302
 
 
303
424
    def __init__(self, parent=None, operations=None):
304
 
        super(DiffWindow, self).__init__(parent=parent)
 
425
        Window.__init__(self, parent)
305
426
        self.set_border_width(0)
306
 
        self.set_title("bzr diff")
 
427
        self.set_title("bzrk diff")
307
428
 
308
429
        # Use two thirds of the screen by default
309
430
        screen = self.get_screen()
315
436
 
316
437
    def construct(self, operations):
317
438
        """Construct the window contents."""
318
 
        self.vbox = Gtk.VBox()
 
439
        self.vbox = gtk.VBox()
319
440
        self.add(self.vbox)
320
 
        if self.SHOW_WIDGETS:
321
 
            self.vbox.show()
 
441
        self.vbox.show()
322
442
        self.diff = DiffWidget()
323
443
        self.vbox.pack_end(self.diff, True, True, 0)
324
 
        if self.SHOW_WIDGETS:
325
 
            self.diff.show_all()
 
444
        self.diff.show_all()
326
445
        # Build after DiffWidget to connect signals
327
446
        menubar = self._get_menu_bar()
328
447
        self.vbox.pack_start(menubar, False, False, 0)
329
448
        hbox = self._get_button_bar(operations)
330
449
        if hbox is not None:
331
450
            self.vbox.pack_start(hbox, False, True, 0)
332
 
 
 
451
        
 
452
    
333
453
    def _get_menu_bar(self):
334
 
        menubar = Gtk.MenuBar()
 
454
        menubar = gtk.MenuBar()
335
455
        # View menu
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"))
 
456
        mb_view = gtk.MenuItem(_i18n("_View"))
 
457
        mb_view_menu = gtk.Menu()
 
458
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
340
459
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
460
        mb_view_wrapsource.show()
341
461
        mb_view_menu.append(mb_view_wrapsource)
 
462
        mb_view.show()
342
463
        mb_view.set_submenu(mb_view_menu)
 
464
        mb_view.show()
343
465
        menubar.append(mb_view)
344
 
        if self.SHOW_WIDGETS:
345
 
            menubar.show_all()
 
466
        menubar.show()
346
467
        return menubar
347
 
 
 
468
    
348
469
    def _get_button_bar(self, operations):
349
470
        """Return a button bar to use.
350
471
 
352
473
        """
353
474
        if operations is None:
354
475
            return None
355
 
        hbox = Gtk.HButtonBox()
356
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
476
        hbox = gtk.HButtonBox()
 
477
        hbox.set_layout(gtk.BUTTONBOX_START)
357
478
        for title, method in operations:
358
 
            merge_button = Gtk.Button(title)
359
 
            if self.SHOW_WIDGETS:
360
 
                merge_button.show()
361
 
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
 
479
            merge_button = gtk.Button(title)
 
480
            merge_button.show()
 
481
            merge_button.set_relief(gtk.RELIEF_NONE)
362
482
            merge_button.connect("clicked", method)
363
 
            hbox.pack_start(merge_button, False, True, 0)
364
 
        if self.SHOW_WIDGETS:
365
 
            hbox.show()
 
483
            hbox.pack_start(merge_button, expand=False, fill=True)
 
484
        hbox.show()
366
485
        return hbox
367
486
 
368
487
    def _get_merge_target(self):
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,))
 
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,))
374
493
        try:
375
494
            result = d.run()
376
 
            if result != Gtk.ResponseType.OK:
 
495
            if result != gtk.RESPONSE_OK:
377
496
                raise SelectCancelled()
378
497
            return d.get_current_folder_uri()
379
498
        finally:
393
512
        error_dialog('Error', str(e))
394
513
 
395
514
    def _get_save_path(self, basename):
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,))
 
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,))
401
520
        d.set_current_name(basename)
402
521
        try:
403
522
            result = d.run()
404
 
            if result != Gtk.ResponseType.OK:
 
523
            if result != gtk.RESPONSE_OK:
405
524
                raise SelectCancelled()
406
525
            return urlutils.local_path_from_url(d.get_uri())
407
526
        finally:
422
541
 
423
542
class DiffController(object):
424
543
 
425
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
544
    def __init__(self, path, patch, window=None):
426
545
        self.path = path
427
546
        self.patch = patch
428
 
        self.allow_dirty = allow_dirty
429
547
        if window is None:
430
548
            window = DiffWindow(operations=self._provide_operations())
431
549
            self.initialize_window(window)
437
555
 
438
556
    def get_diff_sections(self):
439
557
        yield "Complete Diff", None, ''.join(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:
 
558
        for patch in parse_patches(self.patch):
446
559
            oldname = patch.oldname.split('\t')[0]
447
560
            newname = patch.newname.split('\t')[0]
448
561
            yield oldname, newname, str(patch)
469
582
class MergeDirectiveController(DiffController):
470
583
 
471
584
    def __init__(self, path, directive, window=None):
472
 
        super(MergeDirectiveController, self).__init__(
473
 
            path, directive.patch.splitlines(True), window)
 
585
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
586
                                window)
474
587
        self.directive = directive
475
588
        self.merge_target = None
476
589
 
487
600
        tree.lock_write()
488
601
        try:
489
602
            try:
490
 
                if tree.has_changes():
491
 
                    raise errors.UncommittedChanges(tree)
492
 
                merger, verified = _mod_merge.Merger.from_mergeable(
493
 
                    tree, self.directive, pb=None)
 
603
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
604
                    self.directive, progress.DummyProgress())
 
605
                merger.check_basis(True)
494
606
                merger.merge_type = _mod_merge.Merge3Merger
495
607
                conflict_count = merger.do_merge()
496
608
                merger.set_pending()