/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: 2007-07-15 15:13:34 UTC
  • Revision ID: jelmer@samba.org-20070715151334-2t0g8fmpgj6vnqa7
Add icon for Bazaar preferences.

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
 
1
#!/usr/bin/python
 
2
# -*- coding: UTF-8 -*-
1
3
"""Difference window.
2
4
 
3
5
This module contains the code to manage the diff window which shows
4
6
the changes made between two revisions on a branch.
5
7
"""
6
8
 
7
 
__copyright__ = "Copyright 2005 Canonical Ltd."
 
9
__copyright__ = "Copyright © 2005 Canonical Ltd."
8
10
__author__    = "Scott James Remnant <scott@ubuntu.com>"
9
11
 
10
12
 
11
13
from cStringIO import StringIO
12
14
 
13
 
import pygtk
14
 
pygtk.require("2.0")
15
15
import gtk
16
16
import pango
17
 
import os
18
 
import re
19
17
import sys
20
18
 
21
19
try:
23
21
    have_gtksourceview = True
24
22
except ImportError:
25
23
    have_gtksourceview = False
26
 
try:
27
 
    import gconf
28
 
    have_gconf = True
29
 
except ImportError:
30
 
    have_gconf = False
31
 
 
32
 
from bzrlib import (
33
 
    merge as _mod_merge,
34
 
    osutils,
35
 
    progress,
36
 
    urlutils,
37
 
    workingtree,
38
 
)
39
 
from bzrlib.diff import show_diff_trees, internal_diff
 
24
 
 
25
import bzrlib
 
26
 
 
27
from bzrlib.diff import show_diff_trees
40
28
from bzrlib.errors import NoSuchFile
41
 
from bzrlib.patches import parse_patches
42
 
from bzrlib.trace import warning
43
 
from bzrlib.plugins.gtk import _i18n
44
 
from bzrlib.plugins.gtk.window import Window
45
 
from dialog import error_dialog, info_dialog, warning_dialog
46
 
 
47
 
 
48
 
class SelectCancelled(Exception):
49
 
 
50
 
    pass
51
 
 
52
 
 
53
 
class DiffFileView(gtk.ScrolledWindow):
54
 
    """Window for displaying diffs from a diff file"""
 
29
 
 
30
 
 
31
class DiffWindow(gtk.Window):
 
32
    """Diff window.
 
33
 
 
34
    This object represents and manages a single window containing the
 
35
    differences between two revisions on a branch.
 
36
    """
55
37
 
56
38
    def __init__(self):
57
 
        gtk.ScrolledWindow.__init__(self)
 
39
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
 
40
        self.set_border_width(0)
 
41
        self.set_title("bzrk diff")
 
42
 
 
43
        # Use two thirds of the screen by default
 
44
        screen = self.get_screen()
 
45
        monitor = screen.get_monitor_geometry(0)
 
46
        width = int(monitor.width * 0.66)
 
47
        height = int(monitor.height * 0.66)
 
48
        self.set_default_size(width, height)
 
49
 
58
50
        self.construct()
59
 
        self._diffs = {}
60
51
 
61
52
    def construct(self):
62
 
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
63
 
        self.set_shadow_type(gtk.SHADOW_IN)
64
 
 
65
 
        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)
76
 
        else:
77
 
            self.buffer = gtk.TextBuffer()
78
 
            self.sourceview = gtk.TextView(self.buffer)
79
 
 
80
 
        self.sourceview.set_editable(False)
81
 
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
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
220
 
 
221
 
    def set_trees(self, rev_tree, parent_tree):
222
 
        self.rev_tree = rev_tree
223
 
        self.parent_tree = parent_tree
224
 
#        self._build_delta()
225
 
 
226
 
#    def _build_delta(self):
227
 
#        self.parent_tree.lock_read()
228
 
#        self.rev_tree.lock_read()
229
 
#        try:
230
 
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
231
 
#            self.path_to_status = {}
232
 
#            self.path_to_diff = {}
233
 
#            source_inv = self.parent_tree.inventory
234
 
#            target_inv = self.rev_tree.inventory
235
 
#            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)
237
 
#                if change_type in ('modified', 'renamed and modified'):
238
 
#                    source_ie = source_inv[file_id]
239
 
#                    target_ie = target_inv[file_id]
240
 
#                    sio = StringIO()
241
 
#                    source_ie.diff(internal_diff, *old path, *old_tree,
242
 
#                                   *new_path, target_ie, self.rev_tree,
243
 
#                                   sio)
244
 
#                    self.path_to_diff[real_path] = 
245
 
#
246
 
#        finally:
247
 
#            self.rev_tree.unlock()
248
 
#            self.parent_tree.unlock()
249
 
 
250
 
    def show_diff(self, specific_files):
251
 
        sections = []
252
 
        if specific_files is None:
253
 
            self.buffer.set_text(self._diffs[None])
254
 
        else:
255
 
            for specific_file in specific_files:
256
 
                sections.append(self._diffs[specific_file])
257
 
            self.buffer.set_text(''.join(sections))
258
 
 
259
 
 
260
 
class DiffView(DiffFileView):
261
 
    """This is the soft and chewy filling for a DiffWindow."""
262
 
 
263
 
    def __init__(self):
264
 
        DiffFileView.__init__(self)
265
 
        self.rev_tree = None
266
 
        self.parent_tree = None
267
 
 
268
 
    def show_diff(self, specific_files):
269
 
        """Show the diff for the specified files"""
270
 
        s = StringIO()
271
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
272
 
                        old_label='', new_label='',
273
 
                        # path_encoding=sys.getdefaultencoding()
274
 
                        # The default is utf-8, but we interpret the file
275
 
                        # contents as getdefaultencoding(), so we should
276
 
                        # probably try to make the paths in the same encoding.
277
 
                        )
278
 
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
279
 
        # character is not valid in 'encoding' there is nothing to replace, the
280
 
        # 'replace' is for 'str.encode()'
281
 
        try:
282
 
            decoded = s.getvalue().decode(sys.getdefaultencoding())
283
 
        except UnicodeDecodeError:
284
 
            try:
285
 
                decoded = s.getvalue().decode('UTF-8')
286
 
            except UnicodeDecodeError:
287
 
                decoded = s.getvalue().decode('iso-8859-1')
288
 
                # This always works, because every byte has a valid
289
 
                # mapping from iso-8859-1 to Unicode
290
 
        # TextBuffer must contain pure UTF-8 data
291
 
        self.buffer.set_text(decoded.encode('UTF-8'))
292
 
 
293
 
 
294
 
class DiffWidget(gtk.HPaned):
295
 
    """Diff widget
296
 
 
297
 
    """
298
 
    def __init__(self):
299
 
        super(DiffWidget, self).__init__()
 
53
        """Construct the window contents."""
 
54
        # The   window  consists  of   a  pane   containing:  the
 
55
        # hierarchical list  of files on  the left, and  the diff
 
56
        # for the currently selected file on the right.
 
57
        pane = gtk.HPaned()
 
58
        self.add(pane)
 
59
        pane.show()
300
60
 
301
61
        # The file hierarchy: a scrollable treeview
302
62
        scrollwin = gtk.ScrolledWindow()
303
63
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
304
64
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
305
 
        self.pack1(scrollwin)
 
65
        pane.pack1(scrollwin)
306
66
        scrollwin.show()
307
 
        
 
67
 
308
68
        self.model = gtk.TreeStore(str, str)
309
69
        self.treeview = gtk.TreeView(self.model)
310
70
        self.treeview.set_headers_visible(False)
320
80
        column.add_attribute(cell, "text", 0)
321
81
        self.treeview.append_column(column)
322
82
 
323
 
    def set_diff_text(self, lines):
324
 
        """Set the current diff from a list of lines
325
 
 
326
 
        :param lines: The diff to show, in unified diff format
327
 
        """
328
83
        # The diffs of the  selected file: a scrollable source or
329
84
        # text view
330
 
 
331
 
    def set_diff_text_sections(self, sections):
332
 
        if getattr(self, 'diff_view', None) is None:
333
 
            self.diff_view = DiffFileView()
334
 
            self.pack2(self.diff_view)
335
 
        self.diff_view.show()
336
 
        for oldname, newname, patch in sections:
337
 
            self.diff_view._diffs[newname] = str(patch)
338
 
            if newname is None:
339
 
                newname = ''
340
 
            self.model.append(None, [oldname, newname])
341
 
        self.diff_view.show_diff(None)
342
 
 
343
 
    def set_diff(self, rev_tree, parent_tree):
 
85
        scrollwin = gtk.ScrolledWindow()
 
86
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
87
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
 
88
        pane.pack2(scrollwin)
 
89
        scrollwin.show()
 
90
 
 
91
        if have_gtksourceview:
 
92
            self.buffer = gtksourceview.SourceBuffer()
 
93
            slm = gtksourceview.SourceLanguagesManager()
 
94
            gsl = slm.get_language_from_mime_type("text/x-patch")
 
95
            self.buffer.set_language(gsl)
 
96
            self.buffer.set_highlight(True)
 
97
 
 
98
            sourceview = gtksourceview.SourceView(self.buffer)
 
99
        else:
 
100
            self.buffer = gtk.TextBuffer()
 
101
            sourceview = gtk.TextView(self.buffer)
 
102
 
 
103
        sourceview.set_editable(False)
 
104
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
105
        scrollwin.add(sourceview)
 
106
        sourceview.show()
 
107
 
 
108
    def set_diff(self, description, rev_tree, parent_tree):
344
109
        """Set the differences showed by this window.
345
110
 
346
111
        Compares the two trees and populates the window with the
347
112
        differences.
348
113
        """
349
 
        if getattr(self, 'diff_view', None) is None:
350
 
            self.diff_view = DiffView()
351
 
            self.pack2(self.diff_view)
352
 
        self.diff_view.show()
353
 
        self.diff_view.set_trees(rev_tree, parent_tree)
354
114
        self.rev_tree = rev_tree
355
115
        self.parent_tree = parent_tree
356
116
 
381
141
                self.model.append(titer, [ path, path ])
382
142
 
383
143
        self.treeview.expand_all()
384
 
        self.diff_view.show_diff(None)
 
144
        self.set_title(description + " - bzrk diff")
385
145
 
386
146
    def set_file(self, file_path):
387
 
        """Select the current file to display"""
388
147
        tv_path = None
389
148
        for data in self.model:
390
149
            for child in data.iterchildren():
403
162
        if specific_files == [ None ]:
404
163
            return
405
164
        elif specific_files == [ "" ]:
406
 
            specific_files = None
407
 
        
408
 
        self.diff_view.show_diff(specific_files)
409
 
    
410
 
    def _on_wraplines_toggled(self, widget=None, wrap=False):
411
 
        """Callback for when the wrap lines checkbutton is toggled"""
412
 
        if wrap or widget.get_active():
413
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
414
 
        else:
415
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
416
 
 
417
 
class DiffWindow(Window):
418
 
    """Diff window.
419
 
 
420
 
    This object represents and manages a single window containing the
421
 
    differences between two revisions on a branch.
422
 
    """
423
 
 
424
 
    def __init__(self, parent=None, operations=None):
425
 
        Window.__init__(self, parent)
426
 
        self.set_border_width(0)
427
 
        self.set_title("bzrk diff")
428
 
 
429
 
        # Use two thirds of the screen by default
430
 
        screen = self.get_screen()
431
 
        monitor = screen.get_monitor_geometry(0)
432
 
        width = int(monitor.width * 0.66)
433
 
        height = int(monitor.height * 0.66)
434
 
        self.set_default_size(width, height)
435
 
        self.construct(operations)
436
 
 
437
 
    def construct(self, operations):
438
 
        """Construct the window contents."""
439
 
        self.vbox = gtk.VBox()
440
 
        self.add(self.vbox)
441
 
        self.vbox.show()
442
 
        self.diff = DiffWidget()
443
 
        self.vbox.pack_end(self.diff, True, True, 0)
444
 
        self.diff.show_all()
445
 
        # Build after DiffWidget to connect signals
446
 
        menubar = self._get_menu_bar()
447
 
        self.vbox.pack_start(menubar, False, False, 0)
448
 
        hbox = self._get_button_bar(operations)
449
 
        if hbox is not None:
450
 
            self.vbox.pack_start(hbox, False, True, 0)
451
 
        
452
 
    
453
 
    def _get_menu_bar(self):
454
 
        menubar = gtk.MenuBar()
455
 
        # 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"))
459
 
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
460
 
        mb_view_wrapsource.show()
461
 
        mb_view_menu.append(mb_view_wrapsource)
462
 
        mb_view.show()
463
 
        mb_view.set_submenu(mb_view_menu)
464
 
        mb_view.show()
465
 
        menubar.append(mb_view)
466
 
        menubar.show()
467
 
        return menubar
468
 
    
469
 
    def _get_button_bar(self, operations):
470
 
        """Return a button bar to use.
471
 
 
472
 
        :return: None, meaning that no button bar will be used.
473
 
        """
474
 
        if operations is None:
475
 
            return None
476
 
        hbox = gtk.HButtonBox()
477
 
        hbox.set_layout(gtk.BUTTONBOX_START)
478
 
        for title, method in operations:
479
 
            merge_button = gtk.Button(title)
480
 
            merge_button.show()
481
 
            merge_button.set_relief(gtk.RELIEF_NONE)
482
 
            merge_button.connect("clicked", method)
483
 
            hbox.pack_start(merge_button, expand=False, fill=True)
484
 
        hbox.show()
485
 
        return hbox
486
 
 
487
 
    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,))
493
 
        try:
494
 
            result = d.run()
495
 
            if result != gtk.RESPONSE_OK:
496
 
                raise SelectCancelled()
497
 
            return d.get_current_folder_uri()
498
 
        finally:
499
 
            d.destroy()
500
 
 
501
 
    def _merge_successful(self):
502
 
        # No conflicts found.
503
 
        info_dialog(_i18n('Merge successful'),
504
 
                    _i18n('All changes applied successfully.'))
505
 
 
506
 
    def _conflicts(self):
507
 
        warning_dialog(_i18n('Conflicts encountered'),
508
 
                       _i18n('Please resolve the conflicts manually'
509
 
                             ' before committing.'))
510
 
 
511
 
    def _handle_error(self, e):
512
 
        error_dialog('Error', str(e))
513
 
 
514
 
    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,))
520
 
        d.set_current_name(basename)
521
 
        try:
522
 
            result = d.run()
523
 
            if result != gtk.RESPONSE_OK:
524
 
                raise SelectCancelled()
525
 
            return urlutils.local_path_from_url(d.get_uri())
526
 
        finally:
527
 
            d.destroy()
528
 
 
529
 
    def set_diff(self, description, rev_tree, parent_tree):
530
 
        """Set the differences showed by this window.
531
 
 
532
 
        Compares the two trees and populates the window with the
533
 
        differences.
534
 
        """
535
 
        self.diff.set_diff(rev_tree, parent_tree)
536
 
        self.set_title(description + " - bzrk diff")
537
 
 
538
 
    def set_file(self, file_path):
539
 
        self.diff.set_file(file_path)
540
 
 
541
 
 
542
 
class DiffController(object):
543
 
 
544
 
    def __init__(self, path, patch, window=None):
545
 
        self.path = path
546
 
        self.patch = patch
547
 
        if window is None:
548
 
            window = DiffWindow(operations=self._provide_operations())
549
 
            self.initialize_window(window)
550
 
        self.window = window
551
 
 
552
 
    def initialize_window(self, window):
553
 
        window.diff.set_diff_text_sections(self.get_diff_sections())
554
 
        window.set_title(self.path + " - diff")
555
 
 
556
 
    def get_diff_sections(self):
557
 
        yield "Complete Diff", None, ''.join(self.patch)
558
 
        for patch in parse_patches(self.patch):
559
 
            oldname = patch.oldname.split('\t')[0]
560
 
            newname = patch.newname.split('\t')[0]
561
 
            yield oldname, newname, str(patch)
562
 
 
563
 
    def perform_save(self, window):
564
 
        try:
565
 
            save_path = self.window._get_save_path(osutils.basename(self.path))
566
 
        except SelectCancelled:
567
 
            return
568
 
        source = open(self.path, 'rb')
569
 
        try:
570
 
            target = open(save_path, 'wb')
571
 
            try:
572
 
                osutils.pumpfile(source, target)
573
 
            finally:
574
 
                target.close()
575
 
        finally:
576
 
            source.close()
577
 
 
578
 
    def _provide_operations(self):
579
 
        return [('Save', self.perform_save)]
580
 
 
581
 
 
582
 
class MergeDirectiveController(DiffController):
583
 
 
584
 
    def __init__(self, path, directive, window=None):
585
 
        DiffController.__init__(self, path, directive.patch.splitlines(True),
586
 
                                window)
587
 
        self.directive = directive
588
 
        self.merge_target = None
589
 
 
590
 
    def _provide_operations(self):
591
 
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
592
 
 
593
 
    def perform_merge(self, window):
594
 
        if self.merge_target is None:
595
 
            try:
596
 
                self.merge_target = self.window._get_merge_target()
597
 
            except SelectCancelled:
598
 
                return
599
 
        tree = workingtree.WorkingTree.open(self.merge_target)
600
 
        tree.lock_write()
601
 
        try:
602
 
            try:
603
 
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
604
 
                    self.directive, progress.DummyProgress())
605
 
                merger.check_basis(True)
606
 
                merger.merge_type = _mod_merge.Merge3Merger
607
 
                conflict_count = merger.do_merge()
608
 
                merger.set_pending()
609
 
                if conflict_count == 0:
610
 
                    self.window._merge_successful()
611
 
                else:
612
 
                    self.window._conflicts()
613
 
                    # There are conflicts to be resolved.
614
 
                self.window.destroy()
615
 
            except Exception, e:
616
 
                self.window._handle_error(e)
617
 
        finally:
618
 
            tree.unlock()
619
 
 
620
 
 
621
 
def iter_changes_to_status(source, target):
622
 
    """Determine the differences between trees.
623
 
 
624
 
    This is a wrapper around iter_changes which just yields more
625
 
    understandable results.
626
 
 
627
 
    :param source: The source tree (basis tree)
628
 
    :param target: The target tree
629
 
    :return: A list of (file_id, real_path, change_type, display_path)
630
 
    """
631
 
    added = 'added'
632
 
    removed = 'removed'
633
 
    renamed = 'renamed'
634
 
    renamed_and_modified = 'renamed and modified'
635
 
    modified = 'modified'
636
 
    kind_changed = 'kind changed'
637
 
    missing = 'missing'
638
 
 
639
 
    # TODO: Handle metadata changes
640
 
 
641
 
    status = []
642
 
    target.lock_read()
643
 
    try:
644
 
        source.lock_read()
645
 
        try:
646
 
            for (file_id, paths, changed_content, versioned, parent_ids, names,
647
 
                 kinds, executables) in target.iter_changes(source):
648
 
 
649
 
                # Skip the root entry if it isn't very interesting
650
 
                if parent_ids == (None, None):
651
 
                    continue
652
 
 
653
 
                change_type = None
654
 
                if kinds[0] is None:
655
 
                    source_marker = ''
656
 
                else:
657
 
                    source_marker = osutils.kind_marker(kinds[0])
658
 
 
659
 
                if kinds[1] is None:
660
 
                    if kinds[0] is None:
661
 
                        # We assume bzr will flag only files in that case,
662
 
                        # there may be a bzr bug there as only files seems to
663
 
                        # not receive any kind.
664
 
                        marker = osutils.kind_marker('file')
665
 
                    else:
666
 
                        marker = osutils.kind_marker(kinds[0])
667
 
                else:
668
 
                    marker = osutils.kind_marker(kinds[1])
669
 
 
670
 
                real_path = paths[1]
671
 
                if real_path is None:
672
 
                    real_path = paths[0]
673
 
                assert real_path is not None
674
 
 
675
 
                present_source = versioned[0] and kinds[0] is not None
676
 
                present_target = versioned[1] and kinds[1] is not None
677
 
 
678
 
                if kinds[0] is None and kinds[1] is None:
679
 
                    change_type = missing
680
 
                    display_path = real_path + marker
681
 
                elif present_source != present_target:
682
 
                    if present_target:
683
 
                        change_type = added
684
 
                    else:
685
 
                        assert present_source
686
 
                        change_type = removed
687
 
                    display_path = real_path + marker
688
 
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
689
 
                    # Renamed
690
 
                    if changed_content or executables[0] != executables[1]:
691
 
                        # and modified
692
 
                        change_type = renamed_and_modified
693
 
                    else:
694
 
                        change_type = renamed
695
 
                    display_path = (paths[0] + source_marker
696
 
                                    + ' => ' + paths[1] + marker)
697
 
                elif kinds[0] != kinds[1]:
698
 
                    change_type = kind_changed
699
 
                    display_path = (paths[0] + source_marker
700
 
                                    + ' => ' + paths[1] + marker)
701
 
                elif changed_content or executables[0] != executables[1]:
702
 
                    change_type = modified
703
 
                    display_path = real_path + marker
704
 
                else:
705
 
                    assert False, "How did we get here?"
706
 
 
707
 
                status.append((file_id, real_path, change_type, display_path))
708
 
        finally:
709
 
            source.unlock()
710
 
    finally:
711
 
        target.unlock()
712
 
 
713
 
    return status
 
165
            specific_files = []
 
166
 
 
167
        s = StringIO()
 
168
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
 
169
        self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))