/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: 2011-03-14 20:12:19 UTC
  • Revision ID: jelmer@samba.org-20110314201219-wo692nzwywu6mevh
Fix formatting, imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
1
 
# -*- coding: UTF-8 -*-
2
1
"""Difference window.
3
2
 
4
3
This module contains the code to manage the diff window which shows
5
4
the changes made between two revisions on a branch.
6
5
"""
7
6
 
8
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
 
7
__copyright__ = "Copyright 2005 Canonical Ltd."
9
8
__author__    = "Scott James Remnant <scott@ubuntu.com>"
10
9
 
11
10
 
18
17
import os
19
18
import re
20
19
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
21
25
 
22
26
try:
23
 
    import gtksourceview
 
27
    import gtksourceview2
24
28
    have_gtksourceview = True
25
29
except ImportError:
26
30
    have_gtksourceview = False
30
34
except ImportError:
31
35
    have_gconf = False
32
36
 
33
 
import bzrlib
34
 
 
 
37
from bzrlib import (
 
38
    errors,
 
39
    merge as _mod_merge,
 
40
    osutils,
 
41
    urlutils,
 
42
    workingtree,
 
43
)
35
44
from bzrlib.diff import show_diff_trees
36
 
from bzrlib.errors import NoSuchFile
 
45
from bzrlib.patches import parse_patches
37
46
from bzrlib.trace import warning
38
 
 
39
 
 
40
 
class DiffWindow(gtk.Window):
41
 
    """Diff window.
42
 
 
43
 
    This object represents and manages a single window containing the
44
 
    differences between two revisions on a branch.
45
 
    """
 
47
from bzrlib.plugins.gtk import _i18n
 
48
from bzrlib.plugins.gtk.window import Window
 
49
from bzrlib.plugins.gtk.dialog import (
 
50
    error_dialog,
 
51
    info_dialog,
 
52
    warning_dialog,
 
53
    )
 
54
 
 
55
 
 
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"""
46
71
 
47
72
    def __init__(self):
48
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
49
 
        self.set_border_width(0)
50
 
        self.set_title("bzrk diff")
51
 
 
52
 
        # Use two thirds of the screen by default
53
 
        screen = self.get_screen()
54
 
        monitor = screen.get_monitor_geometry(0)
55
 
        width = int(monitor.width * 0.66)
56
 
        height = int(monitor.height * 0.66)
57
 
        self.set_default_size(width, height)
58
 
 
 
73
        gtk.ScrolledWindow.__init__(self)
59
74
        self.construct()
 
75
        self._diffs = {}
60
76
 
61
77
    def construct(self):
62
 
        """Construct the window contents."""
63
 
        # The   window  consists  of   a  pane   containing:  the
64
 
        # hierarchical list  of files on  the left, and  the diff
65
 
        # for the currently selected file on the right.
66
 
        pane = gtk.HPaned()
67
 
        self.add(pane)
68
 
        pane.show()
 
78
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
79
        self.set_shadow_type(gtk.SHADOW_IN)
 
80
 
 
81
        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")
 
87
            if have_gconf:
 
88
                self.apply_gedit_colors(self.buffer)
 
89
            self.apply_colordiff_colors(self.buffer)
 
90
            self.buffer.set_language(gsl)
 
91
            self.buffer.set_highlight_syntax(True)
 
92
 
 
93
            self.sourceview = gtksourceview2.View(self.buffer)
 
94
        else:
 
95
            self.buffer = gtk.TextBuffer()
 
96
            self.sourceview = gtk.TextView(self.buffer)
 
97
 
 
98
        self.sourceview.set_editable(False)
 
99
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
100
        self.add(self.sourceview)
 
101
        self.sourceview.show()
 
102
 
 
103
    @staticmethod
 
104
    def apply_gedit_colors(buf):
 
105
        """Set style to that specified in gedit configuration.
 
106
 
 
107
        This method needs the gconf module.
 
108
 
 
109
        :param buf: a gtksourceview2.Buffer object.
 
110
        """
 
111
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
 
112
        GEDIT_USER_STYLES_PATH = os.path.expanduser('~/.gnome2/gedit/styles')
 
113
 
 
114
        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):
 
127
        """Set style colors for lang using the colordiff configuration file.
 
128
 
 
129
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
130
 
 
131
        :param buf: a "Diff" gtksourceview2.Buffer object.
 
132
        """
 
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
 
158
                # since GSV is richer, accept new names for extra bits,
 
159
                # 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)
 
197
 
 
198
    @staticmethod
 
199
    def parse_colordiffrc(fileobj):
 
200
        """Parse fileobj as a colordiff configuration file.
 
201
 
 
202
        :return: A dict with the key -> value pairs.
 
203
        """
 
204
        colors = {}
 
205
        for line in fileobj:
 
206
            if re.match(r'^\s*#', line):
 
207
                continue
 
208
            if '=' not in line:
 
209
                continue
 
210
            key, val = line.split('=', 1)
 
211
            colors[key.strip()] = val.strip()
 
212
        return colors
 
213
 
 
214
    def set_trees(self, rev_tree, parent_tree):
 
215
        self.rev_tree = rev_tree
 
216
        self.parent_tree = parent_tree
 
217
#        self._build_delta()
 
218
 
 
219
#    def _build_delta(self):
 
220
#        self.parent_tree.lock_read()
 
221
#        self.rev_tree.lock_read()
 
222
#        try:
 
223
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
224
#            self.path_to_status = {}
 
225
#            self.path_to_diff = {}
 
226
#            source_inv = self.parent_tree.inventory
 
227
#            target_inv = self.rev_tree.inventory
 
228
#            for (file_id, real_path, change_type, display_path) in self.delta:
 
229
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
230
#                if change_type in ('modified', 'renamed and modified'):
 
231
#                    source_ie = source_inv[file_id]
 
232
#                    target_ie = target_inv[file_id]
 
233
#                    sio = StringIO()
 
234
#                    source_ie.diff(internal_diff, *old path, *old_tree,
 
235
#                                   *new_path, target_ie, self.rev_tree,
 
236
#                                   sio)
 
237
#                    self.path_to_diff[real_path] = 
 
238
#
 
239
#        finally:
 
240
#            self.rev_tree.unlock()
 
241
#            self.parent_tree.unlock()
 
242
 
 
243
    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
        s = StringIO()
 
264
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
 
265
                        old_label='', new_label='',
 
266
                        # path_encoding=sys.getdefaultencoding()
 
267
                        # The default is utf-8, but we interpret the file
 
268
                        # contents as getdefaultencoding(), so we should
 
269
                        # probably try to make the paths in the same encoding.
 
270
                        )
 
271
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
 
272
        # character is not valid in 'encoding' there is nothing to replace, the
 
273
        # 'replace' is for 'str.encode()'
 
274
        try:
 
275
            decoded = s.getvalue().decode(sys.getdefaultencoding())
 
276
        except UnicodeDecodeError:
 
277
            try:
 
278
                decoded = s.getvalue().decode('UTF-8')
 
279
            except UnicodeDecodeError:
 
280
                decoded = s.getvalue().decode('iso-8859-1')
 
281
                # This always works, because every byte has a valid
 
282
                # mapping from iso-8859-1 to Unicode
 
283
        # TextBuffer must contain pure UTF-8 data
 
284
        self.buffer.set_text(decoded.encode('UTF-8'))
 
285
 
 
286
 
 
287
class DiffWidget(gtk.HPaned):
 
288
    """Diff widget
 
289
 
 
290
    """
 
291
    def __init__(self):
 
292
        super(DiffWidget, self).__init__()
69
293
 
70
294
        # The file hierarchy: a scrollable treeview
71
295
        scrollwin = gtk.ScrolledWindow()
72
296
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
73
297
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
74
 
        pane.pack1(scrollwin)
 
298
        self.pack1(scrollwin)
75
299
        scrollwin.show()
76
 
 
 
300
        
77
301
        self.model = gtk.TreeStore(str, str)
78
302
        self.treeview = gtk.TreeView(self.model)
79
303
        self.treeview.set_headers_visible(False)
89
313
        column.add_attribute(cell, "text", 0)
90
314
        self.treeview.append_column(column)
91
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
        """
92
321
        # The diffs of the  selected file: a scrollable source or
93
322
        # text view
94
 
        scrollwin = gtk.ScrolledWindow()
95
 
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
96
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
97
 
        pane.pack2(scrollwin)
98
 
        scrollwin.show()
99
 
 
100
 
        if have_gtksourceview:
101
 
            self.buffer = gtksourceview.SourceBuffer()
102
 
            slm = gtksourceview.SourceLanguagesManager()
103
 
            gsl = slm.get_language_from_mime_type("text/x-patch")
104
 
            if have_gconf:
105
 
                self.apply_gedit_colors(gsl)
106
 
            self.apply_colordiff_colors(gsl)
107
 
            self.buffer.set_language(gsl)
108
 
            self.buffer.set_highlight(True)
109
 
 
110
 
            sourceview = gtksourceview.SourceView(self.buffer)
111
 
        else:
112
 
            self.buffer = gtk.TextBuffer()
113
 
            sourceview = gtk.TextView(self.buffer)
114
 
 
115
 
        sourceview.set_editable(False)
116
 
        sourceview.modify_font(pango.FontDescription("Monospace"))
117
 
        scrollwin.add(sourceview)
118
 
        sourceview.show()
119
 
 
120
 
    def set_diff(self, description, rev_tree, parent_tree):
 
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)
 
328
        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
 
 
336
    def set_diff(self, rev_tree, parent_tree):
121
337
        """Set the differences showed by this window.
122
338
 
123
339
        Compares the two trees and populates the window with the
124
340
        differences.
125
341
        """
 
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
        self.diff_view.set_trees(rev_tree, parent_tree)
126
347
        self.rev_tree = rev_tree
127
348
        self.parent_tree = parent_tree
128
349
 
153
374
                self.model.append(titer, [ path, path ])
154
375
 
155
376
        self.treeview.expand_all()
156
 
        self.set_title(description + " - bzrk diff")
 
377
        self.diff_view.show_diff(None)
157
378
 
158
379
    def set_file(self, file_path):
 
380
        """Select the current file to display"""
159
381
        tv_path = None
160
382
        for data in self.model:
161
383
            for child in data.iterchildren():
163
385
                    tv_path = child.path
164
386
                    break
165
387
        if tv_path is None:
166
 
            raise NoSuchFile(file_path)
 
388
            raise errors.NoSuchFile(file_path)
167
389
        self.treeview.set_cursor(tv_path)
168
390
        self.treeview.scroll_to_cell(tv_path)
169
391
 
174
396
        if specific_files == [ None ]:
175
397
            return
176
398
        elif specific_files == [ "" ]:
177
 
            specific_files = []
178
 
 
179
 
        s = StringIO()
180
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
181
 
        self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))
182
 
 
183
 
    @staticmethod
184
 
    def apply_gedit_colors(lang):
185
 
        """Set style for lang to that specified in gedit configuration.
186
 
 
187
 
        This method needs the gconf module.
188
 
        
189
 
        :param lang: a gtksourceview.SourceLanguage object.
190
 
        """
191
 
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
192
 
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
193
 
 
194
 
        client = gconf.client_get_default()
195
 
        client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
196
 
 
197
 
        for tag in lang.get_tags():
198
 
            tag_id = tag.get_id()
199
 
            gconf_key = GEDIT_LANG_PATH + '/' + tag_id
200
 
            style_string = client.get_string(gconf_key)
201
 
 
202
 
            if style_string is None:
203
 
                continue
204
 
 
205
 
            # function to get a bool from a string that's either '0' or '1'
206
 
            string_bool = lambda x: bool(int(x))
207
 
 
208
 
            # style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
209
 
            # values are: mask, fg, bg, italic, bold, underline, strike
210
 
            # this packs them into (str_value, attr_name, conv_func) tuples
211
 
            items = zip(style_string.split('/'), ['mask', 'foreground',
212
 
                'background', 'italic', 'bold', 'underline', 'strikethrough' ],
213
 
                [ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
214
 
                    string_bool, string_bool, string_bool ]
215
 
            )
216
 
 
217
 
            style = gtksourceview.SourceTagStyle()
218
 
 
219
 
            # XXX The mask attribute controls whether the present values of
220
 
            # foreground and background color should in fact be used. Ideally
221
 
            # (and that's what gedit does), one could set all three attributes,
222
 
            # and let the TagStyle object figure out which colors to use.
223
 
            # However, in the GtkSourceview python bindings, the mask attribute
224
 
            # is read-only, and it's derived instead from the colors being
225
 
            # set or not. This means that we have to sometimes refrain from
226
 
            # setting fg or bg colors, depending on the value of the mask.
227
 
            # This code could go away if mask were writable.
228
 
            mask = int(items[0][0])
229
 
            if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
230
 
                items[2:3] = []
231
 
            if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
232
 
                items[1:2] = []
233
 
            items[0:1] = [] # skip the mask unconditionally
234
 
 
235
 
            for value, attr, func in items:
236
 
                try:
237
 
                    value = func(value)
238
 
                except ValueError:
239
 
                    warning('gconf key %s contains an invalid value: %s'
240
 
                            % gconf_key, value)
241
 
                else:
242
 
                    setattr(style, attr, value)
243
 
 
244
 
            lang.set_tag_style(tag_id, style)
245
 
 
246
 
    @staticmethod
247
 
    def apply_colordiff_colors(lang):
248
 
        """Set style colors for lang using the colordiff configuration file.
249
 
 
250
 
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
251
 
 
252
 
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
253
 
        """
254
 
        colors = {}
255
 
 
256
 
        for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
257
 
            f = os.path.expanduser(f)
258
 
            if os.path.exists(f):
259
 
                try:
260
 
                    f = file(f)
261
 
                except IOError, e:
262
 
                    warning('could not open file %s: %s' % (f, str(e)))
263
 
                else:
264
 
                    colors.update(DiffWindow.parse_colordiffrc(f))
265
 
                    f.close()
266
 
 
267
 
        if not colors:
268
 
            # ~/.colordiffrc does not exist
 
399
            specific_files = None
 
400
        
 
401
        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:
269
566
            return
270
 
 
271
 
        mapping = {
272
 
                # map GtkSourceView tags to colordiff names
273
 
                # since GSV is richer, accept new names for extra bits,
274
 
                # defaulting to old names if they're not present
275
 
                'Added@32@line': ['newtext'],
276
 
                'Removed@32@line': ['oldtext'],
277
 
                'Location': ['location', 'diffstuff'],
278
 
                'Diff@32@file': ['file', 'diffstuff'],
279
 
                'Special@32@case': ['specialcase', 'diffstuff'],
280
 
        }
281
 
 
282
 
        for tag in lang.get_tags():
283
 
            tag_id = tag.get_id()
284
 
            keys = mapping.get(tag_id, [])
285
 
            color = None
286
 
 
287
 
            for key in keys:
288
 
                color = colors.get(key, None)
289
 
                if color is not None:
290
 
                    break
291
 
 
292
 
            if color is None:
293
 
                continue
294
 
 
295
 
            style = gtksourceview.SourceTagStyle()
296
 
            try:
297
 
                style.foreground = gtk.gdk.color_parse(color)
298
 
            except ValueError:
299
 
                warning('not a valid color: %s' % color)
300
 
            else:
301
 
                lang.set_tag_style(tag_id, style)
302
 
 
303
 
    @staticmethod
304
 
    def parse_colordiffrc(fileobj):
305
 
        """Parse fileobj as a colordiff configuration file.
306
 
        
307
 
        :return: A dict with the key -> value pairs.
308
 
        """
309
 
        colors = {}
310
 
        for line in fileobj:
311
 
            if re.match(r'^\s*#', line):
312
 
                continue
313
 
            if '=' not in line:
314
 
                continue
315
 
            key, val = line.split('=', 1)
316
 
            colors[key.strip()] = val.strip()
317
 
        return colors
318
 
 
 
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):
 
622
    """Determine the differences between trees.
 
623
 
 
624
    This is a wrapper around iter_changes which just yields more
 
625
    understandable results.
 
626
 
 
627
    :param source: The source tree (basis tree)
 
628
    :param target: The target tree
 
629
    :return: A list of (file_id, real_path, change_type, display_path)
 
630
    """
 
631
    added = 'added'
 
632
    removed = 'removed'
 
633
    renamed = 'renamed'
 
634
    renamed_and_modified = 'renamed and modified'
 
635
    modified = 'modified'
 
636
    kind_changed = 'kind changed'
 
637
    missing = 'missing'
 
638
 
 
639
    # TODO: Handle metadata changes
 
640
 
 
641
    status = []
 
642
    target.lock_read()
 
643
    try:
 
644
        source.lock_read()
 
645
        try:
 
646
            for (file_id, paths, changed_content, versioned, parent_ids, names,
 
647
                 kinds, executables) in target.iter_changes(source):
 
648
 
 
649
                # Skip the root entry if it isn't very interesting
 
650
                if parent_ids == (None, None):
 
651
                    continue
 
652
 
 
653
                change_type = None
 
654
                if kinds[0] is None:
 
655
                    source_marker = ''
 
656
                else:
 
657
                    source_marker = osutils.kind_marker(kinds[0])
 
658
 
 
659
                if kinds[1] is None:
 
660
                    if kinds[0] is None:
 
661
                        # We assume bzr will flag only files in that case,
 
662
                        # there may be a bzr bug there as only files seems to
 
663
                        # not receive any kind.
 
664
                        marker = osutils.kind_marker('file')
 
665
                    else:
 
666
                        marker = osutils.kind_marker(kinds[0])
 
667
                else:
 
668
                    marker = osutils.kind_marker(kinds[1])
 
669
 
 
670
                real_path = paths[1]
 
671
                if real_path is None:
 
672
                    real_path = paths[0]
 
673
                assert real_path is not None
 
674
 
 
675
                present_source = versioned[0] and kinds[0] is not None
 
676
                present_target = versioned[1] and kinds[1] is not None
 
677
 
 
678
                if kinds[0] is None and kinds[1] is None:
 
679
                    change_type = missing
 
680
                    display_path = real_path + marker
 
681
                elif present_source != present_target:
 
682
                    if present_target:
 
683
                        change_type = added
 
684
                    else:
 
685
                        assert present_source
 
686
                        change_type = removed
 
687
                    display_path = real_path + marker
 
688
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
 
689
                    # Renamed
 
690
                    if changed_content or executables[0] != executables[1]:
 
691
                        # and modified
 
692
                        change_type = renamed_and_modified
 
693
                    else:
 
694
                        change_type = renamed
 
695
                    display_path = (paths[0] + source_marker
 
696
                                    + ' => ' + paths[1] + marker)
 
697
                elif kinds[0] != kinds[1]:
 
698
                    change_type = kind_changed
 
699
                    display_path = (paths[0] + source_marker
 
700
                                    + ' => ' + paths[1] + marker)
 
701
                elif changed_content or executables[0] != executables[1]:
 
702
                    change_type = modified
 
703
                    display_path = real_path + marker
 
704
                else:
 
705
                    assert False, "How did we get here?"
 
706
 
 
707
                status.append((file_id, real_path, change_type, display_path))
 
708
        finally:
 
709
            source.unlock()
 
710
    finally:
 
711
        target.unlock()
 
712
 
 
713
    return status