/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
 
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
 
27
try:
 
28
    import gconf
 
29
    have_gconf = True
 
30
except ImportError:
 
31
    have_gconf = False
23
32
 
24
33
from bzrlib import (
25
 
    errors,
26
34
    merge as _mod_merge,
27
35
    osutils,
 
36
    progress,
28
37
    urlutils,
29
38
    workingtree,
30
 
    )
31
 
from bzrlib.diff import show_diff_trees
 
39
)
 
40
from bzrlib.diff import show_diff_trees, internal_diff
 
41
from bzrlib.errors import NoSuchFile
32
42
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
 
43
from bzrlib.trace import warning
 
44
from bzrlib.plugins.gtk import _i18n
39
45
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
 
46
from dialog import error_dialog, info_dialog, warning_dialog
48
47
 
49
48
 
50
49
class SelectCancelled(Exception):
52
51
    pass
53
52
 
54
53
 
55
 
class DiffFileView(Gtk.ScrolledWindow):
 
54
class DiffFileView(gtk.ScrolledWindow):
56
55
    """Window for displaying diffs from a diff file"""
57
56
 
58
 
    SHOW_WIDGETS = True
59
 
 
60
57
    def __init__(self):
61
 
        super(DiffFileView, self).__init__()
 
58
        gtk.ScrolledWindow.__init__(self)
62
59
        self.construct()
63
60
        self._diffs = {}
64
61
 
65
62
    def construct(self):
66
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
 
        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)
68
65
 
69
66
        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)
 
67
            self.buffer = gtksourceview.SourceBuffer()
 
68
            slm = gtksourceview.SourceLanguagesManager()
 
69
            gsl = slm.get_language_from_mime_type("text/x-patch")
 
70
            if have_gconf:
 
71
                self.apply_gedit_colors(gsl)
 
72
            self.apply_colordiff_colors(gsl)
 
73
            self.buffer.set_language(gsl)
 
74
            self.buffer.set_highlight(True)
 
75
 
 
76
            sourceview = gtksourceview.SourceView(self.buffer)
76
77
        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()
 
78
            self.buffer = gtk.TextBuffer()
 
79
            sourceview = gtk.TextView(self.buffer)
 
80
 
 
81
        sourceview.set_editable(False)
 
82
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(sourceview)
 
84
        sourceview.show()
 
85
 
 
86
    @staticmethod
 
87
    def apply_gedit_colors(lang):
 
88
        """Set style for lang to that specified in gedit configuration.
 
89
 
 
90
        This method needs the gconf module.
 
91
 
 
92
        :param lang: a gtksourceview.SourceLanguage object.
 
93
        """
 
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)
 
148
 
 
149
    @classmethod
 
150
    def apply_colordiff_colors(klass, lang):
 
151
        """Set style colors for lang using the colordiff configuration file.
 
152
 
 
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
154
 
 
155
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
 
156
        """
 
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
 
176
                # since GSV is richer, accept new names for extra bits,
 
177
                # defaulting to old names if they're not present
 
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)
 
205
 
 
206
    @staticmethod
 
207
    def parse_colordiffrc(fileobj):
 
208
        """Parse fileobj as a colordiff configuration file.
 
209
 
 
210
        :return: A dict with the key -> value pairs.
 
211
        """
 
212
        colors = {}
 
213
        for line in fileobj:
 
214
            if re.match(r'^\s*#', line):
 
215
                continue
 
216
            if '=' not in line:
 
217
                continue
 
218
            key, val = line.split('=', 1)
 
219
            colors[key.strip()] = val.strip()
 
220
        return colors
85
221
 
86
222
    def set_trees(self, rev_tree, parent_tree):
87
223
        self.rev_tree = rev_tree
92
228
#        self.parent_tree.lock_read()
93
229
#        self.rev_tree.lock_read()
94
230
#        try:
95
 
#            self.delta = iter_changes_to_status(
96
 
#               self.parent_tree, self.rev_tree)
 
231
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
97
232
#            self.path_to_status = {}
98
233
#            self.path_to_diff = {}
99
234
#            source_inv = self.parent_tree.inventory
100
235
#            target_inv = self.rev_tree.inventory
101
236
#            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)
 
237
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
104
238
#                if change_type in ('modified', 'renamed and modified'):
105
239
#                    source_ie = source_inv[file_id]
106
240
#                    target_ie = target_inv[file_id]
108
242
#                    source_ie.diff(internal_diff, *old path, *old_tree,
109
243
#                                   *new_path, target_ie, self.rev_tree,
110
244
#                                   sio)
111
 
#                    self.path_to_diff[real_path] =
 
245
#                    self.path_to_diff[real_path] = 
112
246
#
113
247
#        finally:
114
248
#            self.rev_tree.unlock()
128
262
    """This is the soft and chewy filling for a DiffWindow."""
129
263
 
130
264
    def __init__(self):
131
 
        super(DiffView, self).__init__()
 
265
        DiffFileView.__init__(self)
132
266
        self.rev_tree = None
133
267
        self.parent_tree = None
134
268
 
158
292
        self.buffer.set_text(decoded.encode('UTF-8'))
159
293
 
160
294
 
161
 
class DiffWidget(Gtk.HPaned):
 
295
class DiffWidget(gtk.HPaned):
162
296
    """Diff widget
163
297
 
164
298
    """
165
 
 
166
 
    SHOW_WIDGETS = True
167
 
 
168
299
    def __init__(self):
169
300
        super(DiffWidget, self).__init__()
170
301
 
171
302
        # 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)
 
303
        scrollwin = gtk.ScrolledWindow()
 
304
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
175
306
        self.pack1(scrollwin)
176
 
        if self.SHOW_WIDGETS:
177
 
            scrollwin.show()
 
307
        scrollwin.show()
178
308
 
179
 
        self.model = Gtk.TreeStore(str, str)
180
 
        self.treeview = Gtk.TreeView(model=self.model)
 
309
        self.model = gtk.TreeStore(str, str)
 
310
        self.treeview = gtk.TreeView(self.model)
181
311
        self.treeview.set_headers_visible(False)
182
312
        self.treeview.set_search_column(1)
183
313
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
314
        scrollwin.add(self.treeview)
185
 
        if self.SHOW_WIDGETS:
186
 
            self.treeview.show()
 
315
        self.treeview.show()
187
316
 
188
 
        cell = Gtk.CellRendererText()
 
317
        cell = gtk.CellRendererText()
189
318
        cell.set_property("width-chars", 20)
190
 
        column = Gtk.TreeViewColumn()
191
 
        column.pack_start(cell, True)
 
319
        column = gtk.TreeViewColumn()
 
320
        column.pack_start(cell, expand=True)
192
321
        column.add_attribute(cell, "text", 0)
193
322
        self.treeview.append_column(column)
194
323
 
199
328
        """
200
329
        # The diffs of the  selected file: a scrollable source or
201
330
        # 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:
 
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])
210
340
            self.diff_view._diffs[newname] = str(patch)
211
 
            if newname is None:
212
 
                newname = ''
213
 
            self.model.append(None, [oldname, newname])
214
341
        self.diff_view.show_diff(None)
215
342
 
216
343
    def set_diff(self, rev_tree, parent_tree):
219
346
        Compares the two trees and populates the window with the
220
347
        differences.
221
348
        """
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()
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
 
351
        self.diff_view.show()
227
352
        self.diff_view.set_trees(rev_tree, parent_tree)
228
353
        self.rev_tree = rev_tree
229
354
        self.parent_tree = parent_tree
231
356
        self.model.clear()
232
357
        delta = self.rev_tree.changes_from(self.parent_tree)
233
358
 
234
 
        self.model.append(None, ["Complete Diff", ""])
 
359
        self.model.append(None, [ "Complete Diff", "" ])
235
360
 
236
361
        if len(delta.added):
237
 
            titer = self.model.append(None, ["Added", None])
 
362
            titer = self.model.append(None, [ "Added", None ])
238
363
            for path, id, kind in delta.added:
239
 
                self.model.append(titer, [path, path])
 
364
                self.model.append(titer, [ path, path ])
240
365
 
241
366
        if len(delta.removed):
242
 
            titer = self.model.append(None, ["Removed", None])
 
367
            titer = self.model.append(None, [ "Removed", None ])
243
368
            for path, id, kind in delta.removed:
244
 
                self.model.append(titer, [path, path])
 
369
                self.model.append(titer, [ path, path ])
245
370
 
246
371
        if len(delta.renamed):
247
 
            titer = self.model.append(None, ["Renamed", None])
 
372
            titer = self.model.append(None, [ "Renamed", None ])
248
373
            for oldpath, newpath, id, kind, text_modified, meta_modified \
249
374
                    in delta.renamed:
250
 
                self.model.append(titer, [oldpath, newpath])
 
375
                self.model.append(titer, [ oldpath, newpath ])
251
376
 
252
377
        if len(delta.modified):
253
 
            titer = self.model.append(None, ["Modified", None])
 
378
            titer = self.model.append(None, [ "Modified", None ])
254
379
            for path, id, kind, text_modified, meta_modified in delta.modified:
255
 
                self.model.append(titer, [path, path])
 
380
                self.model.append(titer, [ path, path ])
256
381
 
257
382
        self.treeview.expand_all()
258
 
        self.diff_view.show_diff(None)
259
383
 
260
384
    def set_file(self, file_path):
261
385
        """Select the current file to display"""
266
390
                    tv_path = child.path
267
391
                    break
268
392
        if tv_path is None:
269
 
            raise errors.NoSuchFile(file_path)
270
 
        self.treeview.set_cursor(tv_path, None, False)
 
393
            raise NoSuchFile(file_path)
 
394
        self.treeview.set_cursor(tv_path)
271
395
        self.treeview.scroll_to_cell(tv_path)
272
396
 
273
397
    def _treeview_cursor_cb(self, *args):
274
398
        """Callback for when the treeview cursor changes."""
275
399
        (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 == [""]:
 
400
        specific_files = [ self.model[path][1] ]
 
401
        if specific_files == [ None ]:
 
402
            return
 
403
        elif specific_files == [ "" ]:
282
404
            specific_files = None
283
405
 
284
406
        self.diff_view.show_diff(specific_files)
285
407
 
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
408
 
294
409
class DiffWindow(Window):
295
410
    """Diff window.
298
413
    differences between two revisions on a branch.
299
414
    """
300
415
 
301
 
    SHOW_WIDGETS = True
302
 
 
303
 
    def __init__(self, parent=None, operations=None):
304
 
        super(DiffWindow, self).__init__(parent=parent)
 
416
    def __init__(self, parent=None):
 
417
        Window.__init__(self, parent)
305
418
        self.set_border_width(0)
306
 
        self.set_title("bzr diff")
 
419
        self.set_title("bzrk diff")
307
420
 
308
421
        # Use two thirds of the screen by default
309
422
        screen = self.get_screen()
311
424
        width = int(monitor.width * 0.66)
312
425
        height = int(monitor.height * 0.66)
313
426
        self.set_default_size(width, height)
314
 
        self.construct(operations)
315
 
 
316
 
    def construct(self, operations):
 
427
 
 
428
        self.construct()
 
429
 
 
430
    def construct(self):
317
431
        """Construct the window contents."""
318
 
        self.vbox = Gtk.VBox()
 
432
        self.vbox = gtk.VBox()
319
433
        self.add(self.vbox)
320
 
        if self.SHOW_WIDGETS:
321
 
            self.vbox.show()
 
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)
322
438
        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):
 
439
        self.vbox.add(self.diff)
 
440
        self.diff.show_all()
 
441
 
 
442
    def _get_button_bar(self):
349
443
        """Return a button bar to use.
350
444
 
351
445
        :return: None, meaning that no button bar will be used.
352
446
        """
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()
 
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")
409
457
 
410
458
    def set_diff(self, description, rev_tree, parent_tree):
411
459
        """Set the differences showed by this window.
420
468
        self.diff.set_file(file_path)
421
469
 
422
470
 
423
 
class DiffController(object):
 
471
class MergeDirectiveWindow(DiffWindow):
424
472
 
425
 
    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
426
477
        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)]
 
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
479
497
 
480
498
    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)
 
499
        try:
 
500
            tree = self._get_merge_target()
 
501
        except SelectCancelled:
 
502
            return
487
503
        tree.lock_write()
488
504
        try:
489
505
            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)
 
506
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
507
                    self.directive, progress.DummyProgress())
 
508
                merger.check_basis(True)
494
509
                merger.merge_type = _mod_merge.Merge3Merger
495
510
                conflict_count = merger.do_merge()
496
511
                merger.set_pending()
497
512
                if conflict_count == 0:
498
 
                    self.window._merge_successful()
 
513
                    # No conflicts found.
 
514
                    info_dialog(_i18n('Merge successful'),
 
515
                                _i18n('All changes applied successfully.'))
499
516
                else:
500
 
                    self.window._conflicts()
501
517
                    # There are conflicts to be resolved.
502
 
                self.window.destroy()
 
518
                    warning_dialog(_i18n('Conflicts encountered'),
 
519
                                   _i18n('Please resolve the conflicts manually'
 
520
                                         ' before committing.'))
 
521
                self.destroy()
503
522
            except Exception, e:
504
 
                self.window._handle_error(e)
 
523
                error_dialog('Error', str(e))
505
524
        finally:
506
525
            tree.unlock()
507
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
 
508
571
 
509
572
def iter_changes_to_status(source, target):
510
573
    """Determine the differences between trees.
522
585
    renamed_and_modified = 'renamed and modified'
523
586
    modified = 'modified'
524
587
    kind_changed = 'kind changed'
525
 
    missing = 'missing'
526
588
 
527
589
    # TODO: Handle metadata changes
528
590
 
543
605
                    source_marker = ''
544
606
                else:
545
607
                    source_marker = osutils.kind_marker(kinds[0])
546
 
 
547
608
                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])
 
609
                    assert kinds[0] is not None
 
610
                    marker = osutils.kind_marker(kinds[0])
555
611
                else:
556
612
                    marker = osutils.kind_marker(kinds[1])
557
613
 
559
615
                if real_path is None:
560
616
                    real_path = paths[0]
561
617
                assert real_path is not None
 
618
                display_path = real_path + marker
562
619
 
563
620
                present_source = versioned[0] and kinds[0] is not None
564
621
                present_target = versioned[1] and kinds[1] is not None
565
622
 
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:
 
623
                if present_source != present_target:
570
624
                    if present_target:
571
625
                        change_type = added
572
626
                    else:
573
627
                        assert present_source
574
628
                        change_type = removed
575
 
                    display_path = real_path + marker
576
629
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
577
630
                    # Renamed
578
631
                    if changed_content or executables[0] != executables[1]:
586
639
                    change_type = kind_changed
587
640
                    display_path = (paths[0] + source_marker
588
641
                                    + ' => ' + paths[1] + marker)
589
 
                elif changed_content or executables[0] != executables[1]:
 
642
                elif changed_content is True or executables[0] != executables[1]:
590
643
                    change_type = modified
591
 
                    display_path = real_path + marker
592
644
                else:
593
645
                    assert False, "How did we get here?"
594
646