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 260
- compare with another revision
- download diff
- download tarball
- view history from revision 260
- Committer: Aaron Bentley
- Date: 2007-08-16 14:31:02 UTC
- Revision ID: abentley@panoramicfeedback.com-20070816143102-27yzfhdgdv3ggo6e
Fix hue selection to use author in gannotate
- files added:
- .bzrignore
- icons
- olive
- po
- tests
- files removed:
- .bzrignore
- files renamed:
- viz/diffwin.py => diff.py
- annotate/logview.py => logview.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.logview import LogView
31
32
32
33
33
34
(
53
54
self.annotate_colormap = AnnotateColorSaturation()
54
55
55
56
self._create()
56
57
if self.plain:
58
self.span_selector.hide()
59
60
def annotate(self, branch, file_id):
61
57
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
64
65
self.file_id = file_id
66
self.revision_id = getattr(tree, 'get_revision_id',
67
lambda: CURRENT_REVISION)()
65
68
66
# [revision id, line number, committer, revno, highlight color, line]
69
# [revision id, line number, author, revno, highlight color, line]
67
70
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
68
71
gobject.TYPE_STRING,
69
72
gobject.TYPE_STRING,
76
79
branch.lock_read()
77
80
branch.repository.lock_read()
78
81
for line_no, (revision, revno, line)\
79
in enumerate(self._annotate(branch, file_id)):
82
in enumerate(self._annotate(tree, file_id)):
80
83
if revision.revision_id == last_seen and not self.all:
81
84
revno = committer = ""
82
85
else:
83
86
last_seen = revision.revision_id
84
committer = revision.committer
87
committer = revision.properties.get('author',
88
revision.committer)
85
89
86
90
if revision.revision_id not in self.revisions:
87
91
self.revisions[revision.revision_id] = revision
96
100
self.annotations.append(revision)
97
101
98
102
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()
103
now = time.time()
104
self.annomodel.foreach(self._highlight_annotation, now)
103
105
finally:
104
106
branch.repository.unlock()
105
107
branch.unlock()
114
116
# bar?
115
117
print("gannotate: Line number %d does't exist. Defaulting to "
116
118
"line 1." % lineno)
119
return
117
120
else:
118
121
row = lineno - 1
119
122
120
123
self.annoview.set_cursor(row)
121
124
self.annoview.scroll_to_cell(row, use_align=True)
122
125
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())
126
def _dotted_revnos(self, repository, revision_id):
127
"""Return a dict of revision_id -> dotted revno
130
128
131
revision_cache = RevisionCache(repository)
132
for origin, text in weave.annotate_iter(rev_id):
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):
133
155
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 = "?"
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 = "?"
143
168
144
169
yield revision, revno, text
145
170
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
171
def _highlight_annotation(self, model, path, iter, now):
166
172
revision_id, = model.get(iter, REVISION_ID_COL)
167
173
revision = self.revisions[revision_id]
168
174
model.set(iter, HIGHLIGHT_COLOR_COL,
169
175
self.annotate_colormap.get_color(revision, now))
170
176
171
def _show_log(self, w):
177
def _selected_revision(self):
172
178
(path, col) = self.annoview.get_cursor()
173
rev_id = self.annomodel[path][REVISION_ID_COL]
174
self.logview.set_revision(self.revisions[rev_id])
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)
175
195
176
196
def _create(self):
177
197
self.logview = self._create_log_view()
178
198
self.annoview = self._create_annotate_view()
179
self.span_selector = self._create_span_selector()
180
199
181
vbox = gtk.VBox(False, 12)
182
vbox.set_border_width(12)
200
vbox = gtk.VBox(False)
183
201
vbox.show()
184
202
185
203
sw = gtk.ScrolledWindow()
188
206
sw.add(self.annoview)
189
207
self.annoview.gwindow = self
190
208
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)
191
221
192
222
self.pane = pane = gtk.VPaned()
193
pane.add1(sw)
223
pane.add1(swbox)
194
224
pane.add2(self.logview)
195
225
pane.show()
196
226
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)
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)
203
238
204
239
self.add(vbox)
205
240
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
206
249
def row_diff(self, tv, path, tvc):
207
250
row = path[0]
208
251
revision = self.annotations[row]
209
252
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])
253
if revision.revision_id == CURRENT_REVISION:
254
tree1 = self.tree
255
tree2 = self.tree.basis_tree()
213
256
else:
214
tree2 = repository.revision_tree(NULL_REVISION)
215
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
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
216
263
window = DiffWindow()
217
264
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
218
265
window.set_file(tree1.id2path(self.file_id))
222
269
def _create_annotate_view(self):
223
270
tv = gtk.TreeView()
224
271
tv.set_rules_hint(False)
225
tv.connect("cursor-changed", self._show_log)
272
tv.connect("cursor-changed", self._activate_selected_revision)
226
273
tv.show()
227
274
tv.connect("row-activated", self.row_diff)
228
275
271
318
col.add_attribute(cell, "text", TEXT_LINE_COL)
272
319
tv.append_column(col)
273
320
321
# FIXME: Now that C-f is now used for search by text we
322
# may as well disable the auto search.
274
323
tv.set_search_column(LINE_NUM_COL)
275
324
276
325
return tv
277
326
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
327
def _create_log_view(self):
286
328
lv = LogView()
287
329
lv.show()
288
289
330
return lv
290
331
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:
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:
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 = {}
320
411
321
412
322
413
class RevisionCache(object):
323
414
"""A caching revision source"""
324
def __init__(self, real_source):
415
def __init__(self, real_source, seed_cache=None):
325
416
self.__real_source = real_source
326
self.__cache = {}
417
if seed_cache is None:
418
self.__cache = {}
419
else:
420
self.__cache = dict(seed_cache)
327
421
328
422
def get_revision(self, revision_id):
329
423
if revision_id not in self.__cache:
330
424
revision = self.__real_source.get_revision(revision_id)
331
425
self.__cache[revision_id] = revision
332
426
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