/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: John Arbash Meinel
  • Date: 2007-10-02 23:08:12 UTC
  • mto: (322.1.1 trunk) (330.3.3 trunk)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: john@arbash-meinel.com-20071002230812-h8i6pq8fwvodute4
Start testing with Unicode data.
It seems there is some brokenness with serializing Unicode messages.
But otherwise everything seems to be working.

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
 
18
import os
 
19
import re
13
20
import sys
14
 
import inspect
15
21
 
16
 
from gi.repository import Gtk
17
 
from gi.repository import Pango
18
22
try:
19
 
    from gi.repository import GtkSource
 
23
    import gtksourceview
20
24
    have_gtksourceview = True
21
25
except ImportError:
22
26
    have_gtksourceview = False
23
 
 
24
 
from bzrlib import (
25
 
    errors,
26
 
    merge as _mod_merge,
27
 
    osutils,
28
 
    urlutils,
29
 
    workingtree,
30
 
    )
31
 
from bzrlib.diff import show_diff_trees
32
 
from bzrlib.patches import parse_patches
33
 
from bzrlib.plugins.gtk.dialog import (
34
 
    error_dialog,
35
 
    info_dialog,
36
 
    warning_dialog,
37
 
    )
38
 
from bzrlib.plugins.gtk.i18n import _i18n
39
 
from bzrlib.plugins.gtk.window import Window
40
 
 
41
 
 
42
 
def fallback_guess_language(slm, content_type):
43
 
    for lang_id in slm.get_language_ids():
44
 
        lang = slm.get_language(lang_id)
45
 
        if "text/x-patch" in lang.get_mime_types():
46
 
            return lang
47
 
    return None
48
 
 
49
 
 
50
 
class SelectCancelled(Exception):
51
 
 
52
 
    pass
53
 
 
54
 
 
55
 
class DiffFileView(Gtk.ScrolledWindow):
56
 
    """Window for displaying diffs from a diff file"""
57
 
 
58
 
    SHOW_WIDGETS = True
 
27
try:
 
28
    import gconf
 
29
    have_gconf = True
 
30
except ImportError:
 
31
    have_gconf = False
 
32
 
 
33
from bzrlib import osutils
 
34
from bzrlib.diff import show_diff_trees, internal_diff
 
35
from bzrlib.errors import NoSuchFile
 
36
from bzrlib.trace import warning
 
37
 
 
38
 
 
39
class DiffView(gtk.ScrolledWindow):
 
40
    """This is the soft and chewy filling for a DiffWindow."""
59
41
 
60
42
    def __init__(self):
61
 
        super(DiffFileView, self).__init__()
 
43
        gtk.ScrolledWindow.__init__(self)
 
44
 
62
45
        self.construct()
63
 
        self._diffs = {}
 
46
        self.rev_tree = None
 
47
        self.parent_tree = None
64
48
 
65
49
    def construct(self):
66
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
 
        self.set_shadow_type(Gtk.ShadowType.IN)
 
50
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
51
        self.set_shadow_type(gtk.SHADOW_IN)
68
52
 
69
53
        if have_gtksourceview:
70
 
            self.buffer = GtkSource.Buffer()
71
 
            lang_manager = GtkSource.LanguageManager.get_default()
72
 
            language = lang_manager.guess_language(None, "text/x-patch")
73
 
            self.buffer.set_language(language)
74
 
            self.buffer.set_highlight_syntax(True)
75
 
            self.sourceview = GtkSource.View(buffer=self.buffer)
 
54
            self.buffer = gtksourceview.SourceBuffer()
 
55
            slm = gtksourceview.SourceLanguagesManager()
 
56
            gsl = slm.get_language_from_mime_type("text/x-patch")
 
57
            if have_gconf:
 
58
                self.apply_gedit_colors(gsl)
 
59
            self.apply_colordiff_colors(gsl)
 
60
            self.buffer.set_language(gsl)
 
61
            self.buffer.set_highlight(True)
 
62
 
 
63
            sourceview = gtksourceview.SourceView(self.buffer)
76
64
        else:
77
 
            self.buffer = Gtk.TextBuffer()
78
 
            self.sourceview = Gtk.TextView(self.buffer)
79
 
 
80
 
        self.sourceview.set_editable(False)
81
 
        self.sourceview.override_font(Pango.FontDescription("Monospace"))
82
 
        self.add(self.sourceview)
83
 
        if self.SHOW_WIDGETS:
84
 
            self.sourceview.show()
 
65
            self.buffer = gtk.TextBuffer()
 
66
            sourceview = gtk.TextView(self.buffer)
 
67
 
 
68
        sourceview.set_editable(False)
 
69
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
70
        self.add(sourceview)
 
71
        sourceview.show()
 
72
 
 
73
    @staticmethod
 
74
    def apply_gedit_colors(lang):
 
75
        """Set style for lang to that specified in gedit configuration.
 
76
 
 
77
        This method needs the gconf module.
 
78
 
 
79
        :param lang: a gtksourceview.SourceLanguage object.
 
80
        """
 
81
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
 
82
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
 
83
 
 
84
        client = gconf.client_get_default()
 
85
        client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
 
86
 
 
87
        for tag in lang.get_tags():
 
88
            tag_id = tag.get_id()
 
89
            gconf_key = GEDIT_LANG_PATH + '/' + tag_id
 
90
            style_string = client.get_string(gconf_key)
 
91
 
 
92
            if style_string is None:
 
93
                continue
 
94
 
 
95
            # function to get a bool from a string that's either '0' or '1'
 
96
            string_bool = lambda x: bool(int(x))
 
97
 
 
98
            # style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
 
99
            # values are: mask, fg, bg, italic, bold, underline, strike
 
100
            # this packs them into (str_value, attr_name, conv_func) tuples
 
101
            items = zip(style_string.split('/'), ['mask', 'foreground',
 
102
                'background', 'italic', 'bold', 'underline', 'strikethrough' ],
 
103
                [ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
 
104
                    string_bool, string_bool, string_bool ]
 
105
            )
 
106
 
 
107
            style = gtksourceview.SourceTagStyle()
 
108
 
 
109
            # XXX The mask attribute controls whether the present values of
 
110
            # foreground and background color should in fact be used. Ideally
 
111
            # (and that's what gedit does), one could set all three attributes,
 
112
            # and let the TagStyle object figure out which colors to use.
 
113
            # However, in the GtkSourceview python bindings, the mask attribute
 
114
            # is read-only, and it's derived instead from the colors being
 
115
            # set or not. This means that we have to sometimes refrain from
 
116
            # setting fg or bg colors, depending on the value of the mask.
 
117
            # This code could go away if mask were writable.
 
118
            mask = int(items[0][0])
 
119
            if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
 
120
                items[2:3] = []
 
121
            if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
 
122
                items[1:2] = []
 
123
            items[0:1] = [] # skip the mask unconditionally
 
124
 
 
125
            for value, attr, func in items:
 
126
                try:
 
127
                    value = func(value)
 
128
                except ValueError:
 
129
                    warning('gconf key %s contains an invalid value: %s'
 
130
                            % gconf_key, value)
 
131
                else:
 
132
                    setattr(style, attr, value)
 
133
 
 
134
            lang.set_tag_style(tag_id, style)
 
135
 
 
136
    @staticmethod
 
137
    def apply_colordiff_colors(lang):
 
138
        """Set style colors for lang using the colordiff configuration file.
 
139
 
 
140
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
141
 
 
142
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
 
143
        """
 
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(DiffView.parse_colordiffrc(f))
 
155
                    f.close()
 
156
 
 
157
        if not colors:
 
158
            # ~/.colordiffrc does not exist
 
159
            return
 
160
 
 
161
        mapping = {
 
162
                # map GtkSourceView tags 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
                'Added@32@line': ['newtext'],
 
166
                'Removed@32@line': ['oldtext'],
 
167
                'Location': ['location', 'diffstuff'],
 
168
                'Diff@32@file': ['file', 'diffstuff'],
 
169
                'Special@32@case': ['specialcase', 'diffstuff'],
 
170
        }
 
171
 
 
172
        for tag in lang.get_tags():
 
173
            tag_id = tag.get_id()
 
174
            keys = mapping.get(tag_id, [])
 
175
            color = None
 
176
 
 
177
            for key in keys:
 
178
                color = colors.get(key, None)
 
179
                if color is not None:
 
180
                    break
 
181
 
 
182
            if color is None:
 
183
                continue
 
184
 
 
185
            style = gtksourceview.SourceTagStyle()
 
186
            try:
 
187
                style.foreground = gtk.gdk.color_parse(color)
 
188
            except ValueError:
 
189
                warning('not a valid color: %s' % color)
 
190
            else:
 
191
                lang.set_tag_style(tag_id, style)
 
192
 
 
193
    @staticmethod
 
194
    def parse_colordiffrc(fileobj):
 
195
        """Parse fileobj as a colordiff configuration file.
 
196
 
 
197
        :return: A dict with the key -> value pairs.
 
198
        """
 
199
        colors = {}
 
200
        for line in fileobj:
 
201
            if re.match(r'^\s*#', line):
 
202
                continue
 
203
            if '=' not in line:
 
204
                continue
 
205
            key, val = line.split('=', 1)
 
206
            colors[key.strip()] = val.strip()
 
207
        return colors
85
208
 
86
209
    def set_trees(self, rev_tree, parent_tree):
87
210
        self.rev_tree = rev_tree
92
215
#        self.parent_tree.lock_read()
93
216
#        self.rev_tree.lock_read()
94
217
#        try:
95
 
#            self.delta = iter_changes_to_status(
96
 
#               self.parent_tree, self.rev_tree)
 
218
#            self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
97
219
#            self.path_to_status = {}
98
220
#            self.path_to_diff = {}
99
221
#            source_inv = self.parent_tree.inventory
100
222
#            target_inv = self.rev_tree.inventory
101
223
#            for (file_id, real_path, change_type, display_path) in self.delta:
102
 
#                self.path_to_status[real_path] = u'=== %s %s' % (
103
 
#                    change_type, display_path)
 
224
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
104
225
#                if change_type in ('modified', 'renamed and modified'):
105
226
#                    source_ie = source_inv[file_id]
106
227
#                    target_ie = target_inv[file_id]
108
229
#                    source_ie.diff(internal_diff, *old path, *old_tree,
109
230
#                                   *new_path, target_ie, self.rev_tree,
110
231
#                                   sio)
111
 
#                    self.path_to_diff[real_path] =
 
232
#                    self.path_to_diff[real_path] = 
112
233
#
113
234
#        finally:
114
235
#            self.rev_tree.unlock()
115
236
#            self.parent_tree.unlock()
116
237
 
117
238
    def show_diff(self, specific_files):
118
 
        sections = []
119
 
        if specific_files is None:
120
 
            self.buffer.set_text(self._diffs[None])
121
 
        else:
122
 
            for specific_file in specific_files:
123
 
                sections.append(self._diffs[specific_file])
124
 
            self.buffer.set_text(''.join(sections))
125
 
 
126
 
 
127
 
class DiffView(DiffFileView):
128
 
    """This is the soft and chewy filling for a DiffWindow."""
129
 
 
130
 
    def __init__(self):
131
 
        super(DiffView, self).__init__()
132
 
        self.rev_tree = None
133
 
        self.parent_tree = None
134
 
 
135
 
    def show_diff(self, specific_files):
136
 
        """Show the diff for the specified files"""
137
239
        s = StringIO()
138
240
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
139
241
                        old_label='', new_label='',
158
260
        self.buffer.set_text(decoded.encode('UTF-8'))
159
261
 
160
262
 
161
 
class DiffWidget(Gtk.HPaned):
162
 
    """Diff widget
 
263
class DiffWindow(gtk.Window):
 
264
    """Diff window.
163
265
 
 
266
    This object represents and manages a single window containing the
 
267
    differences between two revisions on a branch.
164
268
    """
165
269
 
166
 
    SHOW_WIDGETS = True
167
 
 
168
270
    def __init__(self):
169
 
        super(DiffWidget, self).__init__()
 
271
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
 
272
        self.set_border_width(0)
 
273
        self.set_title("bzrk diff")
 
274
 
 
275
        # Use two thirds of the screen by default
 
276
        screen = self.get_screen()
 
277
        monitor = screen.get_monitor_geometry(0)
 
278
        width = int(monitor.width * 0.66)
 
279
        height = int(monitor.height * 0.66)
 
280
        self.set_default_size(width, height)
 
281
 
 
282
        self.construct()
 
283
 
 
284
    def construct(self):
 
285
        """Construct the window contents."""
 
286
        # The   window  consists  of   a  pane   containing:  the
 
287
        # hierarchical list  of files on  the left, and  the diff
 
288
        # for the currently selected file on the right.
 
289
        pane = gtk.HPaned()
 
290
        self.add(pane)
 
291
        pane.show()
170
292
 
171
293
        # The file hierarchy: a scrollable treeview
172
 
        scrollwin = Gtk.ScrolledWindow()
173
 
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
174
 
        scrollwin.set_shadow_type(Gtk.ShadowType.IN)
175
 
        self.pack1(scrollwin)
176
 
        if self.SHOW_WIDGETS:
177
 
            scrollwin.show()
 
294
        scrollwin = gtk.ScrolledWindow()
 
295
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
296
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
 
297
        pane.pack1(scrollwin)
 
298
        scrollwin.show()
178
299
 
179
 
        self.model = Gtk.TreeStore(str, str)
180
 
        self.treeview = Gtk.TreeView(model=self.model)
 
300
        self.model = gtk.TreeStore(str, str)
 
301
        self.treeview = gtk.TreeView(self.model)
181
302
        self.treeview.set_headers_visible(False)
182
303
        self.treeview.set_search_column(1)
183
304
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
305
        scrollwin.add(self.treeview)
185
 
        if self.SHOW_WIDGETS:
186
 
            self.treeview.show()
 
306
        self.treeview.show()
187
307
 
188
 
        cell = Gtk.CellRendererText()
 
308
        cell = gtk.CellRendererText()
189
309
        cell.set_property("width-chars", 20)
190
 
        column = Gtk.TreeViewColumn()
191
 
        column.pack_start(cell, True)
 
310
        column = gtk.TreeViewColumn()
 
311
        column.pack_start(cell, expand=True)
192
312
        column.add_attribute(cell, "text", 0)
193
313
        self.treeview.append_column(column)
194
314
 
195
 
    def set_diff_text(self, lines):
196
 
        """Set the current diff from a list of lines
197
 
 
198
 
        :param lines: The diff to show, in unified diff format
199
 
        """
200
315
        # The diffs of the  selected file: a scrollable source or
201
316
        # text view
202
 
 
203
 
    def set_diff_text_sections(self, sections):
204
 
        if getattr(self, 'diff_view', None) is None:
205
 
            self.diff_view = DiffFileView()
206
 
            self.pack2(self.diff_view)
207
 
        if self.SHOW_WIDGETS:
208
 
            self.diff_view.show()
209
 
        for oldname, newname, patch in sections:
210
 
            self.diff_view._diffs[newname] = str(patch)
211
 
            if newname is None:
212
 
                newname = ''
213
 
            self.model.append(None, [oldname, newname])
214
 
        self.diff_view.show_diff(None)
215
 
 
216
 
    def set_diff(self, rev_tree, parent_tree):
 
317
        self.diff_view = DiffView()
 
318
        pane.pack2(self.diff_view)
 
319
        self.diff_view.show()
 
320
 
 
321
    def set_diff(self, description, rev_tree, parent_tree):
217
322
        """Set the differences showed by this window.
218
323
 
219
324
        Compares the two trees and populates the window with the
220
325
        differences.
221
326
        """
222
 
        if getattr(self, 'diff_view', None) is None:
223
 
            self.diff_view = DiffView()
224
 
            self.pack2(self.diff_view)
225
 
        if self.SHOW_WIDGETS:
226
 
            self.diff_view.show()
227
327
        self.diff_view.set_trees(rev_tree, parent_tree)
228
328
        self.rev_tree = rev_tree
229
329
        self.parent_tree = parent_tree
231
331
        self.model.clear()
232
332
        delta = self.rev_tree.changes_from(self.parent_tree)
233
333
 
234
 
        self.model.append(None, ["Complete Diff", ""])
 
334
        self.model.append(None, [ "Complete Diff", "" ])
235
335
 
236
336
        if len(delta.added):
237
 
            titer = self.model.append(None, ["Added", None])
 
337
            titer = self.model.append(None, [ "Added", None ])
238
338
            for path, id, kind in delta.added:
239
 
                self.model.append(titer, [path, path])
 
339
                self.model.append(titer, [ path, path ])
240
340
 
241
341
        if len(delta.removed):
242
 
            titer = self.model.append(None, ["Removed", None])
 
342
            titer = self.model.append(None, [ "Removed", None ])
243
343
            for path, id, kind in delta.removed:
244
 
                self.model.append(titer, [path, path])
 
344
                self.model.append(titer, [ path, path ])
245
345
 
246
346
        if len(delta.renamed):
247
 
            titer = self.model.append(None, ["Renamed", None])
 
347
            titer = self.model.append(None, [ "Renamed", None ])
248
348
            for oldpath, newpath, id, kind, text_modified, meta_modified \
249
349
                    in delta.renamed:
250
 
                self.model.append(titer, [oldpath, newpath])
 
350
                self.model.append(titer, [ oldpath, newpath ])
251
351
 
252
352
        if len(delta.modified):
253
 
            titer = self.model.append(None, ["Modified", None])
 
353
            titer = self.model.append(None, [ "Modified", None ])
254
354
            for path, id, kind, text_modified, meta_modified in delta.modified:
255
 
                self.model.append(titer, [path, path])
 
355
                self.model.append(titer, [ path, path ])
256
356
 
257
357
        self.treeview.expand_all()
258
 
        self.diff_view.show_diff(None)
 
358
        self.set_title(description + " - bzrk diff")
259
359
 
260
360
    def set_file(self, file_path):
261
 
        """Select the current file to display"""
262
361
        tv_path = None
263
362
        for data in self.model:
264
363
            for child in data.iterchildren():
266
365
                    tv_path = child.path
267
366
                    break
268
367
        if tv_path is None:
269
 
            raise errors.NoSuchFile(file_path)
270
 
        self.treeview.set_cursor(tv_path, None, False)
 
368
            raise NoSuchFile(file_path)
 
369
        self.treeview.set_cursor(tv_path)
271
370
        self.treeview.scroll_to_cell(tv_path)
272
371
 
273
372
    def _treeview_cursor_cb(self, *args):
274
373
        """Callback for when the treeview cursor changes."""
275
374
        (path, col) = self.treeview.get_cursor()
276
 
        if path is None:
277
 
            return
278
 
        specific_files = [self.model[path][1]]
279
 
        if specific_files == [None]:
280
 
            return
281
 
        elif specific_files == [""]:
 
375
        specific_files = [ self.model[path][1] ]
 
376
        if specific_files == [ None ]:
 
377
            return
 
378
        elif specific_files == [ "" ]:
282
379
            specific_files = None
283
380
 
284
381
        self.diff_view.show_diff(specific_files)
285
382
 
286
 
    def _on_wraplines_toggled(self, widget=None, wrap=False):
287
 
        """Callback for when the wrap lines checkbutton is toggled"""
288
 
        if wrap or widget.get_active():
289
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
290
 
        else:
291
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
292
 
 
293
 
 
294
 
class DiffWindow(Window):
295
 
    """Diff window.
296
 
 
297
 
    This object represents and manages a single window containing the
298
 
    differences between two revisions on a branch.
299
 
    """
300
 
 
301
 
    SHOW_WIDGETS = True
302
 
 
303
 
    def __init__(self, parent=None, operations=None):
304
 
        super(DiffWindow, self).__init__(parent=parent)
305
 
        self.set_border_width(0)
306
 
        self.set_title("bzr diff")
307
 
 
308
 
        # Use two thirds of the screen by default
309
 
        screen = self.get_screen()
310
 
        monitor = screen.get_monitor_geometry(0)
311
 
        width = int(monitor.width * 0.66)
312
 
        height = int(monitor.height * 0.66)
313
 
        self.set_default_size(width, height)
314
 
        self.construct(operations)
315
 
 
316
 
    def construct(self, operations):
317
 
        """Construct the window contents."""
318
 
        self.vbox = Gtk.VBox()
319
 
        self.add(self.vbox)
320
 
        if self.SHOW_WIDGETS:
321
 
            self.vbox.show()
322
 
        self.diff = DiffWidget()
323
 
        self.vbox.pack_end(self.diff, True, True, 0)
324
 
        if self.SHOW_WIDGETS:
325
 
            self.diff.show_all()
326
 
        # Build after DiffWidget to connect signals
327
 
        menubar = self._get_menu_bar()
328
 
        self.vbox.pack_start(menubar, False, False, 0)
329
 
        hbox = self._get_button_bar(operations)
330
 
        if hbox is not None:
331
 
            self.vbox.pack_start(hbox, False, True, 0)
332
 
 
333
 
    def _get_menu_bar(self):
334
 
        menubar = Gtk.MenuBar()
335
 
        # View menu
336
 
        mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
337
 
        mb_view_menu = Gtk.Menu()
338
 
        mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
339
 
            _i18n("Wrap _Long Lines"))
340
 
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
341
 
        mb_view_menu.append(mb_view_wrapsource)
342
 
        mb_view.set_submenu(mb_view_menu)
343
 
        menubar.append(mb_view)
344
 
        if self.SHOW_WIDGETS:
345
 
            menubar.show_all()
346
 
        return menubar
347
 
 
348
 
    def _get_button_bar(self, operations):
349
 
        """Return a button bar to use.
350
 
 
351
 
        :return: None, meaning that no button bar will be used.
352
 
        """
353
 
        if operations is None:
354
 
            return None
355
 
        hbox = Gtk.HButtonBox()
356
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
357
 
        for title, method in operations:
358
 
            merge_button = Gtk.Button(title)
359
 
            if self.SHOW_WIDGETS:
360
 
                merge_button.show()
361
 
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
362
 
            merge_button.connect("clicked", method)
363
 
            hbox.pack_start(merge_button, False, True, 0)
364
 
        if self.SHOW_WIDGETS:
365
 
            hbox.show()
366
 
        return hbox
367
 
 
368
 
    def _get_merge_target(self):
369
 
        d = Gtk.FileChooserDialog('Merge branch', self,
370
 
                                  Gtk.FileChooserAction.SELECT_FOLDER,
371
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
372
 
                                           Gtk.STOCK_CANCEL,
373
 
                                           Gtk.ResponseType.CANCEL,))
374
 
        try:
375
 
            result = d.run()
376
 
            if result != Gtk.ResponseType.OK:
377
 
                raise SelectCancelled()
378
 
            return d.get_current_folder_uri()
379
 
        finally:
380
 
            d.destroy()
381
 
 
382
 
    def _merge_successful(self):
383
 
        # No conflicts found.
384
 
        info_dialog(_i18n('Merge successful'),
385
 
                    _i18n('All changes applied successfully.'))
386
 
 
387
 
    def _conflicts(self):
388
 
        warning_dialog(_i18n('Conflicts encountered'),
389
 
                       _i18n('Please resolve the conflicts manually'
390
 
                             ' before committing.'))
391
 
 
392
 
    def _handle_error(self, e):
393
 
        error_dialog('Error', str(e))
394
 
 
395
 
    def _get_save_path(self, basename):
396
 
        d = Gtk.FileChooserDialog('Save As', self,
397
 
                                  Gtk.FileChooserAction.SAVE,
398
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
399
 
                                           Gtk.STOCK_CANCEL,
400
 
                                           Gtk.ResponseType.CANCEL,))
401
 
        d.set_current_name(basename)
402
 
        try:
403
 
            result = d.run()
404
 
            if result != Gtk.ResponseType.OK:
405
 
                raise SelectCancelled()
406
 
            return urlutils.local_path_from_url(d.get_uri())
407
 
        finally:
408
 
            d.destroy()
409
 
 
410
 
    def set_diff(self, description, rev_tree, parent_tree):
411
 
        """Set the differences showed by this window.
412
 
 
413
 
        Compares the two trees and populates the window with the
414
 
        differences.
415
 
        """
416
 
        self.diff.set_diff(rev_tree, parent_tree)
417
 
        self.set_title(description + " - bzrk diff")
418
 
 
419
 
    def set_file(self, file_path):
420
 
        self.diff.set_file(file_path)
421
 
 
422
 
 
423
 
class DiffController(object):
424
 
 
425
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
426
 
        self.path = path
427
 
        self.patch = patch
428
 
        self.allow_dirty = allow_dirty
429
 
        if window is None:
430
 
            window = DiffWindow(operations=self._provide_operations())
431
 
            self.initialize_window(window)
432
 
        self.window = window
433
 
 
434
 
    def initialize_window(self, window):
435
 
        window.diff.set_diff_text_sections(self.get_diff_sections())
436
 
        window.set_title(self.path + " - diff")
437
 
 
438
 
    def get_diff_sections(self):
439
 
        yield "Complete Diff", None, ''.join(self.patch)
440
 
        # allow_dirty was added to parse_patches in bzrlib 2.2b1
441
 
        if 'allow_dirty' in inspect.getargspec(parse_patches).args:
442
 
            patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
443
 
        else:
444
 
            patches = parse_patches(self.patch)
445
 
        for patch in patches:
446
 
            oldname = patch.oldname.split('\t')[0]
447
 
            newname = patch.newname.split('\t')[0]
448
 
            yield oldname, newname, str(patch)
449
 
 
450
 
    def perform_save(self, window):
451
 
        try:
452
 
            save_path = self.window._get_save_path(osutils.basename(self.path))
453
 
        except SelectCancelled:
454
 
            return
455
 
        source = open(self.path, 'rb')
456
 
        try:
457
 
            target = open(save_path, 'wb')
458
 
            try:
459
 
                osutils.pumpfile(source, target)
460
 
            finally:
461
 
                target.close()
462
 
        finally:
463
 
            source.close()
464
 
 
465
 
    def _provide_operations(self):
466
 
        return [('Save', self.perform_save)]
467
 
 
468
 
 
469
 
class MergeDirectiveController(DiffController):
470
 
 
471
 
    def __init__(self, path, directive, window=None):
472
 
        super(MergeDirectiveController, self).__init__(
473
 
            path, directive.patch.splitlines(True), window)
474
 
        self.directive = directive
475
 
        self.merge_target = None
476
 
 
477
 
    def _provide_operations(self):
478
 
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
479
 
 
480
 
    def perform_merge(self, window):
481
 
        if self.merge_target is None:
482
 
            try:
483
 
                self.merge_target = self.window._get_merge_target()
484
 
            except SelectCancelled:
485
 
                return
486
 
        tree = workingtree.WorkingTree.open(self.merge_target)
487
 
        tree.lock_write()
488
 
        try:
489
 
            try:
490
 
                if tree.has_changes():
491
 
                    raise errors.UncommittedChanges(tree)
492
 
                merger, verified = _mod_merge.Merger.from_mergeable(
493
 
                    tree, self.directive, pb=None)
494
 
                merger.merge_type = _mod_merge.Merge3Merger
495
 
                conflict_count = merger.do_merge()
496
 
                merger.set_pending()
497
 
                if conflict_count == 0:
498
 
                    self.window._merge_successful()
499
 
                else:
500
 
                    self.window._conflicts()
501
 
                    # There are conflicts to be resolved.
502
 
                self.window.destroy()
503
 
            except Exception, e:
504
 
                self.window._handle_error(e)
505
 
        finally:
506
 
            tree.unlock()
507
 
 
508
 
 
509
 
def iter_changes_to_status(source, target):
 
383
 
 
384
def _iter_changes_to_status(source, target):
510
385
    """Determine the differences between trees.
511
386
 
512
 
    This is a wrapper around iter_changes which just yields more
 
387
    This is a wrapper around _iter_changes which just yields more
513
388
    understandable results.
514
389
 
515
390
    :param source: The source tree (basis tree)
522
397
    renamed_and_modified = 'renamed and modified'
523
398
    modified = 'modified'
524
399
    kind_changed = 'kind changed'
525
 
    missing = 'missing'
526
400
 
527
401
    # TODO: Handle metadata changes
528
402
 
532
406
        source.lock_read()
533
407
        try:
534
408
            for (file_id, paths, changed_content, versioned, parent_ids, names,
535
 
                 kinds, executables) in target.iter_changes(source):
 
409
                 kinds, executables) in target._iter_changes(source):
536
410
 
537
411
                # Skip the root entry if it isn't very interesting
538
412
                if parent_ids == (None, None):
543
417
                    source_marker = ''
544
418
                else:
545
419
                    source_marker = osutils.kind_marker(kinds[0])
546
 
 
547
420
                if kinds[1] is None:
548
 
                    if kinds[0] is None:
549
 
                        # We assume bzr will flag only files in that case,
550
 
                        # there may be a bzr bug there as only files seems to
551
 
                        # not receive any kind.
552
 
                        marker = osutils.kind_marker('file')
553
 
                    else:
554
 
                        marker = osutils.kind_marker(kinds[0])
 
421
                    assert kinds[0] is not None
 
422
                    marker = osutils.kind_marker(kinds[0])
555
423
                else:
556
424
                    marker = osutils.kind_marker(kinds[1])
557
425
 
559
427
                if real_path is None:
560
428
                    real_path = paths[0]
561
429
                assert real_path is not None
 
430
                display_path = real_path + marker
562
431
 
563
432
                present_source = versioned[0] and kinds[0] is not None
564
433
                present_target = versioned[1] and kinds[1] is not None
565
434
 
566
 
                if kinds[0] is None and kinds[1] is None:
567
 
                    change_type = missing
568
 
                    display_path = real_path + marker
569
 
                elif present_source != present_target:
 
435
                if present_source != present_target:
570
436
                    if present_target:
571
437
                        change_type = added
572
438
                    else:
573
439
                        assert present_source
574
440
                        change_type = removed
575
 
                    display_path = real_path + marker
576
441
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
577
442
                    # Renamed
578
443
                    if changed_content or executables[0] != executables[1]:
586
451
                    change_type = kind_changed
587
452
                    display_path = (paths[0] + source_marker
588
453
                                    + ' => ' + paths[1] + marker)
589
 
                elif changed_content or executables[0] != executables[1]:
 
454
                elif changed_content is True or executables[0] != executables[1]:
590
455
                    change_type = modified
591
 
                    display_path = real_path + marker
592
456
                else:
593
457
                    assert False, "How did we get here?"
594
458