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
- 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
29
from logview import LogView
30
from spanselector import SpanSelector
32
31
33
32
34
33
(
54
53
self.annotate_colormap = AnnotateColorSaturation()
55
54
56
55
self._create()
56
57
if self.plain:
58
self.span_selector.hide()
59
60
def annotate(self, branch, file_id):
57
61
self.revisions = {}
58
self.history = []
59
self._no_back = set()
60
61
def annotate(self, tree, branch, file_id):
62
62
self.annotations = []
63
63
self.branch = branch
64
self.tree = tree
65
64
self.file_id = file_id
66
self.revision_id = getattr(tree, 'get_revision_id',
67
lambda: CURRENT_REVISION)()
68
65
69
# [revision id, line number, author, revno, highlight color, line]
66
# [revision id, line number, committer, revno, highlight color, line]
70
67
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
71
68
gobject.TYPE_STRING,
72
69
gobject.TYPE_STRING,
79
76
branch.lock_read()
80
77
branch.repository.lock_read()
81
78
for line_no, (revision, revno, line)\
82
in enumerate(self._annotate(tree, file_id)):
79
in enumerate(self._annotate(branch, file_id)):
83
80
if revision.revision_id == last_seen and not self.all:
84
81
revno = committer = ""
85
82
else:
86
83
last_seen = revision.revision_id
87
committer = revision.properties.get('author',
88
revision.committer)
84
committer = revision.committer
89
85
90
86
if revision.revision_id not in self.revisions:
91
87
self.revisions[revision.revision_id] = revision
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
397
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:
398
313
""" A fake revision.
399
314
400
315
For when a revision is referenced but not present.
401
316
"""
402
317
403
def __init__(self, revision_id, committer='?', nick=None):
318
def __init__(self, revision_id):
404
319
self.revision_id = revision_id
405
320
self.parent_ids = []
406
self.committer = committer
321
self.committer = "?"
407
322
self.message = "?"
408
323
self.timestamp = 0.0
409
324
self.timezone = 0
410
self.properties = {}
411
325
412
326
413
327
class RevisionCache(object):
414
328
"""A caching revision source"""
415
def __init__(self, real_source, seed_cache=None):
329
def __init__(self, real_source):
416
330
self.__real_source = real_source
417
if seed_cache is None:
418
self.__cache = {}
419
else:
420
self.__cache = dict(seed_cache)
331
self.__cache = {}
421
332
422
333
def get_revision(self, revision_id):
423
334
if revision_id not in self.__cache:
424
335
revision = self.__real_source.get_revision(revision_id)
425
336
self.__cache[revision_id] = revision
426
337
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