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 66.6.1
- compare with another revision
- download diff
- download tarball
- view history from revision 66.6.1
- Committer: Aaron Bentley
- Date: 2007-01-17 06:42:55 UTC
- mto: This revision was merged to the branch mainline in revision 129.
- Revision ID: aaron.bentley@utoronto.ca-20070117064255-x4gznz5e0lyjq3gk
Remove usused span selector
- files added:
- po/hu.po
- files removed:
- HACKING
- branchview
- preferences
- tests
- files renamed:
- revisionview.py => annotate/logview.py
- branch.py => olive/branch.py
- checkout.py => olive/checkout.py
- commit.py => olive/commit.py
- dialog.py => olive/dialog.py
- merge.py => olive/merge.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
- branchview/linegraph.py => viz/graph.py
- branchview/graphcell.py => viz/graphcell.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
25
from bzrlib import tsort
27
26
from bzrlib.errors import NoSuchRevision
28
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
28
30
29
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
from bzrlib.plugins.gtk.revisionview import RevisionView
32
from bzrlib.plugins.gtk.window import Window
30
from logview import LogView
31
from spanselector import SpanSelector
33
32
34
33
35
34
(
42
41
) = range(6)
43
42
44
43
45
class GAnnotateWindow(Window):
44
class GAnnotateWindow(gtk.Window):
46
45
"""Annotate window."""
47
46
48
def __init__(self, all=False, plain=False, parent=None, branch=None):
47
def __init__(self, all=False, plain=False):
49
48
self.all = all
50
49
self.plain = plain
51
self._branch = branch
52
50
53
Window.__init__(self, parent)
51
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
54
52
55
53
self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
56
54
self.annotate_colormap = AnnotateColorSaturation()
57
55
58
56
self._create()
57
58
def annotate(self, tree, branch, file_id):
59
59
self.revisions = {}
60
self.history = []
61
self._no_back = set()
62
63
def annotate(self, tree, branch, file_id):
64
60
self.annotations = []
65
61
self.branch = branch
66
62
self.tree = tree
67
63
self.file_id = file_id
68
self.revisionview.set_file_id(file_id)
69
64
self.revision_id = getattr(tree, 'get_revision_id',
70
65
lambda: CURRENT_REVISION)()
71
66
72
# [revision id, line number, author, revno, highlight color, line]
67
# [revision id, line number, committer, revno, highlight color, line]
73
68
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
74
69
gobject.TYPE_STRING,
75
70
gobject.TYPE_STRING,
81
76
try:
82
77
branch.lock_read()
83
78
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)
88
79
for line_no, (revision, revno, line)\
89
80
in enumerate(self._annotate(tree, file_id)):
90
81
if revision.revision_id == last_seen and not self.all:
91
revno = author = ""
82
revno = committer = ""
92
83
else:
93
84
last_seen = revision.revision_id
94
author = revision.get_apparent_author()
85
committer = revision.committer
95
86
96
87
if revision.revision_id not in self.revisions:
97
88
self.revisions[revision.revision_id] = revision
98
89
99
90
self.annomodel.append([revision.revision_id,
100
91
line_no + 1,
101
author,
92
committer,
102
93
revno,
103
94
None,
104
95
line.rstrip("\r\n")
106
97
self.annotations.append(revision)
107
98
108
99
if not self.plain:
100
self._set_oldest_newest()
109
101
now = time.time()
110
102
self.annomodel.foreach(self._highlight_annotation, now)
111
103
finally:
114
106
115
107
self.annoview.set_model(self.annomodel)
116
108
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)
120
109
121
110
def jump_to_line(self, lineno):
122
111
if lineno > len(self.annomodel) or lineno < 1:
132
121
self.annoview.set_cursor(row)
133
122
self.annoview.scroll_to_cell(row, use_align=True)
134
123
124
def _dotted_revnos(self, repository, revision_id):
125
"""Return a dict of revision_id -> dotted revno
126
127
:param repository: The repository to get the graph from
128
:param revision_id: The last revision for which this info is needed
129
"""
130
graph = repository.get_revision_graph(revision_id)
131
dotted = {}
132
for n, revision_id, d, revno, e in tsort.merge_sort(graph,
133
revision_id, generate_revno=True):
134
dotted[revision_id] = '.'.join(str(num) for num in revno)
135
return dotted
135
136
136
137
def _annotate(self, tree, file_id):
137
138
current_revision = FakeRevision(CURRENT_REVISION)
138
139
current_revision.committer = self.branch.get_config().username()
139
140
current_revision.timestamp = time.time()
140
141
current_revision.message = '[Not yet committed]'
141
current_revision.parent_ids = tree.get_parent_ids()
142
current_revision.properties['branch-nick'] = self.branch.nick
143
142
current_revno = '%d?' % (self.branch.revno() + 1)
144
143
repository = self.branch.repository
145
144
if self.revision_id == CURRENT_REVISION:
146
145
revision_id = self.branch.last_revision()
147
146
else:
148
147
revision_id = self.revision_id
149
revision_cache = RevisionCache(repository, self.revisions)
148
dotted = self._dotted_revnos(repository, revision_id)
149
revision_cache = RevisionCache(repository)
150
150
for origin, text in tree.annotate_iter(file_id):
151
151
rev_id = origin
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:
152
try:
153
revision = revision_cache.get_revision(rev_id)
154
revno = dotted.get(rev_id, 'merge')
155
if len(revno) > 15:
156
revno = 'merge'
157
except NoSuchRevision:
158
committer = "?"
159
if rev_id == CURRENT_REVISION:
160
revision = current_revision
161
revno = current_revno
162
else:
162
163
revision = FakeRevision(rev_id)
163
164
revno = "?"
164
165
165
166
yield revision, revno, text
166
167
168
def _set_oldest_newest(self):
169
rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
170
if len(rev_dates) == 0:
171
return
172
oldest = min(rev_dates)
173
newest = max(rev_dates)
174
167
175
def _highlight_annotation(self, model, path, iter, now):
168
176
revision_id, = model.get(iter, REVISION_ID_COL)
169
177
revision = self.revisions[revision_id]
170
178
model.set(iter, HIGHLIGHT_COLOR_COL,
171
179
self.annotate_colormap.get_color(revision, now))
172
180
173
def _selected_revision(self):
181
def _show_log(self, w):
174
182
(path, col) = self.annoview.get_cursor()
175
183
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:
182
184
return
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)
185
rev_id = self.annomodel[path][REVISION_ID_COL]
186
self.logview.set_revision(self.revisions[rev_id])
191
187
192
188
def _create(self):
193
self.revisionview = self._create_log_view()
189
self.logview = self._create_log_view()
194
190
self.annoview = self._create_annotate_view()
195
191
196
vbox = gtk.VBox(False)
192
vbox = gtk.VBox(False, 12)
193
vbox.set_border_width(12)
197
194
vbox.show()
198
195
199
196
sw = gtk.ScrolledWindow()
202
199
sw.add(self.annoview)
203
200
self.annoview.gwindow = self
204
201
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)
217
202
218
203
self.pane = pane = gtk.VPaned()
219
pane.add1(swbox)
220
pane.add2(self.revisionview)
204
pane.add1(sw)
205
pane.add2(self.logview)
221
206
pane.show()
222
207
vbox.pack_start(pane, expand=True, 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)
208
209
hbox = gtk.HBox(True, 6)
210
hbox.pack_start(self._create_button_box(), expand=False, fill=True)
211
hbox.show()
212
vbox.pack_start(hbox, expand=False, fill=True)
234
213
235
214
self.add(vbox)
236
215
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):
216
def row_diff(self, tv, path, tvc):
246
217
row = path[0]
247
218
revision = self.annotations[row]
248
219
repository = self.branch.repository
255
226
tree2 = repository.revision_tree(revision.parent_ids[0])
256
227
else:
257
228
tree2 = repository.revision_tree(NULL_REVISION)
258
from bzrlib.plugins.gtk.diff import DiffWindow
229
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
259
230
window = DiffWindow()
260
window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
231
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
261
232
window.set_file(tree1.id2path(self.file_id))
262
233
window.show()
263
234
265
236
def _create_annotate_view(self):
266
237
tv = gtk.TreeView()
267
238
tv.set_rules_hint(False)
268
tv.connect("cursor-changed", self._activate_selected_revision)
239
tv.connect("cursor-changed", self._show_log)
269
240
tv.show()
270
tv.connect("row-activated", self.line_diff)
241
tv.connect("row-activated", self.row_diff)
271
242
272
243
cell = gtk.CellRendererText()
273
244
cell.set_property("xalign", 1.0)
314
285
col.add_attribute(cell, "text", TEXT_LINE_COL)
315
286
tv.append_column(col)
316
287
317
# FIXME: Now that C-f is now used for search by text we
318
# may as well disable the auto search.
319
288
tv.set_search_column(LINE_NUM_COL)
320
289
321
290
return tv
322
291
323
292
def _create_log_view(self):
324
lv = RevisionView(self._branch)
293
lv = LogView()
325
294
lv.show()
295
326
296
return lv
327
297
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
298
def _create_button_box(self):
299
box = gtk.HButtonBox()
300
box.set_layout(gtk.BUTTONBOX_END)
301
box.show()
302
303
button = gtk.Button()
304
button.set_use_stock(True)
305
button.set_label("gtk-close")
306
button.connect("clicked", lambda w: self.destroy())
307
button.show()
308
309
box.pack_start(button, expand=False, fill=False)
310
311
return box
390
312
391
313
392
314
class FakeRevision:
395
317
For when a revision is referenced but not present.
396
318
"""
397
319
398
def __init__(self, revision_id, committer='?', nick=None):
320
def __init__(self, revision_id, committer='?'):
399
321
self.revision_id = revision_id
400
322
self.parent_ids = []
401
323
self.committer = committer
402
324
self.message = "?"
403
325
self.timestamp = 0.0
404
326
self.timezone = 0
405
self.properties = {}
406
407
def get_apparent_author(self):
408
return self.committer
409
327
410
328
411
329
class RevisionCache(object):
412
330
"""A caching revision source"""
413
def __init__(self, real_source, seed_cache=None):
331
def __init__(self, real_source):
414
332
self.__real_source = real_source
415
if seed_cache is None:
416
self.__cache = {}
417
else:
418
self.__cache = dict(seed_cache)
333
self.__cache = {}
419
334
420
335
def get_revision(self, revision_id):
421
336
if revision_id not in self.__cache:
422
337
revision = self.__real_source.get_revision(revision_id)
423
338
self.__cache[revision_id] = revision
424
339
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