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 256.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 256.1.1
- Committer: Szilveszter Farkas (Phanatic)
- Date: 2007-08-13 10:08:10 UTC
- mto: This revision was merged to the branch mainline in revision 257.
- Revision ID: szilveszter.farkas@gmail.com-20070813100810-t1zs503dja54qam0
Updated POT generator script and also regenerated the translation template.
- files added:
- bzr-notify.desktop
- olive
- files removed:
- avatarproviders.py
- branchview
- preferences
- files renamed:
- bazaar-properties.desktop.in => bazaar-properties.desktop
- icons/bzr-icon-64.png => bzr-icon-64.png
- revisionview.py => logview.py
- preferences/__init__.py => preferences.py
- branchview/linegraph.py => viz/graph.py
- branchview/graphcell.py => viz/graphcell.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
18
import os
19
import re
13
20
import sys
14
import inspect
15
21
16
from gi.repository import Gtk
17
from gi.repository import Pango
18
22
try:
19
from gi.repository import GtkSource
23
import gtksourceview
20
24
have_gtksourceview = True
21
25
except ImportError:
22
26
have_gtksourceview = False
23
24
from bzrlib import (
25
errors,
26
merge as _mod_merge,
27
osutils,
28
urlutils,
29
workingtree,
30
)
27
try:
28
import gconf
29
have_gconf = True
30
except ImportError:
31
have_gconf = False
32
33
import bzrlib
34
31
35
from bzrlib.diff import show_diff_trees
32
from bzrlib.patches import parse_patches
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
39
from bzrlib.plugins.gtk.window import Window
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
48
49
50
class SelectCancelled(Exception):
51
52
pass
53
54
55
class DiffFileView(Gtk.ScrolledWindow):
56
"""Window for displaying diffs from a diff file"""
57
58
SHOW_WIDGETS = True
36
from bzrlib.errors import NoSuchFile
37
from bzrlib.trace import warning
38
39
40
class DiffWindow(gtk.Window):
41
"""Diff window.
42
43
This object represents and manages a single window containing the
44
differences between two revisions on a branch.
45
"""
59
46
60
47
def __init__(self):
61
super(DiffFileView, self).__init__()
48
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
49
self.set_border_width(0)
50
self.set_title("bzrk diff")
51
52
# Use two thirds of the screen by default
53
screen = self.get_screen()
54
monitor = screen.get_monitor_geometry(0)
55
width = int(monitor.width * 0.66)
56
height = int(monitor.height * 0.66)
57
self.set_default_size(width, height)
58
62
59
self.construct()
63
self._diffs = {}
64
60
65
61
def construct(self):
66
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
self.set_shadow_type(Gtk.ShadowType.IN)
68
69
if have_gtksourceview:
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)
76
else:
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()
85
86
def set_trees(self, rev_tree, parent_tree):
87
self.rev_tree = rev_tree
88
self.parent_tree = parent_tree
89
# self._build_delta()
90
91
# def _build_delta(self):
92
# self.parent_tree.lock_read()
93
# self.rev_tree.lock_read()
94
# try:
95
# self.delta = iter_changes_to_status(
96
# self.parent_tree, self.rev_tree)
97
# self.path_to_status = {}
98
# self.path_to_diff = {}
99
# source_inv = self.parent_tree.inventory
100
# target_inv = self.rev_tree.inventory
101
# for (file_id, real_path, change_type, display_path) in self.delta:
102
# self.path_to_status[real_path] = u'=== %s %s' % (
103
# change_type, display_path)
104
# if change_type in ('modified', 'renamed and modified'):
105
# source_ie = source_inv[file_id]
106
# target_ie = target_inv[file_id]
107
# sio = StringIO()
108
# source_ie.diff(internal_diff, *old path, *old_tree,
109
# *new_path, target_ie, self.rev_tree,
110
# sio)
111
# self.path_to_diff[real_path] =
112
#
113
# finally:
114
# self.rev_tree.unlock()
115
# self.parent_tree.unlock()
116
117
def show_diff(self, specific_files):
118
sections = []
119
if specific_files is None:
120
self.buffer.set_text(self._diffs[None])
121
else:
122
for specific_file in specific_files:
123
sections.append(self._diffs[specific_file])
124
self.buffer.set_text(''.join(sections))
125
126
127
class DiffView(DiffFileView):
128
"""This is the soft and chewy filling for a DiffWindow."""
129
130
def __init__(self):
131
super(DiffView, self).__init__()
132
self.rev_tree = None
133
self.parent_tree = None
134
135
def show_diff(self, specific_files):
136
"""Show the diff for the specified files"""
137
s = StringIO()
138
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
139
old_label='', new_label='',
140
# path_encoding=sys.getdefaultencoding()
141
# The default is utf-8, but we interpret the file
142
# contents as getdefaultencoding(), so we should
143
# probably try to make the paths in the same encoding.
144
)
145
# str.decode(encoding, 'replace') doesn't do anything. Because if a
146
# character is not valid in 'encoding' there is nothing to replace, the
147
# 'replace' is for 'str.encode()'
148
try:
149
decoded = s.getvalue().decode(sys.getdefaultencoding())
150
except UnicodeDecodeError:
151
try:
152
decoded = s.getvalue().decode('UTF-8')
153
except UnicodeDecodeError:
154
decoded = s.getvalue().decode('iso-8859-1')
155
# This always works, because every byte has a valid
156
# mapping from iso-8859-1 to Unicode
157
# TextBuffer must contain pure UTF-8 data
158
self.buffer.set_text(decoded.encode('UTF-8'))
159
160
161
class DiffWidget(Gtk.HPaned):
162
"""Diff widget
163
164
"""
165
166
SHOW_WIDGETS = True
167
168
def __init__(self):
169
super(DiffWidget, self).__init__()
62
"""Construct the window contents."""
63
# The window consists of a pane containing: the
64
# hierarchical list of files on the left, and the diff
65
# for the currently selected file on the right.
66
pane = gtk.HPaned()
67
self.add(pane)
68
pane.show()
170
69
171
70
# The file hierarchy: a scrollable treeview
172
scrollwin = Gtk.ScrolledWindow()
173
scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
174
scrollwin.set_shadow_type(Gtk.ShadowType.IN)
175
self.pack1(scrollwin)
176
if self.SHOW_WIDGETS:
177
scrollwin.show()
71
scrollwin = gtk.ScrolledWindow()
72
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
73
scrollwin.set_shadow_type(gtk.SHADOW_IN)
74
pane.pack1(scrollwin)
75
scrollwin.show()
178
76
179
self.model = Gtk.TreeStore(str, str)
180
self.treeview = Gtk.TreeView(model=self.model)
77
self.model = gtk.TreeStore(str, str)
78
self.treeview = gtk.TreeView(self.model)
181
79
self.treeview.set_headers_visible(False)
182
80
self.treeview.set_search_column(1)
183
81
self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
82
scrollwin.add(self.treeview)
185
if self.SHOW_WIDGETS:
186
self.treeview.show()
83
self.treeview.show()
187
84
188
cell = Gtk.CellRendererText()
85
cell = gtk.CellRendererText()
189
86
cell.set_property("width-chars", 20)
190
column = Gtk.TreeViewColumn()
191
column.pack_start(cell, True)
87
column = gtk.TreeViewColumn()
88
column.pack_start(cell, expand=True)
192
89
column.add_attribute(cell, "text", 0)
193
90
self.treeview.append_column(column)
194
91
195
def set_diff_text(self, lines):
196
"""Set the current diff from a list of lines
197
198
:param lines: The diff to show, in unified diff format
199
"""
200
92
# The diffs of the selected file: a scrollable source or
201
93
# text view
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 = ''
213
self.model.append(None, [oldname, newname])
214
self.diff_view.show_diff(None)
215
216
def set_diff(self, rev_tree, parent_tree):
94
scrollwin = gtk.ScrolledWindow()
95
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
96
scrollwin.set_shadow_type(gtk.SHADOW_IN)
97
pane.pack2(scrollwin)
98
scrollwin.show()
99
100
if have_gtksourceview:
101
self.buffer = gtksourceview.SourceBuffer()
102
slm = gtksourceview.SourceLanguagesManager()
103
gsl = slm.get_language_from_mime_type("text/x-patch")
104
if have_gconf:
105
self.apply_gedit_colors(gsl)
106
self.apply_colordiff_colors(gsl)
107
self.buffer.set_language(gsl)
108
self.buffer.set_highlight(True)
109
110
sourceview = gtksourceview.SourceView(self.buffer)
111
else:
112
self.buffer = gtk.TextBuffer()
113
sourceview = gtk.TextView(self.buffer)
114
115
sourceview.set_editable(False)
116
sourceview.modify_font(pango.FontDescription("Monospace"))
117
scrollwin.add(sourceview)
118
sourceview.show()
119
120
def set_diff(self, description, rev_tree, parent_tree):
217
121
"""Set the differences showed by this window.
218
122
219
123
Compares the two trees and populates the window with the
220
124
differences.
221
125
"""
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()
227
self.diff_view.set_trees(rev_tree, parent_tree)
228
126
self.rev_tree = rev_tree
229
127
self.parent_tree = parent_tree
230
128
231
129
self.model.clear()
232
130
delta = self.rev_tree.changes_from(self.parent_tree)
233
131
234
self.model.append(None, ["Complete Diff", ""])
132
self.model.append(None, [ "Complete Diff", "" ])
235
133
236
134
if len(delta.added):
237
titer = self.model.append(None, ["Added", None])
135
titer = self.model.append(None, [ "Added", None ])
238
136
for path, id, kind in delta.added:
239
self.model.append(titer, [path, path])
137
self.model.append(titer, [ path, path ])
240
138
241
139
if len(delta.removed):
242
titer = self.model.append(None, ["Removed", None])
140
titer = self.model.append(None, [ "Removed", None ])
243
141
for path, id, kind in delta.removed:
244
self.model.append(titer, [path, path])
142
self.model.append(titer, [ path, path ])
245
143
246
144
if len(delta.renamed):
247
titer = self.model.append(None, ["Renamed", None])
145
titer = self.model.append(None, [ "Renamed", None ])
248
146
for oldpath, newpath, id, kind, text_modified, meta_modified \
249
147
in delta.renamed:
250
self.model.append(titer, [oldpath, newpath])
148
self.model.append(titer, [ oldpath, newpath ])
251
149
252
150
if len(delta.modified):
253
titer = self.model.append(None, ["Modified", None])
151
titer = self.model.append(None, [ "Modified", None ])
254
152
for path, id, kind, text_modified, meta_modified in delta.modified:
255
self.model.append(titer, [path, path])
153
self.model.append(titer, [ path, path ])
256
154
257
155
self.treeview.expand_all()
258
self.diff_view.show_diff(None)
156
self.set_title(description + " - bzrk diff")
259
157
260
158
def set_file(self, file_path):
261
"""Select the current file to display"""
262
159
tv_path = None
263
160
for data in self.model:
264
161
for child in data.iterchildren():
266
163
tv_path = child.path
267
164
break
268
165
if tv_path is None:
269
raise errors.NoSuchFile(file_path)
270
self.treeview.set_cursor(tv_path, None, False)
166
raise NoSuchFile(file_path)
167
self.treeview.set_cursor(tv_path)
271
168
self.treeview.scroll_to_cell(tv_path)
272
169
273
170
def _treeview_cursor_cb(self, *args):
274
171
"""Callback for when the treeview cursor changes."""
275
172
(path, col) = self.treeview.get_cursor()
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 == [""]:
282
specific_files = None
283
284
self.diff_view.show_diff(specific_files)
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
293
294
class DiffWindow(Window):
295
"""Diff window.
296
297
This object represents and manages a single window containing the
298
differences between two revisions on a branch.
299
"""
300
301
SHOW_WIDGETS = True
302
303
def __init__(self, parent=None, operations=None):
304
super(DiffWindow, self).__init__(parent=parent)
305
self.set_border_width(0)
306
self.set_title("bzr diff")
307
308
# Use two thirds of the screen by default
309
screen = self.get_screen()
310
monitor = screen.get_monitor_geometry(0)
311
width = int(monitor.width * 0.66)
312
height = int(monitor.height * 0.66)
313
self.set_default_size(width, height)
314
self.construct(operations)
315
316
def construct(self, operations):
317
"""Construct the window contents."""
318
self.vbox = Gtk.VBox()
319
self.add(self.vbox)
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)
330
if hbox is not None:
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):
349
"""Return a button bar to use.
350
351
:return: None, meaning that no button bar will be used.
352
"""
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()
409
410
def set_diff(self, description, rev_tree, parent_tree):
411
"""Set the differences showed by this window.
412
413
Compares the two trees and populates the window with the
414
differences.
415
"""
416
self.diff.set_diff(rev_tree, parent_tree)
417
self.set_title(description + " - bzrk diff")
418
419
def set_file(self, file_path):
420
self.diff.set_file(file_path)
421
422
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)
474
self.directive = directive
475
self.merge_target = None
476
477
def _provide_operations(self):
478
return [('Merge', self.perform_merge), ('Save', self.perform_save)]
479
480
def perform_merge(self, window):
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)
487
tree.lock_write()
488
try:
489
try:
490
if tree.has_changes():
491
raise errors.UncommittedChanges(tree)
492
merger, verified = _mod_merge.Merger.from_mergeable(
493
tree, self.directive, pb=None)
494
merger.merge_type = _mod_merge.Merge3Merger
495
conflict_count = merger.do_merge()
496
merger.set_pending()
497
if conflict_count == 0:
498
self.window._merge_successful()
499
else:
500
self.window._conflicts()
501
# There are conflicts to be resolved.
502
self.window.destroy()
503
except Exception, e:
504
self.window._handle_error(e)
505
finally:
506
tree.unlock()
507
508
509
def iter_changes_to_status(source, target):
510
"""Determine the differences between trees.
511
512
This is a wrapper around iter_changes which just yields more
513
understandable results.
514
515
:param source: The source tree (basis tree)
516
:param target: The target tree
517
:return: A list of (file_id, real_path, change_type, display_path)
518
"""
519
added = 'added'
520
removed = 'removed'
521
renamed = 'renamed'
522
renamed_and_modified = 'renamed and modified'
523
modified = 'modified'
524
kind_changed = 'kind changed'
525
missing = 'missing'
526
527
# TODO: Handle metadata changes
528
529
status = []
530
target.lock_read()
531
try:
532
source.lock_read()
533
try:
534
for (file_id, paths, changed_content, versioned, parent_ids, names,
535
kinds, executables) in target.iter_changes(source):
536
537
# Skip the root entry if it isn't very interesting
538
if parent_ids == (None, None):
539
continue
540
541
change_type = None
542
if kinds[0] is None:
543
source_marker = ''
544
else:
545
source_marker = osutils.kind_marker(kinds[0])
546
547
if kinds[1] is None:
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])
555
else:
556
marker = osutils.kind_marker(kinds[1])
557
558
real_path = paths[1]
559
if real_path is None:
560
real_path = paths[0]
561
assert real_path is not None
562
563
present_source = versioned[0] and kinds[0] is not None
564
present_target = versioned[1] and kinds[1] is not None
565
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:
570
if present_target:
571
change_type = added
572
else:
573
assert present_source
574
change_type = removed
575
display_path = real_path + marker
576
elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
577
# Renamed
578
if changed_content or executables[0] != executables[1]:
579
# and modified
580
change_type = renamed_and_modified
581
else:
582
change_type = renamed
583
display_path = (paths[0] + source_marker
584
+ ' => ' + paths[1] + marker)
585
elif kinds[0] != kinds[1]:
586
change_type = kind_changed
587
display_path = (paths[0] + source_marker
588
+ ' => ' + paths[1] + marker)
589
elif changed_content or executables[0] != executables[1]:
590
change_type = modified
591
display_path = real_path + marker
592
else:
593
assert False, "How did we get here?"
594
595
status.append((file_id, real_path, change_type, display_path))
596
finally:
597
source.unlock()
598
finally:
599
target.unlock()
600
601
return status
173
specific_files = [ self.model[path][1] ]
174
if specific_files == [ None ]:
175
return
176
elif specific_files == [ "" ]:
177
specific_files = []
178
179
s = StringIO()
180
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
181
self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))
182
183
@staticmethod
184
def apply_gedit_colors(lang):
185
"""Set style for lang to that specified in gedit configuration.
186
187
This method needs the gconf module.
188
189
:param lang: a gtksourceview.SourceLanguage object.
190
"""
191
GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
192
GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
193
194
client = gconf.client_get_default()
195
client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
196
197
for tag in lang.get_tags():
198
tag_id = tag.get_id()
199
gconf_key = GEDIT_LANG_PATH + '/' + tag_id
200
style_string = client.get_string(gconf_key)
201
202
if style_string is None:
203
continue
204
205
# function to get a bool from a string that's either '0' or '1'
206
string_bool = lambda x: bool(int(x))
207
208
# style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
209
# values are: mask, fg, bg, italic, bold, underline, strike
210
# this packs them into (str_value, attr_name, conv_func) tuples
211
items = zip(style_string.split('/'), ['mask', 'foreground',
212
'background', 'italic', 'bold', 'underline', 'strikethrough' ],
213
[ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
214
string_bool, string_bool, string_bool ]
215
)
216
217
style = gtksourceview.SourceTagStyle()
218
219
# XXX The mask attribute controls whether the present values of
220
# foreground and background color should in fact be used. Ideally
221
# (and that's what gedit does), one could set all three attributes,
222
# and let the TagStyle object figure out which colors to use.
223
# However, in the GtkSourceview python bindings, the mask attribute
224
# is read-only, and it's derived instead from the colors being
225
# set or not. This means that we have to sometimes refrain from
226
# setting fg or bg colors, depending on the value of the mask.
227
# This code could go away if mask were writable.
228
mask = int(items[0][0])
229
if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
230
items[2:3] = []
231
if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
232
items[1:2] = []
233
items[0:1] = [] # skip the mask unconditionally
234
235
for value, attr, func in items:
236
try:
237
value = func(value)
238
except ValueError:
239
warning('gconf key %s contains an invalid value: %s'
240
% gconf_key, value)
241
else:
242
setattr(style, attr, value)
243
244
lang.set_tag_style(tag_id, style)
245
246
@staticmethod
247
def apply_colordiff_colors(lang):
248
"""Set style colors for lang using the colordiff configuration file.
249
250
Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
251
252
:param lang: a "Diff" gtksourceview.SourceLanguage object.
253
"""
254
colors = {}
255
256
for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
257
f = os.path.expanduser(f)
258
if os.path.exists(f):
259
try:
260
f = file(f)
261
except IOError, e:
262
warning('could not open file %s: %s' % (f, str(e)))
263
else:
264
colors.update(DiffWindow.parse_colordiffrc(f))
265
f.close()
266
267
if not colors:
268
# ~/.colordiffrc does not exist
269
return
270
271
mapping = {
272
# map GtkSourceView tags to colordiff names
273
# since GSV is richer, accept new names for extra bits,
274
# defaulting to old names if they're not present
275
'Added@32@line': ['newtext'],
276
'Removed@32@line': ['oldtext'],
277
'Location': ['location', 'diffstuff'],
278
'Diff@32@file': ['file', 'diffstuff'],
279
'Special@32@case': ['specialcase', 'diffstuff'],
280
}
281
282
for tag in lang.get_tags():
283
tag_id = tag.get_id()
284
keys = mapping.get(tag_id, [])
285
color = None
286
287
for key in keys:
288
color = colors.get(key, None)
289
if color is not None:
290
break
291
292
if color is None:
293
continue
294
295
style = gtksourceview.SourceTagStyle()
296
try:
297
style.foreground = gtk.gdk.color_parse(color)
298
except ValueError:
299
warning('not a valid color: %s' % color)
300
else:
301
lang.set_tag_style(tag_id, style)
302
303
@staticmethod
304
def parse_colordiffrc(fileobj):
305
"""Parse fileobj as a colordiff configuration file.
306
307
:return: A dict with the key -> value pairs.
308
"""
309
colors = {}
310
for line in fileobj:
311
if re.match(r'^\s*#', line):
312
continue
313
if '=' not in line:
314
continue
315
key, val = line.split('=', 1)
316
colors[key.strip()] = val.strip()
317
return colors
318
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0