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