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 annotate/gannotate.py
- browse files at revision 49
- compare with another revision
- download diff
- download tarball
- view history from revision 49
- Committer: Jelmer Vernooij
- Date: 2006-05-19 16:56:46 UTC
- mfrom: (0.1.25 gannotate)
- Revision ID: jelmer@samba.org-20060519165646-0d867938fdbc9097
Merge in Dan Loda's gannotate plugin and put it in annotate/
- files added:
- .bzrignore
- files removed:
- .bzrignore
- icons
- olive
- po
- tests
- files renamed:
- logview.py => annotate/logview.py
- diff.py => viz/diffwin.py
- files modified:
- AUTHORS
added
removed
annotate/gannotate.py
21
21
import gobject
22
22
import gtk
23
23
import pango
24
import re
25
24
26
from bzrlib import patiencediff, tsort
27
25
from bzrlib.errors import NoSuchRevision
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
26
30
27
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
from bzrlib.plugins.gtk.logview import LogView
28
from logview import LogView
29
from spanselector import SpanSelector
32
30
33
31
34
32
(
54
52
self.annotate_colormap = AnnotateColorSaturation()
55
53
56
54
self._create()
55
56
if self.plain:
57
self.span_selector.hide()
58
59
def annotate(self, branch, file_id):
57
60
self.revisions = {}
58
self.history = []
59
self._no_back = set()
60
61
def annotate(self, tree, branch, file_id):
62
self.annotations = []
63
self.branch = branch
64
self.tree = tree
65
self.file_id = file_id
66
self.revision_id = getattr(tree, 'get_revision_id',
67
lambda: CURRENT_REVISION)()
68
61
69
# [revision id, line number, author, revno, highlight color, line]
62
# [revision id, line number, committer, revno, highlight color, line]
70
63
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
71
64
gobject.TYPE_STRING,
72
65
gobject.TYPE_STRING,
79
72
branch.lock_read()
80
73
branch.repository.lock_read()
81
74
for line_no, (revision, revno, line)\
82
in enumerate(self._annotate(tree, file_id)):
75
in enumerate(self._annotate(branch, file_id)):
83
76
if revision.revision_id == last_seen and not self.all:
84
77
revno = committer = ""
85
78
else:
86
79
last_seen = revision.revision_id
87
committer = revision.properties.get('author',
88
revision.committer)
80
committer = revision.committer
89
81
90
82
if revision.revision_id not in self.revisions:
91
83
self.revisions[revision.revision_id] = revision
97
89
None,
98
90
line.rstrip("\r\n")
99
91
])
100
self.annotations.append(revision)
101
92
102
93
if not self.plain:
103
now = time.time()
104
self.annomodel.foreach(self._highlight_annotation, now)
94
self._set_oldest_newest()
95
# Recall that calling activate_default will emit "span-changed",
96
# so self._span_changed_cb will take care of initial highlighting
97
self.span_selector.activate_default()
105
98
finally:
106
99
branch.repository.unlock()
107
100
branch.unlock()
116
109
# bar?
117
110
print("gannotate: Line number %d does't exist. Defaulting to "
118
111
"line 1." % lineno)
119
return
120
112
else:
121
113
row = lineno - 1
122
114
123
115
self.annoview.set_cursor(row)
124
self.annoview.scroll_to_cell(row, use_align=True)
125
116
126
def _dotted_revnos(self, repository, revision_id):
127
"""Return a dict of revision_id -> dotted revno
117
def _annotate(self, branch, file_id):
118
rev_hist = branch.revision_history()
119
repository = branch.repository
120
rev_tree = repository.revision_tree(branch.last_revision())
121
rev_id = rev_tree.inventory[file_id].revision
122
weave = repository.weave_store.get_weave(file_id,
123
branch.get_transaction())
128
124
129
:param repository: The repository to get the graph from
130
:param revision_id: The last revision for which this info is needed
131
"""
132
graph = repository.get_revision_graph(revision_id)
133
dotted = {}
134
for n, revision_id, d, revno, e in tsort.merge_sort(graph,
135
revision_id, generate_revno=True):
136
dotted[revision_id] = '.'.join(str(num) for num in revno)
137
return dotted
138
139
def _annotate(self, tree, file_id):
140
current_revision = FakeRevision(CURRENT_REVISION)
141
current_revision.committer = self.branch.get_config().username()
142
current_revision.timestamp = time.time()
143
current_revision.message = '[Not yet committed]'
144
current_revision.parent_ids = tree.get_parent_ids()
145
current_revision.properties['branch-nick'] = self.branch.nick
146
current_revno = '%d?' % (self.branch.revno() + 1)
147
repository = self.branch.repository
148
if self.revision_id == CURRENT_REVISION:
149
revision_id = self.branch.last_revision()
150
else:
151
revision_id = self.revision_id
152
dotted = self._dotted_revnos(repository, revision_id)
153
revision_cache = RevisionCache(repository, self.revisions)
154
for origin, text in tree.annotate_iter(file_id):
125
revision_cache = RevisionCache(repository)
126
for origin, text in weave.annotate_iter(rev_id):
155
127
rev_id = origin
156
if rev_id == CURRENT_REVISION:
157
revision = current_revision
158
revno = current_revno
159
else:
160
try:
161
revision = revision_cache.get_revision(rev_id)
162
revno = dotted.get(rev_id, 'merge')
163
if len(revno) > 15:
164
revno = 'merge'
165
except NoSuchRevision:
166
revision = FakeRevision(rev_id)
167
revno = "?"
128
try:
129
revision = revision_cache.get_revision(rev_id)
130
if rev_id in rev_hist:
131
revno = branch.revision_id_to_revno(rev_id)
132
else:
133
revno = "merge"
134
except NoSuchRevision:
135
revision = NoneRevision(rev_id)
136
revno = "?"
168
137
169
138
yield revision, revno, text
170
139
140
def _set_oldest_newest(self):
141
rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
142
oldest = min(rev_dates)
143
newest = max(rev_dates)
144
145
span = self._span_from_seconds(time.time() - oldest)
146
self.span_selector.set_to_oldest_span(span)
147
148
span = self._span_from_seconds(newest - oldest)
149
self.span_selector.set_newest_to_oldest_span(span)
150
151
def _span_from_seconds(self, seconds):
152
return (seconds / (24 * 60 * 60))
153
154
def _span_changed_cb(self, w, span):
155
self.annotate_colormap.set_span(span)
156
now = time.time()
157
self.annomodel.foreach(self._highlight_annotation, now)
158
171
159
def _highlight_annotation(self, model, path, iter, now):
172
160
revision_id, = model.get(iter, REVISION_ID_COL)
173
161
revision = self.revisions[revision_id]
174
162
model.set(iter, HIGHLIGHT_COLOR_COL,
175
163
self.annotate_colormap.get_color(revision, now))
176
164
177
def _selected_revision(self):
165
def _show_log(self, w):
178
166
(path, col) = self.annoview.get_cursor()
179
if path is None:
180
return None
181
return self.annomodel[path][REVISION_ID_COL]
182
183
def _activate_selected_revision(self, w):
184
rev_id = self._selected_revision()
185
if rev_id is None:
186
return
187
selected = self.revisions[rev_id]
188
self.logview.set_revision(selected)
189
if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
190
self._no_back):
191
enable_back = True
192
else:
193
enable_back = False
194
self.back_button.set_sensitive(enable_back)
167
rev_id = self.annomodel[path][REVISION_ID_COL]
168
self.logview.set_revision(self.revisions[rev_id])
195
169
196
170
def _create(self):
197
171
self.logview = self._create_log_view()
198
172
self.annoview = self._create_annotate_view()
173
self.span_selector = self._create_span_selector()
199
174
200
vbox = gtk.VBox(False)
175
vbox = gtk.VBox(False, 12)
176
vbox.set_border_width(12)
201
177
vbox.show()
202
178
203
179
sw = gtk.ScrolledWindow()
204
180
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
205
181
sw.set_shadow_type(gtk.SHADOW_IN)
206
182
sw.add(self.annoview)
207
self.annoview.gwindow = self
208
183
sw.show()
209
210
swbox = gtk.VBox()
211
swbox.pack_start(sw)
212
swbox.show()
213
214
hbox = gtk.HBox(False, 6)
215
self.back_button = self._create_back_button()
216
hbox.pack_start(self.back_button, expand=False, fill=True)
217
self.forward_button = self._create_forward_button()
218
hbox.pack_start(self.forward_button, expand=False, fill=True)
219
hbox.show()
220
vbox.pack_start(hbox, expand=False, fill=True)
221
184
222
185
self.pane = pane = gtk.VPaned()
223
pane.add1(swbox)
186
pane.add1(sw)
224
187
pane.add2(self.logview)
225
188
pane.show()
226
189
vbox.pack_start(pane, expand=True, fill=True)
227
228
self._search = SearchBox()
229
swbox.pack_start(self._search, expand=False, fill=True)
230
accels = gtk.AccelGroup()
231
accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
232
gtk.ACCEL_LOCKED,
233
self._search_by_text)
234
accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
235
gtk.ACCEL_LOCKED,
236
self._search_by_line)
237
self.add_accel_group(accels)
190
191
hbox = gtk.HBox(True, 6)
192
hbox.pack_start(self.span_selector, expand=False, fill=True)
193
hbox.pack_start(self._create_button_box(), expand=False, fill=True)
194
hbox.show()
195
vbox.pack_start(hbox, expand=False, fill=True)
238
196
239
197
self.add(vbox)
240
198
241
def _search_by_text(self, accel_group, window, key, modifiers):
242
self._search.show_for('text')
243
self._search.set_target(self.annoview, TEXT_LINE_COL)
244
245
def _search_by_line(self, accel_group, window, key, modifiers):
246
self._search.show_for('line')
247
self._search.set_target(self.annoview, LINE_NUM_COL)
248
249
def row_diff(self, tv, path, tvc):
250
row = path[0]
251
revision = self.annotations[row]
252
repository = self.branch.repository
253
if revision.revision_id == CURRENT_REVISION:
254
tree1 = self.tree
255
tree2 = self.tree.basis_tree()
256
else:
257
tree1 = repository.revision_tree(revision.revision_id)
258
if len(revision.parent_ids) > 0:
259
tree2 = repository.revision_tree(revision.parent_ids[0])
260
else:
261
tree2 = repository.revision_tree(NULL_REVISION)
262
from bzrlib.plugins.gtk.diff import DiffWindow
263
window = DiffWindow()
264
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
265
window.set_file(tree1.id2path(self.file_id))
266
window.show()
267
268
269
199
def _create_annotate_view(self):
270
200
tv = gtk.TreeView()
271
201
tv.set_rules_hint(False)
272
tv.connect("cursor-changed", self._activate_selected_revision)
202
tv.connect("cursor-changed", self._show_log)
273
203
tv.show()
274
tv.connect("row-activated", self.row_diff)
275
204
276
205
cell = gtk.CellRendererText()
277
206
cell.set_property("xalign", 1.0)
318
247
col.add_attribute(cell, "text", TEXT_LINE_COL)
319
248
tv.append_column(col)
320
249
321
# FIXME: Now that C-f is now used for search by text we
322
# may as well disable the auto search.
323
250
tv.set_search_column(LINE_NUM_COL)
324
251
325
252
return tv
326
253
254
def _create_span_selector(self):
255
ss = SpanSelector()
256
ss.connect("span-changed", self._span_changed_cb)
257
ss.show()
258
259
return ss
260
327
261
def _create_log_view(self):
328
262
lv = LogView()
329
263
lv.show()
264
330
265
return lv
331
266
332
def _create_back_button(self):
333
button = gtk.Button()
334
button.set_use_stock(True)
335
button.set_label("gtk-go-back")
336
button.connect("clicked", lambda w: self.go_back())
337
button.set_relief(gtk.RELIEF_NONE)
338
button.show()
339
return button
340
341
def _create_forward_button(self):
342
button = gtk.Button()
343
button.set_use_stock(True)
344
button.set_label("gtk-go-forward")
345
button.connect("clicked", lambda w: self.go_forward())
346
button.set_relief(gtk.RELIEF_NONE)
347
button.show()
348
button.set_sensitive(False)
349
return button
350
351
def go_back(self):
352
last_tree = self.tree
353
rev_id = self._selected_revision()
354
parent_id = self.revisions[rev_id].parent_ids[0]
355
target_tree = self.branch.repository.revision_tree(parent_id)
356
if self._go(target_tree):
357
self.history.append(last_tree)
358
self.forward_button.set_sensitive(True)
359
else:
360
self._no_back.add(parent_id)
361
self.back_button.set_sensitive(False)
362
363
def go_forward(self):
364
if len(self.history) == 0:
365
return
366
target_tree = self.history.pop()
367
if len(self.history) == 0:
368
self.forward_button.set_sensitive(False)
369
self._go(target_tree)
370
371
def _go(self, target_tree):
372
rev_id = self._selected_revision()
373
if self.file_id in target_tree:
374
offset = self.get_scroll_offset(target_tree)
375
(row,), col = self.annoview.get_cursor()
376
self.annotate(target_tree, self.branch, self.file_id)
377
new_row = row+offset
378
if new_row < 0:
379
new_row = 0
380
self.annoview.set_cursor(new_row)
381
return True
382
else:
383
return False
384
385
def get_scroll_offset(self, tree):
386
old = self.tree.get_file(self.file_id)
387
new = tree.get_file(self.file_id)
388
(row,), col = self.annoview.get_cursor()
389
matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
390
new.readlines())
391
for i, j, n in matcher.get_matching_blocks():
392
if i + n >= row:
393
return j - i
394
395
396
397
class FakeRevision:
267
def _create_button_box(self):
268
box = gtk.HButtonBox()
269
box.set_layout(gtk.BUTTONBOX_END)
270
box.show()
271
272
button = gtk.Button()
273
button.set_use_stock(True)
274
button.set_label("gtk-close")
275
button.connect("clicked", lambda w: self.destroy())
276
button.show()
277
278
box.pack_start(button, expand=False, fill=False)
279
280
return box
281
282
283
class NoneRevision:
398
284
""" A fake revision.
399
285
400
286
For when a revision is referenced but not present.
401
287
"""
402
288
403
def __init__(self, revision_id, committer='?', nick=None):
289
def __init__(self, revision_id):
404
290
self.revision_id = revision_id
405
291
self.parent_ids = []
406
self.committer = committer
292
self.committer = "?"
407
293
self.message = "?"
408
294
self.timestamp = 0.0
409
295
self.timezone = 0
410
self.properties = {}
411
296
412
297
413
298
class RevisionCache(object):
414
299
"""A caching revision source"""
415
def __init__(self, real_source, seed_cache=None):
300
def __init__(self, real_source):
416
301
self.__real_source = real_source
417
if seed_cache is None:
418
self.__cache = {}
419
else:
420
self.__cache = dict(seed_cache)
302
self.__cache = {}
421
303
422
304
def get_revision(self, revision_id):
423
305
if revision_id not in self.__cache:
424
306
revision = self.__real_source.get_revision(revision_id)
425
307
self.__cache[revision_id] = revision
426
308
return self.__cache[revision_id]
427
428
class SearchBox(gtk.HBox):
429
"""A button box for searching in text or lines of annotations"""
430
def __init__(self):
431
gtk.HBox.__init__(self, False, 6)
432
433
# Close button
434
button = gtk.Button()
435
image = gtk.Image()
436
image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
437
button.set_image(image)
438
button.set_relief(gtk.RELIEF_NONE)
439
button.connect("clicked", lambda w: self.hide_all())
440
self.pack_start(button, expand=False, fill=False)
441
442
# Search entry
443
label = gtk.Label()
444
self._label = label
445
self.pack_start(label, expand=False, fill=False)
446
447
entry = gtk.Entry()
448
self._entry = entry
449
entry.connect("activate", lambda w, d: self._do_search(d),
450
'forward')
451
self.pack_start(entry, expand=False, fill=False)
452
453
# Next/previous buttons
454
button = gtk.Button('_Next')
455
image = gtk.Image()
456
image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
457
button.set_image(image)
458
button.connect("clicked", lambda w, d: self._do_search(d),
459
'forward')
460
self.pack_start(button, expand=False, fill=False)
461
462
button = gtk.Button('_Previous')
463
image = gtk.Image()
464
image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
465
button.set_image(image)
466
button.connect("clicked", lambda w, d: self._do_search(d),
467
'backward')
468
self.pack_start(button, expand=False, fill=False)
469
470
# Search options
471
check = gtk.CheckButton('Match case')
472
self._match_case = check
473
self.pack_start(check, expand=False, fill=False)
474
475
check = gtk.CheckButton('Regexp')
476
check.connect("toggled", lambda w: self._set_label())
477
self._regexp = check
478
self.pack_start(check, expand=False, fill=False)
479
480
self._view = None
481
self._column = None
482
# Note that we stay hidden (we do not call self.show_all())
483
484
485
def show_for(self, kind):
486
self._kind = kind
487
self.show_all()
488
self._set_label()
489
# Hide unrelated buttons
490
if kind == 'line':
491
self._match_case.hide()
492
self._regexp.hide()
493
# Be ready
494
self._entry.grab_focus()
495
496
def _set_label(self):
497
if self._kind == 'line':
498
self._label.set_text('Find Line: ')
499
else:
500
if self._regexp.get_active():
501
self._label.set_text('Find Regexp: ')
502
else:
503
self._label.set_text('Find Text: ')
504
505
def set_target(self, view,column):
506
self._view = view
507
self._column = column
508
509
def _match(self, model, iterator, column):
510
matching_case = self._match_case.get_active()
511
string, = model.get(iterator, column)
512
key = self._entry.get_text()
513
if self._regexp.get_active():
514
if matching_case:
515
match = re.compile(key).search(string, 1)
516
else:
517
match = re.compile(key, re.I).search(string, 1)
518
else:
519
if not matching_case:
520
string = string.lower()
521
key = key.lower()
522
match = string.find(key) != -1
523
524
return match
525
526
def _iterate_rows_forward(self, model, start):
527
model_size = len(model)
528
current = start + 1
529
while model_size != 0:
530
if current >= model_size: current = 0
531
yield model.get_iter_from_string('%d' % current)
532
if current == start: raise StopIteration
533
current += 1
534
535
def _iterate_rows_backward(self, model, start):
536
model_size = len(model)
537
current = start - 1
538
while model_size != 0:
539
if current < 0: current = model_size - 1
540
yield model.get_iter_from_string('%d' % current)
541
if current == start: raise StopIteration
542
current -= 1
543
544
def _do_search(self, direction):
545
if direction == 'forward':
546
iterate = self._iterate_rows_forward
547
else:
548
iterate = self._iterate_rows_backward
549
550
model, sel = self._view.get_selection().get_selected()
551
if sel is None:
552
start = 0
553
else:
554
path = model.get_string_from_iter(sel)
555
start = int(path)
556
557
for row in iterate(model, start):
558
if self._match(model, row, self._column):
559
path = model.get_path(row)
560
self._view.set_cursor(path)
561
self._view.scroll_to_cell(path, use_align=True)
562
break
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0