/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 15:47:30 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629154730-xfsotoxwkiytf0ph
Pass graph object rather than full repository to linegraph.

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)
 
333
        self.diff_view = DiffFileView()
329
334
        self.diff_view.show()
 
335
        self.pack2(self.diff_view)
330
336
        for oldname, newname, patch in sections:
331
337
            self.diff_view._diffs[newname] = str(patch)
332
338
            if newname is None:
340
346
        Compares the two trees and populates the window with the
341
347
        differences.
342
348
        """
343
 
        if getattr(self, 'diff_view', None) is None:
344
 
            self.diff_view = DiffView()
345
 
            self.pack2(self.diff_view)
346
 
        if self.SHOW_WIDGETS:
347
 
            self.diff_view.show()
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
 
351
        self.diff_view.show()
348
352
        self.diff_view.set_trees(rev_tree, parent_tree)
349
353
        self.rev_tree = rev_tree
350
354
        self.parent_tree = parent_tree
376
380
                self.model.append(titer, [ path, path ])
377
381
 
378
382
        self.treeview.expand_all()
379
 
        self.diff_view.show_diff(None)
380
383
 
381
384
    def set_file(self, file_path):
382
385
        """Select the current file to display"""
387
390
                    tv_path = child.path
388
391
                    break
389
392
        if tv_path is None:
390
 
            raise errors.NoSuchFile(file_path)
391
 
        self.treeview.set_cursor(tv_path, None, False)
 
393
            raise NoSuchFile(file_path)
 
394
        self.treeview.set_cursor(tv_path)
392
395
        self.treeview.scroll_to_cell(tv_path)
393
396
 
394
397
    def _treeview_cursor_cb(self, *args):
399
402
            return
400
403
        elif specific_files == [ "" ]:
401
404
            specific_files = None
402
 
        
 
405
 
403
406
        self.diff_view.show_diff(specific_files)
404
 
    
405
 
    def _on_wraplines_toggled(self, widget=None, wrap=False):
406
 
        """Callback for when the wrap lines checkbutton is toggled"""
407
 
        if wrap or widget.get_active():
408
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
409
 
        else:
410
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
 
407
 
411
408
 
412
409
class DiffWindow(Window):
413
410
    """Diff window.
417
414
    """
418
415
 
419
416
    def __init__(self, parent=None, operations=None):
420
 
        super(DiffWindow, self).__init__(parent=parent)
 
417
        Window.__init__(self, parent)
421
418
        self.set_border_width(0)
422
419
        self.set_title("bzrk diff")
423
420
 
431
428
 
432
429
    def construct(self, operations):
433
430
        """Construct the window contents."""
434
 
        self.vbox = Gtk.VBox()
 
431
        self.vbox = gtk.VBox()
435
432
        self.add(self.vbox)
436
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)
437
437
        self.diff = DiffWidget()
438
 
        self.vbox.pack_end(self.diff, True, True, 0)
 
438
        self.vbox.add(self.diff)
439
439
        self.diff.show_all()
440
 
        # Build after DiffWidget to connect signals
441
 
        menubar = self._get_menu_bar()
442
 
        self.vbox.pack_start(menubar, False, False, 0)
443
 
        hbox = self._get_button_bar(operations)
444
 
        if hbox is not None:
445
 
            self.vbox.pack_start(hbox, False, True, 0)
446
 
        
447
 
    
448
 
    def _get_menu_bar(self):
449
 
        menubar = Gtk.MenuBar()
450
 
        # View menu
451
 
        mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
452
 
        mb_view_menu = Gtk.Menu()
453
 
        mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
454
 
            _i18n("Wrap _Long Lines"))
455
 
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
456
 
        mb_view_wrapsource.show()
457
 
        mb_view_menu.append(mb_view_wrapsource)
458
 
        mb_view.show()
459
 
        mb_view.set_submenu(mb_view_menu)
460
 
        mb_view.show()
461
 
        menubar.append(mb_view)
462
 
        menubar.show()
463
 
        return menubar
464
 
    
 
440
 
465
441
    def _get_button_bar(self, operations):
466
442
        """Return a button bar to use.
467
443
 
469
445
        """
470
446
        if operations is None:
471
447
            return None
472
 
        hbox = Gtk.HButtonBox()
473
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
448
        hbox = gtk.HButtonBox()
 
449
        hbox.set_layout(gtk.BUTTONBOX_START)
474
450
        for title, method in operations:
475
 
            merge_button = Gtk.Button(title)
 
451
            merge_button = gtk.Button(title)
476
452
            merge_button.show()
477
 
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
 
453
            merge_button.set_relief(gtk.RELIEF_NONE)
478
454
            merge_button.connect("clicked", method)
479
455
            hbox.pack_start(merge_button, expand=False, fill=True)
480
456
        hbox.show()
481
457
        return hbox
482
458
 
483
459
    def _get_merge_target(self):
484
 
        d = Gtk.FileChooserDialog('Merge branch', self,
485
 
                                  Gtk.FileChooserAction.SELECT_FOLDER,
486
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
487
 
                                           Gtk.STOCK_CANCEL,
488
 
                                           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,))
489
465
        try:
490
466
            result = d.run()
491
 
            if result != Gtk.ResponseType.OK:
 
467
            if result != gtk.RESPONSE_OK:
492
468
                raise SelectCancelled()
493
469
            return d.get_current_folder_uri()
494
470
        finally:
508
484
        error_dialog('Error', str(e))
509
485
 
510
486
    def _get_save_path(self, basename):
511
 
        d = Gtk.FileChooserDialog('Save As', self,
512
 
                                  Gtk.FileChooserAction.SAVE,
513
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
514
 
                                           Gtk.STOCK_CANCEL,
515
 
                                           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,))
516
492
        d.set_current_name(basename)
517
493
        try:
518
494
            result = d.run()
519
 
            if result != Gtk.ResponseType.OK:
 
495
            if result != gtk.RESPONSE_OK:
520
496
                raise SelectCancelled()
521
497
            return urlutils.local_path_from_url(d.get_uri())
522
498
        finally:
537
513
 
538
514
class DiffController(object):
539
515
 
540
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
516
    def __init__(self, path, patch, window=None):
541
517
        self.path = path
542
518
        self.patch = patch
543
 
        self.allow_dirty = allow_dirty
544
519
        if window is None:
545
520
            window = DiffWindow(operations=self._provide_operations())
546
521
            self.initialize_window(window)
552
527
 
553
528
    def get_diff_sections(self):
554
529
        yield "Complete Diff", None, ''.join(self.patch)
555
 
        # allow_dirty was added to parse_patches in bzrlib 2.2b1
556
 
        if 'allow_dirty' in inspect.getargspec(parse_patches).args:
557
 
            patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
558
 
        else:
559
 
            patches = parse_patches(self.patch)
560
 
        for patch in patches:
 
530
        for patch in parse_patches(self.patch):
561
531
            oldname = patch.oldname.split('\t')[0]
562
532
            newname = patch.newname.split('\t')[0]
563
533
            yield oldname, newname, str(patch)
584
554
class MergeDirectiveController(DiffController):
585
555
 
586
556
    def __init__(self, path, directive, window=None):
587
 
        super(MergeDirectiveController, self).__init__(
588
 
            path, directive.patch.splitlines(True), window)
 
557
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
558
                                window)
589
559
        self.directive = directive
590
560
        self.merge_target = None
591
561
 
602
572
        tree.lock_write()
603
573
        try:
604
574
            try:
605
 
                if tree.has_changes():
606
 
                    raise errors.UncommittedChanges(tree)
607
 
                merger, verified = _mod_merge.Merger.from_mergeable(
608
 
                    tree, self.directive, pb=None)
 
575
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
576
                    self.directive, progress.DummyProgress())
 
577
                merger.check_basis(True)
609
578
                merger.merge_type = _mod_merge.Merge3Merger
610
579
                conflict_count = merger.do_merge()
611
580
                merger.set_pending()
637
606
    renamed_and_modified = 'renamed and modified'
638
607
    modified = 'modified'
639
608
    kind_changed = 'kind changed'
640
 
    missing = 'missing'
641
609
 
642
610
    # TODO: Handle metadata changes
643
611
 
658
626
                    source_marker = ''
659
627
                else:
660
628
                    source_marker = osutils.kind_marker(kinds[0])
661
 
 
662
629
                if kinds[1] is None:
663
 
                    if kinds[0] is None:
664
 
                        # We assume bzr will flag only files in that case,
665
 
                        # there may be a bzr bug there as only files seems to
666
 
                        # not receive any kind.
667
 
                        marker = osutils.kind_marker('file')
668
 
                    else:
669
 
                        marker = osutils.kind_marker(kinds[0])
 
630
                    assert kinds[0] is not None
 
631
                    marker = osutils.kind_marker(kinds[0])
670
632
                else:
671
633
                    marker = osutils.kind_marker(kinds[1])
672
634
 
674
636
                if real_path is None:
675
637
                    real_path = paths[0]
676
638
                assert real_path is not None
 
639
                display_path = real_path + marker
677
640
 
678
641
                present_source = versioned[0] and kinds[0] is not None
679
642
                present_target = versioned[1] and kinds[1] is not None
680
643
 
681
 
                if kinds[0] is None and kinds[1] is None:
682
 
                    change_type = missing
683
 
                    display_path = real_path + marker
684
 
                elif present_source != present_target:
 
644
                if present_source != present_target:
685
645
                    if present_target:
686
646
                        change_type = added
687
647
                    else:
688
648
                        assert present_source
689
649
                        change_type = removed
690
 
                    display_path = real_path + marker
691
650
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
692
651
                    # Renamed
693
652
                    if changed_content or executables[0] != executables[1]:
701
660
                    change_type = kind_changed
702
661
                    display_path = (paths[0] + source_marker
703
662
                                    + ' => ' + paths[1] + marker)
704
 
                elif changed_content or executables[0] != executables[1]:
 
663
                elif changed_content is True or executables[0] != executables[1]:
705
664
                    change_type = modified
706
 
                    display_path = real_path + marker
707
665
                else:
708
666
                    assert False, "How did we get here?"
709
667