/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

Commit messages never contain config options

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
1
 
#!/usr/bin/python
2
 
# -*- coding: UTF-8 -*-
3
1
"""Difference window.
4
2
 
5
3
This module contains the code to manage the diff window which shows
6
4
the changes made between two revisions on a branch.
7
5
"""
8
6
 
9
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
10
 
__author__    = "Scott James Remnant <scott@ubuntu.com>"
 
7
__copyright__ = "Copyright 2005 Canonical Ltd."
 
8
__author__ = "Scott James Remnant <scott@ubuntu.com>"
11
9
 
12
10
 
13
11
from cStringIO import StringIO
14
12
 
15
 
import gtk
16
 
import pango
 
13
import sys
 
14
import inspect
17
15
 
 
16
from gi.repository import Gtk
 
17
from gi.repository import Pango
18
18
try:
19
 
    import gtksourceview
 
19
    from gi.repository import GtkSource
20
20
    have_gtksourceview = True
21
21
except ImportError:
22
22
    have_gtksourceview = False
23
23
 
24
 
from bzrlib.delta import compare_trees
 
24
from bzrlib import (
 
25
    errors,
 
26
    merge as _mod_merge,
 
27
    osutils,
 
28
    urlutils,
 
29
    workingtree,
 
30
    )
25
31
from bzrlib.diff import show_diff_trees
26
 
 
27
 
 
28
 
class DiffWindow(gtk.Window):
29
 
    """Diff window.
30
 
 
31
 
    This object represents and manages a single window containing the
32
 
    differences between two revisions on a branch.
33
 
    """
34
 
 
35
 
    def __init__(self, app=None):
36
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
37
 
        self.set_border_width(0)
38
 
        self.set_title("bzrk diff")
39
 
 
40
 
        self.app = app
41
 
 
42
 
        # Use two thirds of the screen by default
43
 
        screen = self.get_screen()
44
 
        monitor = screen.get_monitor_geometry(0)
45
 
        width = int(monitor.width * 0.66)
46
 
        height = int(monitor.height * 0.66)
47
 
        self.set_default_size(width, height)
48
 
 
 
32
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
 
39
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
 
48
 
 
49
 
 
50
class SelectCancelled(Exception):
 
51
 
 
52
    pass
 
53
 
 
54
 
 
55
class DiffFileView(Gtk.ScrolledWindow):
 
56
    """Window for displaying diffs from a diff file"""
 
57
 
 
58
    SHOW_WIDGETS = True
 
59
 
 
60
    def __init__(self):
 
61
        super(DiffFileView, self).__init__()
49
62
        self.construct()
 
63
        self._diffs = {}
50
64
 
51
65
    def construct(self):
52
 
        """Construct the window contents."""
53
 
        hbox = gtk.HBox(spacing=6)
54
 
        hbox.set_border_width(12)
55
 
        self.add(hbox)
56
 
        hbox.show()
57
 
 
58
 
        scrollwin = gtk.ScrolledWindow()
59
 
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
60
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
61
 
        hbox.pack_start(scrollwin, expand=False, fill=True)
62
 
        scrollwin.show()
63
 
 
64
 
        self.model = gtk.TreeStore(str, str)
65
 
        self.treeview = gtk.TreeView(self.model)
 
66
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
67
        self.set_shadow_type(Gtk.ShadowType.IN)
 
68
 
 
69
        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)
 
76
        else:
 
77
            self.buffer = Gtk.TextBuffer()
 
78
            self.sourceview = Gtk.TextView(self.buffer)
 
79
 
 
80
        self.sourceview.set_editable(False)
 
81
        self.sourceview.override_font(Pango.FontDescription("Monospace"))
 
82
        self.add(self.sourceview)
 
83
        if self.SHOW_WIDGETS:
 
84
            self.sourceview.show()
 
85
 
 
86
    def set_trees(self, rev_tree, parent_tree):
 
87
        self.rev_tree = rev_tree
 
88
        self.parent_tree = parent_tree
 
89
#        self._build_delta()
 
90
 
 
91
#    def _build_delta(self):
 
92
#        self.parent_tree.lock_read()
 
93
#        self.rev_tree.lock_read()
 
94
#        try:
 
95
#            self.delta = iter_changes_to_status(
 
96
#               self.parent_tree, self.rev_tree)
 
97
#            self.path_to_status = {}
 
98
#            self.path_to_diff = {}
 
99
#            source_inv = self.parent_tree.inventory
 
100
#            target_inv = self.rev_tree.inventory
 
101
#            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)
 
104
#                if change_type in ('modified', 'renamed and modified'):
 
105
#                    source_ie = source_inv[file_id]
 
106
#                    target_ie = target_inv[file_id]
 
107
#                    sio = StringIO()
 
108
#                    source_ie.diff(internal_diff, *old path, *old_tree,
 
109
#                                   *new_path, target_ie, self.rev_tree,
 
110
#                                   sio)
 
111
#                    self.path_to_diff[real_path] =
 
112
#
 
113
#        finally:
 
114
#            self.rev_tree.unlock()
 
115
#            self.parent_tree.unlock()
 
116
 
 
117
    def show_diff(self, specific_files):
 
118
        sections = []
 
119
        if specific_files is None:
 
120
            self.buffer.set_text(self._diffs[None])
 
121
        else:
 
122
            for specific_file in specific_files:
 
123
                sections.append(self._diffs[specific_file])
 
124
            self.buffer.set_text(''.join(sections))
 
125
 
 
126
 
 
127
class DiffView(DiffFileView):
 
128
    """This is the soft and chewy filling for a DiffWindow."""
 
129
 
 
130
    def __init__(self):
 
131
        super(DiffView, self).__init__()
 
132
        self.rev_tree = None
 
133
        self.parent_tree = None
 
134
 
 
135
    def show_diff(self, specific_files):
 
136
        """Show the diff for the specified files"""
 
137
        s = StringIO()
 
138
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
 
139
                        old_label='', new_label='',
 
140
                        # path_encoding=sys.getdefaultencoding()
 
141
                        # The default is utf-8, but we interpret the file
 
142
                        # contents as getdefaultencoding(), so we should
 
143
                        # probably try to make the paths in the same encoding.
 
144
                        )
 
145
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
 
146
        # character is not valid in 'encoding' there is nothing to replace, the
 
147
        # 'replace' is for 'str.encode()'
 
148
        try:
 
149
            decoded = s.getvalue().decode(sys.getdefaultencoding())
 
150
        except UnicodeDecodeError:
 
151
            try:
 
152
                decoded = s.getvalue().decode('UTF-8')
 
153
            except UnicodeDecodeError:
 
154
                decoded = s.getvalue().decode('iso-8859-1')
 
155
                # This always works, because every byte has a valid
 
156
                # mapping from iso-8859-1 to Unicode
 
157
        # TextBuffer must contain pure UTF-8 data
 
158
        self.buffer.set_text(decoded.encode('UTF-8'))
 
159
 
 
160
 
 
161
class DiffWidget(Gtk.HPaned):
 
162
    """Diff widget
 
163
 
 
164
    """
 
165
 
 
166
    SHOW_WIDGETS = True
 
167
 
 
168
    def __init__(self):
 
169
        super(DiffWidget, self).__init__()
 
170
 
 
171
        # 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)
 
175
        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)
66
181
        self.treeview.set_headers_visible(False)
67
182
        self.treeview.set_search_column(1)
68
183
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
69
184
        scrollwin.add(self.treeview)
70
 
        self.treeview.show()
 
185
        if self.SHOW_WIDGETS:
 
186
            self.treeview.show()
71
187
 
72
 
        cell = gtk.CellRendererText()
 
188
        cell = Gtk.CellRendererText()
73
189
        cell.set_property("width-chars", 20)
74
 
        column = gtk.TreeViewColumn()
75
 
        column.pack_start(cell, expand=True)
 
190
        column = Gtk.TreeViewColumn()
 
191
        column.pack_start(cell, True)
76
192
        column.add_attribute(cell, "text", 0)
77
193
        self.treeview.append_column(column)
78
194
 
79
 
 
80
 
        scrollwin = gtk.ScrolledWindow()
81
 
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
82
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
83
 
        hbox.pack_start(scrollwin, expand=True, fill=True)
84
 
        scrollwin.show()
85
 
 
86
 
        if have_gtksourceview:
87
 
            self.buffer = gtksourceview.SourceBuffer()
88
 
            slm = gtksourceview.SourceLanguagesManager()
89
 
            gsl = slm.get_language_from_mime_type("text/x-patch")
90
 
            self.buffer.set_language(gsl)
91
 
            self.buffer.set_highlight(True)
92
 
 
93
 
            sourceview = gtksourceview.SourceView(self.buffer)
94
 
        else:
95
 
            self.buffer = gtk.TextBuffer()
96
 
            sourceview = gtk.TextView(self.buffer)
97
 
 
98
 
        sourceview.set_editable(False)
99
 
        sourceview.modify_font(pango.FontDescription("Monospace"))
100
 
        scrollwin.add(sourceview)
101
 
        sourceview.show()
102
 
 
103
 
    def set_diff(self, branch, revid, parentid):
 
195
    def set_diff_text(self, lines):
 
196
        """Set the current diff from a list of lines
 
197
 
 
198
        :param lines: The diff to show, in unified diff format
 
199
        """
 
200
        # The diffs of the  selected file: a scrollable source or
 
201
        # text view
 
202
 
 
203
    def set_diff_text_sections(self, sections):
 
204
        if getattr(self, 'diff_view', None) is None:
 
205
            self.diff_view = DiffFileView()
 
206
            self.pack2(self.diff_view)
 
207
        if self.SHOW_WIDGETS:
 
208
            self.diff_view.show()
 
209
        for oldname, newname, patch in sections:
 
210
            self.diff_view._diffs[newname] = str(patch)
 
211
            if newname is None:
 
212
                newname = ''
 
213
            self.model.append(None, [oldname, newname])
 
214
        self.diff_view.show_diff(None)
 
215
 
 
216
    def set_diff(self, rev_tree, parent_tree):
104
217
        """Set the differences showed by this window.
105
218
 
106
219
        Compares the two trees and populates the window with the
107
220
        differences.
108
221
        """
109
 
        self.rev_tree = branch.repository.revision_tree(revid)
110
 
        self.parent_tree = branch.repository.revision_tree(parentid)
 
222
        if getattr(self, 'diff_view', None) is None:
 
223
            self.diff_view = DiffView()
 
224
            self.pack2(self.diff_view)
 
225
        if self.SHOW_WIDGETS:
 
226
            self.diff_view.show()
 
227
        self.diff_view.set_trees(rev_tree, parent_tree)
 
228
        self.rev_tree = rev_tree
 
229
        self.parent_tree = parent_tree
111
230
 
112
231
        self.model.clear()
113
 
        delta = compare_trees(self.parent_tree, self.rev_tree)
 
232
        delta = self.rev_tree.changes_from(self.parent_tree)
114
233
 
115
 
        self.model.append(None, [ "Complete Diff", "" ])
 
234
        self.model.append(None, ["Complete Diff", ""])
116
235
 
117
236
        if len(delta.added):
118
 
            titer = self.model.append(None, [ "Added", None ])
 
237
            titer = self.model.append(None, ["Added", None])
119
238
            for path, id, kind in delta.added:
120
 
                self.model.append(titer, [ path, path ])
 
239
                self.model.append(titer, [path, path])
121
240
 
122
241
        if len(delta.removed):
123
 
            titer = self.model.append(None, [ "Removed", None ])
 
242
            titer = self.model.append(None, ["Removed", None])
124
243
            for path, id, kind in delta.removed:
125
 
                self.model.append(titer, [ path, path ])
 
244
                self.model.append(titer, [path, path])
126
245
 
127
246
        if len(delta.renamed):
128
 
            titer = self.model.append(None, [ "Renamed", None ])
 
247
            titer = self.model.append(None, ["Renamed", None])
129
248
            for oldpath, newpath, id, kind, text_modified, meta_modified \
130
249
                    in delta.renamed:
131
 
                self.model.append(titer, [ oldpath, oldpath ])
 
250
                self.model.append(titer, [oldpath, newpath])
132
251
 
133
252
        if len(delta.modified):
134
 
            titer = self.model.append(None, [ "Modified", None ])
 
253
            titer = self.model.append(None, ["Modified", None])
135
254
            for path, id, kind, text_modified, meta_modified in delta.modified:
136
 
                self.model.append(titer, [ path, path ])
 
255
                self.model.append(titer, [path, path])
137
256
 
138
257
        self.treeview.expand_all()
139
 
        self.set_title(revid + " - " + branch.nick + " - bzrk diff")
 
258
        self.diff_view.show_diff(None)
 
259
 
 
260
    def set_file(self, file_path):
 
261
        """Select the current file to display"""
 
262
        tv_path = None
 
263
        for data in self.model:
 
264
            for child in data.iterchildren():
 
265
                if child[0] == file_path or child[1] == file_path:
 
266
                    tv_path = child.path
 
267
                    break
 
268
        if tv_path is None:
 
269
            raise errors.NoSuchFile(file_path)
 
270
        self.treeview.set_cursor(tv_path, None, False)
 
271
        self.treeview.scroll_to_cell(tv_path)
140
272
 
141
273
    def _treeview_cursor_cb(self, *args):
142
274
        """Callback for when the treeview cursor changes."""
143
275
        (path, col) = self.treeview.get_cursor()
144
 
        specific_files = [ self.model[path][1] ]
145
 
        if specific_files == [ None ]:
146
 
            return
147
 
        elif specific_files == [ "" ]:
148
 
            specific_files = []
149
 
 
150
 
        s = StringIO()
151
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
152
 
        self.buffer.set_text(s.getvalue())
 
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 == [""]:
 
282
            specific_files = None
 
283
 
 
284
        self.diff_view.show_diff(specific_files)
 
285
 
 
286
    def _on_wraplines_toggled(self, widget=None, wrap=False):
 
287
        """Callback for when the wrap lines checkbutton is toggled"""
 
288
        if wrap or widget.get_active():
 
289
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
 
290
        else:
 
291
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
 
292
 
 
293
 
 
294
class DiffWindow(Window):
 
295
    """Diff window.
 
296
 
 
297
    This object represents and manages a single window containing the
 
298
    differences between two revisions on a branch.
 
299
    """
 
300
 
 
301
    SHOW_WIDGETS = True
 
302
 
 
303
    def __init__(self, parent=None, operations=None):
 
304
        super(DiffWindow, self).__init__(parent=parent)
 
305
        self.set_border_width(0)
 
306
        self.set_title("bzr diff")
 
307
 
 
308
        # Use two thirds of the screen by default
 
309
        screen = self.get_screen()
 
310
        monitor = screen.get_monitor_geometry(0)
 
311
        width = int(monitor.width * 0.66)
 
312
        height = int(monitor.height * 0.66)
 
313
        self.set_default_size(width, height)
 
314
        self.construct(operations)
 
315
 
 
316
    def construct(self, operations):
 
317
        """Construct the window contents."""
 
318
        self.vbox = Gtk.VBox()
 
319
        self.add(self.vbox)
 
320
        if self.SHOW_WIDGETS:
 
321
            self.vbox.show()
 
322
        self.diff = DiffWidget()
 
323
        self.vbox.pack_end(self.diff, True, True, 0)
 
324
        if self.SHOW_WIDGETS:
 
325
            self.diff.show_all()
 
326
        # Build after DiffWidget to connect signals
 
327
        menubar = self._get_menu_bar()
 
328
        self.vbox.pack_start(menubar, False, False, 0)
 
329
        hbox = self._get_button_bar(operations)
 
330
        if hbox is not None:
 
331
            self.vbox.pack_start(hbox, False, True, 0)
 
332
 
 
333
    def _get_menu_bar(self):
 
334
        menubar = Gtk.MenuBar()
 
335
        # 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"))
 
340
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
341
        mb_view_menu.append(mb_view_wrapsource)
 
342
        mb_view.set_submenu(mb_view_menu)
 
343
        menubar.append(mb_view)
 
344
        if self.SHOW_WIDGETS:
 
345
            menubar.show_all()
 
346
        return menubar
 
347
 
 
348
    def _get_button_bar(self, operations):
 
349
        """Return a button bar to use.
 
350
 
 
351
        :return: None, meaning that no button bar will be used.
 
352
        """
 
353
        if operations is None:
 
354
            return None
 
355
        hbox = Gtk.HButtonBox()
 
356
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
357
        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)
 
362
            merge_button.connect("clicked", method)
 
363
            hbox.pack_start(merge_button, False, True, 0)
 
364
        if self.SHOW_WIDGETS:
 
365
            hbox.show()
 
366
        return hbox
 
367
 
 
368
    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,))
 
374
        try:
 
375
            result = d.run()
 
376
            if result != Gtk.ResponseType.OK:
 
377
                raise SelectCancelled()
 
378
            return d.get_current_folder_uri()
 
379
        finally:
 
380
            d.destroy()
 
381
 
 
382
    def _merge_successful(self):
 
383
        # No conflicts found.
 
384
        info_dialog(_i18n('Merge successful'),
 
385
                    _i18n('All changes applied successfully.'))
 
386
 
 
387
    def _conflicts(self):
 
388
        warning_dialog(_i18n('Conflicts encountered'),
 
389
                       _i18n('Please resolve the conflicts manually'
 
390
                             ' before committing.'))
 
391
 
 
392
    def _handle_error(self, e):
 
393
        error_dialog('Error', str(e))
 
394
 
 
395
    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,))
 
401
        d.set_current_name(basename)
 
402
        try:
 
403
            result = d.run()
 
404
            if result != Gtk.ResponseType.OK:
 
405
                raise SelectCancelled()
 
406
            return urlutils.local_path_from_url(d.get_uri())
 
407
        finally:
 
408
            d.destroy()
 
409
 
 
410
    def set_diff(self, description, rev_tree, parent_tree):
 
411
        """Set the differences showed by this window.
 
412
 
 
413
        Compares the two trees and populates the window with the
 
414
        differences.
 
415
        """
 
416
        self.diff.set_diff(rev_tree, parent_tree)
 
417
        self.set_title(description + " - bzrk diff")
 
418
 
 
419
    def set_file(self, file_path):
 
420
        self.diff.set_file(file_path)
 
421
 
 
422
 
 
423
class DiffController(object):
 
424
 
 
425
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
426
        self.path = path
 
427
        self.patch = patch
 
428
        self.allow_dirty = allow_dirty
 
429
        if window is None:
 
430
            window = DiffWindow(operations=self._provide_operations())
 
431
            self.initialize_window(window)
 
432
        self.window = window
 
433
 
 
434
    def initialize_window(self, window):
 
435
        window.diff.set_diff_text_sections(self.get_diff_sections())
 
436
        window.set_title(self.path + " - diff")
 
437
 
 
438
    def get_diff_sections(self):
 
439
        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:
 
446
            oldname = patch.oldname.split('\t')[0]
 
447
            newname = patch.newname.split('\t')[0]
 
448
            yield oldname, newname, str(patch)
 
449
 
 
450
    def perform_save(self, window):
 
451
        try:
 
452
            save_path = self.window._get_save_path(osutils.basename(self.path))
 
453
        except SelectCancelled:
 
454
            return
 
455
        source = open(self.path, 'rb')
 
456
        try:
 
457
            target = open(save_path, 'wb')
 
458
            try:
 
459
                osutils.pumpfile(source, target)
 
460
            finally:
 
461
                target.close()
 
462
        finally:
 
463
            source.close()
 
464
 
 
465
    def _provide_operations(self):
 
466
        return [('Save', self.perform_save)]
 
467
 
 
468
 
 
469
class MergeDirectiveController(DiffController):
 
470
 
 
471
    def __init__(self, path, directive, window=None):
 
472
        super(MergeDirectiveController, self).__init__(
 
473
            path, directive.patch.splitlines(True), window)
 
474
        self.directive = directive
 
475
        self.merge_target = None
 
476
 
 
477
    def _provide_operations(self):
 
478
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
 
479
 
 
480
    def perform_merge(self, window):
 
481
        if self.merge_target is None:
 
482
            try:
 
483
                self.merge_target = self.window._get_merge_target()
 
484
            except SelectCancelled:
 
485
                return
 
486
        tree = workingtree.WorkingTree.open(self.merge_target)
 
487
        tree.lock_write()
 
488
        try:
 
489
            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)
 
494
                merger.merge_type = _mod_merge.Merge3Merger
 
495
                conflict_count = merger.do_merge()
 
496
                merger.set_pending()
 
497
                if conflict_count == 0:
 
498
                    self.window._merge_successful()
 
499
                else:
 
500
                    self.window._conflicts()
 
501
                    # There are conflicts to be resolved.
 
502
                self.window.destroy()
 
503
            except Exception, e:
 
504
                self.window._handle_error(e)
 
505
        finally:
 
506
            tree.unlock()
 
507
 
 
508
 
 
509
def iter_changes_to_status(source, target):
 
510
    """Determine the differences between trees.
 
511
 
 
512
    This is a wrapper around iter_changes which just yields more
 
513
    understandable results.
 
514
 
 
515
    :param source: The source tree (basis tree)
 
516
    :param target: The target tree
 
517
    :return: A list of (file_id, real_path, change_type, display_path)
 
518
    """
 
519
    added = 'added'
 
520
    removed = 'removed'
 
521
    renamed = 'renamed'
 
522
    renamed_and_modified = 'renamed and modified'
 
523
    modified = 'modified'
 
524
    kind_changed = 'kind changed'
 
525
    missing = 'missing'
 
526
 
 
527
    # TODO: Handle metadata changes
 
528
 
 
529
    status = []
 
530
    target.lock_read()
 
531
    try:
 
532
        source.lock_read()
 
533
        try:
 
534
            for (file_id, paths, changed_content, versioned, parent_ids, names,
 
535
                 kinds, executables) in target.iter_changes(source):
 
536
 
 
537
                # Skip the root entry if it isn't very interesting
 
538
                if parent_ids == (None, None):
 
539
                    continue
 
540
 
 
541
                change_type = None
 
542
                if kinds[0] is None:
 
543
                    source_marker = ''
 
544
                else:
 
545
                    source_marker = osutils.kind_marker(kinds[0])
 
546
 
 
547
                if kinds[1] is None:
 
548
                    if kinds[0] is None:
 
549
                        # We assume bzr will flag only files in that case,
 
550
                        # there may be a bzr bug there as only files seems to
 
551
                        # not receive any kind.
 
552
                        marker = osutils.kind_marker('file')
 
553
                    else:
 
554
                        marker = osutils.kind_marker(kinds[0])
 
555
                else:
 
556
                    marker = osutils.kind_marker(kinds[1])
 
557
 
 
558
                real_path = paths[1]
 
559
                if real_path is None:
 
560
                    real_path = paths[0]
 
561
                assert real_path is not None
 
562
 
 
563
                present_source = versioned[0] and kinds[0] is not None
 
564
                present_target = versioned[1] and kinds[1] is not None
 
565
 
 
566
                if kinds[0] is None and kinds[1] is None:
 
567
                    change_type = missing
 
568
                    display_path = real_path + marker
 
569
                elif present_source != present_target:
 
570
                    if present_target:
 
571
                        change_type = added
 
572
                    else:
 
573
                        assert present_source
 
574
                        change_type = removed
 
575
                    display_path = real_path + marker
 
576
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
 
577
                    # Renamed
 
578
                    if changed_content or executables[0] != executables[1]:
 
579
                        # and modified
 
580
                        change_type = renamed_and_modified
 
581
                    else:
 
582
                        change_type = renamed
 
583
                    display_path = (paths[0] + source_marker
 
584
                                    + ' => ' + paths[1] + marker)
 
585
                elif kinds[0] != kinds[1]:
 
586
                    change_type = kind_changed
 
587
                    display_path = (paths[0] + source_marker
 
588
                                    + ' => ' + paths[1] + marker)
 
589
                elif changed_content or executables[0] != executables[1]:
 
590
                    change_type = modified
 
591
                    display_path = real_path + marker
 
592
                else:
 
593
                    assert False, "How did we get here?"
 
594
 
 
595
                status.append((file_id, real_path, change_type, display_path))
 
596
        finally:
 
597
            source.unlock()
 
598
    finally:
 
599
        target.unlock()
 
600
 
 
601
    return status