/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

  • Committer: Jelmer Vernooij
  • Date: 2007-08-27 12:38:18 UTC
  • Revision ID: jelmer@samba.org-20070827123818-0qd8chb7c7n7hx23
Tags: bzr-gtk-0.90.0
Add common widget for selecting branches.

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