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 782.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 782.1.1
- Committer: Curtis Hovey
- Date: 2012-03-11 18:24:06 UTC
- mto: This revision was merged to the branch mainline in revision 785.
- Revision ID: sinzui.is@verizon.net-20120311182406-f4jqpff65b30g3al
Create the mnemonic for the button label.
- files added:
- HACKING
- branchview
- preferences
- tests
- files removed:
- NEWS
- debian
- olive
- 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/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
16
16
17
17
import time
18
18
19
import pygtk
20
pygtk.require("2.0")
21
import gobject
22
import gtk
23
import pango
19
from gi.repository import GObject
20
from gi.repository import Gdk
21
from gi.repository import Gtk
22
from gi.repository import Pango
23
import re
24
24
25
from bzrlib import patiencediff
25
26
from bzrlib.errors import NoSuchRevision
26
from bzrlib.revision import NULL_REVISION
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
27
28
28
from colormap import AnnotateColorMap, AnnotateColorSaturation
29
from logview import LogView
30
from spanselector import SpanSelector
29
from bzrlib.plugins.gtk.annotate.colormap import AnnotateColorSaturation
30
from bzrlib.plugins.gtk.i18n import _i18n
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, branch=None):
47
49
self.all = all
48
50
self.plain = plain
49
50
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
51
52
self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
51
self._branch = branch
52
53
super(GAnnotateWindow, self).__init__(parent=parent)
54
55
self.set_icon(
56
self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
53
57
self.annotate_colormap = AnnotateColorSaturation()
54
58
55
59
self._create()
56
57
if self.plain:
58
self.span_selector.hide()
59
60
def annotate(self, branch, file_id):
61
60
self.revisions = {}
61
self.history = []
62
self._no_back = set()
63
64
def annotate(self, tree, branch, file_id):
62
65
self.annotations = []
63
66
self.branch = branch
67
self.tree = tree
64
68
self.file_id = file_id
65
66
# [revision id, line number, committer, revno, highlight color, line]
67
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
68
gobject.TYPE_STRING,
69
gobject.TYPE_STRING,
70
gobject.TYPE_STRING,
71
gobject.TYPE_STRING,
72
gobject.TYPE_STRING)
73
69
self.revisionview.set_file_id(file_id)
70
self.revision_id = getattr(tree, 'get_revision_id',
71
lambda: CURRENT_REVISION)()
72
73
# [revision id, line number, author, revno, highlight color, line]
74
self.annomodel = Gtk.ListStore(GObject.TYPE_STRING,
75
GObject.TYPE_INT,
76
GObject.TYPE_STRING,
77
GObject.TYPE_STRING,
78
GObject.TYPE_STRING,
79
GObject.TYPE_STRING)
80
74
81
last_seen = None
75
82
try:
76
83
branch.lock_read()
77
84
branch.repository.lock_read()
85
self.dotted = {}
86
revno_map = self.branch.get_revision_id_to_revno_map()
87
for revision_id, revno in revno_map.iteritems():
88
self.dotted[revision_id] = '.'.join(str(num) for num in revno)
78
89
for line_no, (revision, revno, line)\
79
in enumerate(self._annotate(branch, file_id)):
90
in enumerate(self._annotate(tree, file_id)):
80
91
if revision.revision_id == last_seen and not self.all:
81
revno = committer = ""
92
revno = author = ""
82
93
else:
83
94
last_seen = revision.revision_id
84
committer = revision.committer
95
author = ", ".join(revision.get_apparent_authors())
85
96
86
97
if revision.revision_id not in self.revisions:
87
98
self.revisions[revision.revision_id] = revision
88
99
89
100
self.annomodel.append([revision.revision_id,
90
101
line_no + 1,
91
committer,
102
author,
92
103
revno,
93
104
None,
94
105
line.rstrip("\r\n")
95
])
106
])
96
107
self.annotations.append(revision)
97
108
98
109
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()
110
now = time.time()
111
self.annomodel.foreach(self._highlight_annotation, now)
103
112
finally:
104
113
branch.repository.unlock()
105
114
branch.unlock()
106
115
107
116
self.annoview.set_model(self.annomodel)
108
117
self.annoview.grab_focus()
118
my_revno = self.dotted.get(self.revision_id, 'current')
119
title = '%s (%s) - gannotate' % (self.tree.id2path(file_id), my_revno)
120
self.set_title(title)
109
121
110
122
def jump_to_line(self, lineno):
111
123
if lineno > len(self.annomodel) or lineno < 1:
114
126
# bar?
115
127
print("gannotate: Line number %d does't exist. Defaulting to "
116
128
"line 1." % lineno)
117
return
129
return
118
130
else:
119
131
row = lineno - 1
120
132
121
self.annoview.set_cursor(row)
122
self.annoview.scroll_to_cell(row, use_align=True)
133
tree_path = Gtk.TreePath(path=row)
134
self.annoview.set_cursor(tree_path, None, False)
135
self.annoview.scroll_to_cell(tree_path, use_align=True)
123
136
124
def _annotate(self, branch, file_id):
125
rev_hist = branch.revision_history()
126
repository = branch.repository
127
rev_tree = repository.revision_tree(branch.last_revision())
128
rev_id = rev_tree.inventory[file_id].revision
129
weave = repository.weave_store.get_weave(file_id,
130
branch.get_transaction())
131
132
revision_cache = RevisionCache(repository)
133
for origin, text in weave.annotate_iter(rev_id):
137
def _annotate(self, tree, file_id):
138
current_revision = FakeRevision(CURRENT_REVISION)
139
current_revision.committer = self.branch.get_config().username()
140
current_revision.timestamp = time.time()
141
current_revision.message = '[Not yet committed]'
142
current_revision.parent_ids = tree.get_parent_ids()
143
current_revision.properties['branch-nick'] = self.branch._get_nick(local=True)
144
current_revno = '%d?' % (self.branch.revno() + 1)
145
repository = self.branch.repository
146
if self.revision_id == CURRENT_REVISION:
147
revision_id = self.branch.last_revision()
148
else:
149
revision_id = self.revision_id
150
revision_cache = RevisionCache(repository, self.revisions)
151
for origin, text in tree.annotate_iter(file_id):
134
152
rev_id = origin
135
try:
136
revision = revision_cache.get_revision(rev_id)
137
if rev_id in rev_hist:
138
revno = branch.revision_id_to_revno(rev_id)
139
else:
140
revno = "merge"
141
except NoSuchRevision:
142
revision = NoneRevision(rev_id)
143
revno = "?"
153
if rev_id == CURRENT_REVISION:
154
revision = current_revision
155
revno = current_revno
156
else:
157
try:
158
revision = revision_cache.get_revision(rev_id)
159
revno = self.dotted.get(rev_id, 'merge')
160
if len(revno) > 15:
161
revno = 'merge'
162
except NoSuchRevision:
163
revision = FakeRevision(rev_id)
164
revno = "?"
144
165
145
166
yield revision, revno, text
146
167
147
def _set_oldest_newest(self):
148
rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
149
if len(rev_dates) == 0:
150
return
151
oldest = min(rev_dates)
152
newest = max(rev_dates)
153
154
span = self._span_from_seconds(time.time() - oldest)
155
self.span_selector.set_to_oldest_span(span)
156
157
span = self._span_from_seconds(newest - oldest)
158
self.span_selector.set_newest_to_oldest_span(span)
159
160
def _span_from_seconds(self, seconds):
161
return (seconds / (24 * 60 * 60))
162
163
def _span_changed_cb(self, w, span):
164
self.annotate_colormap.set_span(span)
165
now = time.time()
166
self.annomodel.foreach(self._highlight_annotation, now)
167
168
168
def _highlight_annotation(self, model, path, iter, now):
169
169
revision_id, = model.get(iter, REVISION_ID_COL)
170
170
revision = self.revisions[revision_id]
171
model.set(iter, HIGHLIGHT_COLOR_COL,
172
self.annotate_colormap.get_color(revision, now))
171
# XXX sinzui 2011-08-12: What does get_color return?
172
color = self.annotate_colormap.get_color(revision, now)
173
model.set_value(iter, HIGHLIGHT_COLOR_COL, color)
173
174
174
def _show_log(self, w):
175
def _selected_revision(self):
175
176
(path, col) = self.annoview.get_cursor()
176
177
if path is None:
178
return None
179
return self.annomodel[path][REVISION_ID_COL]
180
181
def _activate_selected_revision(self, w):
182
rev_id = self._selected_revision()
183
if not rev_id or rev_id == NULL_REVISION:
177
184
return
178
rev_id = self.annomodel[path][REVISION_ID_COL]
179
self.logview.set_revision(self.revisions[rev_id])
185
selected = self.revisions[rev_id]
186
self.revisionview.set_revision(selected)
187
if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
188
self._no_back):
189
enable_back = True
190
else:
191
enable_back = False
192
self.back_button.set_sensitive(enable_back)
180
193
181
194
def _create(self):
182
self.logview = self._create_log_view()
195
self.revisionview = self._create_log_view()
183
196
self.annoview = self._create_annotate_view()
184
self.span_selector = self._create_span_selector()
185
197
186
vbox = gtk.VBox(False, 12)
187
vbox.set_border_width(12)
198
vbox = Gtk.VBox(homogeneous=False, spacing=0)
188
199
vbox.show()
189
200
190
sw = gtk.ScrolledWindow()
191
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
192
sw.set_shadow_type(gtk.SHADOW_IN)
201
sw = Gtk.ScrolledWindow()
202
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
203
sw.set_shadow_type(Gtk.ShadowType.IN)
193
204
sw.add(self.annoview)
194
205
self.annoview.gwindow = self
195
206
sw.show()
196
197
self.pane = pane = gtk.VPaned()
198
pane.add1(sw)
199
pane.add2(self.logview)
207
208
swbox = Gtk.VBox()
209
swbox.pack_start(sw, True, True, 0)
210
swbox.show()
211
212
hbox = Gtk.HBox(homogeneous=False, spacing=6)
213
self.back_button = self._create_back_button()
214
hbox.pack_start(self.back_button, False, True, 0)
215
self.forward_button = self._create_forward_button()
216
hbox.pack_start(self.forward_button, False, True, 0)
217
self.find_button = self._create_find_button()
218
hbox.pack_start(self.find_button, False, True, 0)
219
self.goto_button = self._create_goto_button()
220
hbox.pack_start(self.goto_button, False, True, 0)
221
hbox.show()
222
vbox.pack_start(hbox, False, True, 0)
223
224
self.pane = pane = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
225
pane.add1(swbox)
226
pane.add2(self.revisionview)
200
227
pane.show()
201
vbox.pack_start(pane, expand=True, fill=True)
202
203
hbox = gtk.HBox(True, 6)
204
hbox.pack_start(self.span_selector, expand=False, fill=True)
205
hbox.pack_start(self._create_button_box(), expand=False, fill=True)
206
hbox.show()
207
vbox.pack_start(hbox, expand=False, fill=True)
228
vbox.pack_start(pane, True, True, 0)
229
230
self._search = SearchBox()
231
swbox.pack_start(self._search, False, True, 0)
232
accels = Gtk.AccelGroup()
233
accels.connect(Gdk.KEY_f, Gdk.ModifierType.CONTROL_MASK,
234
Gtk.AccelFlags.LOCKED,
235
self._search_by_text)
236
accels.connect(Gdk.KEY_g, Gdk.ModifierType.CONTROL_MASK,
237
Gtk.AccelFlags.LOCKED,
238
self._search_by_line)
239
self.add_accel_group(accels)
208
240
209
241
self.add(vbox)
210
242
211
def row_diff(self, tv, path, tvc):
212
row = path[0]
243
def _search_by_text(self, *ignored): # (accel_group, window, key, modifiers):
244
self._search.show_for('text')
245
self._search.set_target(self.annoview, TEXT_LINE_COL)
246
247
def _search_by_line(self, *ignored): # accel_group, window, key, modifiers):
248
self._search.show_for('line')
249
self._search.set_target(self.annoview, LINE_NUM_COL)
250
251
def line_diff(self, tv, path, tvc):
252
row = path.get_indices()[0]
213
253
revision = self.annotations[row]
214
254
repository = self.branch.repository
215
tree1 = repository.revision_tree(revision.revision_id)
216
if len(revision.parent_ids) > 0:
217
tree2 = repository.revision_tree(revision.parent_ids[0])
255
if revision.revision_id == CURRENT_REVISION:
256
tree1 = self.tree
257
tree2 = self.tree.basis_tree()
218
258
else:
219
tree2 = repository.revision_tree(NULL_REVISION)
220
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
221
window = DiffWindow()
222
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
259
tree1 = repository.revision_tree(revision.revision_id)
260
if len(revision.parent_ids) > 0:
261
tree2 = repository.revision_tree(revision.parent_ids[0])
262
else:
263
tree2 = repository.revision_tree(NULL_REVISION)
264
from bzrlib.plugins.gtk.diff import DiffWindow
265
window = DiffWindow(self)
266
window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
223
267
window.set_file(tree1.id2path(self.file_id))
224
268
window.show()
225
269
226
270
227
271
def _create_annotate_view(self):
228
tv = gtk.TreeView()
272
tv = Gtk.TreeView()
229
273
tv.set_rules_hint(False)
230
tv.connect("cursor-changed", self._show_log)
274
tv.connect("cursor-changed", self._activate_selected_revision)
231
275
tv.show()
232
tv.connect("row-activated", self.row_diff)
276
tv.connect("row-activated", self.line_diff)
233
277
234
cell = gtk.CellRendererText()
278
cell = Gtk.CellRendererText()
235
279
cell.set_property("xalign", 1.0)
236
280
cell.set_property("ypad", 0)
237
281
cell.set_property("family", "Monospace")
238
282
cell.set_property("cell-background-gdk",
239
tv.get_style().bg[gtk.STATE_NORMAL])
240
col = gtk.TreeViewColumn()
283
tv.get_style().bg[Gtk.StateType.NORMAL])
284
col = Gtk.TreeViewColumn()
241
285
col.set_resizable(False)
242
col.pack_start(cell, expand=True)
286
col.pack_start(cell, True)
243
287
col.add_attribute(cell, "text", LINE_NUM_COL)
244
288
tv.append_column(col)
245
289
246
cell = gtk.CellRendererText()
290
cell = Gtk.CellRendererText()
247
291
cell.set_property("ypad", 0)
248
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
292
cell.set_property("ellipsize", Pango.EllipsizeMode.END)
249
293
cell.set_property("cell-background-gdk",
250
self.get_style().bg[gtk.STATE_NORMAL])
251
col = gtk.TreeViewColumn("Committer")
294
self.get_style().bg[Gtk.StateType.NORMAL])
295
col = Gtk.TreeViewColumn("Committer")
252
296
col.set_resizable(True)
253
col.pack_start(cell, expand=True)
297
col.pack_start(cell, True)
254
298
col.add_attribute(cell, "text", COMMITTER_COL)
255
299
tv.append_column(col)
256
300
257
cell = gtk.CellRendererText()
301
cell = Gtk.CellRendererText()
258
302
cell.set_property("xalign", 1.0)
259
303
cell.set_property("ypad", 0)
260
304
cell.set_property("cell-background-gdk",
261
self.get_style().bg[gtk.STATE_NORMAL])
262
col = gtk.TreeViewColumn("Revno")
305
self.get_style().bg[Gtk.StateType.NORMAL])
306
col = Gtk.TreeViewColumn("Revno")
263
307
col.set_resizable(False)
264
col.pack_start(cell, expand=True)
308
col.pack_start(cell, True)
265
309
col.add_attribute(cell, "markup", REVNO_COL)
266
310
tv.append_column(col)
267
311
268
cell = gtk.CellRendererText()
312
cell = Gtk.CellRendererText()
269
313
cell.set_property("ypad", 0)
270
314
cell.set_property("family", "Monospace")
271
col = gtk.TreeViewColumn()
315
col = Gtk.TreeViewColumn()
272
316
col.set_resizable(False)
273
col.pack_start(cell, expand=True)
317
col.pack_start(cell, True)
274
318
# col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
275
319
col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
276
320
col.add_attribute(cell, "text", TEXT_LINE_COL)
277
321
tv.append_column(col)
278
322
279
tv.set_search_column(LINE_NUM_COL)
280
323
# interactive substring search
324
def search_equal_func(model, column, key, iter):
325
return model.get_value(iter, TEXT_LINE_COL).lower().find(key.lower()) == -1
326
327
tv.set_enable_search(True)
328
tv.set_search_equal_func(search_equal_func, None)
329
281
330
return tv
282
331
283
def _create_span_selector(self):
284
ss = SpanSelector()
285
ss.connect("span-changed", self._span_changed_cb)
286
ss.show()
287
288
return ss
289
290
332
def _create_log_view(self):
291
lv = LogView()
333
lv = RevisionView(self._branch)
292
334
lv.show()
293
294
335
return lv
295
336
296
def _create_button_box(self):
297
box = gtk.HButtonBox()
298
box.set_layout(gtk.BUTTONBOX_END)
299
box.show()
300
301
button = gtk.Button()
302
button.set_use_stock(True)
303
button.set_label("gtk-close")
304
button.connect("clicked", lambda w: self.destroy())
305
button.show()
306
307
box.pack_start(button, expand=False, fill=False)
308
309
return box
310
311
312
class NoneRevision:
337
def _create_back_button(self):
338
button = Gtk.Button()
339
button.set_use_stock(True)
340
button.set_label("gtk-go-back")
341
button.connect("clicked", lambda w: self.go_back())
342
button.set_relief(Gtk.ReliefStyle.NONE)
343
button.show()
344
return button
345
346
def _create_forward_button(self):
347
button = Gtk.Button()
348
button.set_use_stock(True)
349
button.set_label("gtk-go-forward")
350
button.connect("clicked", lambda w: self.go_forward())
351
button.set_relief(Gtk.ReliefStyle.NONE)
352
button.show()
353
button.set_sensitive(False)
354
return button
355
356
def _create_find_button(self):
357
button = Gtk.Button()
358
button.set_use_stock(True)
359
button.set_label("gtk-find")
360
button.set_tooltip_text("Search for text (Ctrl+F)")
361
button.connect("clicked", self._search_by_text)
362
button.set_relief(Gtk.ReliefStyle.NONE)
363
button.show()
364
button.set_sensitive(True)
365
return button
366
367
def _create_goto_button(self):
368
button = Gtk.Button()
369
button.set_label("Goto Line")
370
button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
371
button.connect("clicked", self._search_by_line)
372
button.set_relief(Gtk.ReliefStyle.NONE)
373
button.show()
374
button.set_sensitive(True)
375
return button
376
377
def go_back(self):
378
last_tree = self.tree
379
rev_id = self._selected_revision()
380
parent_id = self.revisions[rev_id].parent_ids[0]
381
target_tree = self.branch.repository.revision_tree(parent_id)
382
if self._go(target_tree):
383
self.history.append(last_tree)
384
self.forward_button.set_sensitive(True)
385
else:
386
self._no_back.add(parent_id)
387
self.back_button.set_sensitive(False)
388
389
def go_forward(self):
390
if len(self.history) == 0:
391
return
392
target_tree = self.history.pop()
393
if len(self.history) == 0:
394
self.forward_button.set_sensitive(False)
395
self._go(target_tree)
396
397
def _go(self, target_tree):
398
rev_id = self._selected_revision()
399
if self.file_id in target_tree:
400
offset = self.get_scroll_offset(target_tree)
401
path, col = self.annoview.get_cursor()
402
(row,) = path.get_indices()
403
self.annotate(target_tree, self.branch, self.file_id)
404
new_row = row+offset
405
if new_row < 0:
406
new_row = 0
407
new_path = Gtk.TreePath(path=new_row)
408
self.annoview.set_cursor(new_path, None, False)
409
return True
410
else:
411
return False
412
413
def get_scroll_offset(self, tree):
414
old = self.tree.get_file(self.file_id)
415
new = tree.get_file(self.file_id)
416
path, col = self.annoview.get_cursor()
417
(row,) = path.get_indices()
418
matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
419
new.readlines())
420
for i, j, n in matcher.get_matching_blocks():
421
if i + n >= row:
422
return j - i
423
424
425
class FakeRevision(object):
313
426
""" A fake revision.
314
427
315
428
For when a revision is referenced but not present.
316
429
"""
317
430
318
def __init__(self, revision_id):
431
def __init__(self, revision_id, committer='?', nick=None):
319
432
self.revision_id = revision_id
320
433
self.parent_ids = []
321
self.committer = "?"
434
self.committer = committer
322
435
self.message = "?"
323
436
self.timestamp = 0.0
324
437
self.timezone = 0
438
self.properties = {}
439
440
def get_apparent_authors(self):
441
return [self.committer]
325
442
326
443
327
444
class RevisionCache(object):
328
445
"""A caching revision source"""
329
def __init__(self, real_source):
446
447
def __init__(self, real_source, seed_cache=None):
330
448
self.__real_source = real_source
331
self.__cache = {}
449
if seed_cache is None:
450
self.__cache = {}
451
else:
452
self.__cache = dict(seed_cache)
332
453
333
454
def get_revision(self, revision_id):
334
455
if revision_id not in self.__cache:
335
456
revision = self.__real_source.get_revision(revision_id)
336
457
self.__cache[revision_id] = revision
337
458
return self.__cache[revision_id]
459
460
461
class SearchBox(Gtk.HBox):
462
"""A button box for searching in text or lines of annotations"""
463
def __init__(self):
464
super(SearchBox, self).__init__(homogeneous=False, spacing=6)
465
466
# Close button
467
button = Gtk.Button()
468
image = Gtk.Image()
469
image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
470
button.set_image(image)
471
button.set_relief(Gtk.ReliefStyle.NONE)
472
button.connect("clicked", lambda w: self.hide())
473
self.pack_start(button, False, False, 0)
474
475
# Search entry
476
label = Gtk.Label()
477
self._label = label
478
self.pack_start(label, False, False, 0)
479
480
entry = Gtk.Entry()
481
self._entry = entry
482
entry.connect("activate", lambda w, d: self._do_search(d),
483
'forward')
484
self.pack_start(entry, False, False, 0)
485
486
# Next/previous buttons
487
button = Gtk.Button(_i18n('_Next'), use_underline=True)
488
image = Gtk.Image()
489
image.set_from_stock('gtk-go-forward', Gtk.IconSize.BUTTON)
490
button.set_image(image)
491
button.connect("clicked", lambda w, d: self._do_search(d),
492
'forward')
493
self.pack_start(button, False, False, 0)
494
495
button = Gtk.Button(_i18n('_Previous'), use_underline=True)
496
image = Gtk.Image()
497
image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
498
button.set_image(image)
499
button.connect("clicked", lambda w, d: self._do_search(d),
500
'backward')
501
self.pack_start(button, False, False, 0)
502
503
# Search options
504
check = Gtk.CheckButton('Match case')
505
self._match_case = check
506
self.pack_start(check, False, False, 0)
507
508
check = Gtk.CheckButton('Regexp')
509
check.connect("toggled", lambda w: self._set_label())
510
self._regexp = check
511
self.pack_start(check, False, False, 0)
512
513
self._view = None
514
self._column = None
515
# Note that we stay hidden (we do not call self.show_all())
516
517
518
def show_for(self, kind):
519
self._kind = kind
520
self.show_all()
521
self._set_label()
522
# Hide unrelated buttons
523
if kind == 'line':
524
self._match_case.hide()
525
self._regexp.hide()
526
# Be ready
527
self._entry.grab_focus()
528
529
def _set_label(self):
530
if self._kind == 'line':
531
self._label.set_text('Find Line: ')
532
else:
533
if self._regexp.get_active():
534
self._label.set_text('Find Regexp: ')
535
else:
536
self._label.set_text('Find Text: ')
537
538
def set_target(self, view,column):
539
self._view = view
540
self._column = column
541
542
def _match(self, model, iterator, column):
543
matching_case = self._match_case.get_active()
544
cell_value, = model.get(iterator, column)
545
key = self._entry.get_text()
546
if column == LINE_NUM_COL:
547
# FIXME: For goto-line there are faster algorithms than searching
548
# every line til we find the right one! -- mbp 2011-01-27
549
return key.strip() == str(cell_value)
550
elif self._regexp.get_active():
551
if matching_case:
552
match = re.compile(key).search(cell_value, 1)
553
else:
554
match = re.compile(key, re.I).search(cell_value, 1)
555
else:
556
if not matching_case:
557
cell_value = cell_value.lower()
558
key = key.lower()
559
match = cell_value.find(key) != -1
560
561
return match
562
563
def _iterate_rows_forward(self, model, start):
564
model_size = len(model)
565
current = start + 1
566
while model_size != 0:
567
if current >= model_size: current = 0
568
yield model.get_iter_from_string('%d' % current)
569
if current == start: raise StopIteration
570
current += 1
571
572
def _iterate_rows_backward(self, model, start):
573
model_size = len(model)
574
current = start - 1
575
while model_size != 0:
576
if current < 0: current = model_size - 1
577
yield model.get_iter_from_string('%d' % current)
578
if current == start: raise StopIteration
579
current -= 1
580
581
def _do_search(self, direction):
582
if direction == 'forward':
583
iterate = self._iterate_rows_forward
584
else:
585
iterate = self._iterate_rows_backward
586
587
model, sel = self._view.get_selection().get_selected()
588
if sel is None:
589
start = 0
590
else:
591
path = model.get_string_from_iter(sel)
592
start = int(path)
593
594
for row in iterate(model, start):
595
if self._match(model, row, self._column):
596
path = model.get_path(row)
597
self._view.set_cursor(path, None, False)
598
self._view.scroll_to_cell(path, use_align=True)
599
break
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0