/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: Aaron Bentley
  • Date: 2007-08-16 14:31:02 UTC
  • Revision ID: abentley@panoramicfeedback.com-20070816143102-27yzfhdgdv3ggo6e
Fix hue selection to use author in gannotate

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