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