/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: 2009-06-10 18:07:35 UTC
  • Revision ID: jelmer@samba.org-20090610180735-w6efmw1c233z105e
Reorder bencode imports, prefer the new location to prevent deprecation warnings.

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
 
20
from xml.etree.ElementTree import Element, SubElement, tostring
15
21
 
16
 
from gi.repository import Gtk
17
 
from gi.repository import Pango
18
22
try:
19
 
    from gi.repository import GtkSource
 
23
    import gtksourceview2
20
24
    have_gtksourceview = True
21
25
except ImportError:
22
26
    have_gtksourceview = False
 
27
try:
 
28
    import gconf
 
29
    have_gconf = True
 
30
except ImportError:
 
31
    have_gconf = False
23
32
 
24
33
from bzrlib import (
25
 
    errors,
26
34
    merge as _mod_merge,
27
35
    osutils,
 
36
    progress,
28
37
    urlutils,
29
38
    workingtree,
30
 
    )
31
 
from bzrlib.diff import show_diff_trees
 
39
)
 
40
from bzrlib.diff import show_diff_trees, internal_diff
 
41
from bzrlib.errors import NoSuchFile
32
42
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
 
43
from bzrlib.trace import warning
 
44
from bzrlib.plugins.gtk import _i18n
39
45
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
 
46
from dialog import error_dialog, info_dialog, warning_dialog
48
47
 
49
48
 
50
49
class SelectCancelled(Exception):
52
51
    pass
53
52
 
54
53
 
55
 
class DiffFileView(Gtk.ScrolledWindow):
 
54
class DiffFileView(gtk.ScrolledWindow):
56
55
    """Window for displaying diffs from a diff file"""
57
56
 
58
 
    SHOW_WIDGETS = True
59
 
 
60
57
    def __init__(self):
61
 
        super(DiffFileView, self).__init__()
 
58
        gtk.ScrolledWindow.__init__(self)
62
59
        self.construct()
63
60
        self._diffs = {}
64
61
 
65
62
    def construct(self):
66
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
 
        self.set_shadow_type(Gtk.ShadowType.IN)
 
63
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
64
        self.set_shadow_type(gtk.SHADOW_IN)
68
65
 
69
66
        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)
 
67
            self.buffer = gtksourceview2.Buffer()
 
68
            slm = gtksourceview2.LanguageManager()
 
69
            gsl = slm.guess_language(content_type="text/x-patch")
 
70
            if have_gconf:
 
71
                self.apply_gedit_colors(self.buffer)
 
72
            self.apply_colordiff_colors(self.buffer)
 
73
            self.buffer.set_language(gsl)
74
74
            self.buffer.set_highlight_syntax(True)
75
 
            self.sourceview = GtkSource.View(buffer=self.buffer)
 
75
 
 
76
            self.sourceview = gtksourceview2.View(self.buffer)
76
77
        else:
77
 
            self.buffer = Gtk.TextBuffer()
78
 
            self.sourceview = Gtk.TextView(self.buffer)
 
78
            self.buffer = gtk.TextBuffer()
 
79
            self.sourceview = gtk.TextView(self.buffer)
79
80
 
80
81
        self.sourceview.set_editable(False)
81
 
        self.sourceview.override_font(Pango.FontDescription("Monospace"))
 
82
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
82
83
        self.add(self.sourceview)
83
 
        if self.SHOW_WIDGETS:
84
 
            self.sourceview.show()
 
84
        self.sourceview.show()
 
85
 
 
86
    @staticmethod
 
87
    def apply_gedit_colors(buf):
 
88
        """Set style to that specified in gedit configuration.
 
89
 
 
90
        This method needs the gconf module.
 
91
 
 
92
        :param buf: a gtksourceview2.Buffer object.
 
93
        """
 
94
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
 
95
 
 
96
        client = gconf.client_get_default()
 
97
        style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
 
98
        style_scheme = gtksourceview2.StyleSchemeManager().get_scheme(style_scheme_name)
 
99
        
 
100
        buf.set_style_scheme(style_scheme)
 
101
 
 
102
    @classmethod
 
103
    def apply_colordiff_colors(klass, buf):
 
104
        """Set style colors for lang using the colordiff configuration file.
 
105
 
 
106
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
107
 
 
108
        :param buf: a "Diff" gtksourceview2.Buffer object.
 
109
        """
 
110
        scheme_manager = gtksourceview2.StyleSchemeManager()
 
111
        style_scheme = scheme_manager.get_scheme('colordiff')
 
112
        
 
113
        # if style scheme not found, we'll generate it from colordiffrc
 
114
        # TODO: reload if colordiffrc has changed.
 
115
        if style_scheme is None:
 
116
            colors = {}
 
117
 
 
118
            for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
 
119
                f = os.path.expanduser(f)
 
120
                if os.path.exists(f):
 
121
                    try:
 
122
                        f = file(f)
 
123
                    except IOError, e:
 
124
                        warning('could not open file %s: %s' % (f, str(e)))
 
125
                    else:
 
126
                        colors.update(klass.parse_colordiffrc(f))
 
127
                        f.close()
 
128
 
 
129
            if not colors:
 
130
                # ~/.colordiffrc does not exist
 
131
                return
 
132
            
 
133
            mapping = {
 
134
                # map GtkSourceView2 scheme styles to colordiff names
 
135
                # since GSV is richer, accept new names for extra bits,
 
136
                # defaulting to old names if they're not present
 
137
                'diff:added-line': ['newtext'],
 
138
                'diff:removed-line': ['oldtext'],
 
139
                'diff:location': ['location', 'diffstuff'],
 
140
                'diff:file': ['file', 'diffstuff'],
 
141
                'diff:special-case': ['specialcase', 'diffstuff'],
 
142
            }
 
143
            
 
144
            converted_colors = {}
 
145
            for name, values in mapping.items():
 
146
                color = None
 
147
                for value in values:
 
148
                    color = colors.get(value, None)
 
149
                    if color is not None:
 
150
                        break
 
151
                if color is None:
 
152
                    continue
 
153
                converted_colors[name] = color
 
154
            
 
155
            # some xml magic to produce needed style scheme description
 
156
            e_style_scheme = Element('style-scheme')
 
157
            e_style_scheme.set('id', 'colordiff')
 
158
            e_style_scheme.set('_name', 'ColorDiff')
 
159
            e_style_scheme.set('version', '1.0')
 
160
            for name, color in converted_colors.items():
 
161
                style = SubElement(e_style_scheme, 'style')
 
162
                style.set('name', name)
 
163
                style.set('foreground', '#%s' % color)
 
164
            
 
165
            scheme_xml = tostring(e_style_scheme, 'UTF-8')
 
166
            if not os.path.exists(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles')):
 
167
                os.makedirs(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles'))
 
168
            file(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles/colordiff.xml'), 'w').write(scheme_xml)
 
169
            
 
170
            scheme_manager.force_rescan()
 
171
            style_scheme = scheme_manager.get_scheme('colordiff')
 
172
        
 
173
        buf.set_style_scheme(style_scheme)
 
174
 
 
175
    @staticmethod
 
176
    def parse_colordiffrc(fileobj):
 
177
        """Parse fileobj as a colordiff configuration file.
 
178
 
 
179
        :return: A dict with the key -> value pairs.
 
180
        """
 
181
        colors = {}
 
182
        for line in fileobj:
 
183
            if re.match(r'^\s*#', line):
 
184
                continue
 
185
            if '=' not in line:
 
186
                continue
 
187
            key, val = line.split('=', 1)
 
188
            colors[key.strip()] = val.strip()
 
189
        return colors
85
190
 
86
191
    def set_trees(self, rev_tree, parent_tree):
87
192
        self.rev_tree = rev_tree
92
197
#        self.parent_tree.lock_read()
93
198
#        self.rev_tree.lock_read()
94
199
#        try:
95
 
#            self.delta = iter_changes_to_status(
96
 
#               self.parent_tree, self.rev_tree)
 
200
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
97
201
#            self.path_to_status = {}
98
202
#            self.path_to_diff = {}
99
203
#            source_inv = self.parent_tree.inventory
100
204
#            target_inv = self.rev_tree.inventory
101
205
#            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)
 
206
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
104
207
#                if change_type in ('modified', 'renamed and modified'):
105
208
#                    source_ie = source_inv[file_id]
106
209
#                    target_ie = target_inv[file_id]
108
211
#                    source_ie.diff(internal_diff, *old path, *old_tree,
109
212
#                                   *new_path, target_ie, self.rev_tree,
110
213
#                                   sio)
111
 
#                    self.path_to_diff[real_path] =
 
214
#                    self.path_to_diff[real_path] = 
112
215
#
113
216
#        finally:
114
217
#            self.rev_tree.unlock()
128
231
    """This is the soft and chewy filling for a DiffWindow."""
129
232
 
130
233
    def __init__(self):
131
 
        super(DiffView, self).__init__()
 
234
        DiffFileView.__init__(self)
132
235
        self.rev_tree = None
133
236
        self.parent_tree = None
134
237
 
158
261
        self.buffer.set_text(decoded.encode('UTF-8'))
159
262
 
160
263
 
161
 
class DiffWidget(Gtk.HPaned):
 
264
class DiffWidget(gtk.HPaned):
162
265
    """Diff widget
163
266
 
164
267
    """
165
 
 
166
 
    SHOW_WIDGETS = True
167
 
 
168
268
    def __init__(self):
169
269
        super(DiffWidget, self).__init__()
170
270
 
171
271
        # 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)
 
272
        scrollwin = gtk.ScrolledWindow()
 
273
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
274
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
175
275
        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)
 
276
        scrollwin.show()
 
277
        
 
278
        self.model = gtk.TreeStore(str, str)
 
279
        self.treeview = gtk.TreeView(self.model)
181
280
        self.treeview.set_headers_visible(False)
182
281
        self.treeview.set_search_column(1)
183
282
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
283
        scrollwin.add(self.treeview)
185
 
        if self.SHOW_WIDGETS:
186
 
            self.treeview.show()
 
284
        self.treeview.show()
187
285
 
188
 
        cell = Gtk.CellRendererText()
 
286
        cell = gtk.CellRendererText()
189
287
        cell.set_property("width-chars", 20)
190
 
        column = Gtk.TreeViewColumn()
191
 
        column.pack_start(cell, True)
 
288
        column = gtk.TreeViewColumn()
 
289
        column.pack_start(cell, expand=True)
192
290
        column.add_attribute(cell, "text", 0)
193
291
        self.treeview.append_column(column)
194
292
 
204
302
        if getattr(self, 'diff_view', None) is None:
205
303
            self.diff_view = DiffFileView()
206
304
            self.pack2(self.diff_view)
207
 
        if self.SHOW_WIDGETS:
208
 
            self.diff_view.show()
 
305
        self.diff_view.show()
209
306
        for oldname, newname, patch in sections:
210
307
            self.diff_view._diffs[newname] = str(patch)
211
308
            if newname is None:
222
319
        if getattr(self, 'diff_view', None) is None:
223
320
            self.diff_view = DiffView()
224
321
            self.pack2(self.diff_view)
225
 
        if self.SHOW_WIDGETS:
226
 
            self.diff_view.show()
 
322
        self.diff_view.show()
227
323
        self.diff_view.set_trees(rev_tree, parent_tree)
228
324
        self.rev_tree = rev_tree
229
325
        self.parent_tree = parent_tree
231
327
        self.model.clear()
232
328
        delta = self.rev_tree.changes_from(self.parent_tree)
233
329
 
234
 
        self.model.append(None, ["Complete Diff", ""])
 
330
        self.model.append(None, [ "Complete Diff", "" ])
235
331
 
236
332
        if len(delta.added):
237
 
            titer = self.model.append(None, ["Added", None])
 
333
            titer = self.model.append(None, [ "Added", None ])
238
334
            for path, id, kind in delta.added:
239
 
                self.model.append(titer, [path, path])
 
335
                self.model.append(titer, [ path, path ])
240
336
 
241
337
        if len(delta.removed):
242
 
            titer = self.model.append(None, ["Removed", None])
 
338
            titer = self.model.append(None, [ "Removed", None ])
243
339
            for path, id, kind in delta.removed:
244
 
                self.model.append(titer, [path, path])
 
340
                self.model.append(titer, [ path, path ])
245
341
 
246
342
        if len(delta.renamed):
247
 
            titer = self.model.append(None, ["Renamed", None])
 
343
            titer = self.model.append(None, [ "Renamed", None ])
248
344
            for oldpath, newpath, id, kind, text_modified, meta_modified \
249
345
                    in delta.renamed:
250
 
                self.model.append(titer, [oldpath, newpath])
 
346
                self.model.append(titer, [ oldpath, newpath ])
251
347
 
252
348
        if len(delta.modified):
253
 
            titer = self.model.append(None, ["Modified", None])
 
349
            titer = self.model.append(None, [ "Modified", None ])
254
350
            for path, id, kind, text_modified, meta_modified in delta.modified:
255
 
                self.model.append(titer, [path, path])
 
351
                self.model.append(titer, [ path, path ])
256
352
 
257
353
        self.treeview.expand_all()
258
354
        self.diff_view.show_diff(None)
266
362
                    tv_path = child.path
267
363
                    break
268
364
        if tv_path is None:
269
 
            raise errors.NoSuchFile(file_path)
270
 
        self.treeview.set_cursor(tv_path, None, False)
 
365
            raise NoSuchFile(file_path)
 
366
        self.treeview.set_cursor(tv_path)
271
367
        self.treeview.scroll_to_cell(tv_path)
272
368
 
273
369
    def _treeview_cursor_cb(self, *args):
274
370
        """Callback for when the treeview cursor changes."""
275
371
        (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 == [""]:
 
372
        specific_files = [ self.model[path][1] ]
 
373
        if specific_files == [ None ]:
 
374
            return
 
375
        elif specific_files == [ "" ]:
282
376
            specific_files = None
283
 
 
 
377
        
284
378
        self.diff_view.show_diff(specific_files)
285
 
 
 
379
    
286
380
    def _on_wraplines_toggled(self, widget=None, wrap=False):
287
381
        """Callback for when the wrap lines checkbutton is toggled"""
288
382
        if wrap or widget.get_active():
289
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
 
383
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
290
384
        else:
291
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
292
 
 
 
385
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
293
386
 
294
387
class DiffWindow(Window):
295
388
    """Diff window.
298
391
    differences between two revisions on a branch.
299
392
    """
300
393
 
301
 
    SHOW_WIDGETS = True
302
 
 
303
394
    def __init__(self, parent=None, operations=None):
304
 
        super(DiffWindow, self).__init__(parent=parent)
 
395
        Window.__init__(self, parent)
305
396
        self.set_border_width(0)
306
 
        self.set_title("bzr diff")
 
397
        self.set_title("bzrk diff")
307
398
 
308
399
        # Use two thirds of the screen by default
309
400
        screen = self.get_screen()
315
406
 
316
407
    def construct(self, operations):
317
408
        """Construct the window contents."""
318
 
        self.vbox = Gtk.VBox()
 
409
        self.vbox = gtk.VBox()
319
410
        self.add(self.vbox)
320
 
        if self.SHOW_WIDGETS:
321
 
            self.vbox.show()
 
411
        self.vbox.show()
322
412
        self.diff = DiffWidget()
323
413
        self.vbox.pack_end(self.diff, True, True, 0)
324
 
        if self.SHOW_WIDGETS:
325
 
            self.diff.show_all()
 
414
        self.diff.show_all()
326
415
        # Build after DiffWidget to connect signals
327
416
        menubar = self._get_menu_bar()
328
417
        self.vbox.pack_start(menubar, False, False, 0)
329
418
        hbox = self._get_button_bar(operations)
330
419
        if hbox is not None:
331
420
            self.vbox.pack_start(hbox, False, True, 0)
332
 
 
 
421
        
 
422
    
333
423
    def _get_menu_bar(self):
334
 
        menubar = Gtk.MenuBar()
 
424
        menubar = gtk.MenuBar()
335
425
        # 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"))
 
426
        mb_view = gtk.MenuItem(_i18n("_View"))
 
427
        mb_view_menu = gtk.Menu()
 
428
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
340
429
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
430
        mb_view_wrapsource.show()
341
431
        mb_view_menu.append(mb_view_wrapsource)
 
432
        mb_view.show()
342
433
        mb_view.set_submenu(mb_view_menu)
 
434
        mb_view.show()
343
435
        menubar.append(mb_view)
344
 
        if self.SHOW_WIDGETS:
345
 
            menubar.show_all()
 
436
        menubar.show()
346
437
        return menubar
347
 
 
 
438
    
348
439
    def _get_button_bar(self, operations):
349
440
        """Return a button bar to use.
350
441
 
352
443
        """
353
444
        if operations is None:
354
445
            return None
355
 
        hbox = Gtk.HButtonBox()
356
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
446
        hbox = gtk.HButtonBox()
 
447
        hbox.set_layout(gtk.BUTTONBOX_START)
357
448
        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)
 
449
            merge_button = gtk.Button(title)
 
450
            merge_button.show()
 
451
            merge_button.set_relief(gtk.RELIEF_NONE)
362
452
            merge_button.connect("clicked", method)
363
 
            hbox.pack_start(merge_button, False, True, 0)
364
 
        if self.SHOW_WIDGETS:
365
 
            hbox.show()
 
453
            hbox.pack_start(merge_button, expand=False, fill=True)
 
454
        hbox.show()
366
455
        return hbox
367
456
 
368
457
    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,))
 
458
        d = gtk.FileChooserDialog('Merge branch', self,
 
459
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
460
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
461
                                           gtk.STOCK_CANCEL,
 
462
                                           gtk.RESPONSE_CANCEL,))
374
463
        try:
375
464
            result = d.run()
376
 
            if result != Gtk.ResponseType.OK:
 
465
            if result != gtk.RESPONSE_OK:
377
466
                raise SelectCancelled()
378
467
            return d.get_current_folder_uri()
379
468
        finally:
393
482
        error_dialog('Error', str(e))
394
483
 
395
484
    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,))
 
485
        d = gtk.FileChooserDialog('Save As', self,
 
486
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
487
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
488
                                           gtk.STOCK_CANCEL,
 
489
                                           gtk.RESPONSE_CANCEL,))
401
490
        d.set_current_name(basename)
402
491
        try:
403
492
            result = d.run()
404
 
            if result != Gtk.ResponseType.OK:
 
493
            if result != gtk.RESPONSE_OK:
405
494
                raise SelectCancelled()
406
495
            return urlutils.local_path_from_url(d.get_uri())
407
496
        finally:
422
511
 
423
512
class DiffController(object):
424
513
 
425
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
514
    def __init__(self, path, patch, window=None):
426
515
        self.path = path
427
516
        self.patch = patch
428
 
        self.allow_dirty = allow_dirty
429
517
        if window is None:
430
518
            window = DiffWindow(operations=self._provide_operations())
431
519
            self.initialize_window(window)
437
525
 
438
526
    def get_diff_sections(self):
439
527
        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:
 
528
        for patch in parse_patches(self.patch):
446
529
            oldname = patch.oldname.split('\t')[0]
447
530
            newname = patch.newname.split('\t')[0]
448
531
            yield oldname, newname, str(patch)
469
552
class MergeDirectiveController(DiffController):
470
553
 
471
554
    def __init__(self, path, directive, window=None):
472
 
        super(MergeDirectiveController, self).__init__(
473
 
            path, directive.patch.splitlines(True), window)
 
555
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
556
                                window)
474
557
        self.directive = directive
475
558
        self.merge_target = None
476
559
 
487
570
        tree.lock_write()
488
571
        try:
489
572
            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)
 
573
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
574
                    self.directive, progress.DummyProgress())
 
575
                merger.check_basis(True)
494
576
                merger.merge_type = _mod_merge.Merge3Merger
495
577
                conflict_count = merger.do_merge()
496
578
                merger.set_pending()