/b-gtk/fix-viz

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

Allow bzr-gtk and Bazaar versions to be out of sync. No longer warn about 
newer versions of Bazaar, on the assumption the API is sufficiently stable now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
31
from bzrlib.plugins.gtk.revisionview import RevisionView
32
32
from bzrlib.plugins.gtk.window import Window
33
33
 
45
45
class GAnnotateWindow(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, parent=None):
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
        Window.__init__(self, parent)
 
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()
69
67
        self.revisionview.set_file_id(file_id)
70
68
        self.revision_id = getattr(tree, 'get_revision_id', 
71
69
                                   lambda: CURRENT_REVISION)()
72
 
 
 
70
        
73
71
        # [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
 
 
 
72
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
 
73
                                       gobject.TYPE_STRING,
 
74
                                       gobject.TYPE_STRING,
 
75
                                       gobject.TYPE_STRING,
 
76
                                       gobject.TYPE_STRING,
 
77
                                       gobject.TYPE_STRING)
 
78
        
81
79
        last_seen = None
82
80
        try:
83
81
            branch.lock_read()
84
82
            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
83
            for line_no, (revision, revno, line)\
90
 
                in enumerate(self._annotate(tree, file_id)):
 
84
                    in enumerate(self._annotate(tree, file_id)):
91
85
                if revision.revision_id == last_seen and not self.all:
92
86
                    revno = author = ""
93
87
                else:
94
88
                    last_seen = revision.revision_id
95
 
                    author = ", ".join(revision.get_apparent_authors())
 
89
                    author = revision.get_apparent_author()
96
90
 
97
91
                if revision.revision_id not in self.revisions:
98
92
                    self.revisions[revision.revision_id] = revision
103
97
                                       revno,
104
98
                                       None,
105
99
                                       line.rstrip("\r\n")
106
 
                                       ])
 
100
                                      ])
107
101
                self.annotations.append(revision)
108
102
 
109
103
            if not self.plain:
115
109
 
116
110
        self.annoview.set_model(self.annomodel)
117
111
        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
112
 
122
113
    def jump_to_line(self, lineno):
123
114
        if lineno > len(self.annomodel) or lineno < 1:
126
117
            # bar?
127
118
            print("gannotate: Line number %d does't exist. Defaulting to "
128
119
                  "line 1." % lineno)
129
 
            return
 
120
            return
130
121
        else:
131
122
            row = lineno - 1
132
123
 
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)
 
124
        self.annoview.set_cursor(row)
 
125
        self.annoview.scroll_to_cell(row, use_align=True)
 
126
 
 
127
    def _dotted_revnos(self, repository, revision_id):
 
128
        """Return a dict of revision_id -> dotted revno
 
129
        
 
130
        :param repository: The repository to get the graph from
 
131
        :param revision_id: The last revision for which this info is needed
 
132
        """
 
133
        graph = repository.get_revision_graph(revision_id)
 
134
        dotted = {}
 
135
        for n, revision_id, d, revno, e in tsort.merge_sort(graph, 
 
136
            revision_id, generate_revno=True):
 
137
            dotted[revision_id] = '.'.join(str(num) for num in revno)
 
138
        return dotted
136
139
 
137
140
    def _annotate(self, tree, file_id):
138
141
        current_revision = FakeRevision(CURRENT_REVISION)
140
143
        current_revision.timestamp = time.time()
141
144
        current_revision.message = '[Not yet committed]'
142
145
        current_revision.parent_ids = tree.get_parent_ids()
143
 
        current_revision.properties['branch-nick'] = self.branch._get_nick(local=True)
 
146
        current_revision.properties['branch-nick'] = self.branch.nick
144
147
        current_revno = '%d?' % (self.branch.revno() + 1)
145
148
        repository = self.branch.repository
146
149
        if self.revision_id == CURRENT_REVISION:
147
150
            revision_id = self.branch.last_revision()
148
151
        else:
149
152
            revision_id = self.revision_id
 
153
        dotted = self._dotted_revnos(repository, revision_id)
150
154
        revision_cache = RevisionCache(repository, self.revisions)
151
155
        for origin, text in tree.annotate_iter(file_id):
152
156
            rev_id = origin
156
160
            else:
157
161
                try:
158
162
                    revision = revision_cache.get_revision(rev_id)
159
 
                    revno = self.dotted.get(rev_id, 'merge')
 
163
                    revno = dotted.get(rev_id, 'merge')
160
164
                    if len(revno) > 15:
161
165
                        revno = 'merge'
162
166
                except NoSuchRevision:
168
172
    def _highlight_annotation(self, model, path, iter, now):
169
173
        revision_id, = model.get(iter, REVISION_ID_COL)
170
174
        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)
 
175
        model.set(iter, HIGHLIGHT_COLOR_COL,
 
176
                  self.annotate_colormap.get_color(revision, now))
174
177
 
175
178
    def _selected_revision(self):
176
179
        (path, col) = self.annoview.get_cursor()
180
183
 
181
184
    def _activate_selected_revision(self, w):
182
185
        rev_id = self._selected_revision()
183
 
        if not rev_id or rev_id == NULL_REVISION:
 
186
        if rev_id is None:
184
187
            return
185
188
        selected = self.revisions[rev_id]
186
189
        self.revisionview.set_revision(selected)
195
198
        self.revisionview = self._create_log_view()
196
199
        self.annoview = self._create_annotate_view()
197
200
 
198
 
        vbox = Gtk.VBox(homogeneous=False, spacing=0)
 
201
        vbox = gtk.VBox(False)
199
202
        vbox.show()
200
203
 
201
 
        sw = Gtk.ScrolledWindow()
202
 
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
203
 
        sw.set_shadow_type(Gtk.ShadowType.IN)
 
204
        sw = gtk.ScrolledWindow()
 
205
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
206
        sw.set_shadow_type(gtk.SHADOW_IN)
204
207
        sw.add(self.annoview)
205
208
        self.annoview.gwindow = self
206
209
        sw.show()
207
210
 
208
 
        swbox = Gtk.VBox()
209
 
        swbox.pack_start(sw, True, True, 0)
 
211
        swbox = gtk.VBox()
 
212
        swbox.pack_start(sw)
210
213
        swbox.show()
211
214
 
212
 
        hbox = Gtk.HBox(homogeneous=False, spacing=6)
 
215
        hbox = gtk.HBox(False, 6)
213
216
        self.back_button = self._create_back_button()
214
 
        hbox.pack_start(self.back_button, False, True, 0)
 
217
        hbox.pack_start(self.back_button, expand=False, fill=True)
215
218
        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)
 
219
        hbox.pack_start(self.forward_button, expand=False, fill=True)
221
220
        hbox.show()
222
 
        vbox.pack_start(hbox, False, True, 0)
223
 
 
224
 
        self.pane = pane = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
 
221
        vbox.pack_start(hbox, expand=False, fill=True)
 
222
        
 
223
        self.pane = pane = gtk.VPaned()
225
224
        pane.add1(swbox)
226
225
        pane.add2(self.revisionview)
227
226
        pane.show()
228
 
        vbox.pack_start(pane, True, True, 0)
 
227
        vbox.pack_start(pane, expand=True, fill=True)
229
228
 
230
229
        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,
 
230
        swbox.pack_start(self._search, expand=False, fill=True)
 
231
        accels = gtk.AccelGroup()
 
232
        accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
 
233
                             gtk.ACCEL_LOCKED,
235
234
                             self._search_by_text)
236
 
        accels.connect(Gdk.KEY_g, Gdk.ModifierType.CONTROL_MASK,
237
 
                             Gtk.AccelFlags.LOCKED,
 
235
        accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
 
236
                             gtk.ACCEL_LOCKED,
238
237
                             self._search_by_line)
239
238
        self.add_accel_group(accels)
240
239
 
241
240
        self.add(vbox)
242
241
 
243
 
    def _search_by_text(self, *ignored): # (accel_group, window, key, modifiers):
 
242
    def _search_by_text(self, accel_group, window, key, modifiers):
244
243
        self._search.show_for('text')
245
244
        self._search.set_target(self.annoview, TEXT_LINE_COL)
246
245
 
247
 
    def _search_by_line(self, *ignored): # accel_group, window, key, modifiers):
 
246
    def _search_by_line(self, accel_group, window, key, modifiers):
248
247
        self._search.show_for('line')
249
248
        self._search.set_target(self.annoview, LINE_NUM_COL)
250
249
 
251
 
    def line_diff(self, tv, path, tvc):
252
 
        row = path.get_indices()[0]
 
250
    def row_diff(self, tv, path, tvc):
 
251
        row = path[0]
253
252
        revision = self.annotations[row]
254
253
        repository = self.branch.repository
255
254
        if revision.revision_id == CURRENT_REVISION:
262
261
            else:
263
262
                tree2 = repository.revision_tree(NULL_REVISION)
264
263
        from bzrlib.plugins.gtk.diff import DiffWindow
265
 
        window = DiffWindow(self)
266
 
        window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
 
264
        window = DiffWindow()
 
265
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
267
266
        window.set_file(tree1.id2path(self.file_id))
268
267
        window.show()
269
268
 
270
269
 
271
270
    def _create_annotate_view(self):
272
 
        tv = Gtk.TreeView()
 
271
        tv = gtk.TreeView()
273
272
        tv.set_rules_hint(False)
274
273
        tv.connect("cursor-changed", self._activate_selected_revision)
275
274
        tv.show()
276
 
        tv.connect("row-activated", self.line_diff)
 
275
        tv.connect("row-activated", self.row_diff)
277
276
 
278
 
        cell = Gtk.CellRendererText()
 
277
        cell = gtk.CellRendererText()
279
278
        cell.set_property("xalign", 1.0)
280
279
        cell.set_property("ypad", 0)
281
280
        cell.set_property("family", "Monospace")
282
281
        cell.set_property("cell-background-gdk",
283
 
                          tv.get_style().bg[Gtk.StateType.NORMAL])
284
 
        col = Gtk.TreeViewColumn()
 
282
                          tv.get_style().bg[gtk.STATE_NORMAL])
 
283
        col = gtk.TreeViewColumn()
285
284
        col.set_resizable(False)
286
 
        col.pack_start(cell, True)
 
285
        col.pack_start(cell, expand=True)
287
286
        col.add_attribute(cell, "text", LINE_NUM_COL)
288
287
        tv.append_column(col)
289
288
 
290
 
        cell = Gtk.CellRendererText()
 
289
        cell = gtk.CellRendererText()
291
290
        cell.set_property("ypad", 0)
292
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
 
291
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
293
292
        cell.set_property("cell-background-gdk",
294
 
                          self.get_style().bg[Gtk.StateType.NORMAL])
295
 
        col = Gtk.TreeViewColumn("Committer")
 
293
                          self.get_style().bg[gtk.STATE_NORMAL])
 
294
        col = gtk.TreeViewColumn("Committer")
296
295
        col.set_resizable(True)
297
 
        col.pack_start(cell, True)
 
296
        col.pack_start(cell, expand=True)
298
297
        col.add_attribute(cell, "text", COMMITTER_COL)
299
298
        tv.append_column(col)
300
299
 
301
 
        cell = Gtk.CellRendererText()
 
300
        cell = gtk.CellRendererText()
302
301
        cell.set_property("xalign", 1.0)
303
302
        cell.set_property("ypad", 0)
304
303
        cell.set_property("cell-background-gdk",
305
 
                          self.get_style().bg[Gtk.StateType.NORMAL])
306
 
        col = Gtk.TreeViewColumn("Revno")
 
304
                          self.get_style().bg[gtk.STATE_NORMAL])
 
305
        col = gtk.TreeViewColumn("Revno")
307
306
        col.set_resizable(False)
308
 
        col.pack_start(cell, True)
 
307
        col.pack_start(cell, expand=True)
309
308
        col.add_attribute(cell, "markup", REVNO_COL)
310
309
        tv.append_column(col)
311
310
 
312
 
        cell = Gtk.CellRendererText()
 
311
        cell = gtk.CellRendererText()
313
312
        cell.set_property("ypad", 0)
314
313
        cell.set_property("family", "Monospace")
315
 
        col = Gtk.TreeViewColumn()
 
314
        col = gtk.TreeViewColumn()
316
315
        col.set_resizable(False)
317
 
        col.pack_start(cell, True)
 
316
        col.pack_start(cell, expand=True)
318
317
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
319
318
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
320
319
        col.add_attribute(cell, "text", TEXT_LINE_COL)
321
320
        tv.append_column(col)
322
321
 
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)
 
322
        # FIXME: Now that C-f is now used for search by text we
 
323
        # may as well disable the auto search.
 
324
        tv.set_search_column(LINE_NUM_COL)
329
325
 
330
326
        return tv
331
327
 
332
328
    def _create_log_view(self):
333
 
        lv = RevisionView(self._branch)
 
329
        lv = RevisionView()
334
330
        lv.show()
335
331
        return lv
336
332
 
337
333
    def _create_back_button(self):
338
 
        button = Gtk.Button()
 
334
        button = gtk.Button()
339
335
        button.set_use_stock(True)
340
336
        button.set_label("gtk-go-back")
341
337
        button.connect("clicked", lambda w: self.go_back())
342
 
        button.set_relief(Gtk.ReliefStyle.NONE)
 
338
        button.set_relief(gtk.RELIEF_NONE)
343
339
        button.show()
344
340
        return button
345
341
 
346
342
    def _create_forward_button(self):
347
 
        button = Gtk.Button()
 
343
        button = gtk.Button()
348
344
        button.set_use_stock(True)
349
345
        button.set_label("gtk-go-forward")
350
346
        button.connect("clicked", lambda w: self.go_forward())
351
 
        button.set_relief(Gtk.ReliefStyle.NONE)
 
347
        button.set_relief(gtk.RELIEF_NONE)
352
348
        button.show()
353
349
        button.set_sensitive(False)
354
350
        return button
355
351
 
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
352
    def go_back(self):
378
353
        last_tree = self.tree
379
354
        rev_id = self._selected_revision()
398
373
        rev_id = self._selected_revision()
399
374
        if self.file_id in target_tree:
400
375
            offset = self.get_scroll_offset(target_tree)
401
 
            path, col = self.annoview.get_cursor()
402
 
            (row,) = path.get_indices()
 
376
            (row,), col = self.annoview.get_cursor()
403
377
            self.annotate(target_tree, self.branch, self.file_id)
404
378
            new_row = row+offset
405
379
            if new_row < 0:
406
380
                new_row = 0
407
 
            new_path = Gtk.TreePath(path=new_row)
408
 
            self.annoview.set_cursor(new_path, None, False)
 
381
            self.annoview.set_cursor(new_row)
409
382
            return True
410
383
        else:
411
384
            return False
413
386
    def get_scroll_offset(self, tree):
414
387
        old = self.tree.get_file(self.file_id)
415
388
        new = tree.get_file(self.file_id)
416
 
        path, col = self.annoview.get_cursor()
417
 
        (row,) = path.get_indices()
 
389
        (row,), col = self.annoview.get_cursor()
418
390
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
419
391
                                                       new.readlines())
420
392
        for i, j, n in matcher.get_matching_blocks():
422
394
                return j - i
423
395
 
424
396
 
425
 
class FakeRevision(object):
 
397
class FakeRevision:
426
398
    """ A fake revision.
427
399
 
428
400
    For when a revision is referenced but not present.
437
409
        self.timezone = 0
438
410
        self.properties = {}
439
411
 
440
 
    def get_apparent_authors(self):
441
 
        return [self.committer]
 
412
    def get_apparent_author(self):
 
413
        return self.committer
442
414
 
443
415
 
444
416
class RevisionCache(object):
445
417
    """A caching revision source"""
446
 
 
447
418
    def __init__(self, real_source, seed_cache=None):
448
419
        self.__real_source = real_source
449
420
        if seed_cache is None:
457
428
            self.__cache[revision_id] = revision
458
429
        return self.__cache[revision_id]
459
430
 
460
 
 
461
 
class SearchBox(Gtk.HBox):
 
431
class SearchBox(gtk.HBox):
462
432
    """A button box for searching in text or lines of annotations"""
463
433
    def __init__(self):
464
 
        super(SearchBox, self).__init__(homogeneous=False, spacing=6)
 
434
        gtk.HBox.__init__(self, False, 6)
465
435
 
466
436
        # Close button
467
 
        button = Gtk.Button()
468
 
        image = Gtk.Image()
469
 
        image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
 
437
        button = gtk.Button()
 
438
        image = gtk.Image()
 
439
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
470
440
        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)
 
441
        button.set_relief(gtk.RELIEF_NONE)
 
442
        button.connect("clicked", lambda w: self.hide_all())
 
443
        self.pack_start(button, expand=False, fill=False)
474
444
 
475
445
        # Search entry
476
 
        label = Gtk.Label()
 
446
        label = gtk.Label()
477
447
        self._label = label
478
 
        self.pack_start(label, False, False, 0)
 
448
        self.pack_start(label, expand=False, fill=False)
479
449
 
480
 
        entry = Gtk.Entry()
 
450
        entry = gtk.Entry()
481
451
        self._entry = entry
482
452
        entry.connect("activate", lambda w, d: self._do_search(d),
483
453
                      'forward')
484
 
        self.pack_start(entry, False, False, 0)
 
454
        self.pack_start(entry, expand=False, fill=False)
485
455
 
486
456
        # 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)
 
457
        button = gtk.Button('_Next')
 
458
        image = gtk.Image()
 
459
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
490
460
        button.set_image(image)
491
461
        button.connect("clicked", lambda w, d: self._do_search(d),
492
462
                       'forward')
493
 
        self.pack_start(button, False, False, 0)
 
463
        self.pack_start(button, expand=False, fill=False)
494
464
 
495
 
        button = Gtk.Button(_i18n('_Previous'), use_underline=True)
496
 
        image = Gtk.Image()
497
 
        image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
 
465
        button = gtk.Button('_Previous')
 
466
        image = gtk.Image()
 
467
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
498
468
        button.set_image(image)
499
469
        button.connect("clicked", lambda w, d: self._do_search(d),
500
470
                       'backward')
501
 
        self.pack_start(button, False, False, 0)
 
471
        self.pack_start(button, expand=False, fill=False)
502
472
 
503
473
        # Search options
504
 
        check = Gtk.CheckButton('Match case')
 
474
        check = gtk.CheckButton('Match case')
505
475
        self._match_case = check
506
 
        self.pack_start(check, False, False, 0)
 
476
        self.pack_start(check, expand=False, fill=False)
507
477
 
508
 
        check = Gtk.CheckButton('Regexp')
 
478
        check = gtk.CheckButton('Regexp')
509
479
        check.connect("toggled", lambda w: self._set_label())
510
480
        self._regexp = check
511
 
        self.pack_start(check, False, False, 0)
 
481
        self.pack_start(check, expand=False, fill=False)
512
482
 
513
483
        self._view = None
514
484
        self._column = None
541
511
 
542
512
    def _match(self, model, iterator, column):
543
513
        matching_case = self._match_case.get_active()
544
 
        cell_value, = model.get(iterator, column)
 
514
        string, = model.get(iterator, column)
545
515
        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():
 
516
        if self._regexp.get_active():
551
517
            if matching_case:
552
 
                match = re.compile(key).search(cell_value, 1)
 
518
                match = re.compile(key).search(string, 1)
553
519
            else:
554
 
                match = re.compile(key, re.I).search(cell_value, 1)
 
520
                match = re.compile(key, re.I).search(string, 1)
555
521
        else:
556
522
            if not matching_case:
557
 
                cell_value = cell_value.lower()
 
523
                string = string.lower()
558
524
                key = key.lower()
559
 
            match = cell_value.find(key) != -1
 
525
            match = string.find(key) != -1
560
526
 
561
527
        return match
562
528
 
594
560
        for row in iterate(model, start):
595
561
            if self._match(model, row, self._column):
596
562
                path = model.get_path(row)
597
 
                self._view.set_cursor(path, None, False)
 
563
                self._view.set_cursor(path)
598
564
                self._view.scroll_to_cell(path, use_align=True)
599
565
                break