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 231
- compare with another revision
- download diff
- download tarball
- view history from revision 231
- Committer: Jelmer Vernooij
- Date: 2007-07-15 18:12:57 UTC
- Revision ID: jelmer@samba.org-20070715181257-g264qus2zyi3v39z
Add RevisionSelectionBox widget, use in TagDialog.
- 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
69
# [revision id, line number, committer, revno, highlight color, line]
67
70
self.annomodel = gtk.ListStore(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:
96
99
self.annotations.append(revision)
97
100
98
101
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()
102
now = time.time()
103
self.annomodel.foreach(self._highlight_annotation, now)
103
104
finally:
104
105
branch.repository.unlock()
105
106
branch.unlock()
114
115
# bar?
115
116
print("gannotate: Line number %d does't exist. Defaulting to "
116
117
"line 1." % lineno)
118
return
117
119
else:
118
120
row = lineno - 1
119
121
120
122
self.annoview.set_cursor(row)
121
123
self.annoview.scroll_to_cell(row, use_align=True)
122
124
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())
125
def _dotted_revnos(self, repository, revision_id):
126
"""Return a dict of revision_id -> dotted revno
130
127
131
revision_cache = RevisionCache(repository)
132
for origin, text in weave.annotate_iter(rev_id):
128
:param repository: The repository to get the graph from
129
:param revision_id: The last revision for which this info is needed
130
"""
131
graph = repository.get_revision_graph(revision_id)
132
dotted = {}
133
for n, revision_id, d, revno, e in tsort.merge_sort(graph,
134
revision_id, generate_revno=True):
135
dotted[revision_id] = '.'.join(str(num) for num in revno)
136
return dotted
137
138
def _annotate(self, tree, file_id):
139
current_revision = FakeRevision(CURRENT_REVISION)
140
current_revision.committer = self.branch.get_config().username()
141
current_revision.timestamp = time.time()
142
current_revision.message = '[Not yet committed]'
143
current_revision.parent_ids = tree.get_parent_ids()
144
current_revision.properties['branch-nick'] = self.branch.nick
145
current_revno = '%d?' % (self.branch.revno() + 1)
146
repository = self.branch.repository
147
if self.revision_id == CURRENT_REVISION:
148
revision_id = self.branch.last_revision()
149
else:
150
revision_id = self.revision_id
151
dotted = self._dotted_revnos(repository, revision_id)
152
revision_cache = RevisionCache(repository, self.revisions)
153
for origin, text in tree.annotate_iter(file_id):
133
154
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 = "?"
155
if rev_id == CURRENT_REVISION:
156
revision = current_revision
157
revno = current_revno
158
else:
159
try:
160
revision = revision_cache.get_revision(rev_id)
161
revno = dotted.get(rev_id, 'merge')
162
if len(revno) > 15:
163
revno = 'merge'
164
except NoSuchRevision:
165
revision = FakeRevision(rev_id)
166
revno = "?"
143
167
144
168
yield revision, revno, text
145
169
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
170
def _highlight_annotation(self, model, path, iter, now):
166
171
revision_id, = model.get(iter, REVISION_ID_COL)
167
172
revision = self.revisions[revision_id]
168
173
model.set(iter, HIGHLIGHT_COLOR_COL,
169
174
self.annotate_colormap.get_color(revision, now))
170
175
171
def _show_log(self, w):
176
def _selected_revision(self):
172
177
(path, col) = self.annoview.get_cursor()
173
rev_id = self.annomodel[path][REVISION_ID_COL]
174
self.logview.set_revision(self.revisions[rev_id])
178
if path is None:
179
return None
180
return self.annomodel[path][REVISION_ID_COL]
181
182
def _activate_selected_revision(self, w):
183
rev_id = self._selected_revision()
184
if rev_id is None:
185
return
186
selected = self.revisions[rev_id]
187
self.logview.set_revision(selected)
188
if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
189
self._no_back):
190
enable_back = True
191
else:
192
enable_back = False
193
self.back_button.set_sensitive(enable_back)
175
194
176
195
def _create(self):
177
196
self.logview = self._create_log_view()
178
197
self.annoview = self._create_annotate_view()
179
self.span_selector = self._create_span_selector()
180
198
181
vbox = gtk.VBox(False, 12)
182
vbox.set_border_width(12)
199
vbox = gtk.VBox(False)
183
200
vbox.show()
184
201
185
202
sw = gtk.ScrolledWindow()
188
205
sw.add(self.annoview)
189
206
self.annoview.gwindow = self
190
207
sw.show()
208
209
swbox = gtk.VBox()
210
swbox.pack_start(sw)
211
swbox.show()
212
213
hbox = gtk.HBox(False, 6)
214
self.back_button = self._create_back_button()
215
hbox.pack_start(self.back_button, expand=False, fill=True)
216
self.forward_button = self._create_forward_button()
217
hbox.pack_start(self.forward_button, expand=False, fill=True)
218
hbox.show()
219
vbox.pack_start(hbox, expand=False, fill=True)
191
220
192
221
self.pane = pane = gtk.VPaned()
193
pane.add1(sw)
222
pane.add1(swbox)
194
223
pane.add2(self.logview)
195
224
pane.show()
196
225
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)
226
227
self._search = SearchBox()
228
swbox.pack_start(self._search, expand=False, fill=True)
229
accels = gtk.AccelGroup()
230
accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
231
gtk.ACCEL_LOCKED,
232
self._search_by_text)
233
accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
234
gtk.ACCEL_LOCKED,
235
self._search_by_line)
236
self.add_accel_group(accels)
203
237
204
238
self.add(vbox)
205
239
240
def _search_by_text(self, accel_group, window, key, modifiers):
241
self._search.show_for('text')
242
self._search.set_target(self.annoview, TEXT_LINE_COL)
243
244
def _search_by_line(self, accel_group, window, key, modifiers):
245
self._search.show_for('line')
246
self._search.set_target(self.annoview, LINE_NUM_COL)
247
206
248
def row_diff(self, tv, path, tvc):
207
249
row = path[0]
208
250
revision = self.annotations[row]
209
251
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])
252
if revision.revision_id == CURRENT_REVISION:
253
tree1 = self.tree
254
tree2 = self.tree.basis_tree()
213
255
else:
214
tree2 = repository.revision_tree(NULL_REVISION)
215
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
256
tree1 = repository.revision_tree(revision.revision_id)
257
if len(revision.parent_ids) > 0:
258
tree2 = repository.revision_tree(revision.parent_ids[0])
259
else:
260
tree2 = repository.revision_tree(NULL_REVISION)
261
from bzrlib.plugins.gtk.diff import DiffWindow
216
262
window = DiffWindow()
217
263
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
218
264
window.set_file(tree1.id2path(self.file_id))
222
268
def _create_annotate_view(self):
223
269
tv = gtk.TreeView()
224
270
tv.set_rules_hint(False)
225
tv.connect("cursor-changed", self._show_log)
271
tv.connect("cursor-changed", self._activate_selected_revision)
226
272
tv.show()
227
273
tv.connect("row-activated", self.row_diff)
228
274
271
317
col.add_attribute(cell, "text", TEXT_LINE_COL)
272
318
tv.append_column(col)
273
319
320
# FIXME: Now that C-f is now used for search by text we
321
# may as well disable the auto search.
274
322
tv.set_search_column(LINE_NUM_COL)
275
323
276
324
return tv
277
325
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
326
def _create_log_view(self):
286
327
lv = LogView()
287
328
lv.show()
288
289
329
return lv
290
330
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:
331
def _create_back_button(self):
332
button = gtk.Button()
333
button.set_use_stock(True)
334
button.set_label("gtk-go-back")
335
button.connect("clicked", lambda w: self.go_back())
336
button.set_relief(gtk.RELIEF_NONE)
337
button.show()
338
return button
339
340
def _create_forward_button(self):
341
button = gtk.Button()
342
button.set_use_stock(True)
343
button.set_label("gtk-go-forward")
344
button.connect("clicked", lambda w: self.go_forward())
345
button.set_relief(gtk.RELIEF_NONE)
346
button.show()
347
button.set_sensitive(False)
348
return button
349
350
def go_back(self):
351
last_tree = self.tree
352
rev_id = self._selected_revision()
353
parent_id = self.revisions[rev_id].parent_ids[0]
354
target_tree = self.branch.repository.revision_tree(parent_id)
355
if self._go(target_tree):
356
self.history.append(last_tree)
357
self.forward_button.set_sensitive(True)
358
else:
359
self._no_back.add(parent_id)
360
self.back_button.set_sensitive(False)
361
362
def go_forward(self):
363
if len(self.history) == 0:
364
return
365
target_tree = self.history.pop()
366
if len(self.history) == 0:
367
self.forward_button.set_sensitive(False)
368
self._go(target_tree)
369
370
def _go(self, target_tree):
371
rev_id = self._selected_revision()
372
if self.file_id in target_tree:
373
offset = self.get_scroll_offset(target_tree)
374
(row,), col = self.annoview.get_cursor()
375
self.annotate(target_tree, self.branch, self.file_id)
376
new_row = row+offset
377
if new_row < 0:
378
new_row = 0
379
self.annoview.set_cursor(new_row)
380
return True
381
else:
382
return False
383
384
def get_scroll_offset(self, tree):
385
old = self.tree.get_file(self.file_id)
386
new = tree.get_file(self.file_id)
387
(row,), col = self.annoview.get_cursor()
388
matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
389
new.readlines())
390
for i, j, n in matcher.get_matching_blocks():
391
if i + n >= row:
392
return j - i
393
394
395
396
class FakeRevision:
308
397
""" A fake revision.
309
398
310
399
For when a revision is referenced but not present.
311
400
"""
312
401
313
def __init__(self, revision_id):
402
def __init__(self, revision_id, committer='?', nick=None):
314
403
self.revision_id = revision_id
315
404
self.parent_ids = []
316
self.committer = "?"
405
self.committer = committer
317
406
self.message = "?"
318
407
self.timestamp = 0.0
319
408
self.timezone = 0
409
self.properties = {}
320
410
321
411
322
412
class RevisionCache(object):
323
413
"""A caching revision source"""
324
def __init__(self, real_source):
414
def __init__(self, real_source, seed_cache=None):
325
415
self.__real_source = real_source
326
self.__cache = {}
416
if seed_cache is None:
417
self.__cache = {}
418
else:
419
self.__cache = dict(seed_cache)
327
420
328
421
def get_revision(self, revision_id):
329
422
if revision_id not in self.__cache:
330
423
revision = self.__real_source.get_revision(revision_id)
331
424
self.__cache[revision_id] = revision
332
425
return self.__cache[revision_id]
426
427
class SearchBox(gtk.HBox):
428
"""A button box for searching in text or lines of annotations"""
429
def __init__(self):
430
gtk.HBox.__init__(self, False, 6)
431
432
# Close button
433
button = gtk.Button()
434
image = gtk.Image()
435
image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
436
button.set_image(image)
437
button.set_relief(gtk.RELIEF_NONE)
438
button.connect("clicked", lambda w: self.hide_all())
439
self.pack_start(button, expand=False, fill=False)
440
441
# Search entry
442
label = gtk.Label()
443
self._label = label
444
self.pack_start(label, expand=False, fill=False)
445
446
entry = gtk.Entry()
447
self._entry = entry
448
entry.connect("activate", lambda w, d: self._do_search(d),
449
'forward')
450
self.pack_start(entry, expand=False, fill=False)
451
452
# Next/previous buttons
453
button = gtk.Button('_Next')
454
image = gtk.Image()
455
image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
456
button.set_image(image)
457
button.connect("clicked", lambda w, d: self._do_search(d),
458
'forward')
459
self.pack_start(button, expand=False, fill=False)
460
461
button = gtk.Button('_Previous')
462
image = gtk.Image()
463
image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
464
button.set_image(image)
465
button.connect("clicked", lambda w, d: self._do_search(d),
466
'backward')
467
self.pack_start(button, expand=False, fill=False)
468
469
# Search options
470
check = gtk.CheckButton('Match case')
471
self._match_case = check
472
self.pack_start(check, expand=False, fill=False)
473
474
check = gtk.CheckButton('Regexp')
475
check.connect("toggled", lambda w: self._set_label())
476
self._regexp = check
477
self.pack_start(check, expand=False, fill=False)
478
479
self._view = None
480
self._column = None
481
# Note that we stay hidden (we do not call self.show_all())
482
483
484
def show_for(self, kind):
485
self._kind = kind
486
self.show_all()
487
self._set_label()
488
# Hide unrelated buttons
489
if kind == 'line':
490
self._match_case.hide()
491
self._regexp.hide()
492
# Be ready
493
self._entry.grab_focus()
494
495
def _set_label(self):
496
if self._kind == 'line':
497
self._label.set_text('Find Line: ')
498
else:
499
if self._regexp.get_active():
500
self._label.set_text('Find Regexp: ')
501
else:
502
self._label.set_text('Find Text: ')
503
504
def set_target(self, view,column):
505
self._view = view
506
self._column = column
507
508
def _match(self, model, iterator, column):
509
matching_case = self._match_case.get_active()
510
string, = model.get(iterator, column)
511
key = self._entry.get_text()
512
if self._regexp.get_active():
513
if matching_case:
514
match = re.compile(key).search(string, 1)
515
else:
516
match = re.compile(key, re.I).search(string, 1)
517
else:
518
if not matching_case:
519
string = string.lower()
520
key = key.lower()
521
match = string.find(key) != -1
522
523
return match
524
525
def _iterate_rows_forward(self, model, start):
526
model_size = len(model)
527
current = start + 1
528
while model_size != 0:
529
if current >= model_size: current = 0
530
yield model.get_iter_from_string('%d' % current)
531
if current == start: raise StopIteration
532
current += 1
533
534
def _iterate_rows_backward(self, model, start):
535
model_size = len(model)
536
current = start - 1
537
while model_size != 0:
538
if current < 0: current = model_size - 1
539
yield model.get_iter_from_string('%d' % current)
540
if current == start: raise StopIteration
541
current -= 1
542
543
def _do_search(self, direction):
544
if direction == 'forward':
545
iterate = self._iterate_rows_forward
546
else:
547
iterate = self._iterate_rows_backward
548
549
model, sel = self._view.get_selection().get_selected()
550
if sel is None:
551
start = 0
552
else:
553
path = model.get_string_from_iter(sel)
554
start = int(path)
555
556
for row in iterate(model, start):
557
if self._match(model, row, self._column):
558
path = model.get_path(row)
559
self._view.set_cursor(path)
560
self._view.scroll_to_cell(path, use_align=True)
561
break
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0