/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-12-21 20:20:37 UTC
  • mto: This revision was merged to the branch mainline in revision 422.
  • Revision ID: jelmer@samba.org-20071221202037-6zvbwefvrte3e2zy
Fix URL.

Show diffs side-by-side

added added

removed removed

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