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.2.19
- compare with another revision
- download diff
- download tarball
- view history from revision 66.2.19
- Committer: Aaron Bentley
- Date: 2006-12-21 06:19:52 UTC
- mto: This revision was merged to the branch mainline in revision 126.
- Revision ID: aaron.bentley@utoronto.ca-20061221061952-el04e349vxfad4w7
Increase box height by 1 to fix diagonal jagginess
- files added:
- cmenu.ui
- olive
- 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
16
16
17
17
import time
18
18
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
19
import pygtk
20
pygtk.require("2.0")
21
import gobject
22
import gtk
23
import pango
24
24
25
from bzrlib import patiencediff
25
from bzrlib import tsort
26
26
from bzrlib.errors import NoSuchRevision
27
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
28
28
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
29
from colormap import AnnotateColorMap, AnnotateColorSaturation
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
53
super(GAnnotateWindow, self).__init__(parent=parent)
54
55
self.set_icon(
56
self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
50
51
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
52
53
self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
57
54
self.annotate_colormap = AnnotateColorSaturation()
58
55
59
56
self._create()
57
58
if self.plain:
59
self.span_selector.hide()
60
61
def annotate(self, tree, branch, file_id):
60
62
self.revisions = {}
61
self.history = []
62
self._no_back = set()
63
64
def annotate(self, tree, branch, file_id):
65
63
self.annotations = []
66
64
self.branch = branch
67
65
self.tree = tree
68
66
self.file_id = file_id
69
self.revisionview.set_file_id(file_id)
70
67
self.revision_id = getattr(tree, 'get_revision_id',
71
68
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
69
70
# [revision id, line number, committer, revno, highlight color, line]
71
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
72
gobject.TYPE_STRING,
73
gobject.TYPE_STRING,
74
gobject.TYPE_STRING,
75
gobject.TYPE_STRING,
76
gobject.TYPE_STRING)
77
81
78
last_seen = None
82
79
try:
83
80
branch.lock_read()
84
81
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)
89
82
for line_no, (revision, revno, line)\
90
in enumerate(self._annotate(tree, file_id)):
83
in enumerate(self._annotate(tree, file_id)):
91
84
if revision.revision_id == last_seen and not self.all:
92
revno = author = ""
85
revno = committer = ""
93
86
else:
94
87
last_seen = revision.revision_id
95
author = ", ".join(revision.get_apparent_authors())
88
committer = revision.committer
96
89
97
90
if revision.revision_id not in self.revisions:
98
91
self.revisions[revision.revision_id] = revision
99
92
100
93
self.annomodel.append([revision.revision_id,
101
94
line_no + 1,
102
author,
95
committer,
103
96
revno,
104
97
None,
105
98
line.rstrip("\r\n")
106
])
99
])
107
100
self.annotations.append(revision)
108
101
109
102
if not self.plain:
110
now = time.time()
111
self.annomodel.foreach(self._highlight_annotation, now)
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()
112
107
finally:
113
108
branch.repository.unlock()
114
109
branch.unlock()
115
110
116
111
self.annoview.set_model(self.annomodel)
117
112
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)
121
113
122
114
def jump_to_line(self, lineno):
123
115
if lineno > len(self.annomodel) or lineno < 1:
126
118
# bar?
127
119
print("gannotate: Line number %d does't exist. Defaulting to "
128
120
"line 1." % lineno)
129
return
121
return
130
122
else:
131
123
row = lineno - 1
132
124
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)
125
self.annoview.set_cursor(row)
126
self.annoview.scroll_to_cell(row, use_align=True)
127
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
136
140
137
141
def _annotate(self, tree, file_id):
138
142
current_revision = FakeRevision(CURRENT_REVISION)
139
143
current_revision.committer = self.branch.get_config().username()
140
144
current_revision.timestamp = time.time()
141
145
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
146
current_revno = '%d?' % (self.branch.revno() + 1)
145
147
repository = self.branch.repository
146
148
if self.revision_id == CURRENT_REVISION:
147
149
revision_id = self.branch.last_revision()
148
150
else:
149
151
revision_id = self.revision_id
150
revision_cache = RevisionCache(repository, self.revisions)
152
dotted = self._dotted_revnos(repository, revision_id)
153
revision_cache = RevisionCache(repository)
151
154
for origin, text in tree.annotate_iter(file_id):
152
155
rev_id = origin
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:
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:
163
167
revision = FakeRevision(rev_id)
164
168
revno = "?"
165
169
166
170
yield revision, revno, text
167
171
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
168
193
def _highlight_annotation(self, model, path, iter, now):
169
194
revision_id, = model.get(iter, REVISION_ID_COL)
170
195
revision = self.revisions[revision_id]
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)
196
model.set(iter, HIGHLIGHT_COLOR_COL,
197
self.annotate_colormap.get_color(revision, now))
174
198
175
def _selected_revision(self):
199
def _show_log(self, w):
176
200
(path, col) = self.annoview.get_cursor()
177
201
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:
184
202
return
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)
203
rev_id = self.annomodel[path][REVISION_ID_COL]
204
self.logview.set_revision(self.revisions[rev_id])
193
205
194
206
def _create(self):
195
self.revisionview = self._create_log_view()
207
self.logview = self._create_log_view()
196
208
self.annoview = self._create_annotate_view()
209
self.span_selector = self._create_span_selector()
197
210
198
vbox = Gtk.VBox(homogeneous=False, spacing=0)
211
vbox = gtk.VBox(False, 12)
212
vbox.set_border_width(12)
199
213
vbox.show()
200
214
201
sw = Gtk.ScrolledWindow()
202
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
203
sw.set_shadow_type(Gtk.ShadowType.IN)
215
sw = gtk.ScrolledWindow()
216
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
217
sw.set_shadow_type(gtk.SHADOW_IN)
204
218
sw.add(self.annoview)
205
219
self.annoview.gwindow = self
206
220
sw.show()
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
222
self.pane = pane = gtk.VPaned()
223
pane.add1(sw)
224
pane.add2(self.logview)
225
pane.show()
226
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)
221
231
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)
227
pane.show()
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)
232
vbox.pack_start(hbox, expand=False, fill=True)
240
233
241
234
self.add(vbox)
242
235
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]
236
def row_diff(self, tv, path, tvc):
237
row = path[0]
253
238
revision = self.annotations[row]
254
239
repository = self.branch.repository
255
240
if revision.revision_id == CURRENT_REVISION:
261
246
tree2 = repository.revision_tree(revision.parent_ids[0])
262
247
else:
263
248
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)
249
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
250
window = DiffWindow()
251
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
267
252
window.set_file(tree1.id2path(self.file_id))
268
253
window.show()
269
254
270
255
271
256
def _create_annotate_view(self):
272
tv = Gtk.TreeView()
257
tv = gtk.TreeView()
273
258
tv.set_rules_hint(False)
274
tv.connect("cursor-changed", self._activate_selected_revision)
259
tv.connect("cursor-changed", self._show_log)
275
260
tv.show()
276
tv.connect("row-activated", self.line_diff)
261
tv.connect("row-activated", self.row_diff)
277
262
278
cell = Gtk.CellRendererText()
263
cell = gtk.CellRendererText()
279
264
cell.set_property("xalign", 1.0)
280
265
cell.set_property("ypad", 0)
281
266
cell.set_property("family", "Monospace")
282
267
cell.set_property("cell-background-gdk",
283
tv.get_style().bg[Gtk.StateType.NORMAL])
284
col = Gtk.TreeViewColumn()
268
tv.get_style().bg[gtk.STATE_NORMAL])
269
col = gtk.TreeViewColumn()
285
270
col.set_resizable(False)
286
col.pack_start(cell, True)
271
col.pack_start(cell, expand=True)
287
272
col.add_attribute(cell, "text", LINE_NUM_COL)
288
273
tv.append_column(col)
289
274
290
cell = Gtk.CellRendererText()
275
cell = gtk.CellRendererText()
291
276
cell.set_property("ypad", 0)
292
cell.set_property("ellipsize", Pango.EllipsizeMode.END)
277
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
293
278
cell.set_property("cell-background-gdk",
294
self.get_style().bg[Gtk.StateType.NORMAL])
295
col = Gtk.TreeViewColumn("Committer")
279
self.get_style().bg[gtk.STATE_NORMAL])
280
col = gtk.TreeViewColumn("Committer")
296
281
col.set_resizable(True)
297
col.pack_start(cell, True)
282
col.pack_start(cell, expand=True)
298
283
col.add_attribute(cell, "text", COMMITTER_COL)
299
284
tv.append_column(col)
300
285
301
cell = Gtk.CellRendererText()
286
cell = gtk.CellRendererText()
302
287
cell.set_property("xalign", 1.0)
303
288
cell.set_property("ypad", 0)
304
289
cell.set_property("cell-background-gdk",
305
self.get_style().bg[Gtk.StateType.NORMAL])
306
col = Gtk.TreeViewColumn("Revno")
290
self.get_style().bg[gtk.STATE_NORMAL])
291
col = gtk.TreeViewColumn("Revno")
307
292
col.set_resizable(False)
308
col.pack_start(cell, True)
293
col.pack_start(cell, expand=True)
309
294
col.add_attribute(cell, "markup", REVNO_COL)
310
295
tv.append_column(col)
311
296
312
cell = Gtk.CellRendererText()
297
cell = gtk.CellRendererText()
313
298
cell.set_property("ypad", 0)
314
299
cell.set_property("family", "Monospace")
315
col = Gtk.TreeViewColumn()
300
col = gtk.TreeViewColumn()
316
301
col.set_resizable(False)
317
col.pack_start(cell, True)
302
col.pack_start(cell, expand=True)
318
303
# col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
319
304
col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
320
305
col.add_attribute(cell, "text", TEXT_LINE_COL)
321
306
tv.append_column(col)
322
307
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
308
tv.set_search_column(LINE_NUM_COL)
309
330
310
return tv
331
311
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
332
319
def _create_log_view(self):
333
lv = RevisionView(self._branch)
320
lv = LogView()
334
321
lv.show()
322
335
323
return lv
336
324
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):
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
339
340
341
class FakeRevision:
426
342
""" A fake revision.
427
343
428
344
For when a revision is referenced but not present.
429
345
"""
430
346
431
def __init__(self, revision_id, committer='?', nick=None):
347
def __init__(self, revision_id, committer='?'):
432
348
self.revision_id = revision_id
433
349
self.parent_ids = []
434
350
self.committer = committer
435
351
self.message = "?"
436
352
self.timestamp = 0.0
437
353
self.timezone = 0
438
self.properties = {}
439
440
def get_apparent_authors(self):
441
return [self.committer]
442
354
443
355
444
356
class RevisionCache(object):
445
357
"""A caching revision source"""
446
447
def __init__(self, real_source, seed_cache=None):
358
def __init__(self, real_source):
448
359
self.__real_source = real_source
449
if seed_cache is None:
450
self.__cache = {}
451
else:
452
self.__cache = dict(seed_cache)
360
self.__cache = {}
453
361
454
362
def get_revision(self, revision_id):
455
363
if revision_id not in self.__cache:
456
364
revision = self.__real_source.get_revision(revision_id)
457
365
self.__cache[revision_id] = revision
458
366
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