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 140
- compare with another revision
- download diff
- download tarball
- view history from revision 140
- Committer: Jelmer Vernooij
- Date: 2007-02-01 15:50:40 UTC
- Revision ID: jelmer@samba.org-20070201155040-3hq4mfbxs99kzazy
add framework for tests.
- files added:
- cmenu.ui
- olive
- files removed:
- HACKING
- branchview
- preferences
- 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
- errors.py => olive/errors.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
19
import pygtk
20
pygtk.require("2.0")
21
import gobject
22
import gtk
23
import pango
23
24
import re
24
25
25
from bzrlib import patiencediff
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
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
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
from logview import LogView
32
from spanselector import SpanSelector
33
33
34
34
35
35
(
42
42
) = range(6)
43
43
44
44
45
class GAnnotateWindow(Window):
45
class GAnnotateWindow(gtk.Window):
46
46
"""Annotate window."""
47
47
48
def __init__(self, all=False, plain=False, parent=None, branch=None):
48
def __init__(self, all=False, plain=False):
49
49
self.all = all
50
50
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))
51
52
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
53
54
self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
57
55
self.annotate_colormap = AnnotateColorSaturation()
58
56
59
57
self._create()
60
58
self.revisions = {}
61
self.history = []
62
self._no_back = set()
63
59
64
60
def annotate(self, tree, branch, file_id):
65
61
self.annotations = []
66
62
self.branch = branch
67
63
self.tree = tree
68
64
self.file_id = file_id
69
self.revisionview.set_file_id(file_id)
70
65
self.revision_id = getattr(tree, 'get_revision_id',
71
66
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
67
68
# [revision id, line number, committer, revno, highlight color, line]
69
self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
70
gobject.TYPE_STRING,
71
gobject.TYPE_STRING,
72
gobject.TYPE_STRING,
73
gobject.TYPE_STRING,
74
gobject.TYPE_STRING)
75
81
76
last_seen = None
82
77
try:
83
78
branch.lock_read()
84
79
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
80
for line_no, (revision, revno, line)\
90
in enumerate(self._annotate(tree, file_id)):
81
in enumerate(self._annotate(tree, file_id)):
91
82
if revision.revision_id == last_seen and not self.all:
92
revno = author = ""
83
revno = committer = ""
93
84
else:
94
85
last_seen = revision.revision_id
95
author = ", ".join(revision.get_apparent_authors())
86
committer = revision.committer
96
87
97
88
if revision.revision_id not in self.revisions:
98
89
self.revisions[revision.revision_id] = revision
99
90
100
91
self.annomodel.append([revision.revision_id,
101
92
line_no + 1,
102
author,
93
committer,
103
94
revno,
104
95
None,
105
96
line.rstrip("\r\n")
106
])
97
])
107
98
self.annotations.append(revision)
108
99
109
100
if not self.plain:
115
106
116
107
self.annoview.set_model(self.annomodel)
117
108
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
109
122
110
def jump_to_line(self, lineno):
123
111
if lineno > len(self.annomodel) or lineno < 1:
126
114
# bar?
127
115
print("gannotate: Line number %d does't exist. Defaulting to "
128
116
"line 1." % lineno)
129
return
117
return
130
118
else:
131
119
row = lineno - 1
132
120
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)
121
self.annoview.set_cursor(row)
122
self.annoview.scroll_to_cell(row, use_align=True)
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
136
136
137
137
def _annotate(self, tree, file_id):
138
138
current_revision = FakeRevision(CURRENT_REVISION)
140
140
current_revision.timestamp = time.time()
141
141
current_revision.message = '[Not yet committed]'
142
142
current_revision.parent_ids = tree.get_parent_ids()
143
current_revision.properties['branch-nick'] = self.branch._get_nick(local=True)
144
143
current_revno = '%d?' % (self.branch.revno() + 1)
145
144
repository = self.branch.repository
146
145
if self.revision_id == CURRENT_REVISION:
147
146
revision_id = self.branch.last_revision()
148
147
else:
149
148
revision_id = self.revision_id
149
dotted = self._dotted_revnos(repository, revision_id)
150
150
revision_cache = RevisionCache(repository, self.revisions)
151
151
for origin, text in tree.annotate_iter(file_id):
152
152
rev_id = origin
156
156
else:
157
157
try:
158
158
revision = revision_cache.get_revision(rev_id)
159
revno = self.dotted.get(rev_id, 'merge')
159
revno = dotted.get(rev_id, 'merge')
160
160
if len(revno) > 15:
161
161
revno = 'merge'
162
162
except NoSuchRevision:
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
# 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)
171
model.set(iter, HIGHLIGHT_COLOR_COL,
172
self.annotate_colormap.get_color(revision, now))
174
173
175
174
def _selected_revision(self):
176
175
(path, col) = self.annoview.get_cursor()
178
177
return None
179
178
return self.annomodel[path][REVISION_ID_COL]
180
179
181
def _activate_selected_revision(self, w):
180
def _show_log(self, w):
182
181
rev_id = self._selected_revision()
183
if not rev_id or rev_id == NULL_REVISION:
182
if rev_id is None:
184
183
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)
184
self.logview.set_revision(self.revisions[rev_id])
193
185
194
186
def _create(self):
195
self.revisionview = self._create_log_view()
187
self.logview = self._create_log_view()
196
188
self.annoview = self._create_annotate_view()
197
189
198
vbox = Gtk.VBox(homogeneous=False, spacing=0)
190
vbox = gtk.VBox(False, 12)
191
vbox.set_border_width(12)
199
192
vbox.show()
200
193
201
sw = Gtk.ScrolledWindow()
202
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
203
sw.set_shadow_type(Gtk.ShadowType.IN)
194
sw = gtk.ScrolledWindow()
195
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
196
sw.set_shadow_type(gtk.SHADOW_IN)
204
197
sw.add(self.annoview)
205
198
self.annoview.gwindow = self
206
199
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
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
201
self.pane = pane = gtk.VPaned()
202
pane.add1(sw)
203
pane.add2(self.logview)
227
204
pane.show()
228
vbox.pack_start(pane, True, True, 0)
205
vbox.pack_start(pane, expand=True, fill=True)
229
206
230
207
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,
208
vbox.pack_start(self._search, expand=False, fill=True)
209
accels = gtk.AccelGroup()
210
accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
211
gtk.ACCEL_LOCKED,
235
212
self._search_by_text)
236
accels.connect(Gdk.KEY_g, Gdk.ModifierType.CONTROL_MASK,
237
Gtk.AccelFlags.LOCKED,
213
accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
214
gtk.ACCEL_LOCKED,
238
215
self._search_by_line)
239
216
self.add_accel_group(accels)
240
217
218
hbox = gtk.HBox(True, 6)
219
hbox.pack_start(self._create_prev_button(), expand=False, fill=True)
220
hbox.pack_end(self._create_button_box(), expand=False, fill=True)
221
hbox.show()
222
vbox.pack_start(hbox, expand=False, fill=True)
223
241
224
self.add(vbox)
242
225
243
def _search_by_text(self, *ignored): # (accel_group, window, key, modifiers):
226
def _search_by_text(self, accel_group, window, key, modifiers):
244
227
self._search.show_for('text')
245
228
self._search.set_target(self.annoview, TEXT_LINE_COL)
246
229
247
def _search_by_line(self, *ignored): # accel_group, window, key, modifiers):
230
def _search_by_line(self, accel_group, window, key, modifiers):
248
231
self._search.show_for('line')
249
232
self._search.set_target(self.annoview, LINE_NUM_COL)
250
233
251
def line_diff(self, tv, path, tvc):
252
row = path.get_indices()[0]
234
def row_diff(self, tv, path, tvc):
235
row = path[0]
253
236
revision = self.annotations[row]
254
237
repository = self.branch.repository
255
238
if revision.revision_id == CURRENT_REVISION:
261
244
tree2 = repository.revision_tree(revision.parent_ids[0])
262
245
else:
263
246
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)
247
from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
248
window = DiffWindow()
249
window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
267
250
window.set_file(tree1.id2path(self.file_id))
268
251
window.show()
269
252
270
253
271
254
def _create_annotate_view(self):
272
tv = Gtk.TreeView()
255
tv = gtk.TreeView()
273
256
tv.set_rules_hint(False)
274
tv.connect("cursor-changed", self._activate_selected_revision)
257
tv.connect("cursor-changed", self._show_log)
275
258
tv.show()
276
tv.connect("row-activated", self.line_diff)
259
tv.connect("row-activated", self.row_diff)
277
260
278
cell = Gtk.CellRendererText()
261
cell = gtk.CellRendererText()
279
262
cell.set_property("xalign", 1.0)
280
263
cell.set_property("ypad", 0)
281
264
cell.set_property("family", "Monospace")
282
265
cell.set_property("cell-background-gdk",
283
tv.get_style().bg[Gtk.StateType.NORMAL])
284
col = Gtk.TreeViewColumn()
266
tv.get_style().bg[gtk.STATE_NORMAL])
267
col = gtk.TreeViewColumn()
285
268
col.set_resizable(False)
286
col.pack_start(cell, True)
269
col.pack_start(cell, expand=True)
287
270
col.add_attribute(cell, "text", LINE_NUM_COL)
288
271
tv.append_column(col)
289
272
290
cell = Gtk.CellRendererText()
273
cell = gtk.CellRendererText()
291
274
cell.set_property("ypad", 0)
292
cell.set_property("ellipsize", Pango.EllipsizeMode.END)
275
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
293
276
cell.set_property("cell-background-gdk",
294
self.get_style().bg[Gtk.StateType.NORMAL])
295
col = Gtk.TreeViewColumn("Committer")
277
self.get_style().bg[gtk.STATE_NORMAL])
278
col = gtk.TreeViewColumn("Committer")
296
279
col.set_resizable(True)
297
col.pack_start(cell, True)
280
col.pack_start(cell, expand=True)
298
281
col.add_attribute(cell, "text", COMMITTER_COL)
299
282
tv.append_column(col)
300
283
301
cell = Gtk.CellRendererText()
284
cell = gtk.CellRendererText()
302
285
cell.set_property("xalign", 1.0)
303
286
cell.set_property("ypad", 0)
304
287
cell.set_property("cell-background-gdk",
305
self.get_style().bg[Gtk.StateType.NORMAL])
306
col = Gtk.TreeViewColumn("Revno")
288
self.get_style().bg[gtk.STATE_NORMAL])
289
col = gtk.TreeViewColumn("Revno")
307
290
col.set_resizable(False)
308
col.pack_start(cell, True)
291
col.pack_start(cell, expand=True)
309
292
col.add_attribute(cell, "markup", REVNO_COL)
310
293
tv.append_column(col)
311
294
312
cell = Gtk.CellRendererText()
295
cell = gtk.CellRendererText()
313
296
cell.set_property("ypad", 0)
314
297
cell.set_property("family", "Monospace")
315
col = Gtk.TreeViewColumn()
298
col = gtk.TreeViewColumn()
316
299
col.set_resizable(False)
317
col.pack_start(cell, True)
300
col.pack_start(cell, expand=True)
318
301
# col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
319
302
col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
320
303
col.add_attribute(cell, "text", TEXT_LINE_COL)
321
304
tv.append_column(col)
322
305
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)
306
# FIXME: Now that C-f is now used for search by text we
307
# may as well disable the auto search.
308
tv.set_search_column(LINE_NUM_COL)
329
309
330
310
return tv
331
311
332
312
def _create_log_view(self):
333
lv = RevisionView(self._branch)
313
lv = LogView()
334
314
lv.show()
315
335
316
return lv
336
317
337
def _create_back_button(self):
338
button = Gtk.Button()
318
def _create_button_box(self):
319
box = gtk.HButtonBox()
320
box.set_layout(gtk.BUTTONBOX_END)
321
box.show()
322
323
button = gtk.Button()
324
button.set_use_stock(True)
325
button.set_label("gtk-close")
326
button.connect("clicked", lambda w: self.destroy())
327
button.show()
328
329
box.pack_start(button, expand=False, fill=False)
330
331
return box
332
333
def _create_prev_button(self):
334
box = gtk.HButtonBox()
335
box.set_layout(gtk.BUTTONBOX_START)
336
box.show()
337
338
button = gtk.Button()
339
339
button.set_use_stock(True)
340
340
button.set_label("gtk-go-back")
341
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
342
button.show()
343
box.pack_start(button, expand=False, fill=False)
344
return box
376
345
377
346
def go_back(self):
378
last_tree = self.tree
379
347
rev_id = self._selected_revision()
380
348
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
349
tree = self.branch.repository.revision_tree(parent_id)
350
if self.file_id in tree:
351
offset = self.get_scroll_offset(tree)
352
(row,), col = self.annoview.get_cursor()
353
self.annotate(tree, self.branch, self.file_id)
354
self.annoview.set_cursor(row+offset)
412
355
413
356
def get_scroll_offset(self, tree):
414
357
old = self.tree.get_file(self.file_id)
415
358
new = tree.get_file(self.file_id)
416
path, col = self.annoview.get_cursor()
417
(row,) = path.get_indices()
359
(row,), col = self.annoview.get_cursor()
418
360
matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
419
361
new.readlines())
420
362
for i, j, n in matcher.get_matching_blocks():
422
364
return j - i
423
365
424
366
425
class FakeRevision(object):
367
368
class FakeRevision:
426
369
""" A fake revision.
427
370
428
371
For when a revision is referenced but not present.
429
372
"""
430
373
431
def __init__(self, revision_id, committer='?', nick=None):
374
def __init__(self, revision_id, committer='?'):
432
375
self.revision_id = revision_id
433
376
self.parent_ids = []
434
377
self.committer = committer
435
378
self.message = "?"
436
379
self.timestamp = 0.0
437
380
self.timezone = 0
438
self.properties = {}
439
440
def get_apparent_authors(self):
441
return [self.committer]
442
381
443
382
444
383
class RevisionCache(object):
445
384
"""A caching revision source"""
446
447
385
def __init__(self, real_source, seed_cache=None):
448
386
self.__real_source = real_source
449
387
if seed_cache is None:
457
395
self.__cache[revision_id] = revision
458
396
return self.__cache[revision_id]
459
397
460
461
class SearchBox(Gtk.HBox):
398
class SearchBox(gtk.HBox):
462
399
"""A button box for searching in text or lines of annotations"""
463
400
def __init__(self):
464
super(SearchBox, self).__init__(homogeneous=False, spacing=6)
401
gtk.HBox.__init__(self, False, 6)
465
402
466
403
# Close button
467
button = Gtk.Button()
468
image = Gtk.Image()
469
image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
404
button = gtk.Button()
405
image = gtk.Image()
406
image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
470
407
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)
408
button.set_relief(gtk.RELIEF_NONE)
409
button.connect("clicked", lambda w: self.hide_all())
410
self.pack_start(button, expand=False, fill=False)
474
411
475
412
# Search entry
476
label = Gtk.Label()
413
label = gtk.Label()
477
414
self._label = label
478
self.pack_start(label, False, False, 0)
415
self.pack_start(label, expand=False, fill=False)
479
416
480
entry = Gtk.Entry()
417
entry = gtk.Entry()
481
418
self._entry = entry
482
419
entry.connect("activate", lambda w, d: self._do_search(d),
483
420
'forward')
484
self.pack_start(entry, False, False, 0)
421
self.pack_start(entry, expand=False, fill=False)
485
422
486
423
# 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)
424
button = gtk.Button('_Next')
425
image = gtk.Image()
426
image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
490
427
button.set_image(image)
491
428
button.connect("clicked", lambda w, d: self._do_search(d),
492
429
'forward')
493
self.pack_start(button, False, False, 0)
430
self.pack_start(button, expand=False, fill=False)
494
431
495
button = Gtk.Button(_i18n('_Previous'), use_underline=True)
496
image = Gtk.Image()
497
image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
432
button = gtk.Button('_Previous')
433
image = gtk.Image()
434
image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
498
435
button.set_image(image)
499
436
button.connect("clicked", lambda w, d: self._do_search(d),
500
437
'backward')
501
self.pack_start(button, False, False, 0)
438
self.pack_start(button, expand=False, fill=False)
502
439
503
440
# Search options
504
check = Gtk.CheckButton('Match case')
441
check = gtk.CheckButton('Match case')
505
442
self._match_case = check
506
self.pack_start(check, False, False, 0)
443
self.pack_start(check, expand=False, fill=False)
507
444
508
check = Gtk.CheckButton('Regexp')
445
check = gtk.CheckButton('Regexp')
509
446
check.connect("toggled", lambda w: self._set_label())
510
447
self._regexp = check
511
self.pack_start(check, False, False, 0)
448
self.pack_start(check, expand=False, fill=False)
512
449
513
450
self._view = None
514
451
self._column = None
541
478
542
479
def _match(self, model, iterator, column):
543
480
matching_case = self._match_case.get_active()
544
cell_value, = model.get(iterator, column)
481
string, = model.get(iterator, column)
545
482
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():
483
if self._regexp.get_active():
551
484
if matching_case:
552
match = re.compile(key).search(cell_value, 1)
485
match = re.compile(key).search(string, 1)
553
486
else:
554
match = re.compile(key, re.I).search(cell_value, 1)
487
match = re.compile(key, re.I).search(string, 1)
555
488
else:
556
489
if not matching_case:
557
cell_value = cell_value.lower()
490
string = string.lower()
558
491
key = key.lower()
559
match = cell_value.find(key) != -1
492
match = string.find(key) != -1
560
493
561
494
return match
562
495
594
527
for row in iterate(model, start):
595
528
if self._match(model, row, self._column):
596
529
path = model.get_path(row)
597
self._view.set_cursor(path, None, False)
530
self._view.set_cursor(path)
598
531
self._view.scroll_to_cell(path, use_align=True)
599
532
break
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0