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