/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 viz/diffwin.py

  • Committer: Jelmer Vernooij
  • Date: 2006-09-30 10:21:43 UTC
  • Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/diffwin.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
 
try:
21
 
    from xml.etree.ElementTree import Element, SubElement, tostring
22
 
except ImportError:
23
 
    from elementtree.ElementTree import Element, SubElement, tostring
24
18
 
25
19
try:
26
 
    import gtksourceview2
 
20
    import gtksourceview
27
21
    have_gtksourceview = True
28
22
except ImportError:
29
23
    have_gtksourceview = False
30
 
try:
31
 
    import gconf
32
 
    have_gconf = True
33
 
except ImportError:
34
 
    have_gconf = False
35
 
 
36
 
from bzrlib import (
37
 
    errors,
38
 
    merge as _mod_merge,
39
 
    osutils,
40
 
    urlutils,
41
 
    workingtree,
42
 
)
43
 
from bzrlib.diff import show_diff_trees, internal_diff
44
 
from bzrlib.patches import parse_patches
45
 
from bzrlib.trace import warning
46
 
from bzrlib.plugins.gtk import _i18n
47
 
from bzrlib.plugins.gtk.window import Window
48
 
from dialog import error_dialog, info_dialog, warning_dialog
49
 
 
50
 
 
51
 
def fallback_guess_language(slm, content_type):
52
 
    for lang_id in slm.get_language_ids():
53
 
        lang = slm.get_language(lang_id)
54
 
        if "text/x-patch" in lang.get_mime_types():
55
 
            return lang
56
 
    return None
57
 
 
58
 
 
59
 
class SelectCancelled(Exception):
60
 
 
61
 
    pass
62
 
 
63
 
 
64
 
class DiffFileView(gtk.ScrolledWindow):
65
 
    """Window for displaying diffs from a diff file"""
 
24
 
 
25
import bzrlib
 
26
 
 
27
from bzrlib.diff import show_diff_trees
 
28
from bzrlib.errors import NoSuchFile
 
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
    """
66
37
 
67
38
    def __init__(self):
68
 
        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
 
69
50
        self.construct()
70
 
        self._diffs = {}
71
51
 
72
52
    def construct(self):
73
 
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
74
 
        self.set_shadow_type(gtk.SHADOW_IN)
75
 
 
76
 
        if have_gtksourceview:
77
 
            self.buffer = gtksourceview2.Buffer()
78
 
            slm = gtksourceview2.LanguageManager()
79
 
            guess_language = getattr(gtksourceview2.LanguageManager, 
80
 
                "guess_language", fallback_guess_language)
81
 
            gsl = guess_language(slm, content_type="text/x-patch")
82
 
            if have_gconf:
83
 
                self.apply_gedit_colors(self.buffer)
84
 
            self.apply_colordiff_colors(self.buffer)
85
 
            self.buffer.set_language(gsl)
86
 
            self.buffer.set_highlight_syntax(True)
87
 
 
88
 
            self.sourceview = gtksourceview2.View(self.buffer)
89
 
        else:
90
 
            self.buffer = gtk.TextBuffer()
91
 
            self.sourceview = gtk.TextView(self.buffer)
92
 
 
93
 
        self.sourceview.set_editable(False)
94
 
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
95
 
        self.add(self.sourceview)
96
 
        self.sourceview.show()
97
 
 
98
 
    @staticmethod
99
 
    def apply_gedit_colors(buf):
100
 
        """Set style to that specified in gedit configuration.
101
 
 
102
 
        This method needs the gconf module.
103
 
 
104
 
        :param buf: a gtksourceview2.Buffer object.
105
 
        """
106
 
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
107
 
 
108
 
        client = gconf.client_get_default()
109
 
        style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
110
 
        if style_scheme_name is not None:
111
 
            style_scheme = gtksourceview2.StyleSchemeManager().get_scheme(style_scheme_name)
112
 
            
113
 
            buf.set_style_scheme(style_scheme)
114
 
 
115
 
    @classmethod
116
 
    def apply_colordiff_colors(klass, buf):
117
 
        """Set style colors for lang using the colordiff configuration file.
118
 
 
119
 
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
120
 
 
121
 
        :param buf: a "Diff" gtksourceview2.Buffer object.
122
 
        """
123
 
        scheme_manager = gtksourceview2.StyleSchemeManager()
124
 
        style_scheme = scheme_manager.get_scheme('colordiff')
125
 
        
126
 
        # if style scheme not found, we'll generate it from colordiffrc
127
 
        # TODO: reload if colordiffrc has changed.
128
 
        if style_scheme is None:
129
 
            colors = {}
130
 
 
131
 
            for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
132
 
                f = os.path.expanduser(f)
133
 
                if os.path.exists(f):
134
 
                    try:
135
 
                        f = file(f)
136
 
                    except IOError, e:
137
 
                        warning('could not open file %s: %s' % (f, str(e)))
138
 
                    else:
139
 
                        colors.update(klass.parse_colordiffrc(f))
140
 
                        f.close()
141
 
 
142
 
            if not colors:
143
 
                # ~/.colordiffrc does not exist
144
 
                return
145
 
            
146
 
            mapping = {
147
 
                # map GtkSourceView2 scheme styles to colordiff names
148
 
                # since GSV is richer, accept new names for extra bits,
149
 
                # defaulting to old names if they're not present
150
 
                'diff:added-line': ['newtext'],
151
 
                'diff:removed-line': ['oldtext'],
152
 
                'diff:location': ['location', 'diffstuff'],
153
 
                'diff:file': ['file', 'diffstuff'],
154
 
                'diff:special-case': ['specialcase', 'diffstuff'],
155
 
            }
156
 
            
157
 
            converted_colors = {}
158
 
            for name, values in mapping.items():
159
 
                color = None
160
 
                for value in values:
161
 
                    color = colors.get(value, None)
162
 
                    if color is not None:
163
 
                        break
164
 
                if color is None:
165
 
                    continue
166
 
                converted_colors[name] = color
167
 
            
168
 
            # some xml magic to produce needed style scheme description
169
 
            e_style_scheme = Element('style-scheme')
170
 
            e_style_scheme.set('id', 'colordiff')
171
 
            e_style_scheme.set('_name', 'ColorDiff')
172
 
            e_style_scheme.set('version', '1.0')
173
 
            for name, color in converted_colors.items():
174
 
                style = SubElement(e_style_scheme, 'style')
175
 
                style.set('name', name)
176
 
                style.set('foreground', '#%s' % color)
177
 
            
178
 
            scheme_xml = tostring(e_style_scheme, 'UTF-8')
179
 
            if not os.path.exists(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles')):
180
 
                os.makedirs(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles'))
181
 
            file(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles/colordiff.xml'), 'w').write(scheme_xml)
182
 
            
183
 
            scheme_manager.force_rescan()
184
 
            style_scheme = scheme_manager.get_scheme('colordiff')
185
 
        
186
 
        buf.set_style_scheme(style_scheme)
187
 
 
188
 
    @staticmethod
189
 
    def parse_colordiffrc(fileobj):
190
 
        """Parse fileobj as a colordiff configuration file.
191
 
 
192
 
        :return: A dict with the key -> value pairs.
193
 
        """
194
 
        colors = {}
195
 
        for line in fileobj:
196
 
            if re.match(r'^\s*#', line):
197
 
                continue
198
 
            if '=' not in line:
199
 
                continue
200
 
            key, val = line.split('=', 1)
201
 
            colors[key.strip()] = val.strip()
202
 
        return colors
203
 
 
204
 
    def set_trees(self, rev_tree, parent_tree):
205
 
        self.rev_tree = rev_tree
206
 
        self.parent_tree = parent_tree
207
 
#        self._build_delta()
208
 
 
209
 
#    def _build_delta(self):
210
 
#        self.parent_tree.lock_read()
211
 
#        self.rev_tree.lock_read()
212
 
#        try:
213
 
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
214
 
#            self.path_to_status = {}
215
 
#            self.path_to_diff = {}
216
 
#            source_inv = self.parent_tree.inventory
217
 
#            target_inv = self.rev_tree.inventory
218
 
#            for (file_id, real_path, change_type, display_path) in self.delta:
219
 
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
220
 
#                if change_type in ('modified', 'renamed and modified'):
221
 
#                    source_ie = source_inv[file_id]
222
 
#                    target_ie = target_inv[file_id]
223
 
#                    sio = StringIO()
224
 
#                    source_ie.diff(internal_diff, *old path, *old_tree,
225
 
#                                   *new_path, target_ie, self.rev_tree,
226
 
#                                   sio)
227
 
#                    self.path_to_diff[real_path] = 
228
 
#
229
 
#        finally:
230
 
#            self.rev_tree.unlock()
231
 
#            self.parent_tree.unlock()
232
 
 
233
 
    def show_diff(self, specific_files):
234
 
        sections = []
235
 
        if specific_files is None:
236
 
            self.buffer.set_text(self._diffs[None])
237
 
        else:
238
 
            for specific_file in specific_files:
239
 
                sections.append(self._diffs[specific_file])
240
 
            self.buffer.set_text(''.join(sections))
241
 
 
242
 
 
243
 
class DiffView(DiffFileView):
244
 
    """This is the soft and chewy filling for a DiffWindow."""
245
 
 
246
 
    def __init__(self):
247
 
        DiffFileView.__init__(self)
248
 
        self.rev_tree = None
249
 
        self.parent_tree = None
250
 
 
251
 
    def show_diff(self, specific_files):
252
 
        """Show the diff for the specified files"""
253
 
        s = StringIO()
254
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
255
 
                        old_label='', new_label='',
256
 
                        # path_encoding=sys.getdefaultencoding()
257
 
                        # The default is utf-8, but we interpret the file
258
 
                        # contents as getdefaultencoding(), so we should
259
 
                        # probably try to make the paths in the same encoding.
260
 
                        )
261
 
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
262
 
        # character is not valid in 'encoding' there is nothing to replace, the
263
 
        # 'replace' is for 'str.encode()'
264
 
        try:
265
 
            decoded = s.getvalue().decode(sys.getdefaultencoding())
266
 
        except UnicodeDecodeError:
267
 
            try:
268
 
                decoded = s.getvalue().decode('UTF-8')
269
 
            except UnicodeDecodeError:
270
 
                decoded = s.getvalue().decode('iso-8859-1')
271
 
                # This always works, because every byte has a valid
272
 
                # mapping from iso-8859-1 to Unicode
273
 
        # TextBuffer must contain pure UTF-8 data
274
 
        self.buffer.set_text(decoded.encode('UTF-8'))
275
 
 
276
 
 
277
 
class DiffWidget(gtk.HPaned):
278
 
    """Diff widget
279
 
 
280
 
    """
281
 
    def __init__(self):
282
 
        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()
283
60
 
284
61
        # The file hierarchy: a scrollable treeview
285
62
        scrollwin = gtk.ScrolledWindow()
286
63
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
287
64
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
288
 
        self.pack1(scrollwin)
 
65
        pane.pack1(scrollwin)
289
66
        scrollwin.show()
290
 
        
 
67
 
291
68
        self.model = gtk.TreeStore(str, str)
292
69
        self.treeview = gtk.TreeView(self.model)
293
70
        self.treeview.set_headers_visible(False)
303
80
        column.add_attribute(cell, "text", 0)
304
81
        self.treeview.append_column(column)
305
82
 
306
 
    def set_diff_text(self, lines):
307
 
        """Set the current diff from a list of lines
308
 
 
309
 
        :param lines: The diff to show, in unified diff format
310
 
        """
311
83
        # The diffs of the  selected file: a scrollable source or
312
84
        # text view
313
 
 
314
 
    def set_diff_text_sections(self, sections):
315
 
        if getattr(self, 'diff_view', None) is None:
316
 
            self.diff_view = DiffFileView()
317
 
            self.pack2(self.diff_view)
318
 
        self.diff_view.show()
319
 
        for oldname, newname, patch in sections:
320
 
            self.diff_view._diffs[newname] = str(patch)
321
 
            if newname is None:
322
 
                newname = ''
323
 
            self.model.append(None, [oldname, newname])
324
 
        self.diff_view.show_diff(None)
325
 
 
326
 
    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):
327
109
        """Set the differences showed by this window.
328
110
 
329
111
        Compares the two trees and populates the window with the
330
112
        differences.
331
113
        """
332
 
        if getattr(self, 'diff_view', None) is None:
333
 
            self.diff_view = DiffView()
334
 
            self.pack2(self.diff_view)
335
 
        self.diff_view.show()
336
 
        self.diff_view.set_trees(rev_tree, parent_tree)
337
114
        self.rev_tree = rev_tree
338
115
        self.parent_tree = parent_tree
339
116
 
364
141
                self.model.append(titer, [ path, path ])
365
142
 
366
143
        self.treeview.expand_all()
367
 
        self.diff_view.show_diff(None)
 
144
        self.set_title(description + " - bzrk diff")
368
145
 
369
146
    def set_file(self, file_path):
370
 
        """Select the current file to display"""
371
147
        tv_path = None
372
148
        for data in self.model:
373
149
            for child in data.iterchildren():
375
151
                    tv_path = child.path
376
152
                    break
377
153
        if tv_path is None:
378
 
            raise errors.NoSuchFile(file_path)
 
154
            raise NoSuchFile(file_path)
379
155
        self.treeview.set_cursor(tv_path)
380
156
        self.treeview.scroll_to_cell(tv_path)
381
157
 
386
162
        if specific_files == [ None ]:
387
163
            return
388
164
        elif specific_files == [ "" ]:
389
 
            specific_files = None
390
 
        
391
 
        self.diff_view.show_diff(specific_files)
392
 
    
393
 
    def _on_wraplines_toggled(self, widget=None, wrap=False):
394
 
        """Callback for when the wrap lines checkbutton is toggled"""
395
 
        if wrap or widget.get_active():
396
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
397
 
        else:
398
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
399
 
 
400
 
class DiffWindow(Window):
401
 
    """Diff window.
402
 
 
403
 
    This object represents and manages a single window containing the
404
 
    differences between two revisions on a branch.
405
 
    """
406
 
 
407
 
    def __init__(self, parent=None, operations=None):
408
 
        Window.__init__(self, parent)
409
 
        self.set_border_width(0)
410
 
        self.set_title("bzrk diff")
411
 
 
412
 
        # Use two thirds of the screen by default
413
 
        screen = self.get_screen()
414
 
        monitor = screen.get_monitor_geometry(0)
415
 
        width = int(monitor.width * 0.66)
416
 
        height = int(monitor.height * 0.66)
417
 
        self.set_default_size(width, height)
418
 
        self.construct(operations)
419
 
 
420
 
    def construct(self, operations):
421
 
        """Construct the window contents."""
422
 
        self.vbox = gtk.VBox()
423
 
        self.add(self.vbox)
424
 
        self.vbox.show()
425
 
        self.diff = DiffWidget()
426
 
        self.vbox.pack_end(self.diff, True, True, 0)
427
 
        self.diff.show_all()
428
 
        # Build after DiffWidget to connect signals
429
 
        menubar = self._get_menu_bar()
430
 
        self.vbox.pack_start(menubar, False, False, 0)
431
 
        hbox = self._get_button_bar(operations)
432
 
        if hbox is not None:
433
 
            self.vbox.pack_start(hbox, False, True, 0)
434
 
        
435
 
    
436
 
    def _get_menu_bar(self):
437
 
        menubar = gtk.MenuBar()
438
 
        # View menu
439
 
        mb_view = gtk.MenuItem(_i18n("_View"))
440
 
        mb_view_menu = gtk.Menu()
441
 
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
442
 
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
443
 
        mb_view_wrapsource.show()
444
 
        mb_view_menu.append(mb_view_wrapsource)
445
 
        mb_view.show()
446
 
        mb_view.set_submenu(mb_view_menu)
447
 
        mb_view.show()
448
 
        menubar.append(mb_view)
449
 
        menubar.show()
450
 
        return menubar
451
 
    
452
 
    def _get_button_bar(self, operations):
453
 
        """Return a button bar to use.
454
 
 
455
 
        :return: None, meaning that no button bar will be used.
456
 
        """
457
 
        if operations is None:
458
 
            return None
459
 
        hbox = gtk.HButtonBox()
460
 
        hbox.set_layout(gtk.BUTTONBOX_START)
461
 
        for title, method in operations:
462
 
            merge_button = gtk.Button(title)
463
 
            merge_button.show()
464
 
            merge_button.set_relief(gtk.RELIEF_NONE)
465
 
            merge_button.connect("clicked", method)
466
 
            hbox.pack_start(merge_button, expand=False, fill=True)
467
 
        hbox.show()
468
 
        return hbox
469
 
 
470
 
    def _get_merge_target(self):
471
 
        d = gtk.FileChooserDialog('Merge branch', self,
472
 
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
473
 
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
474
 
                                           gtk.STOCK_CANCEL,
475
 
                                           gtk.RESPONSE_CANCEL,))
476
 
        try:
477
 
            result = d.run()
478
 
            if result != gtk.RESPONSE_OK:
479
 
                raise SelectCancelled()
480
 
            return d.get_current_folder_uri()
481
 
        finally:
482
 
            d.destroy()
483
 
 
484
 
    def _merge_successful(self):
485
 
        # No conflicts found.
486
 
        info_dialog(_i18n('Merge successful'),
487
 
                    _i18n('All changes applied successfully.'))
488
 
 
489
 
    def _conflicts(self):
490
 
        warning_dialog(_i18n('Conflicts encountered'),
491
 
                       _i18n('Please resolve the conflicts manually'
492
 
                             ' before committing.'))
493
 
 
494
 
    def _handle_error(self, e):
495
 
        error_dialog('Error', str(e))
496
 
 
497
 
    def _get_save_path(self, basename):
498
 
        d = gtk.FileChooserDialog('Save As', self,
499
 
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
500
 
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
501
 
                                           gtk.STOCK_CANCEL,
502
 
                                           gtk.RESPONSE_CANCEL,))
503
 
        d.set_current_name(basename)
504
 
        try:
505
 
            result = d.run()
506
 
            if result != gtk.RESPONSE_OK:
507
 
                raise SelectCancelled()
508
 
            return urlutils.local_path_from_url(d.get_uri())
509
 
        finally:
510
 
            d.destroy()
511
 
 
512
 
    def set_diff(self, description, rev_tree, parent_tree):
513
 
        """Set the differences showed by this window.
514
 
 
515
 
        Compares the two trees and populates the window with the
516
 
        differences.
517
 
        """
518
 
        self.diff.set_diff(rev_tree, parent_tree)
519
 
        self.set_title(description + " - bzrk diff")
520
 
 
521
 
    def set_file(self, file_path):
522
 
        self.diff.set_file(file_path)
523
 
 
524
 
 
525
 
class DiffController(object):
526
 
 
527
 
    def __init__(self, path, patch, window=None):
528
 
        self.path = path
529
 
        self.patch = patch
530
 
        if window is None:
531
 
            window = DiffWindow(operations=self._provide_operations())
532
 
            self.initialize_window(window)
533
 
        self.window = window
534
 
 
535
 
    def initialize_window(self, window):
536
 
        window.diff.set_diff_text_sections(self.get_diff_sections())
537
 
        window.set_title(self.path + " - diff")
538
 
 
539
 
    def get_diff_sections(self):
540
 
        yield "Complete Diff", None, ''.join(self.patch)
541
 
        for patch in parse_patches(self.patch):
542
 
            oldname = patch.oldname.split('\t')[0]
543
 
            newname = patch.newname.split('\t')[0]
544
 
            yield oldname, newname, str(patch)
545
 
 
546
 
    def perform_save(self, window):
547
 
        try:
548
 
            save_path = self.window._get_save_path(osutils.basename(self.path))
549
 
        except SelectCancelled:
550
 
            return
551
 
        source = open(self.path, 'rb')
552
 
        try:
553
 
            target = open(save_path, 'wb')
554
 
            try:
555
 
                osutils.pumpfile(source, target)
556
 
            finally:
557
 
                target.close()
558
 
        finally:
559
 
            source.close()
560
 
 
561
 
    def _provide_operations(self):
562
 
        return [('Save', self.perform_save)]
563
 
 
564
 
 
565
 
class MergeDirectiveController(DiffController):
566
 
 
567
 
    def __init__(self, path, directive, window=None):
568
 
        DiffController.__init__(self, path, directive.patch.splitlines(True),
569
 
                                window)
570
 
        self.directive = directive
571
 
        self.merge_target = None
572
 
 
573
 
    def _provide_operations(self):
574
 
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
575
 
 
576
 
    def perform_merge(self, window):
577
 
        if self.merge_target is None:
578
 
            try:
579
 
                self.merge_target = self.window._get_merge_target()
580
 
            except SelectCancelled:
581
 
                return
582
 
        tree = workingtree.WorkingTree.open(self.merge_target)
583
 
        tree.lock_write()
584
 
        try:
585
 
            try:
586
 
                if tree.has_changes():
587
 
                    raise errors.UncommittedChanges(tree)
588
 
                merger, verified = _mod_merge.Merger.from_mergeable(
589
 
                    tree, self.directive, pb=None)
590
 
                merger.merge_type = _mod_merge.Merge3Merger
591
 
                conflict_count = merger.do_merge()
592
 
                merger.set_pending()
593
 
                if conflict_count == 0:
594
 
                    self.window._merge_successful()
595
 
                else:
596
 
                    self.window._conflicts()
597
 
                    # There are conflicts to be resolved.
598
 
                self.window.destroy()
599
 
            except Exception, e:
600
 
                self.window._handle_error(e)
601
 
        finally:
602
 
            tree.unlock()
603
 
 
604
 
 
605
 
def iter_changes_to_status(source, target):
606
 
    """Determine the differences between trees.
607
 
 
608
 
    This is a wrapper around iter_changes which just yields more
609
 
    understandable results.
610
 
 
611
 
    :param source: The source tree (basis tree)
612
 
    :param target: The target tree
613
 
    :return: A list of (file_id, real_path, change_type, display_path)
614
 
    """
615
 
    added = 'added'
616
 
    removed = 'removed'
617
 
    renamed = 'renamed'
618
 
    renamed_and_modified = 'renamed and modified'
619
 
    modified = 'modified'
620
 
    kind_changed = 'kind changed'
621
 
    missing = 'missing'
622
 
 
623
 
    # TODO: Handle metadata changes
624
 
 
625
 
    status = []
626
 
    target.lock_read()
627
 
    try:
628
 
        source.lock_read()
629
 
        try:
630
 
            for (file_id, paths, changed_content, versioned, parent_ids, names,
631
 
                 kinds, executables) in target.iter_changes(source):
632
 
 
633
 
                # Skip the root entry if it isn't very interesting
634
 
                if parent_ids == (None, None):
635
 
                    continue
636
 
 
637
 
                change_type = None
638
 
                if kinds[0] is None:
639
 
                    source_marker = ''
640
 
                else:
641
 
                    source_marker = osutils.kind_marker(kinds[0])
642
 
 
643
 
                if kinds[1] is None:
644
 
                    if kinds[0] is None:
645
 
                        # We assume bzr will flag only files in that case,
646
 
                        # there may be a bzr bug there as only files seems to
647
 
                        # not receive any kind.
648
 
                        marker = osutils.kind_marker('file')
649
 
                    else:
650
 
                        marker = osutils.kind_marker(kinds[0])
651
 
                else:
652
 
                    marker = osutils.kind_marker(kinds[1])
653
 
 
654
 
                real_path = paths[1]
655
 
                if real_path is None:
656
 
                    real_path = paths[0]
657
 
                assert real_path is not None
658
 
 
659
 
                present_source = versioned[0] and kinds[0] is not None
660
 
                present_target = versioned[1] and kinds[1] is not None
661
 
 
662
 
                if kinds[0] is None and kinds[1] is None:
663
 
                    change_type = missing
664
 
                    display_path = real_path + marker
665
 
                elif present_source != present_target:
666
 
                    if present_target:
667
 
                        change_type = added
668
 
                    else:
669
 
                        assert present_source
670
 
                        change_type = removed
671
 
                    display_path = real_path + marker
672
 
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
673
 
                    # Renamed
674
 
                    if changed_content or executables[0] != executables[1]:
675
 
                        # and modified
676
 
                        change_type = renamed_and_modified
677
 
                    else:
678
 
                        change_type = renamed
679
 
                    display_path = (paths[0] + source_marker
680
 
                                    + ' => ' + paths[1] + marker)
681
 
                elif kinds[0] != kinds[1]:
682
 
                    change_type = kind_changed
683
 
                    display_path = (paths[0] + source_marker
684
 
                                    + ' => ' + paths[1] + marker)
685
 
                elif changed_content or executables[0] != executables[1]:
686
 
                    change_type = modified
687
 
                    display_path = real_path + marker
688
 
                else:
689
 
                    assert False, "How did we get here?"
690
 
 
691
 
                status.append((file_id, real_path, change_type, display_path))
692
 
        finally:
693
 
            source.unlock()
694
 
    finally:
695
 
        target.unlock()
696
 
 
697
 
    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'))