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