/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: Vincent Ladeuil
  • Date: 2008-05-05 18:16:46 UTC
  • mto: (487.1.1 gtk)
  • mto: This revision was merged to the branch mainline in revision 490.
  • Revision ID: v.ladeuil+lp@free.fr-20080505181646-n95l8ltw2u6jtr26
Fix bug #187283 fix replacing _() by _i18n().

* genpot.sh 
Remove duplication. Add the ability to specify the genrated pot
file on command-line for debugging purposes.

* po/olive-gtk.pot:
Regenerated.

* __init__.py, branch.py, branchview/treeview.py, checkout.py,
commit.py, conflicts.py, diff.py, errors.py, initialize.py,
merge.py, nautilus-bzr.py, olive/__init__.py, olive/add.py,
olive/bookmark.py, olive/guifiles.py, olive/info.py,
olive/menu.py, olive/mkdir.py, olive/move.py, olive/remove.py,
olive/rename.py, push.py, revbrowser.py, status.py, tags.py:
Replace all calls to _() by calls to _i18n(), the latter being
defined in __init__.py and imported in the other modules from
there. This fix the problem encountered countless times when
running bzr selftest and getting silly error messages about
boolean not being callables.

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
33
from bzrlib import (
45
 
    errors,
46
34
    merge as _mod_merge,
47
35
    osutils,
 
36
    progress,
48
37
    urlutils,
49
38
    workingtree,
50
 
    )
51
 
from bzrlib.diff import show_diff_trees
 
39
)
 
40
from bzrlib.diff import show_diff_trees, internal_diff
 
41
from bzrlib.errors import NoSuchFile
52
42
from bzrlib.patches import parse_patches
53
43
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
 
44
from bzrlib.plugins.gtk import _i18n
60
45
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
 
46
from dialog import error_dialog, info_dialog, warning_dialog
69
47
 
70
48
 
71
49
class SelectCancelled(Exception):
73
51
    pass
74
52
 
75
53
 
76
 
class DiffFileView(Gtk.ScrolledWindow):
 
54
class DiffFileView(gtk.ScrolledWindow):
77
55
    """Window for displaying diffs from a diff file"""
78
56
 
79
57
    def __init__(self):
80
 
        super(DiffFileView, self).__init__()
 
58
        gtk.ScrolledWindow.__init__(self)
81
59
        self.construct()
82
60
        self._diffs = {}
83
61
 
84
62
    def construct(self):
85
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
86
 
        self.set_shadow_type(Gtk.ShadowType.IN)
 
63
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
64
        self.set_shadow_type(gtk.SHADOW_IN)
87
65
 
88
66
        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")
 
67
            self.buffer = gtksourceview.SourceBuffer()
 
68
            slm = gtksourceview.SourceLanguagesManager()
 
69
            gsl = slm.get_language_from_mime_type("text/x-patch")
92
70
            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)
 
71
                self.apply_gedit_colors(gsl)
 
72
            self.apply_colordiff_colors(gsl)
 
73
            self.buffer.set_language(gsl)
 
74
            self.buffer.set_highlight(True)
97
75
 
98
 
            self.sourceview = GtkSource.View(buffer=self.buffer)
 
76
            sourceview = gtksourceview.SourceView(self.buffer)
99
77
        else:
100
 
            self.buffer = Gtk.TextBuffer()
101
 
            self.sourceview = Gtk.TextView(self.buffer)
 
78
            self.buffer = gtk.TextBuffer()
 
79
            sourceview = gtk.TextView(self.buffer)
102
80
 
103
 
        self.sourceview.set_editable(False)
104
 
        self.sourceview.modify_font(Pango.FontDescription("Monospace"))
105
 
        self.add(self.sourceview)
106
 
        self.sourceview.show()
 
81
        sourceview.set_editable(False)
 
82
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(sourceview)
 
84
        sourceview.show()
107
85
 
108
86
    @staticmethod
109
 
    def apply_gedit_colors(buf):
110
 
        """Set style to that specified in gedit configuration.
 
87
    def apply_gedit_colors(lang):
 
88
        """Set style for lang to that specified in gedit configuration.
111
89
 
112
90
        This method needs the gconf module.
113
91
 
114
 
        :param buf: a GtkSource.Buffer object.
 
92
        :param lang: a gtksourceview.SourceLanguage object.
115
93
        """
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)
 
94
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
 
95
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
 
96
 
 
97
        client = gconf.client_get_default()
 
98
        client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
 
99
 
 
100
        for tag in lang.get_tags():
 
101
            tag_id = tag.get_id()
 
102
            gconf_key = GEDIT_LANG_PATH + '/' + tag_id
 
103
            style_string = client.get_string(gconf_key)
 
104
 
 
105
            if style_string is None:
 
106
                continue
 
107
 
 
108
            # function to get a bool from a string that's either '0' or '1'
 
109
            string_bool = lambda x: bool(int(x))
 
110
 
 
111
            # style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
 
112
            # values are: mask, fg, bg, italic, bold, underline, strike
 
113
            # this packs them into (str_value, attr_name, conv_func) tuples
 
114
            items = zip(style_string.split('/'), ['mask', 'foreground',
 
115
                'background', 'italic', 'bold', 'underline', 'strikethrough' ],
 
116
                [ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
 
117
                    string_bool, string_bool, string_bool ]
 
118
            )
 
119
 
 
120
            style = gtksourceview.SourceTagStyle()
 
121
 
 
122
            # XXX The mask attribute controls whether the present values of
 
123
            # foreground and background color should in fact be used. Ideally
 
124
            # (and that's what gedit does), one could set all three attributes,
 
125
            # and let the TagStyle object figure out which colors to use.
 
126
            # However, in the GtkSourceview python bindings, the mask attribute
 
127
            # is read-only, and it's derived instead from the colors being
 
128
            # set or not. This means that we have to sometimes refrain from
 
129
            # setting fg or bg colors, depending on the value of the mask.
 
130
            # This code could go away if mask were writable.
 
131
            mask = int(items[0][0])
 
132
            if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
 
133
                items[2:3] = []
 
134
            if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
 
135
                items[1:2] = []
 
136
            items[0:1] = [] # skip the mask unconditionally
 
137
 
 
138
            for value, attr, func in items:
 
139
                try:
 
140
                    value = func(value)
 
141
                except ValueError:
 
142
                    warning('gconf key %s contains an invalid value: %s'
 
143
                            % gconf_key, value)
 
144
                else:
 
145
                    setattr(style, attr, value)
 
146
 
 
147
            lang.set_tag_style(tag_id, style)
129
148
 
130
149
    @classmethod
131
 
    def apply_colordiff_colors(klass, buf):
 
150
    def apply_colordiff_colors(klass, lang):
132
151
        """Set style colors for lang using the colordiff configuration file.
133
152
 
134
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
135
154
 
136
 
        :param buf: a "Diff" GtkSource.Buffer object.
 
155
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
137
156
        """
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
 
157
        colors = {}
 
158
 
 
159
        for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
 
160
            f = os.path.expanduser(f)
 
161
            if os.path.exists(f):
 
162
                try:
 
163
                    f = file(f)
 
164
                except IOError, e:
 
165
                    warning('could not open file %s: %s' % (f, str(e)))
 
166
                else:
 
167
                    colors.update(klass.parse_colordiffrc(f))
 
168
                    f.close()
 
169
 
 
170
        if not colors:
 
171
            # ~/.colordiffrc does not exist
 
172
            return
 
173
 
 
174
        mapping = {
 
175
                # map GtkSourceView tags to colordiff names
163
176
                # since GSV is richer, accept new names for extra bits,
164
177
                # 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)
 
178
                'Added@32@line': ['newtext'],
 
179
                'Removed@32@line': ['oldtext'],
 
180
                'Location': ['location', 'diffstuff'],
 
181
                'Diff@32@file': ['file', 'diffstuff'],
 
182
                'Special@32@case': ['specialcase', 'diffstuff'],
 
183
        }
 
184
 
 
185
        for tag in lang.get_tags():
 
186
            tag_id = tag.get_id()
 
187
            keys = mapping.get(tag_id, [])
 
188
            color = None
 
189
 
 
190
            for key in keys:
 
191
                color = colors.get(key, None)
 
192
                if color is not None:
 
193
                    break
 
194
 
 
195
            if color is None:
 
196
                continue
 
197
 
 
198
            style = gtksourceview.SourceTagStyle()
 
199
            try:
 
200
                style.foreground = gtk.gdk.color_parse(color)
 
201
            except ValueError:
 
202
                warning('not a valid color: %s' % color)
 
203
            else:
 
204
                lang.set_tag_style(tag_id, style)
206
205
 
207
206
    @staticmethod
208
207
    def parse_colordiffrc(fileobj):
229
228
#        self.parent_tree.lock_read()
230
229
#        self.rev_tree.lock_read()
231
230
#        try:
232
 
#            self.delta = iter_changes_to_status(
233
 
#               self.parent_tree, self.rev_tree)
 
231
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
234
232
#            self.path_to_status = {}
235
233
#            self.path_to_diff = {}
236
234
#            source_inv = self.parent_tree.inventory
237
235
#            target_inv = self.rev_tree.inventory
238
236
#            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)
 
237
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
241
238
#                if change_type in ('modified', 'renamed and modified'):
242
239
#                    source_ie = source_inv[file_id]
243
240
#                    target_ie = target_inv[file_id]
245
242
#                    source_ie.diff(internal_diff, *old path, *old_tree,
246
243
#                                   *new_path, target_ie, self.rev_tree,
247
244
#                                   sio)
248
 
#                    self.path_to_diff[real_path] =
 
245
#                    self.path_to_diff[real_path] = 
249
246
#
250
247
#        finally:
251
248
#            self.rev_tree.unlock()
265
262
    """This is the soft and chewy filling for a DiffWindow."""
266
263
 
267
264
    def __init__(self):
268
 
        super(DiffView, self).__init__()
 
265
        DiffFileView.__init__(self)
269
266
        self.rev_tree = None
270
267
        self.parent_tree = None
271
268
 
295
292
        self.buffer.set_text(decoded.encode('UTF-8'))
296
293
 
297
294
 
298
 
class DiffWidget(Gtk.HPaned):
 
295
class DiffWidget(gtk.HPaned):
299
296
    """Diff widget
300
297
 
301
298
    """
302
 
 
303
 
    SHOW_WIDGETS = True
304
 
 
305
299
    def __init__(self):
306
300
        super(DiffWidget, self).__init__()
307
301
 
308
302
        # 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)
 
303
        scrollwin = gtk.ScrolledWindow()
 
304
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
312
306
        self.pack1(scrollwin)
313
 
        if self.SHOW_WIDGETS:
314
 
            scrollwin.show()
 
307
        scrollwin.show()
315
308
 
316
 
        self.model = Gtk.TreeStore(str, str)
317
 
        self.treeview = Gtk.TreeView(model=self.model)
 
309
        self.model = gtk.TreeStore(str, str)
 
310
        self.treeview = gtk.TreeView(self.model)
318
311
        self.treeview.set_headers_visible(False)
319
312
        self.treeview.set_search_column(1)
320
313
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
321
314
        scrollwin.add(self.treeview)
322
 
        if self.SHOW_WIDGETS:
323
 
            self.treeview.show()
 
315
        self.treeview.show()
324
316
 
325
 
        cell = Gtk.CellRendererText()
 
317
        cell = gtk.CellRendererText()
326
318
        cell.set_property("width-chars", 20)
327
 
        column = Gtk.TreeViewColumn()
328
 
        column.pack_start(cell, True)
 
319
        column = gtk.TreeViewColumn()
 
320
        column.pack_start(cell, expand=True)
329
321
        column.add_attribute(cell, "text", 0)
330
322
        self.treeview.append_column(column)
331
323
 
336
328
        """
337
329
        # The diffs of the  selected file: a scrollable source or
338
330
        # 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:
 
331
        self.diff_view = DiffFileView()
 
332
        self.diff_view.show()
 
333
        self.pack2(self.diff_view)
 
334
        self.model.append(None, [ "Complete Diff", "" ])
 
335
        self.diff_view._diffs[None] = ''.join(lines)
 
336
        for patch in parse_patches(lines):
 
337
            oldname = patch.oldname.split('\t')[0]
 
338
            newname = patch.newname.split('\t')[0]
 
339
            self.model.append(None, [oldname, newname])
347
340
            self.diff_view._diffs[newname] = str(patch)
348
 
            if newname is None:
349
 
                newname = ''
350
 
            self.model.append(None, [oldname, newname])
351
341
        self.diff_view.show_diff(None)
352
342
 
353
343
    def set_diff(self, rev_tree, parent_tree):
356
346
        Compares the two trees and populates the window with the
357
347
        differences.
358
348
        """
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()
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
 
351
        self.diff_view.show()
364
352
        self.diff_view.set_trees(rev_tree, parent_tree)
365
353
        self.rev_tree = rev_tree
366
354
        self.parent_tree = parent_tree
368
356
        self.model.clear()
369
357
        delta = self.rev_tree.changes_from(self.parent_tree)
370
358
 
371
 
        self.model.append(None, ["Complete Diff", ""])
 
359
        self.model.append(None, [ "Complete Diff", "" ])
372
360
 
373
361
        if len(delta.added):
374
 
            titer = self.model.append(None, ["Added", None])
 
362
            titer = self.model.append(None, [ "Added", None ])
375
363
            for path, id, kind in delta.added:
376
 
                self.model.append(titer, [path, path])
 
364
                self.model.append(titer, [ path, path ])
377
365
 
378
366
        if len(delta.removed):
379
 
            titer = self.model.append(None, ["Removed", None])
 
367
            titer = self.model.append(None, [ "Removed", None ])
380
368
            for path, id, kind in delta.removed:
381
 
                self.model.append(titer, [path, path])
 
369
                self.model.append(titer, [ path, path ])
382
370
 
383
371
        if len(delta.renamed):
384
 
            titer = self.model.append(None, ["Renamed", None])
 
372
            titer = self.model.append(None, [ "Renamed", None ])
385
373
            for oldpath, newpath, id, kind, text_modified, meta_modified \
386
374
                    in delta.renamed:
387
 
                self.model.append(titer, [oldpath, newpath])
 
375
                self.model.append(titer, [ oldpath, newpath ])
388
376
 
389
377
        if len(delta.modified):
390
 
            titer = self.model.append(None, ["Modified", None])
 
378
            titer = self.model.append(None, [ "Modified", None ])
391
379
            for path, id, kind, text_modified, meta_modified in delta.modified:
392
 
                self.model.append(titer, [path, path])
 
380
                self.model.append(titer, [ path, path ])
393
381
 
394
382
        self.treeview.expand_all()
395
 
        self.diff_view.show_diff(None)
396
383
 
397
384
    def set_file(self, file_path):
398
385
        """Select the current file to display"""
403
390
                    tv_path = child.path
404
391
                    break
405
392
        if tv_path is None:
406
 
            raise errors.NoSuchFile(file_path)
407
 
        self.treeview.set_cursor(tv_path, None, False)
 
393
            raise NoSuchFile(file_path)
 
394
        self.treeview.set_cursor(tv_path)
408
395
        self.treeview.scroll_to_cell(tv_path)
409
396
 
410
397
    def _treeview_cursor_cb(self, *args):
411
398
        """Callback for when the treeview cursor changes."""
412
399
        (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 == [""]:
 
400
        specific_files = [ self.model[path][1] ]
 
401
        if specific_files == [ None ]:
 
402
            return
 
403
        elif specific_files == [ "" ]:
419
404
            specific_files = None
420
405
 
421
406
        self.diff_view.show_diff(specific_files)
422
407
 
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
408
 
431
409
class DiffWindow(Window):
432
410
    """Diff window.
435
413
    differences between two revisions on a branch.
436
414
    """
437
415
 
438
 
    def __init__(self, parent=None, operations=None):
439
 
        super(DiffWindow, self).__init__(parent=parent)
 
416
    def __init__(self, parent=None):
 
417
        Window.__init__(self, parent)
440
418
        self.set_border_width(0)
441
419
        self.set_title("bzrk diff")
442
420
 
446
424
        width = int(monitor.width * 0.66)
447
425
        height = int(monitor.height * 0.66)
448
426
        self.set_default_size(width, height)
449
 
        self.construct(operations)
450
 
 
451
 
    def construct(self, operations):
 
427
 
 
428
        self.construct()
 
429
 
 
430
    def construct(self):
452
431
        """Construct the window contents."""
453
 
        self.vbox = Gtk.VBox()
 
432
        self.vbox = gtk.VBox()
454
433
        self.add(self.vbox)
455
434
        self.vbox.show()
 
435
        hbox = self._get_button_bar()
 
436
        if hbox is not None:
 
437
            self.vbox.pack_start(hbox, expand=False, fill=True)
456
438
        self.diff = DiffWidget()
457
 
        self.vbox.pack_end(self.diff, True, True, 0)
 
439
        self.vbox.add(self.diff)
458
440
        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):
 
441
 
 
442
    def _get_button_bar(self):
484
443
        """Return a button bar to use.
485
444
 
486
445
        :return: None, meaning that no button bar will be used.
487
446
        """
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()
 
447
        return None
 
448
 
 
449
    def set_diff_text(self, description, lines):
 
450
        """Set the diff from a text.
 
451
 
 
452
        The diff must be in unified diff format, and will be parsed to
 
453
        determine filenames.
 
454
        """
 
455
        self.diff.set_diff_text(lines)
 
456
        self.set_title(description + " - bzrk diff")
542
457
 
543
458
    def set_diff(self, description, rev_tree, parent_tree):
544
459
        """Set the differences showed by this window.
553
468
        self.diff.set_file(file_path)
554
469
 
555
470
 
556
 
class DiffController(object):
 
471
class MergeDirectiveWindow(DiffWindow):
557
472
 
558
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
473
    def __init__(self, directive, path):
 
474
        DiffWindow.__init__(self, None)
 
475
        self._merge_target = None
 
476
        self.directive = directive
559
477
        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)]
 
478
 
 
479
    def _get_button_bar(self):
 
480
        """The button bar has only the Merge button"""
 
481
        merge_button = gtk.Button('Merge')
 
482
        merge_button.show()
 
483
        merge_button.set_relief(gtk.RELIEF_NONE)
 
484
        merge_button.connect("clicked", self.perform_merge)
 
485
 
 
486
        save_button = gtk.Button('Save')
 
487
        save_button.show()
 
488
        save_button.set_relief(gtk.RELIEF_NONE)
 
489
        save_button.connect("clicked", self.perform_save)
 
490
 
 
491
        hbox = gtk.HButtonBox()
 
492
        hbox.set_layout(gtk.BUTTONBOX_START)
 
493
        hbox.pack_start(merge_button, expand=False, fill=True)
 
494
        hbox.pack_start(save_button, expand=False, fill=True)
 
495
        hbox.show()
 
496
        return hbox
612
497
 
613
498
    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)
 
499
        try:
 
500
            tree = self._get_merge_target()
 
501
        except SelectCancelled:
 
502
            return
620
503
        tree.lock_write()
621
504
        try:
622
505
            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)
 
506
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
507
                    self.directive, progress.DummyProgress())
 
508
                merger.check_basis(True)
627
509
                merger.merge_type = _mod_merge.Merge3Merger
628
510
                conflict_count = merger.do_merge()
629
511
                merger.set_pending()
630
512
                if conflict_count == 0:
631
 
                    self.window._merge_successful()
 
513
                    # No conflicts found.
 
514
                    info_dialog(_i18n('Merge successful'),
 
515
                                _i18n('All changes applied successfully.'))
632
516
                else:
633
 
                    self.window._conflicts()
634
517
                    # There are conflicts to be resolved.
635
 
                self.window.destroy()
 
518
                    warning_dialog(_i18n('Conflicts encountered'),
 
519
                                   _i18n('Please resolve the conflicts manually'
 
520
                                         ' before committing.'))
 
521
                self.destroy()
636
522
            except Exception, e:
637
 
                self.window._handle_error(e)
 
523
                error_dialog('Error', str(e))
638
524
        finally:
639
525
            tree.unlock()
640
526
 
 
527
    def _get_merge_target(self):
 
528
        if self._merge_target is not None:
 
529
            return self._merge_target
 
530
        d = gtk.FileChooserDialog('Merge branch', self,
 
531
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
532
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
533
                                           gtk.STOCK_CANCEL,
 
534
                                           gtk.RESPONSE_CANCEL,))
 
535
        try:
 
536
            result = d.run()
 
537
            if result != gtk.RESPONSE_OK:
 
538
                raise SelectCancelled()
 
539
            uri = d.get_current_folder_uri()
 
540
        finally:
 
541
            d.destroy()
 
542
        return workingtree.WorkingTree.open(uri)
 
543
 
 
544
    def perform_save(self, window):
 
545
        d = gtk.FileChooserDialog('Save As', self,
 
546
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
547
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
548
                                           gtk.STOCK_CANCEL,
 
549
                                           gtk.RESPONSE_CANCEL,))
 
550
        d.set_current_name(osutils.basename(self.path))
 
551
        try:
 
552
            try:
 
553
                result = d.run()
 
554
                if result != gtk.RESPONSE_OK:
 
555
                    raise SelectCancelled()
 
556
                uri = d.get_uri()
 
557
            finally:
 
558
                d.destroy()
 
559
        except SelectCancelled:
 
560
            return
 
561
        source = open(self.path, 'rb')
 
562
        try:
 
563
            target = open(urlutils.local_path_from_url(uri), 'wb')
 
564
            try:
 
565
                target.write(source.read())
 
566
            finally:
 
567
                target.close()
 
568
        finally:
 
569
            source.close()
 
570
 
641
571
 
642
572
def iter_changes_to_status(source, target):
643
573
    """Determine the differences between trees.
655
585
    renamed_and_modified = 'renamed and modified'
656
586
    modified = 'modified'
657
587
    kind_changed = 'kind changed'
658
 
    missing = 'missing'
659
588
 
660
589
    # TODO: Handle metadata changes
661
590
 
676
605
                    source_marker = ''
677
606
                else:
678
607
                    source_marker = osutils.kind_marker(kinds[0])
679
 
 
680
608
                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])
 
609
                    assert kinds[0] is not None
 
610
                    marker = osutils.kind_marker(kinds[0])
688
611
                else:
689
612
                    marker = osutils.kind_marker(kinds[1])
690
613
 
692
615
                if real_path is None:
693
616
                    real_path = paths[0]
694
617
                assert real_path is not None
 
618
                display_path = real_path + marker
695
619
 
696
620
                present_source = versioned[0] and kinds[0] is not None
697
621
                present_target = versioned[1] and kinds[1] is not None
698
622
 
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:
 
623
                if present_source != present_target:
703
624
                    if present_target:
704
625
                        change_type = added
705
626
                    else:
706
627
                        assert present_source
707
628
                        change_type = removed
708
 
                    display_path = real_path + marker
709
629
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
710
630
                    # Renamed
711
631
                    if changed_content or executables[0] != executables[1]:
719
639
                    change_type = kind_changed
720
640
                    display_path = (paths[0] + source_marker
721
641
                                    + ' => ' + paths[1] + marker)
722
 
                elif changed_content or executables[0] != executables[1]:
 
642
                elif changed_content is True or executables[0] != executables[1]:
723
643
                    change_type = modified
724
 
                    display_path = real_path + marker
725
644
                else:
726
645
                    assert False, "How did we get here?"
727
646