/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

Commit messages never contain config options

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
 
1
# Copyright (C) 2005 Dan Loda <danloda@gmail.com>
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import time
 
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
 
24
 
 
25
from bzrlib import patiencediff
 
26
from bzrlib.errors import NoSuchRevision
 
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
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
 
33
 
 
34
 
 
35
(
 
36
    REVISION_ID_COL,
 
37
    LINE_NUM_COL,
 
38
    COMMITTER_COL,
 
39
    REVNO_COL,
 
40
    HIGHLIGHT_COLOR_COL,
 
41
    TEXT_LINE_COL
 
42
) = range(6)
 
43
 
 
44
 
 
45
class GAnnotateWindow(Window):
 
46
    """Annotate window."""
 
47
 
 
48
    def __init__(self, all=False, plain=False, parent=None, branch=None):
 
49
        self.all = all
 
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))
 
57
        self.annotate_colormap = AnnotateColorSaturation()
 
58
 
 
59
        self._create()
 
60
        self.revisions = {}
 
61
        self.history = []
 
62
        self._no_back = set()
 
63
 
 
64
    def annotate(self, tree, branch, file_id):
 
65
        self.annotations = []
 
66
        self.branch = branch
 
67
        self.tree = tree
 
68
        self.file_id = file_id
 
69
        self.revisionview.set_file_id(file_id)
 
70
        self.revision_id = getattr(tree, 'get_revision_id', 
 
71
                                   lambda: CURRENT_REVISION)()
 
72
 
 
73
        # [revision id, line number, author, revno, highlight color, line]
 
74
        self.annomodel = Gtk.ListStore(GObject.TYPE_STRING,
 
75
                                       GObject.TYPE_INT,
 
76
                                       GObject.TYPE_STRING,
 
77
                                       GObject.TYPE_STRING,
 
78
                                       GObject.TYPE_STRING,
 
79
                                       GObject.TYPE_STRING)
 
80
 
 
81
        last_seen = None
 
82
        try:
 
83
            branch.lock_read()
 
84
            branch.repository.lock_read()
 
85
            self.dotted = {}
 
86
            revno_map = self.branch.get_revision_id_to_revno_map()
 
87
            for revision_id, revno in revno_map.iteritems():
 
88
                self.dotted[revision_id] = '.'.join(str(num) for num in revno)
 
89
            for line_no, (revision, revno, line)\
 
90
                in enumerate(self._annotate(tree, file_id)):
 
91
                if revision.revision_id == last_seen and not self.all:
 
92
                    revno = author = ""
 
93
                else:
 
94
                    last_seen = revision.revision_id
 
95
                    author = ", ".join(revision.get_apparent_authors())
 
96
 
 
97
                if revision.revision_id not in self.revisions:
 
98
                    self.revisions[revision.revision_id] = revision
 
99
 
 
100
                self.annomodel.append([revision.revision_id,
 
101
                                       line_no + 1,
 
102
                                       author,
 
103
                                       revno,
 
104
                                       None,
 
105
                                       line.rstrip("\r\n")
 
106
                                       ])
 
107
                self.annotations.append(revision)
 
108
 
 
109
            if not self.plain:
 
110
                now = time.time()
 
111
                self.annomodel.foreach(self._highlight_annotation, now)
 
112
        finally:
 
113
            branch.repository.unlock()
 
114
            branch.unlock()
 
115
 
 
116
        self.annoview.set_model(self.annomodel)
 
117
        self.annoview.grab_focus()
 
118
        my_revno = self.dotted.get(self.revision_id, 'current')
 
119
        title = '%s (%s) - gannotate' % (self.tree.id2path(file_id), my_revno)
 
120
        self.set_title(title)
 
121
 
 
122
    def jump_to_line(self, lineno):
 
123
        if lineno > len(self.annomodel) or lineno < 1:
 
124
            row = 0
 
125
            # FIXME:should really deal with this in the gui. Perhaps a status
 
126
            # bar?
 
127
            print("gannotate: Line number %d does't exist. Defaulting to "
 
128
                  "line 1." % lineno)
 
129
            return
 
130
        else:
 
131
            row = lineno - 1
 
132
 
 
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)
 
136
 
 
137
    def _annotate(self, tree, file_id):
 
138
        current_revision = FakeRevision(CURRENT_REVISION)
 
139
        current_revision.committer = self.branch.get_config().username()
 
140
        current_revision.timestamp = time.time()
 
141
        current_revision.message = '[Not yet committed]'
 
142
        current_revision.parent_ids = tree.get_parent_ids()
 
143
        current_revision.properties['branch-nick'] = self.branch._get_nick(local=True)
 
144
        current_revno = '%d?' % (self.branch.revno() + 1)
 
145
        repository = self.branch.repository
 
146
        if self.revision_id == CURRENT_REVISION:
 
147
            revision_id = self.branch.last_revision()
 
148
        else:
 
149
            revision_id = self.revision_id
 
150
        revision_cache = RevisionCache(repository, self.revisions)
 
151
        for origin, text in tree.annotate_iter(file_id):
 
152
            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:
 
163
                    revision = FakeRevision(rev_id)
 
164
                    revno = "?"
 
165
 
 
166
            yield revision, revno, text
 
167
 
 
168
    def _highlight_annotation(self, model, path, iter, now):
 
169
        revision_id, = model.get(iter, REVISION_ID_COL)
 
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)
 
174
 
 
175
    def _selected_revision(self):
 
176
        (path, col) = self.annoview.get_cursor()
 
177
        if path is None:
 
178
            return None
 
179
        return self.annomodel[path][REVISION_ID_COL]
 
180
 
 
181
    def _activate_selected_revision(self, w):
 
182
        rev_id = self._selected_revision()
 
183
        if not rev_id or rev_id == NULL_REVISION:
 
184
            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)
 
193
 
 
194
    def _create(self):
 
195
        self.revisionview = self._create_log_view()
 
196
        self.annoview = self._create_annotate_view()
 
197
 
 
198
        vbox = Gtk.VBox(homogeneous=False, spacing=0)
 
199
        vbox.show()
 
200
 
 
201
        sw = Gtk.ScrolledWindow()
 
202
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
203
        sw.set_shadow_type(Gtk.ShadowType.IN)
 
204
        sw.add(self.annoview)
 
205
        self.annoview.gwindow = self
 
206
        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)
 
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)
 
240
 
 
241
        self.add(vbox)
 
242
 
 
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]
 
253
        revision = self.annotations[row]
 
254
        repository = self.branch.repository
 
255
        if revision.revision_id == CURRENT_REVISION:
 
256
            tree1 = self.tree
 
257
            tree2 = self.tree.basis_tree()
 
258
        else:
 
259
            tree1 = repository.revision_tree(revision.revision_id)
 
260
            if len(revision.parent_ids) > 0:
 
261
                tree2 = repository.revision_tree(revision.parent_ids[0])
 
262
            else:
 
263
                tree2 = repository.revision_tree(NULL_REVISION)
 
264
        from bzrlib.plugins.gtk.diff import DiffWindow
 
265
        window = DiffWindow(self)
 
266
        window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
 
267
        window.set_file(tree1.id2path(self.file_id))
 
268
        window.show()
 
269
 
 
270
 
 
271
    def _create_annotate_view(self):
 
272
        tv = Gtk.TreeView()
 
273
        tv.set_rules_hint(False)
 
274
        tv.connect("cursor-changed", self._activate_selected_revision)
 
275
        tv.show()
 
276
        tv.connect("row-activated", self.line_diff)
 
277
 
 
278
        cell = Gtk.CellRendererText()
 
279
        cell.set_property("xalign", 1.0)
 
280
        cell.set_property("ypad", 0)
 
281
        cell.set_property("family", "Monospace")
 
282
        cell.set_property(
 
283
            "cell-background-rgba",
 
284
            tv.get_style_context().get_background_color(Gtk.StateType.NORMAL))
 
285
        col = Gtk.TreeViewColumn()
 
286
        col.set_resizable(False)
 
287
        col.pack_start(cell, True)
 
288
        col.add_attribute(cell, "text", LINE_NUM_COL)
 
289
        tv.append_column(col)
 
290
 
 
291
        style_context = self.get_style_context()
 
292
 
 
293
        cell = Gtk.CellRendererText()
 
294
        cell.set_property("ypad", 0)
 
295
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
 
296
        cell.set_property(
 
297
            "cell-background-rgba",
 
298
            style_context.get_background_color(Gtk.StateType.NORMAL))
 
299
        col = Gtk.TreeViewColumn("Committer")
 
300
        col.set_resizable(True)
 
301
        col.pack_start(cell, True)
 
302
        col.add_attribute(cell, "text", COMMITTER_COL)
 
303
        tv.append_column(col)
 
304
 
 
305
        cell = Gtk.CellRendererText()
 
306
        cell.set_property("xalign", 1.0)
 
307
        cell.set_property("ypad", 0)
 
308
        cell.set_property(
 
309
            "cell-background-rgba",
 
310
            style_context.get_background_color(Gtk.StateType.NORMAL))
 
311
        col = Gtk.TreeViewColumn("Revno")
 
312
        col.set_resizable(False)
 
313
        col.pack_start(cell, True)
 
314
        col.add_attribute(cell, "markup", REVNO_COL)
 
315
        tv.append_column(col)
 
316
 
 
317
        cell = Gtk.CellRendererText()
 
318
        cell.set_property("ypad", 0)
 
319
        cell.set_property("family", "Monospace")
 
320
        col = Gtk.TreeViewColumn()
 
321
        col.set_resizable(False)
 
322
        col.pack_start(cell, True)
 
323
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
 
324
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
 
325
        col.add_attribute(cell, "text", TEXT_LINE_COL)
 
326
        tv.append_column(col)
 
327
 
 
328
        # interactive substring search
 
329
        def search_equal_func(model, column, key, iter):
 
330
            return model.get_value(iter, TEXT_LINE_COL).lower().find(key.lower()) == -1
 
331
 
 
332
        tv.set_enable_search(True)
 
333
        tv.set_search_equal_func(search_equal_func, None)
 
334
 
 
335
        return tv
 
336
 
 
337
    def _create_log_view(self):
 
338
        lv = RevisionView(self._branch)
 
339
        lv.show()
 
340
        return lv
 
341
 
 
342
    def _create_back_button(self):
 
343
        button = Gtk.Button()
 
344
        button.set_use_stock(True)
 
345
        button.set_label("gtk-go-back")
 
346
        button.connect("clicked", lambda w: self.go_back())
 
347
        button.set_relief(Gtk.ReliefStyle.NONE)
 
348
        button.show()
 
349
        return button
 
350
 
 
351
    def _create_forward_button(self):
 
352
        button = Gtk.Button()
 
353
        button.set_use_stock(True)
 
354
        button.set_label("gtk-go-forward")
 
355
        button.connect("clicked", lambda w: self.go_forward())
 
356
        button.set_relief(Gtk.ReliefStyle.NONE)
 
357
        button.show()
 
358
        button.set_sensitive(False)
 
359
        return button
 
360
 
 
361
    def _create_find_button(self):
 
362
        button = Gtk.Button()
 
363
        button.set_use_stock(True)
 
364
        button.set_label("gtk-find")
 
365
        button.set_tooltip_text("Search for text (Ctrl+F)")
 
366
        button.connect("clicked", self._search_by_text)
 
367
        button.set_relief(Gtk.ReliefStyle.NONE)
 
368
        button.show()
 
369
        button.set_sensitive(True)
 
370
        return button
 
371
 
 
372
    def _create_goto_button(self):
 
373
        button = Gtk.Button()
 
374
        button.set_label("Goto Line")
 
375
        button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
 
376
        button.connect("clicked", self._search_by_line)
 
377
        button.set_relief(Gtk.ReliefStyle.NONE)
 
378
        button.show()
 
379
        button.set_sensitive(True)
 
380
        return button
 
381
 
 
382
    def go_back(self):
 
383
        last_tree = self.tree
 
384
        rev_id = self._selected_revision()
 
385
        parent_id = self.revisions[rev_id].parent_ids[0]
 
386
        target_tree = self.branch.repository.revision_tree(parent_id)
 
387
        if self._go(target_tree):
 
388
            self.history.append(last_tree)
 
389
            self.forward_button.set_sensitive(True)
 
390
        else:
 
391
            self._no_back.add(parent_id)
 
392
            self.back_button.set_sensitive(False)
 
393
 
 
394
    def go_forward(self):
 
395
        if len(self.history) == 0:
 
396
            return
 
397
        target_tree = self.history.pop()
 
398
        if len(self.history) == 0:
 
399
            self.forward_button.set_sensitive(False)
 
400
        self._go(target_tree)
 
401
 
 
402
    def _go(self, target_tree):
 
403
        rev_id = self._selected_revision()
 
404
        if self.file_id in target_tree:
 
405
            offset = self.get_scroll_offset(target_tree)
 
406
            path, col = self.annoview.get_cursor()
 
407
            (row,) = path.get_indices()
 
408
            self.annotate(target_tree, self.branch, self.file_id)
 
409
            new_row = row+offset
 
410
            if new_row < 0:
 
411
                new_row = 0
 
412
            new_path = Gtk.TreePath(path=new_row)
 
413
            self.annoview.set_cursor(new_path, None, False)
 
414
            return True
 
415
        else:
 
416
            return False
 
417
 
 
418
    def get_scroll_offset(self, tree):
 
419
        old = self.tree.get_file(self.file_id)
 
420
        new = tree.get_file(self.file_id)
 
421
        path, col = self.annoview.get_cursor()
 
422
        (row,) = path.get_indices()
 
423
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
 
424
                                                       new.readlines())
 
425
        for i, j, n in matcher.get_matching_blocks():
 
426
            if i + n >= row:
 
427
                return j - i
 
428
 
 
429
 
 
430
class FakeRevision(object):
 
431
    """ A fake revision.
 
432
 
 
433
    For when a revision is referenced but not present.
 
434
    """
 
435
 
 
436
    def __init__(self, revision_id, committer='?', nick=None):
 
437
        self.revision_id = revision_id
 
438
        self.parent_ids = []
 
439
        self.committer = committer
 
440
        self.message = "?"
 
441
        self.timestamp = 0.0
 
442
        self.timezone = 0
 
443
        self.properties = {}
 
444
 
 
445
    def get_apparent_authors(self):
 
446
        return [self.committer]
 
447
 
 
448
 
 
449
class RevisionCache(object):
 
450
    """A caching revision source"""
 
451
 
 
452
    def __init__(self, real_source, seed_cache=None):
 
453
        self.__real_source = real_source
 
454
        if seed_cache is None:
 
455
            self.__cache = {}
 
456
        else:
 
457
            self.__cache = dict(seed_cache)
 
458
 
 
459
    def get_revision(self, revision_id):
 
460
        if revision_id not in self.__cache:
 
461
            revision = self.__real_source.get_revision(revision_id)
 
462
            self.__cache[revision_id] = revision
 
463
        return self.__cache[revision_id]
 
464
 
 
465
 
 
466
class SearchBox(Gtk.HBox):
 
467
    """A button box for searching in text or lines of annotations"""
 
468
    def __init__(self):
 
469
        super(SearchBox, self).__init__(homogeneous=False, spacing=6)
 
470
 
 
471
        # Close button
 
472
        button = Gtk.Button()
 
473
        image = Gtk.Image()
 
474
        image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
 
475
        button.set_image(image)
 
476
        button.set_relief(Gtk.ReliefStyle.NONE)
 
477
        button.connect("clicked", lambda w: self.hide())
 
478
        self.pack_start(button, False, False, 0)
 
479
 
 
480
        # Search entry
 
481
        label = Gtk.Label()
 
482
        self._label = label
 
483
        self.pack_start(label, False, False, 0)
 
484
 
 
485
        entry = Gtk.Entry()
 
486
        self._entry = entry
 
487
        entry.connect("activate", lambda w, d: self._do_search(d),
 
488
                      'forward')
 
489
        self.pack_start(entry, False, False, 0)
 
490
 
 
491
        # Next/previous buttons
 
492
        button = Gtk.Button(_i18n('_Next'), use_underline=True)
 
493
        image = Gtk.Image()
 
494
        image.set_from_stock('gtk-go-forward', Gtk.IconSize.BUTTON)
 
495
        button.set_image(image)
 
496
        button.connect("clicked", lambda w, d: self._do_search(d),
 
497
                       'forward')
 
498
        self.pack_start(button, False, False, 0)
 
499
 
 
500
        button = Gtk.Button(_i18n('_Previous'), use_underline=True)
 
501
        image = Gtk.Image()
 
502
        image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
 
503
        button.set_image(image)
 
504
        button.connect("clicked", lambda w, d: self._do_search(d),
 
505
                       'backward')
 
506
        self.pack_start(button, False, False, 0)
 
507
 
 
508
        # Search options
 
509
        check = Gtk.CheckButton('Match case')
 
510
        self._match_case = check
 
511
        self.pack_start(check, False, False, 0)
 
512
 
 
513
        check = Gtk.CheckButton('Regexp')
 
514
        check.connect("toggled", lambda w: self._set_label())
 
515
        self._regexp = check
 
516
        self.pack_start(check, False, False, 0)
 
517
 
 
518
        self._view = None
 
519
        self._column = None
 
520
        # Note that we stay hidden (we do not call self.show_all())
 
521
 
 
522
 
 
523
    def show_for(self, kind):
 
524
        self._kind = kind
 
525
        self.show_all()
 
526
        self._set_label()
 
527
        # Hide unrelated buttons
 
528
        if kind == 'line':
 
529
            self._match_case.hide()
 
530
            self._regexp.hide()
 
531
        # Be ready
 
532
        self._entry.grab_focus()
 
533
 
 
534
    def _set_label(self):
 
535
        if self._kind == 'line':
 
536
            self._label.set_text('Find Line: ')
 
537
        else:
 
538
            if self._regexp.get_active():
 
539
                self._label.set_text('Find Regexp: ')
 
540
            else:
 
541
                self._label.set_text('Find Text: ')
 
542
 
 
543
    def set_target(self, view,column):
 
544
        self._view = view
 
545
        self._column = column
 
546
 
 
547
    def _match(self, model, iterator, column):
 
548
        matching_case = self._match_case.get_active()
 
549
        cell_value, = model.get(iterator, column)
 
550
        key = self._entry.get_text()
 
551
        if column == LINE_NUM_COL:
 
552
            # FIXME: For goto-line there are faster algorithms than searching 
 
553
            # every line til we find the right one! -- mbp 2011-01-27
 
554
            return key.strip() == str(cell_value)
 
555
        elif self._regexp.get_active():
 
556
            if matching_case:
 
557
                match = re.compile(key).search(cell_value, 1)
 
558
            else:
 
559
                match = re.compile(key, re.I).search(cell_value, 1)
 
560
        else:
 
561
            if not matching_case:
 
562
                cell_value = cell_value.lower()
 
563
                key = key.lower()
 
564
            match = cell_value.find(key) != -1
 
565
 
 
566
        return match
 
567
 
 
568
    def _iterate_rows_forward(self, model, start):
 
569
        model_size = len(model)
 
570
        current = start + 1
 
571
        while model_size != 0:
 
572
            if current >= model_size: current =  0
 
573
            yield model.get_iter_from_string('%d' % current)
 
574
            if current == start: raise StopIteration
 
575
            current += 1
 
576
 
 
577
    def _iterate_rows_backward(self, model, start):
 
578
        model_size = len(model)
 
579
        current = start - 1
 
580
        while model_size != 0:
 
581
            if current < 0: current = model_size - 1
 
582
            yield model.get_iter_from_string('%d' % current)
 
583
            if current == start: raise StopIteration
 
584
            current -= 1
 
585
 
 
586
    def _do_search(self, direction):
 
587
        if direction == 'forward':
 
588
            iterate = self._iterate_rows_forward
 
589
        else:
 
590
            iterate = self._iterate_rows_backward
 
591
 
 
592
        model, sel = self._view.get_selection().get_selected()
 
593
        if sel is None:
 
594
            start = 0
 
595
        else:
 
596
            path = model.get_string_from_iter(sel)
 
597
            start = int(path)
 
598
 
 
599
        for row in iterate(model, start):
 
600
            if self._match(model, row, self._column):
 
601
                path = model.get_path(row)
 
602
                self._view.set_cursor(path, None, False)
 
603
                self._view.scroll_to_cell(path, use_align=True)
 
604
                break