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
- browse files at revision 774
- compare with another revision
- download diff
- download tarball
- view history from revision 774
- Committer: Curtis Hovey
- Date: 2012-02-04 14:05:59 UTC
- mfrom: (772.2.5 handle-patch)
- Revision ID: sinzui.is@verizon.net-20120204140559-307aeiy47rieqxsf
Merged bzr-handle-patch gtk3 fix.
- files added:
- avatarproviders.py
- preferences
- files removed:
- cmenu.ui
- olive
- files renamed:
- bazaar-properties.desktop => bazaar-properties.desktop.in
- bzr-notify.desktop => bzr-notify.desktop.in
- bzr-icon-64.png => icons/bzr-icon-64.png
- preferences.py => preferences/__init__.py
- files modified:
- .bzrignore
added
removed
diff.py
1
# -*- coding: UTF-8 -*-
2
1
"""Difference window.
3
2
4
3
This module contains the code to manage the diff window which shows
5
4
the changes made between two revisions on a branch.
6
5
"""
7
6
8
__copyright__ = "Copyright © 2005 Canonical Ltd."
9
__author__ = "Scott James Remnant <scott@ubuntu.com>"
7
__copyright__ = "Copyright 2005 Canonical Ltd."
8
__author__ = "Scott James Remnant <scott@ubuntu.com>"
10
9
11
10
12
11
from cStringIO import StringIO
13
12
14
import pygtk
15
pygtk.require("2.0")
16
import gtk
17
import pango
18
13
import os
19
14
import re
20
15
import sys
16
import inspect
17
try:
18
from xml.etree.ElementTree import (
19
Element,
20
SubElement,
21
tostring,
22
)
23
Element, SubElement, tostring # Hush PEP8 redefinition.
24
except ImportError:
25
from elementtree.ElementTree import (
26
Element,
27
SubElement,
28
tostring,
29
)
21
30
31
from gi.repository import Gtk
32
from gi.repository import Pango
22
33
try:
23
import gtksourceview
34
from gi.repository import GtkSource
24
35
have_gtksourceview = True
25
36
except ImportError:
26
37
have_gtksourceview = False
27
38
try:
28
import gconf
39
from gi.repository import GConf
29
40
have_gconf = True
30
41
except ImportError:
31
42
have_gconf = False
32
43
33
from bzrlib import osutils
34
from bzrlib.diff import show_diff_trees, internal_diff
35
from bzrlib.errors import NoSuchFile
44
from bzrlib import (
45
errors,
46
merge as _mod_merge,
47
osutils,
48
urlutils,
49
workingtree,
50
)
51
from bzrlib.diff import show_diff_trees
52
from bzrlib.patches import parse_patches
36
53
from bzrlib.trace import warning
54
from bzrlib.plugins.gtk.dialog import (
55
error_dialog,
56
info_dialog,
57
warning_dialog,
58
)
59
from bzrlib.plugins.gtk.i18n import _i18n
37
60
from bzrlib.plugins.gtk.window import Window
38
61
39
62
40
class DiffView(gtk.ScrolledWindow):
41
"""This is the soft and chewy filling for a DiffWindow."""
63
def fallback_guess_language(slm, content_type):
64
for lang_id in slm.get_language_ids():
65
lang = slm.get_language(lang_id)
66
if "text/x-patch" in lang.get_mime_types():
67
return lang
68
return None
69
70
71
class SelectCancelled(Exception):
72
73
pass
74
75
76
class DiffFileView(Gtk.ScrolledWindow):
77
"""Window for displaying diffs from a diff file"""
42
78
43
79
def __init__(self):
44
gtk.ScrolledWindow.__init__(self)
45
80
super(DiffFileView, self).__init__()
46
81
self.construct()
47
self.rev_tree = None
48
self.parent_tree = None
82
self._diffs = {}
49
83
50
84
def construct(self):
51
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
52
self.set_shadow_type(gtk.SHADOW_IN)
85
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
86
self.set_shadow_type(Gtk.ShadowType.IN)
53
87
54
88
if have_gtksourceview:
55
self.buffer = gtksourceview.SourceBuffer()
56
slm = gtksourceview.SourceLanguagesManager()
57
gsl = slm.get_language_from_mime_type("text/x-patch")
89
self.buffer = GtkSource.Buffer()
90
lang_manager = GtkSource.LanguageManager.get_default()
91
language = lang_manager.guess_language(None, "text/x-patch")
58
92
if have_gconf:
59
self.apply_gedit_colors(gsl)
60
self.apply_colordiff_colors(gsl)
61
self.buffer.set_language(gsl)
62
self.buffer.set_highlight(True)
93
self.apply_gedit_colors(self.buffer)
94
self.apply_colordiff_colors(self.buffer)
95
self.buffer.set_language(language)
96
self.buffer.set_highlight_syntax(True)
63
97
64
sourceview = gtksourceview.SourceView(self.buffer)
98
self.sourceview = GtkSource.View(buffer=self.buffer)
65
99
else:
66
self.buffer = gtk.TextBuffer()
67
sourceview = gtk.TextView(self.buffer)
100
self.buffer = Gtk.TextBuffer()
101
self.sourceview = Gtk.TextView(self.buffer)
68
102
69
sourceview.set_editable(False)
70
sourceview.modify_font(pango.FontDescription("Monospace"))
71
self.add(sourceview)
72
sourceview.show()
103
self.sourceview.set_editable(False)
104
self.sourceview.modify_font(Pango.FontDescription("Monospace"))
105
self.add(self.sourceview)
106
self.sourceview.show()
73
107
74
108
@staticmethod
75
def apply_gedit_colors(lang):
76
"""Set style for lang to that specified in gedit configuration.
109
def apply_gedit_colors(buf):
110
"""Set style to that specified in gedit configuration.
77
111
78
112
This method needs the gconf module.
79
113
80
:param lang: a gtksourceview.SourceLanguage object.
114
:param buf: a GtkSource.Buffer object.
81
115
"""
82
GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
83
GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
84
85
client = gconf.client_get_default()
86
client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
87
88
for tag in lang.get_tags():
89
tag_id = tag.get_id()
90
gconf_key = GEDIT_LANG_PATH + '/' + tag_id
91
style_string = client.get_string(gconf_key)
92
93
if style_string is None:
94
continue
95
96
# function to get a bool from a string that's either '0' or '1'
97
string_bool = lambda x: bool(int(x))
98
99
# style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
100
# values are: mask, fg, bg, italic, bold, underline, strike
101
# this packs them into (str_value, attr_name, conv_func) tuples
102
items = zip(style_string.split('/'), ['mask', 'foreground',
103
'background', 'italic', 'bold', 'underline', 'strikethrough' ],
104
[ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
105
string_bool, string_bool, string_bool ]
106
)
107
108
style = gtksourceview.SourceTagStyle()
109
110
# XXX The mask attribute controls whether the present values of
111
# foreground and background color should in fact be used. Ideally
112
# (and that's what gedit does), one could set all three attributes,
113
# and let the TagStyle object figure out which colors to use.
114
# However, in the GtkSourceview python bindings, the mask attribute
115
# is read-only, and it's derived instead from the colors being
116
# set or not. This means that we have to sometimes refrain from
117
# setting fg or bg colors, depending on the value of the mask.
118
# This code could go away if mask were writable.
119
mask = int(items[0][0])
120
if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
121
items[2:3] = []
122
if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
123
items[1:2] = []
124
items[0:1] = [] # skip the mask unconditionally
125
126
for value, attr, func in items:
127
try:
128
value = func(value)
129
except ValueError:
130
warning('gconf key %s contains an invalid value: %s'
131
% gconf_key, value)
132
else:
133
setattr(style, attr, value)
134
135
lang.set_tag_style(tag_id, style)
136
137
@staticmethod
138
def apply_colordiff_colors(lang):
116
GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
117
GEDIT_USER_STYLES_PATH = os.path.expanduser('~/.gnome2/gedit/styles')
118
119
client = GConf.Client.get_default()
120
style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
121
if style_scheme_name is not None:
122
style_scheme_mgr = GtkSource.StyleSchemeManager()
123
style_scheme_mgr.append_search_path(GEDIT_USER_STYLES_PATH)
124
125
style_scheme = style_scheme_mgr.get_scheme(style_scheme_name)
126
127
if style_scheme is not None:
128
buf.set_style_scheme(style_scheme)
129
130
@classmethod
131
def apply_colordiff_colors(klass, buf):
139
132
"""Set style colors for lang using the colordiff configuration file.
140
133
141
134
Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
142
135
143
:param lang: a "Diff" gtksourceview.SourceLanguage object.
136
:param buf: a "Diff" GtkSource.Buffer object.
144
137
"""
145
colors = {}
146
147
for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
148
f = os.path.expanduser(f)
149
if os.path.exists(f):
150
try:
151
f = file(f)
152
except IOError, e:
153
warning('could not open file %s: %s' % (f, str(e)))
154
else:
155
colors.update(DiffView.parse_colordiffrc(f))
156
f.close()
157
158
if not colors:
159
# ~/.colordiffrc does not exist
160
return
161
162
mapping = {
163
# map GtkSourceView tags to colordiff names
138
scheme_manager = GtkSource.StyleSchemeManager()
139
style_scheme = scheme_manager.get_scheme('colordiff')
140
141
# if style scheme not found, we'll generate it from colordiffrc
142
# TODO: reload if colordiffrc has changed.
143
if style_scheme is None:
144
colors = {}
145
146
for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
147
f = os.path.expanduser(f)
148
if os.path.exists(f):
149
try:
150
f = file(f)
151
except IOError, e:
152
warning('could not open file %s: %s' % (f, str(e)))
153
else:
154
colors.update(klass.parse_colordiffrc(f))
155
f.close()
156
157
if not colors:
158
# ~/.colordiffrc does not exist
159
return
160
161
mapping = {
162
# map GtkSourceView2 scheme styles to colordiff names
164
163
# since GSV is richer, accept new names for extra bits,
165
164
# defaulting to old names if they're not present
166
'Added@32@line': ['newtext'],
167
'Removed@32@line': ['oldtext'],
168
'Location': ['location', 'diffstuff'],
169
'Diff@32@file': ['file', 'diffstuff'],
170
'Special@32@case': ['specialcase', 'diffstuff'],
171
}
172
173
for tag in lang.get_tags():
174
tag_id = tag.get_id()
175
keys = mapping.get(tag_id, [])
176
color = None
177
178
for key in keys:
179
color = colors.get(key, None)
180
if color is not None:
181
break
182
183
if color is None:
184
continue
185
186
style = gtksourceview.SourceTagStyle()
187
try:
188
style.foreground = gtk.gdk.color_parse(color)
189
except ValueError:
190
warning('not a valid color: %s' % color)
191
else:
192
lang.set_tag_style(tag_id, style)
165
'diff:added-line': ['newtext'],
166
'diff:removed-line': ['oldtext'],
167
'diff:location': ['location', 'diffstuff'],
168
'diff:file': ['file', 'diffstuff'],
169
'diff:special-case': ['specialcase', 'diffstuff'],
170
}
171
172
converted_colors = {}
173
for name, values in mapping.items():
174
color = None
175
for value in values:
176
color = colors.get(value, None)
177
if color is not None:
178
break
179
if color is None:
180
continue
181
converted_colors[name] = color
182
183
# some xml magic to produce needed style scheme description
184
e_style_scheme = Element('style-scheme')
185
e_style_scheme.set('id', 'colordiff')
186
e_style_scheme.set('_name', 'ColorDiff')
187
e_style_scheme.set('version', '1.0')
188
for name, color in converted_colors.items():
189
style = SubElement(e_style_scheme, 'style')
190
style.set('name', name)
191
style.set('foreground', '#%s' % color)
192
193
scheme_xml = tostring(e_style_scheme, 'UTF-8')
194
if not os.path.exists(os.path.expanduser(
195
'~/.local/share/gtksourceview-2.0/styles')):
196
os.makedirs(os.path.expanduser(
197
'~/.local/share/gtksourceview-2.0/styles'))
198
file(os.path.expanduser(
199
'~/.local/share/gtksourceview-2.0/styles/colordiff.xml'),
200
'w').write(scheme_xml)
201
202
scheme_manager.force_rescan()
203
style_scheme = scheme_manager.get_scheme('colordiff')
204
205
buf.set_style_scheme(style_scheme)
193
206
194
207
@staticmethod
195
208
def parse_colordiffrc(fileobj):
216
229
# self.parent_tree.lock_read()
217
230
# self.rev_tree.lock_read()
218
231
# try:
219
# self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
232
# self.delta = iter_changes_to_status(
233
# self.parent_tree, self.rev_tree)
220
234
# self.path_to_status = {}
221
235
# self.path_to_diff = {}
222
236
# source_inv = self.parent_tree.inventory
223
237
# target_inv = self.rev_tree.inventory
224
238
# for (file_id, real_path, change_type, display_path) in self.delta:
225
# self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
239
# self.path_to_status[real_path] = u'=== %s %s' % (
240
# change_type, display_path)
226
241
# if change_type in ('modified', 'renamed and modified'):
227
242
# source_ie = source_inv[file_id]
228
243
# target_ie = target_inv[file_id]
230
245
# source_ie.diff(internal_diff, *old path, *old_tree,
231
246
# *new_path, target_ie, self.rev_tree,
232
247
# sio)
233
# self.path_to_diff[real_path] =
248
# self.path_to_diff[real_path] =
234
249
#
235
250
# finally:
236
251
# self.rev_tree.unlock()
237
252
# self.parent_tree.unlock()
238
253
239
254
def show_diff(self, specific_files):
255
sections = []
256
if specific_files is None:
257
self.buffer.set_text(self._diffs[None])
258
else:
259
for specific_file in specific_files:
260
sections.append(self._diffs[specific_file])
261
self.buffer.set_text(''.join(sections))
262
263
264
class DiffView(DiffFileView):
265
"""This is the soft and chewy filling for a DiffWindow."""
266
267
def __init__(self):
268
super(DiffView, self).__init__()
269
self.rev_tree = None
270
self.parent_tree = None
271
272
def show_diff(self, specific_files):
273
"""Show the diff for the specified files"""
240
274
s = StringIO()
241
275
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
242
276
old_label='', new_label='',
261
295
self.buffer.set_text(decoded.encode('UTF-8'))
262
296
263
297
264
class DiffWindow(Window):
265
"""Diff window.
298
class DiffWidget(Gtk.HPaned):
299
"""Diff widget
266
300
267
This object represents and manages a single window containing the
268
differences between two revisions on a branch.
269
301
"""
270
302
271
def __init__(self, parent=None):
272
Window.__init__(self, parent)
273
self.set_border_width(0)
274
self.set_title("bzrk diff")
275
276
# Use two thirds of the screen by default
277
screen = self.get_screen()
278
monitor = screen.get_monitor_geometry(0)
279
width = int(monitor.width * 0.66)
280
height = int(monitor.height * 0.66)
281
self.set_default_size(width, height)
282
283
self.construct()
284
285
def construct(self):
286
"""Construct the window contents."""
287
# The window consists of a pane containing: the
288
# hierarchical list of files on the left, and the diff
289
# for the currently selected file on the right.
290
pane = gtk.HPaned()
291
self.add(pane)
292
pane.show()
303
SHOW_WIDGETS = True
304
305
def __init__(self):
306
super(DiffWidget, self).__init__()
293
307
294
308
# The file hierarchy: a scrollable treeview
295
scrollwin = gtk.ScrolledWindow()
296
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
297
scrollwin.set_shadow_type(gtk.SHADOW_IN)
298
pane.pack1(scrollwin)
299
scrollwin.show()
309
scrollwin = Gtk.ScrolledWindow()
310
scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
311
scrollwin.set_shadow_type(Gtk.ShadowType.IN)
312
self.pack1(scrollwin)
313
if self.SHOW_WIDGETS:
314
scrollwin.show()
300
315
301
self.model = gtk.TreeStore(str, str)
302
self.treeview = gtk.TreeView(self.model)
316
self.model = Gtk.TreeStore(str, str)
317
self.treeview = Gtk.TreeView(model=self.model)
303
318
self.treeview.set_headers_visible(False)
304
319
self.treeview.set_search_column(1)
305
320
self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
306
321
scrollwin.add(self.treeview)
307
self.treeview.show()
322
if self.SHOW_WIDGETS:
323
self.treeview.show()
308
324
309
cell = gtk.CellRendererText()
325
cell = Gtk.CellRendererText()
310
326
cell.set_property("width-chars", 20)
311
column = gtk.TreeViewColumn()
312
column.pack_start(cell, expand=True)
327
column = Gtk.TreeViewColumn()
328
column.pack_start(cell, True)
313
329
column.add_attribute(cell, "text", 0)
314
330
self.treeview.append_column(column)
315
331
332
def set_diff_text(self, lines):
333
"""Set the current diff from a list of lines
334
335
:param lines: The diff to show, in unified diff format
336
"""
316
337
# The diffs of the selected file: a scrollable source or
317
338
# text view
318
self.diff_view = DiffView()
319
pane.pack2(self.diff_view)
320
self.diff_view.show()
321
322
def set_diff(self, description, rev_tree, parent_tree):
339
340
def set_diff_text_sections(self, sections):
341
if getattr(self, 'diff_view', None) is None:
342
self.diff_view = DiffFileView()
343
self.pack2(self.diff_view)
344
if self.SHOW_WIDGETS:
345
self.diff_view.show()
346
for oldname, newname, patch in sections:
347
self.diff_view._diffs[newname] = str(patch)
348
if newname is None:
349
newname = ''
350
self.model.append(None, [oldname, newname])
351
self.diff_view.show_diff(None)
352
353
def set_diff(self, rev_tree, parent_tree):
323
354
"""Set the differences showed by this window.
324
355
325
356
Compares the two trees and populates the window with the
326
357
differences.
327
358
"""
359
if getattr(self, 'diff_view', None) is None:
360
self.diff_view = DiffView()
361
self.pack2(self.diff_view)
362
if self.SHOW_WIDGETS:
363
self.diff_view.show()
328
364
self.diff_view.set_trees(rev_tree, parent_tree)
329
365
self.rev_tree = rev_tree
330
366
self.parent_tree = parent_tree
332
368
self.model.clear()
333
369
delta = self.rev_tree.changes_from(self.parent_tree)
334
370
335
self.model.append(None, [ "Complete Diff", "" ])
371
self.model.append(None, ["Complete Diff", ""])
336
372
337
373
if len(delta.added):
338
titer = self.model.append(None, [ "Added", None ])
374
titer = self.model.append(None, ["Added", None])
339
375
for path, id, kind in delta.added:
340
self.model.append(titer, [ path, path ])
376
self.model.append(titer, [path, path])
341
377
342
378
if len(delta.removed):
343
titer = self.model.append(None, [ "Removed", None ])
379
titer = self.model.append(None, ["Removed", None])
344
380
for path, id, kind in delta.removed:
345
self.model.append(titer, [ path, path ])
381
self.model.append(titer, [path, path])
346
382
347
383
if len(delta.renamed):
348
titer = self.model.append(None, [ "Renamed", None ])
384
titer = self.model.append(None, ["Renamed", None])
349
385
for oldpath, newpath, id, kind, text_modified, meta_modified \
350
386
in delta.renamed:
351
self.model.append(titer, [ oldpath, newpath ])
387
self.model.append(titer, [oldpath, newpath])
352
388
353
389
if len(delta.modified):
354
titer = self.model.append(None, [ "Modified", None ])
390
titer = self.model.append(None, ["Modified", None])
355
391
for path, id, kind, text_modified, meta_modified in delta.modified:
356
self.model.append(titer, [ path, path ])
392
self.model.append(titer, [path, path])
357
393
358
394
self.treeview.expand_all()
359
self.set_title(description + " - bzrk diff")
395
self.diff_view.show_diff(None)
360
396
361
397
def set_file(self, file_path):
398
"""Select the current file to display"""
362
399
tv_path = None
363
400
for data in self.model:
364
401
for child in data.iterchildren():
366
403
tv_path = child.path
367
404
break
368
405
if tv_path is None:
369
raise NoSuchFile(file_path)
370
self.treeview.set_cursor(tv_path)
406
raise errors.NoSuchFile(file_path)
407
self.treeview.set_cursor(tv_path, None, False)
371
408
self.treeview.scroll_to_cell(tv_path)
372
409
373
410
def _treeview_cursor_cb(self, *args):
374
411
"""Callback for when the treeview cursor changes."""
375
412
(path, col) = self.treeview.get_cursor()
376
specific_files = [ self.model[path][1] ]
377
if specific_files == [ None ]:
378
return
379
elif specific_files == [ "" ]:
413
if path is None:
414
return
415
specific_files = [self.model[path][1]]
416
if specific_files == [None]:
417
return
418
elif specific_files == [""]:
380
419
specific_files = None
381
420
382
421
self.diff_view.show_diff(specific_files)
383
422
384
385
def _iter_changes_to_status(source, target):
423
def _on_wraplines_toggled(self, widget=None, wrap=False):
424
"""Callback for when the wrap lines checkbutton is toggled"""
425
if wrap or widget.get_active():
426
self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
427
else:
428
self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
429
430
431
class DiffWindow(Window):
432
"""Diff window.
433
434
This object represents and manages a single window containing the
435
differences between two revisions on a branch.
436
"""
437
438
SHOW_WIDGETS = True
439
440
def __init__(self, parent=None, operations=None):
441
super(DiffWindow, self).__init__(parent=parent)
442
self.set_border_width(0)
443
self.set_title("bzr diff")
444
445
# Use two thirds of the screen by default
446
screen = self.get_screen()
447
monitor = screen.get_monitor_geometry(0)
448
width = int(monitor.width * 0.66)
449
height = int(monitor.height * 0.66)
450
self.set_default_size(width, height)
451
self.construct(operations)
452
453
def construct(self, operations):
454
"""Construct the window contents."""
455
self.vbox = Gtk.VBox()
456
self.add(self.vbox)
457
if self.SHOW_WIDGETS:
458
self.vbox.show()
459
self.diff = DiffWidget()
460
self.vbox.pack_end(self.diff, True, True, 0)
461
if self.SHOW_WIDGETS:
462
self.diff.show_all()
463
# Build after DiffWidget to connect signals
464
menubar = self._get_menu_bar()
465
self.vbox.pack_start(menubar, False, False, 0)
466
hbox = self._get_button_bar(operations)
467
if hbox is not None:
468
self.vbox.pack_start(hbox, False, True, 0)
469
470
def _get_menu_bar(self):
471
menubar = Gtk.MenuBar()
472
# View menu
473
mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
474
mb_view_menu = Gtk.Menu()
475
mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
476
_i18n("Wrap _Long Lines"))
477
mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
478
mb_view_menu.append(mb_view_wrapsource)
479
mb_view.set_submenu(mb_view_menu)
480
menubar.append(mb_view)
481
if self.SHOW_WIDGETS:
482
menubar.show_all()
483
return menubar
484
485
def _get_button_bar(self, operations):
486
"""Return a button bar to use.
487
488
:return: None, meaning that no button bar will be used.
489
"""
490
if operations is None:
491
return None
492
hbox = Gtk.HButtonBox()
493
hbox.set_layout(Gtk.ButtonBoxStyle.START)
494
for title, method in operations:
495
merge_button = Gtk.Button(title)
496
if self.SHOW_WIDGETS:
497
merge_button.show()
498
merge_button.set_relief(Gtk.ReliefStyle.NONE)
499
merge_button.connect("clicked", method)
500
hbox.pack_start(merge_button, False, True, 0)
501
if self.SHOW_WIDGETS:
502
hbox.show()
503
return hbox
504
505
def _get_merge_target(self):
506
d = Gtk.FileChooserDialog('Merge branch', self,
507
Gtk.FileChooserAction.SELECT_FOLDER,
508
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
509
Gtk.STOCK_CANCEL,
510
Gtk.ResponseType.CANCEL,))
511
try:
512
result = d.run()
513
if result != Gtk.ResponseType.OK:
514
raise SelectCancelled()
515
return d.get_current_folder_uri()
516
finally:
517
d.destroy()
518
519
def _merge_successful(self):
520
# No conflicts found.
521
info_dialog(_i18n('Merge successful'),
522
_i18n('All changes applied successfully.'))
523
524
def _conflicts(self):
525
warning_dialog(_i18n('Conflicts encountered'),
526
_i18n('Please resolve the conflicts manually'
527
' before committing.'))
528
529
def _handle_error(self, e):
530
error_dialog('Error', str(e))
531
532
def _get_save_path(self, basename):
533
d = Gtk.FileChooserDialog('Save As', self,
534
Gtk.FileChooserAction.SAVE,
535
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
536
Gtk.STOCK_CANCEL,
537
Gtk.ResponseType.CANCEL,))
538
d.set_current_name(basename)
539
try:
540
result = d.run()
541
if result != Gtk.ResponseType.OK:
542
raise SelectCancelled()
543
return urlutils.local_path_from_url(d.get_uri())
544
finally:
545
d.destroy()
546
547
def set_diff(self, description, rev_tree, parent_tree):
548
"""Set the differences showed by this window.
549
550
Compares the two trees and populates the window with the
551
differences.
552
"""
553
self.diff.set_diff(rev_tree, parent_tree)
554
self.set_title(description + " - bzrk diff")
555
556
def set_file(self, file_path):
557
self.diff.set_file(file_path)
558
559
560
class DiffController(object):
561
562
def __init__(self, path, patch, window=None, allow_dirty=False):
563
self.path = path
564
self.patch = patch
565
self.allow_dirty = allow_dirty
566
if window is None:
567
window = DiffWindow(operations=self._provide_operations())
568
self.initialize_window(window)
569
self.window = window
570
571
def initialize_window(self, window):
572
window.diff.set_diff_text_sections(self.get_diff_sections())
573
window.set_title(self.path + " - diff")
574
575
def get_diff_sections(self):
576
yield "Complete Diff", None, ''.join(self.patch)
577
# allow_dirty was added to parse_patches in bzrlib 2.2b1
578
if 'allow_dirty' in inspect.getargspec(parse_patches).args:
579
patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
580
else:
581
patches = parse_patches(self.patch)
582
for patch in patches:
583
oldname = patch.oldname.split('\t')[0]
584
newname = patch.newname.split('\t')[0]
585
yield oldname, newname, str(patch)
586
587
def perform_save(self, window):
588
try:
589
save_path = self.window._get_save_path(osutils.basename(self.path))
590
except SelectCancelled:
591
return
592
source = open(self.path, 'rb')
593
try:
594
target = open(save_path, 'wb')
595
try:
596
osutils.pumpfile(source, target)
597
finally:
598
target.close()
599
finally:
600
source.close()
601
602
def _provide_operations(self):
603
return [('Save', self.perform_save)]
604
605
606
class MergeDirectiveController(DiffController):
607
608
def __init__(self, path, directive, window=None):
609
super(MergeDirectiveController, self).__init__(
610
path, directive.patch.splitlines(True), window)
611
self.directive = directive
612
self.merge_target = None
613
614
def _provide_operations(self):
615
return [('Merge', self.perform_merge), ('Save', self.perform_save)]
616
617
def perform_merge(self, window):
618
if self.merge_target is None:
619
try:
620
self.merge_target = self.window._get_merge_target()
621
except SelectCancelled:
622
return
623
tree = workingtree.WorkingTree.open(self.merge_target)
624
tree.lock_write()
625
try:
626
try:
627
if tree.has_changes():
628
raise errors.UncommittedChanges(tree)
629
merger, verified = _mod_merge.Merger.from_mergeable(
630
tree, self.directive, pb=None)
631
merger.merge_type = _mod_merge.Merge3Merger
632
conflict_count = merger.do_merge()
633
merger.set_pending()
634
if conflict_count == 0:
635
self.window._merge_successful()
636
else:
637
self.window._conflicts()
638
# There are conflicts to be resolved.
639
self.window.destroy()
640
except Exception, e:
641
self.window._handle_error(e)
642
finally:
643
tree.unlock()
644
645
646
def iter_changes_to_status(source, target):
386
647
"""Determine the differences between trees.
387
648
388
This is a wrapper around _iter_changes which just yields more
649
This is a wrapper around iter_changes which just yields more
389
650
understandable results.
390
651
391
652
:param source: The source tree (basis tree)
398
659
renamed_and_modified = 'renamed and modified'
399
660
modified = 'modified'
400
661
kind_changed = 'kind changed'
662
missing = 'missing'
401
663
402
664
# TODO: Handle metadata changes
403
665
407
669
source.lock_read()
408
670
try:
409
671
for (file_id, paths, changed_content, versioned, parent_ids, names,
410
kinds, executables) in target._iter_changes(source):
672
kinds, executables) in target.iter_changes(source):
411
673
412
674
# Skip the root entry if it isn't very interesting
413
675
if parent_ids == (None, None):
418
680
source_marker = ''
419
681
else:
420
682
source_marker = osutils.kind_marker(kinds[0])
683
421
684
if kinds[1] is None:
422
assert kinds[0] is not None
423
marker = osutils.kind_marker(kinds[0])
685
if kinds[0] is None:
686
# We assume bzr will flag only files in that case,
687
# there may be a bzr bug there as only files seems to
688
# not receive any kind.
689
marker = osutils.kind_marker('file')
690
else:
691
marker = osutils.kind_marker(kinds[0])
424
692
else:
425
693
marker = osutils.kind_marker(kinds[1])
426
694
428
696
if real_path is None:
429
697
real_path = paths[0]
430
698
assert real_path is not None
431
display_path = real_path + marker
432
699
433
700
present_source = versioned[0] and kinds[0] is not None
434
701
present_target = versioned[1] and kinds[1] is not None
435
702
436
if present_source != present_target:
703
if kinds[0] is None and kinds[1] is None:
704
change_type = missing
705
display_path = real_path + marker
706
elif present_source != present_target:
437
707
if present_target:
438
708
change_type = added
439
709
else:
440
710
assert present_source
441
711
change_type = removed
712
display_path = real_path + marker
442
713
elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
443
714
# Renamed
444
715
if changed_content or executables[0] != executables[1]:
452
723
change_type = kind_changed
453
724
display_path = (paths[0] + source_marker
454
725
+ ' => ' + paths[1] + marker)
455
elif changed_content is True or executables[0] != executables[1]:
726
elif changed_content or executables[0] != executables[1]:
456
727
change_type = modified
728
display_path = real_path + marker
457
729
else:
458
730
assert False, "How did we get here?"
459
731
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0