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