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