/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to diff.py

  • Committer: Jelmer Vernooij
  • Date: 2008-06-29 18:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629181229-1l2m4cf7vvbyh8qg
Simplify progress bar code, use embedded progress bar inside viz window.

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
__copyright__ = "Copyright © 2005 Canonical Ltd."
8
9
__author__    = "Scott James Remnant <scott@ubuntu.com>"
9
10
 
10
11
 
11
12
from cStringIO import StringIO
12
13
 
13
 
from gi.repository import Gtk
14
 
from gi.repository import Pango
 
14
import pygtk
 
15
pygtk.require("2.0")
 
16
import gtk
 
17
import pango
15
18
import os
16
19
import re
17
20
import sys
18
 
import inspect
19
 
try:
20
 
    from xml.etree.ElementTree import Element, SubElement, tostring
21
 
except ImportError:
22
 
    from elementtree.ElementTree import Element, SubElement, tostring
23
21
 
24
22
try:
25
 
    from gi.repository import GtkSource
 
23
    import gtksourceview
26
24
    have_gtksourceview = True
27
25
except ImportError:
28
26
    have_gtksourceview = False
29
27
try:
30
 
    from gi.repository import GConf
 
28
    import gconf
31
29
    have_gconf = True
32
30
except ImportError:
33
31
    have_gconf = False
34
32
 
35
33
from bzrlib import (
36
 
    errors,
37
34
    merge as _mod_merge,
38
35
    osutils,
 
36
    progress,
39
37
    urlutils,
40
38
    workingtree,
41
39
)
42
 
from bzrlib.diff import show_diff_trees
 
40
from bzrlib.diff import show_diff_trees, internal_diff
 
41
from bzrlib.errors import NoSuchFile
43
42
from bzrlib.patches import parse_patches
44
43
from bzrlib.trace import warning
45
 
from bzrlib.plugins.gtk.dialog import (
46
 
    error_dialog,
47
 
    info_dialog,
48
 
    warning_dialog,
49
 
    )
50
 
from bzrlib.plugins.gtk.i18n import _i18n
 
44
from bzrlib.plugins.gtk import _i18n
51
45
from bzrlib.plugins.gtk.window import Window
52
 
 
53
 
 
54
 
def fallback_guess_language(slm, content_type):
55
 
    for lang_id in slm.get_language_ids():
56
 
        lang = slm.get_language(lang_id)
57
 
        if "text/x-patch" in lang.get_mime_types():
58
 
            return lang
59
 
    return None
 
46
from dialog import error_dialog, info_dialog, warning_dialog
60
47
 
61
48
 
62
49
class SelectCancelled(Exception):
64
51
    pass
65
52
 
66
53
 
67
 
class DiffFileView(Gtk.ScrolledWindow):
 
54
class DiffFileView(gtk.ScrolledWindow):
68
55
    """Window for displaying diffs from a diff file"""
69
56
 
70
57
    def __init__(self):
71
 
        super(DiffFileView, self).__init__()
 
58
        gtk.ScrolledWindow.__init__(self)
72
59
        self.construct()
73
60
        self._diffs = {}
74
61
 
75
62
    def construct(self):
76
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
77
 
        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)
78
65
 
79
66
        if have_gtksourceview:
80
 
            self.buffer = GtkSource.Buffer()
81
 
            lang_manager = GtkSource.LanguageManager.get_default()
82
 
            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")
83
70
            if have_gconf:
84
 
                self.apply_gedit_colors(self.buffer)
85
 
            self.apply_colordiff_colors(self.buffer)
86
 
            self.buffer.set_language(language)
87
 
            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)
88
75
 
89
 
            self.sourceview = GtkSource.View(buffer=self.buffer)
 
76
            sourceview = gtksourceview.SourceView(self.buffer)
90
77
        else:
91
 
            self.buffer = Gtk.TextBuffer()
92
 
            self.sourceview = Gtk.TextView(self.buffer)
 
78
            self.buffer = gtk.TextBuffer()
 
79
            sourceview = gtk.TextView(self.buffer)
93
80
 
94
 
        self.sourceview.set_editable(False)
95
 
        self.sourceview.modify_font(Pango.FontDescription("Monospace"))
96
 
        self.add(self.sourceview)
97
 
        self.sourceview.show()
 
81
        sourceview.set_editable(False)
 
82
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(sourceview)
 
84
        sourceview.show()
98
85
 
99
86
    @staticmethod
100
 
    def apply_gedit_colors(buf):
101
 
        """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.
102
89
 
103
90
        This method needs the gconf module.
104
91
 
105
 
        :param buf: a GtkSource.Buffer object.
 
92
        :param lang: a gtksourceview.SourceLanguage object.
106
93
        """
107
 
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
108
 
        GEDIT_USER_STYLES_PATH = os.path.expanduser('~/.gnome2/gedit/styles')
109
 
 
110
 
        client = GConf.Client.get_default()
111
 
        style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
112
 
        if style_scheme_name is not None:
113
 
            style_scheme_mgr = GtkSource.StyleSchemeManager()
114
 
            style_scheme_mgr.append_search_path(GEDIT_USER_STYLES_PATH)
115
 
            
116
 
            style_scheme = style_scheme_mgr.get_scheme(style_scheme_name)
117
 
            
118
 
            if style_scheme is not None:
119
 
                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)
120
148
 
121
149
    @classmethod
122
 
    def apply_colordiff_colors(klass, buf):
 
150
    def apply_colordiff_colors(klass, lang):
123
151
        """Set style colors for lang using the colordiff configuration file.
124
152
 
125
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
126
154
 
127
 
        :param buf: a "Diff" GtkSource.Buffer object.
 
155
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
128
156
        """
129
 
        scheme_manager = GtkSource.StyleSchemeManager()
130
 
        style_scheme = scheme_manager.get_scheme('colordiff')
131
 
        
132
 
        # if style scheme not found, we'll generate it from colordiffrc
133
 
        # TODO: reload if colordiffrc has changed.
134
 
        if style_scheme is None:
135
 
            colors = {}
136
 
 
137
 
            for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
138
 
                f = os.path.expanduser(f)
139
 
                if os.path.exists(f):
140
 
                    try:
141
 
                        f = file(f)
142
 
                    except IOError, e:
143
 
                        warning('could not open file %s: %s' % (f, str(e)))
144
 
                    else:
145
 
                        colors.update(klass.parse_colordiffrc(f))
146
 
                        f.close()
147
 
 
148
 
            if not colors:
149
 
                # ~/.colordiffrc does not exist
150
 
                return
151
 
            
152
 
            mapping = {
153
 
                # 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
154
176
                # since GSV is richer, accept new names for extra bits,
155
177
                # defaulting to old names if they're not present
156
 
                'diff:added-line': ['newtext'],
157
 
                'diff:removed-line': ['oldtext'],
158
 
                'diff:location': ['location', 'diffstuff'],
159
 
                'diff:file': ['file', 'diffstuff'],
160
 
                'diff:special-case': ['specialcase', 'diffstuff'],
161
 
            }
162
 
            
163
 
            converted_colors = {}
164
 
            for name, values in mapping.items():
165
 
                color = None
166
 
                for value in values:
167
 
                    color = colors.get(value, None)
168
 
                    if color is not None:
169
 
                        break
170
 
                if color is None:
171
 
                    continue
172
 
                converted_colors[name] = color
173
 
            
174
 
            # some xml magic to produce needed style scheme description
175
 
            e_style_scheme = Element('style-scheme')
176
 
            e_style_scheme.set('id', 'colordiff')
177
 
            e_style_scheme.set('_name', 'ColorDiff')
178
 
            e_style_scheme.set('version', '1.0')
179
 
            for name, color in converted_colors.items():
180
 
                style = SubElement(e_style_scheme, 'style')
181
 
                style.set('name', name)
182
 
                style.set('foreground', '#%s' % color)
183
 
            
184
 
            scheme_xml = tostring(e_style_scheme, 'UTF-8')
185
 
            if not os.path.exists(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles')):
186
 
                os.makedirs(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles'))
187
 
            file(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles/colordiff.xml'), 'w').write(scheme_xml)
188
 
            
189
 
            scheme_manager.force_rescan()
190
 
            style_scheme = scheme_manager.get_scheme('colordiff')
191
 
        
192
 
        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)
193
205
 
194
206
    @staticmethod
195
207
    def parse_colordiffrc(fileobj):
250
262
    """This is the soft and chewy filling for a DiffWindow."""
251
263
 
252
264
    def __init__(self):
253
 
        super(DiffView, self).__init__()
 
265
        DiffFileView.__init__(self)
254
266
        self.rev_tree = None
255
267
        self.parent_tree = None
256
268
 
280
292
        self.buffer.set_text(decoded.encode('UTF-8'))
281
293
 
282
294
 
283
 
class DiffWidget(Gtk.HPaned):
 
295
class DiffWidget(gtk.HPaned):
284
296
    """Diff widget
285
297
 
286
298
    """
287
 
 
288
 
    SHOW_WIDGETS = True
289
 
 
290
299
    def __init__(self):
291
300
        super(DiffWidget, self).__init__()
292
301
 
293
302
        # The file hierarchy: a scrollable treeview
294
 
        scrollwin = Gtk.ScrolledWindow()
295
 
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
296
 
        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)
297
306
        self.pack1(scrollwin)
298
 
        if self.SHOW_WIDGETS:
299
 
            scrollwin.show()
300
 
        
301
 
        self.model = Gtk.TreeStore(str, str)
302
 
        self.treeview = Gtk.TreeView(model=self.model)
 
307
        scrollwin.show()
 
308
 
 
309
        self.model = gtk.TreeStore(str, str)
 
310
        self.treeview = gtk.TreeView(self.model)
303
311
        self.treeview.set_headers_visible(False)
304
312
        self.treeview.set_search_column(1)
305
313
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
306
314
        scrollwin.add(self.treeview)
307
 
        if self.SHOW_WIDGETS:
308
 
            self.treeview.show()
 
315
        self.treeview.show()
309
316
 
310
 
        cell = Gtk.CellRendererText()
 
317
        cell = gtk.CellRendererText()
311
318
        cell.set_property("width-chars", 20)
312
 
        column = Gtk.TreeViewColumn()
313
 
        column.pack_start(cell, True)
 
319
        column = gtk.TreeViewColumn()
 
320
        column.pack_start(cell, expand=True)
314
321
        column.add_attribute(cell, "text", 0)
315
322
        self.treeview.append_column(column)
316
323
 
323
330
        # text view
324
331
 
325
332
    def set_diff_text_sections(self, sections):
326
 
        if getattr(self, 'diff_view', None) is None:
327
 
            self.diff_view = DiffFileView()
328
 
            self.pack2(self.diff_view)
329
 
        if self.SHOW_WIDGETS:
330
 
            self.diff_view.show()
 
333
        self.diff_view = DiffFileView()
 
334
        self.diff_view.show()
 
335
        self.pack2(self.diff_view)
331
336
        for oldname, newname, patch in sections:
332
337
            self.diff_view._diffs[newname] = str(patch)
333
338
            if newname is None:
341
346
        Compares the two trees and populates the window with the
342
347
        differences.
343
348
        """
344
 
        if getattr(self, 'diff_view', None) is None:
345
 
            self.diff_view = DiffView()
346
 
            self.pack2(self.diff_view)
347
 
        if self.SHOW_WIDGETS:
348
 
            self.diff_view.show()
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
 
351
        self.diff_view.show()
349
352
        self.diff_view.set_trees(rev_tree, parent_tree)
350
353
        self.rev_tree = rev_tree
351
354
        self.parent_tree = parent_tree
377
380
                self.model.append(titer, [ path, path ])
378
381
 
379
382
        self.treeview.expand_all()
380
 
        self.diff_view.show_diff(None)
381
383
 
382
384
    def set_file(self, file_path):
383
385
        """Select the current file to display"""
388
390
                    tv_path = child.path
389
391
                    break
390
392
        if tv_path is None:
391
 
            raise errors.NoSuchFile(file_path)
392
 
        self.treeview.set_cursor(tv_path, None, False)
 
393
            raise NoSuchFile(file_path)
 
394
        self.treeview.set_cursor(tv_path)
393
395
        self.treeview.scroll_to_cell(tv_path)
394
396
 
395
397
    def _treeview_cursor_cb(self, *args):
396
398
        """Callback for when the treeview cursor changes."""
397
399
        (path, col) = self.treeview.get_cursor()
398
 
        if path is None:
399
 
            return
400
400
        specific_files = [ self.model[path][1] ]
401
401
        if specific_files == [ None ]:
402
402
            return
403
403
        elif specific_files == [ "" ]:
404
404
            specific_files = None
405
 
        
 
405
 
406
406
        self.diff_view.show_diff(specific_files)
407
 
    
408
 
    def _on_wraplines_toggled(self, widget=None, wrap=False):
409
 
        """Callback for when the wrap lines checkbutton is toggled"""
410
 
        if wrap or widget.get_active():
411
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
412
 
        else:
413
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
 
407
 
414
408
 
415
409
class DiffWindow(Window):
416
410
    """Diff window.
420
414
    """
421
415
 
422
416
    def __init__(self, parent=None, operations=None):
423
 
        super(DiffWindow, self).__init__(parent=parent)
 
417
        Window.__init__(self, parent)
424
418
        self.set_border_width(0)
425
419
        self.set_title("bzrk diff")
426
420
 
434
428
 
435
429
    def construct(self, operations):
436
430
        """Construct the window contents."""
437
 
        self.vbox = Gtk.VBox()
 
431
        self.vbox = gtk.VBox()
438
432
        self.add(self.vbox)
439
433
        self.vbox.show()
 
434
        hbox = self._get_button_bar(operations)
 
435
        if hbox is not None:
 
436
            self.vbox.pack_start(hbox, expand=False, fill=True)
440
437
        self.diff = DiffWidget()
441
 
        self.vbox.pack_end(self.diff, True, True, 0)
 
438
        self.vbox.add(self.diff)
442
439
        self.diff.show_all()
443
 
        # Build after DiffWidget to connect signals
444
 
        menubar = self._get_menu_bar()
445
 
        self.vbox.pack_start(menubar, False, False, 0)
446
 
        hbox = self._get_button_bar(operations)
447
 
        if hbox is not None:
448
 
            self.vbox.pack_start(hbox, False, True, 0)
449
 
        
450
 
    
451
 
    def _get_menu_bar(self):
452
 
        menubar = Gtk.MenuBar()
453
 
        # View menu
454
 
        mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
455
 
        mb_view_menu = Gtk.Menu()
456
 
        mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
457
 
            _i18n("Wrap _Long Lines"))
458
 
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
459
 
        mb_view_wrapsource.show()
460
 
        mb_view_menu.append(mb_view_wrapsource)
461
 
        mb_view.show()
462
 
        mb_view.set_submenu(mb_view_menu)
463
 
        mb_view.show()
464
 
        menubar.append(mb_view)
465
 
        menubar.show()
466
 
        return menubar
467
 
    
 
440
 
468
441
    def _get_button_bar(self, operations):
469
442
        """Return a button bar to use.
470
443
 
472
445
        """
473
446
        if operations is None:
474
447
            return None
475
 
        hbox = Gtk.HButtonBox()
476
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
448
        hbox = gtk.HButtonBox()
 
449
        hbox.set_layout(gtk.BUTTONBOX_START)
477
450
        for title, method in operations:
478
 
            merge_button = Gtk.Button(title)
 
451
            merge_button = gtk.Button(title)
479
452
            merge_button.show()
480
 
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
 
453
            merge_button.set_relief(gtk.RELIEF_NONE)
481
454
            merge_button.connect("clicked", method)
482
455
            hbox.pack_start(merge_button, expand=False, fill=True)
483
456
        hbox.show()
484
457
        return hbox
485
458
 
486
459
    def _get_merge_target(self):
487
 
        d = Gtk.FileChooserDialog('Merge branch', self,
488
 
                                  Gtk.FileChooserAction.SELECT_FOLDER,
489
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
490
 
                                           Gtk.STOCK_CANCEL,
491
 
                                           Gtk.ResponseType.CANCEL,))
 
460
        d = gtk.FileChooserDialog('Merge branch', self,
 
461
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
462
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
463
                                           gtk.STOCK_CANCEL,
 
464
                                           gtk.RESPONSE_CANCEL,))
492
465
        try:
493
466
            result = d.run()
494
 
            if result != Gtk.ResponseType.OK:
 
467
            if result != gtk.RESPONSE_OK:
495
468
                raise SelectCancelled()
496
469
            return d.get_current_folder_uri()
497
470
        finally:
511
484
        error_dialog('Error', str(e))
512
485
 
513
486
    def _get_save_path(self, basename):
514
 
        d = Gtk.FileChooserDialog('Save As', self,
515
 
                                  Gtk.FileChooserAction.SAVE,
516
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
517
 
                                           Gtk.STOCK_CANCEL,
518
 
                                           Gtk.ResponseType.CANCEL,))
 
487
        d = gtk.FileChooserDialog('Save As', self,
 
488
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
489
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
490
                                           gtk.STOCK_CANCEL,
 
491
                                           gtk.RESPONSE_CANCEL,))
519
492
        d.set_current_name(basename)
520
493
        try:
521
494
            result = d.run()
522
 
            if result != Gtk.ResponseType.OK:
 
495
            if result != gtk.RESPONSE_OK:
523
496
                raise SelectCancelled()
524
497
            return urlutils.local_path_from_url(d.get_uri())
525
498
        finally:
540
513
 
541
514
class DiffController(object):
542
515
 
543
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
516
    def __init__(self, path, patch, window=None):
544
517
        self.path = path
545
518
        self.patch = patch
546
 
        self.allow_dirty = allow_dirty
547
519
        if window is None:
548
520
            window = DiffWindow(operations=self._provide_operations())
549
521
            self.initialize_window(window)
555
527
 
556
528
    def get_diff_sections(self):
557
529
        yield "Complete Diff", None, ''.join(self.patch)
558
 
        # allow_dirty was added to parse_patches in bzrlib 2.2b1
559
 
        if 'allow_dirty' in inspect.getargspec(parse_patches).args:
560
 
            patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
561
 
        else:
562
 
            patches = parse_patches(self.patch)
563
 
        for patch in patches:
 
530
        for patch in parse_patches(self.patch):
564
531
            oldname = patch.oldname.split('\t')[0]
565
532
            newname = patch.newname.split('\t')[0]
566
533
            yield oldname, newname, str(patch)
587
554
class MergeDirectiveController(DiffController):
588
555
 
589
556
    def __init__(self, path, directive, window=None):
590
 
        super(MergeDirectiveController, self).__init__(
591
 
            path, directive.patch.splitlines(True), window)
 
557
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
558
                                window)
592
559
        self.directive = directive
593
560
        self.merge_target = None
594
561
 
605
572
        tree.lock_write()
606
573
        try:
607
574
            try:
608
 
                if tree.has_changes():
609
 
                    raise errors.UncommittedChanges(tree)
610
 
                merger, verified = _mod_merge.Merger.from_mergeable(
611
 
                    tree, self.directive, pb=None)
 
575
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
576
                    self.directive, progress.DummyProgress())
 
577
                merger.check_basis(True)
612
578
                merger.merge_type = _mod_merge.Merge3Merger
613
579
                conflict_count = merger.do_merge()
614
580
                merger.set_pending()
640
606
    renamed_and_modified = 'renamed and modified'
641
607
    modified = 'modified'
642
608
    kind_changed = 'kind changed'
643
 
    missing = 'missing'
644
609
 
645
610
    # TODO: Handle metadata changes
646
611
 
661
626
                    source_marker = ''
662
627
                else:
663
628
                    source_marker = osutils.kind_marker(kinds[0])
664
 
 
665
629
                if kinds[1] is None:
666
 
                    if kinds[0] is None:
667
 
                        # We assume bzr will flag only files in that case,
668
 
                        # there may be a bzr bug there as only files seems to
669
 
                        # not receive any kind.
670
 
                        marker = osutils.kind_marker('file')
671
 
                    else:
672
 
                        marker = osutils.kind_marker(kinds[0])
 
630
                    assert kinds[0] is not None
 
631
                    marker = osutils.kind_marker(kinds[0])
673
632
                else:
674
633
                    marker = osutils.kind_marker(kinds[1])
675
634
 
677
636
                if real_path is None:
678
637
                    real_path = paths[0]
679
638
                assert real_path is not None
 
639
                display_path = real_path + marker
680
640
 
681
641
                present_source = versioned[0] and kinds[0] is not None
682
642
                present_target = versioned[1] and kinds[1] is not None
683
643
 
684
 
                if kinds[0] is None and kinds[1] is None:
685
 
                    change_type = missing
686
 
                    display_path = real_path + marker
687
 
                elif present_source != present_target:
 
644
                if present_source != present_target:
688
645
                    if present_target:
689
646
                        change_type = added
690
647
                    else:
691
648
                        assert present_source
692
649
                        change_type = removed
693
 
                    display_path = real_path + marker
694
650
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
695
651
                    # Renamed
696
652
                    if changed_content or executables[0] != executables[1]:
704
660
                    change_type = kind_changed
705
661
                    display_path = (paths[0] + source_marker
706
662
                                    + ' => ' + paths[1] + marker)
707
 
                elif changed_content or executables[0] != executables[1]:
 
663
                elif changed_content is True or executables[0] != executables[1]:
708
664
                    change_type = modified
709
 
                    display_path = real_path + marker
710
665
                else:
711
666
                    assert False, "How did we get here?"
712
667