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 85
- compare with another revision
- download diff
- download tarball
- view history from revision 85
- Committer: Jelmer Vernooij
- Date: 2006-09-30 10:21:43 UTC
- Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.
- files added:
- NEWS
- debian
- files removed:
- HACKING
- tests
- files renamed:
- logview.py => annotate/logview.py
- branch.py => olive/branch.py
- checkout.py => olive/checkout.py
- commit.py => olive/commit.py
- dialog.py => olive/dialog.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
- viz/linegraph.py => viz/graph.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
27
25
from bzrlib.errors import NoSuchRevision
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
26
from bzrlib.revision import NULL_REVISION
29
27
30
28
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
from bzrlib.plugins.gtk.logview import LogView
32
from bzrlib.plugins.gtk.window import Window
29
from logview import LogView
30
from spanselector import SpanSelector
33
31
34
32
35
33
(
42
40
) = range(6)
43
41
44
42
45
class GAnnotateWindow(Window):
43
class GAnnotateWindow(gtk.Window):
46
44
"""Annotate window."""
47
45
48
def __init__(self, all=False, plain=False, parent=None):
46
def __init__(self, all=False, plain=False):
49
47
self.all = all
50
48
self.plain = plain
51
49
52
Window.__init__(self, parent)
50
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
53
51
54
52
self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
55
53
self.annotate_colormap = AnnotateColorSaturation()
56
54
57
55
self._create()
56
57
if self.plain:
58
self.span_selector.hide()
59
60
def annotate(self, branch, file_id):
58
61
self.revisions = {}
59
self.history = []
60
self._no_back = set()
61
62
def annotate(self, tree, branch, file_id):
63
62
self.annotations = []
64
63
self.branch = branch
65
self.tree = tree
66
64
self.file_id = file_id
67
self.revision_id = getattr(tree, 'get_revision_id',
68
lambda: CURRENT_REVISION)()
69
65
70
# [revision id, line number, author, revno, highlight color, line]
66
# [revision id, line number, committer, revno, highlight color, line]
71
67
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
72
68
gobject.TYPE_STRING,
73
69
gobject.TYPE_STRING,
80
76
branch.lock_read()
81
77
branch.repository.lock_read()
82
78
for line_no, (revision, revno, line)\
83
in enumerate(self._annotate(tree, file_id)):
79
in enumerate(self._annotate(branch, file_id)):
84
80
if revision.revision_id == last_seen and not self.all:
85
revno = author = ""
81
revno = committer = ""
86
82
else:
87
83
last_seen = revision.revision_id
88
author = revision.get_apparent_author()
84
committer = revision.committer
89
85
90
86
if revision.revision_id not in self.revisions:
91
87
self.revisions[revision.revision_id] = revision
92
88
93
89
self.annomodel.append([revision.revision_id,
94
90
line_no + 1,
95
author,
91
committer,
96
92
revno,
97
93
None,
98
94
line.rstrip("\r\n")
100
96
self.annotations.append(revision)
101
97
102
98
if not self.plain:
103
now = time.time()
104
self.annomodel.foreach(self._highlight_annotation, now)
99
self._set_oldest_newest()
100
# Recall that calling activate_default will emit "span-changed",
101
# so self._span_changed_cb will take care of initial highlighting
102
self.span_selector.activate_default()
105
103
finally:
106
104
branch.repository.unlock()
107
105
branch.unlock()
123
121
self.annoview.set_cursor(row)
124
122
self.annoview.scroll_to_cell(row, use_align=True)
125
123
126
def _dotted_revnos(self, repository, revision_id):
127
"""Return a dict of revision_id -> dotted revno
124
def _annotate(self, branch, file_id):
125
rev_hist = branch.revision_history()
126
repository = branch.repository
127
rev_tree = repository.revision_tree(branch.last_revision())
128
rev_id = rev_tree.inventory[file_id].revision
129
weave = repository.weave_store.get_weave(file_id,
130
branch.get_transaction())
128
131
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):
132
revision_cache = RevisionCache(repository)
133
for origin, text in weave.annotate_iter(rev_id):
155
134
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 = "?"
135
try:
136
revision = revision_cache.get_revision(rev_id)
137
if rev_id in rev_hist:
138
revno = branch.revision_id_to_revno(rev_id)
139
else:
140
revno = "merge"
141
except NoSuchRevision:
142
revision = NoneRevision(rev_id)
143
revno = "?"
168
144
169
145
yield revision, revno, text
170
146
147
def _set_oldest_newest(self):
148
rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
149
if len(rev_dates) == 0:
150
return
151
oldest = min(rev_dates)
152
newest = max(rev_dates)
153
154
span = self._span_from_seconds(time.time() - oldest)
155
self.span_selector.set_to_oldest_span(span)
156
157
span = self._span_from_seconds(newest - oldest)
158
self.span_selector.set_newest_to_oldest_span(span)
159
160
def _span_from_seconds(self, seconds):
161
return (seconds / (24 * 60 * 60))
162
163
def _span_changed_cb(self, w, span):
164
self.annotate_colormap.set_span(span)
165
now = time.time()
166
self.annomodel.foreach(self._highlight_annotation, now)
167
171
168
def _highlight_annotation(self, model, path, iter, now):
172
169
revision_id, = model.get(iter, REVISION_ID_COL)
173
170
revision = self.revisions[revision_id]
174
171
model.set(iter, HIGHLIGHT_COLOR_COL,
175
172
self.annotate_colormap.get_color(revision, now))
176
173
177
def _selected_revision(self):
174
def _show_log(self, w):
178
175
(path, col) = self.annoview.get_cursor()
179
176
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
177
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)
178
rev_id = self.annomodel[path][REVISION_ID_COL]
179
self.logview.set_revision(self.revisions[rev_id])
195
180
196
181
def _create(self):
197
182
self.logview = self._create_log_view()
198
183
self.annoview = self._create_annotate_view()
184
self.span_selector = self._create_span_selector()
199
185
200
vbox = gtk.VBox(False)
186
vbox = gtk.VBox(False, 12)
187
vbox.set_border_width(12)
201
188
vbox.show()
202
189
203
190
sw = gtk.ScrolledWindow()
206
193
sw.add(self.annoview)
207
194
self.annoview.gwindow = self
208
195
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
196
222
197
self.pane = pane = gtk.VPaned()
223
pane.add1(swbox)
198
pane.add1(sw)
224
199
pane.add2(self.logview)
225
200
pane.show()
226
201
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)
202
203
hbox = gtk.HBox(True, 6)
204
hbox.pack_start(self.span_selector, expand=False, fill=True)
205
hbox.pack_start(self._create_button_box(), expand=False, fill=True)
206
hbox.show()
207
vbox.pack_start(hbox, expand=False, fill=True)
238
208
239
209
self.add(vbox)
240
210
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
211
def row_diff(self, tv, path, tvc):
250
212
row = path[0]
251
213
revision = self.annotations[row]
252
214
repository = self.branch.repository
253
if revision.revision_id == CURRENT_REVISION:
254
tree1 = self.tree
255
tree2 = self.tree.basis_tree()
215
tree1 = repository.revision_tree(revision.revision_id)
216
if len(revision.parent_ids) > 0:
217
tree2 = repository.revision_tree(revision.parent_ids[0])
256
218
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
219
tree2 = repository.revision_tree(NULL_REVISION)
220
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
263
221
window = DiffWindow()
264
222
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
265
223
window.set_file(tree1.id2path(self.file_id))
269
227
def _create_annotate_view(self):
270
228
tv = gtk.TreeView()
271
229
tv.set_rules_hint(False)
272
tv.connect("cursor-changed", self._activate_selected_revision)
230
tv.connect("cursor-changed", self._show_log)
273
231
tv.show()
274
232
tv.connect("row-activated", self.row_diff)
275
233
318
276
col.add_attribute(cell, "text", TEXT_LINE_COL)
319
277
tv.append_column(col)
320
278
321
# FIXME: Now that C-f is now used for search by text we
322
# may as well disable the auto search.
323
279
tv.set_search_column(LINE_NUM_COL)
324
280
325
281
return tv
326
282
283
def _create_span_selector(self):
284
ss = SpanSelector()
285
ss.connect("span-changed", self._span_changed_cb)
286
ss.show()
287
288
return ss
289
327
290
def _create_log_view(self):
328
291
lv = LogView()
329
292
lv.show()
293
330
294
return lv
331
295
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
class FakeRevision:
296
def _create_button_box(self):
297
box = gtk.HButtonBox()
298
box.set_layout(gtk.BUTTONBOX_END)
299
box.show()
300
301
button = gtk.Button()
302
button.set_use_stock(True)
303
button.set_label("gtk-close")
304
button.connect("clicked", lambda w: self.destroy())
305
button.show()
306
307
box.pack_start(button, expand=False, fill=False)
308
309
return box
310
311
312
class NoneRevision:
397
313
""" A fake revision.
398
314
399
315
For when a revision is referenced but not present.
400
316
"""
401
317
402
def __init__(self, revision_id, committer='?', nick=None):
318
def __init__(self, revision_id):
403
319
self.revision_id = revision_id
404
320
self.parent_ids = []
405
self.committer = committer
321
self.committer = "?"
406
322
self.message = "?"
407
323
self.timestamp = 0.0
408
324
self.timezone = 0
409
self.properties = {}
410
411
def get_apparent_author(self):
412
return self.committer
413
325
414
326
415
327
class RevisionCache(object):
416
328
"""A caching revision source"""
417
def __init__(self, real_source, seed_cache=None):
329
def __init__(self, real_source):
418
330
self.__real_source = real_source
419
if seed_cache is None:
420
self.__cache = {}
421
else:
422
self.__cache = dict(seed_cache)
331
self.__cache = {}
423
332
424
333
def get_revision(self, revision_id):
425
334
if revision_id not in self.__cache:
426
335
revision = self.__real_source.get_revision(revision_id)
427
336
self.__cache[revision_id] = revision
428
337
return self.__cache[revision_id]
429
430
class SearchBox(gtk.HBox):
431
"""A button box for searching in text or lines of annotations"""
432
def __init__(self):
433
gtk.HBox.__init__(self, False, 6)
434
435
# Close button
436
button = gtk.Button()
437
image = gtk.Image()
438
image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
439
button.set_image(image)
440
button.set_relief(gtk.RELIEF_NONE)
441
button.connect("clicked", lambda w: self.hide_all())
442
self.pack_start(button, expand=False, fill=False)
443
444
# Search entry
445
label = gtk.Label()
446
self._label = label
447
self.pack_start(label, expand=False, fill=False)
448
449
entry = gtk.Entry()
450
self._entry = entry
451
entry.connect("activate", lambda w, d: self._do_search(d),
452
'forward')
453
self.pack_start(entry, expand=False, fill=False)
454
455
# Next/previous buttons
456
button = gtk.Button('_Next')
457
image = gtk.Image()
458
image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
459
button.set_image(image)
460
button.connect("clicked", lambda w, d: self._do_search(d),
461
'forward')
462
self.pack_start(button, expand=False, fill=False)
463
464
button = gtk.Button('_Previous')
465
image = gtk.Image()
466
image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
467
button.set_image(image)
468
button.connect("clicked", lambda w, d: self._do_search(d),
469
'backward')
470
self.pack_start(button, expand=False, fill=False)
471
472
# Search options
473
check = gtk.CheckButton('Match case')
474
self._match_case = check
475
self.pack_start(check, expand=False, fill=False)
476
477
check = gtk.CheckButton('Regexp')
478
check.connect("toggled", lambda w: self._set_label())
479
self._regexp = check
480
self.pack_start(check, expand=False, fill=False)
481
482
self._view = None
483
self._column = None
484
# Note that we stay hidden (we do not call self.show_all())
485
486
487
def show_for(self, kind):
488
self._kind = kind
489
self.show_all()
490
self._set_label()
491
# Hide unrelated buttons
492
if kind == 'line':
493
self._match_case.hide()
494
self._regexp.hide()
495
# Be ready
496
self._entry.grab_focus()
497
498
def _set_label(self):
499
if self._kind == 'line':
500
self._label.set_text('Find Line: ')
501
else:
502
if self._regexp.get_active():
503
self._label.set_text('Find Regexp: ')
504
else:
505
self._label.set_text('Find Text: ')
506
507
def set_target(self, view,column):
508
self._view = view
509
self._column = column
510
511
def _match(self, model, iterator, column):
512
matching_case = self._match_case.get_active()
513
string, = model.get(iterator, column)
514
key = self._entry.get_text()
515
if self._regexp.get_active():
516
if matching_case:
517
match = re.compile(key).search(string, 1)
518
else:
519
match = re.compile(key, re.I).search(string, 1)
520
else:
521
if not matching_case:
522
string = string.lower()
523
key = key.lower()
524
match = string.find(key) != -1
525
526
return match
527
528
def _iterate_rows_forward(self, model, start):
529
model_size = len(model)
530
current = start + 1
531
while model_size != 0:
532
if current >= model_size: current = 0
533
yield model.get_iter_from_string('%d' % current)
534
if current == start: raise StopIteration
535
current += 1
536
537
def _iterate_rows_backward(self, model, start):
538
model_size = len(model)
539
current = start - 1
540
while model_size != 0:
541
if current < 0: current = model_size - 1
542
yield model.get_iter_from_string('%d' % current)
543
if current == start: raise StopIteration
544
current -= 1
545
546
def _do_search(self, direction):
547
if direction == 'forward':
548
iterate = self._iterate_rows_forward
549
else:
550
iterate = self._iterate_rows_backward
551
552
model, sel = self._view.get_selection().get_selected()
553
if sel is None:
554
start = 0
555
else:
556
path = model.get_string_from_iter(sel)
557
start = int(path)
558
559
for row in iterate(model, start):
560
if self._match(model, row, self._column):
561
path = model.get_path(row)
562
self._view.set_cursor(path)
563
self._view.scroll_to_cell(path, use_align=True)
564
break
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0