/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: 2008-06-29 19:18:34 UTC
  • mto: This revision was merged to the branch mainline in revision 515.
  • Revision ID: jelmer@samba.org-20080629191834-ha2ecpv5szt96nge
Make sure signed testament matches repository data.

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
21
21
import gobject
22
22
import gtk
23
23
import pango
 
24
import re
24
25
 
25
 
from bzrlib import tsort
 
26
from bzrlib import patiencediff, tsort
26
27
from bzrlib.errors import NoSuchRevision
27
 
from bzrlib.revision import NULL_REVISION
 
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
28
29
 
29
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
30
 
from logview import LogView
31
 
from spanselector import SpanSelector
 
31
from bzrlib.plugins.gtk.revisionview import RevisionView
 
32
from bzrlib.plugins.gtk.window import Window
32
33
 
33
34
 
34
35
(
41
42
) = range(6)
42
43
 
43
44
 
44
 
class GAnnotateWindow(gtk.Window):
 
45
class GAnnotateWindow(Window):
45
46
    """Annotate window."""
46
47
 
47
 
    def __init__(self, all=False, plain=False):
 
48
    def __init__(self, all=False, plain=False, parent=None, branch=None):
48
49
        self.all = all
49
50
        self.plain = plain
 
51
        self._branch = branch
50
52
        
51
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
 
53
        Window.__init__(self, parent)
52
54
        
53
55
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
54
56
        self.annotate_colormap = AnnotateColorSaturation()
55
57
 
56
58
        self._create()
57
 
 
58
 
        if self.plain:
59
 
            self.span_selector.hide()
60
 
 
61
 
    def annotate(self, branch, file_id, revision_id=None):
62
59
        self.revisions = {}
 
60
        self.history = []
 
61
        self._no_back = set()
 
62
 
 
63
    def annotate(self, tree, branch, file_id):
63
64
        self.annotations = []
64
65
        self.branch = branch
 
66
        self.tree = tree
65
67
        self.file_id = file_id
66
 
        self.revision_id = revision_id
 
68
        self.revisionview.set_file_id(file_id)
 
69
        self.revision_id = getattr(tree, 'get_revision_id', 
 
70
                                   lambda: CURRENT_REVISION)()
67
71
        
68
 
        # [revision id, line number, committer, revno, highlight color, line]
 
72
        # [revision id, line number, author, revno, highlight color, line]
69
73
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
70
74
                                       gobject.TYPE_STRING,
71
75
                                       gobject.TYPE_STRING,
77
81
        try:
78
82
            branch.lock_read()
79
83
            branch.repository.lock_read()
 
84
            self.dotted = {}
 
85
            revno_map = self.branch.get_revision_id_to_revno_map()
 
86
            for revision_id, revno in revno_map.iteritems():
 
87
                self.dotted[revision_id] = '.'.join(str(num) for num in revno)
80
88
            for line_no, (revision, revno, line)\
81
 
                    in enumerate(self._annotate(branch, file_id, revision_id)):
 
89
                    in enumerate(self._annotate(tree, file_id)):
82
90
                if revision.revision_id == last_seen and not self.all:
83
 
                    revno = committer = ""
 
91
                    revno = author = ""
84
92
                else:
85
93
                    last_seen = revision.revision_id
86
 
                    committer = revision.committer
 
94
                    author = revision.get_apparent_author()
87
95
 
88
96
                if revision.revision_id not in self.revisions:
89
97
                    self.revisions[revision.revision_id] = revision
90
98
 
91
99
                self.annomodel.append([revision.revision_id,
92
100
                                       line_no + 1,
93
 
                                       committer,
 
101
                                       author,
94
102
                                       revno,
95
103
                                       None,
96
104
                                       line.rstrip("\r\n")
98
106
                self.annotations.append(revision)
99
107
 
100
108
            if not self.plain:
101
 
                self._set_oldest_newest()
102
 
                # Recall that calling activate_default will emit "span-changed",
103
 
                # so self._span_changed_cb will take care of initial highlighting
104
 
                self.span_selector.activate_default()
 
109
                now = time.time()
 
110
                self.annomodel.foreach(self._highlight_annotation, now)
105
111
        finally:
106
112
            branch.repository.unlock()
107
113
            branch.unlock()
108
114
 
109
115
        self.annoview.set_model(self.annomodel)
110
116
        self.annoview.grab_focus()
 
117
        my_revno = self.dotted.get(self.revision_id, 'current')
 
118
        title = '%s (%s) - gannotate' % (self.tree.id2path(file_id), my_revno)
 
119
        self.set_title(title)
111
120
 
112
121
    def jump_to_line(self, lineno):
113
122
        if lineno > len(self.annomodel) or lineno < 1:
123
132
        self.annoview.set_cursor(row)
124
133
        self.annoview.scroll_to_cell(row, use_align=True)
125
134
 
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
138
135
 
139
 
    def _annotate(self, branch, file_id, revision_id):
140
 
        repository = branch.repository
141
 
        if revision_id is None:
142
 
            revision_id = branch.last_revision()
143
 
        dotted = self._dotted_revnos(repository, revision_id)
144
 
        rev_tree = repository.revision_tree(revision_id)
145
 
        revision_id = rev_tree.inventory[file_id].revision
146
 
        weave = repository.weave_store.get_weave(file_id,
147
 
                                                 branch.get_transaction())
148
 
        
149
 
        revision_cache = RevisionCache(repository)
150
 
        for origin, text in weave.annotate_iter(revision_id):
 
136
    def _annotate(self, tree, file_id):
 
137
        current_revision = FakeRevision(CURRENT_REVISION)
 
138
        current_revision.committer = self.branch.get_config().username()
 
139
        current_revision.timestamp = time.time()
 
140
        current_revision.message = '[Not yet committed]'
 
141
        current_revision.parent_ids = tree.get_parent_ids()
 
142
        current_revision.properties['branch-nick'] = self.branch.nick
 
143
        current_revno = '%d?' % (self.branch.revno() + 1)
 
144
        repository = self.branch.repository
 
145
        if self.revision_id == CURRENT_REVISION:
 
146
            revision_id = self.branch.last_revision()
 
147
        else:
 
148
            revision_id = self.revision_id
 
149
        revision_cache = RevisionCache(repository, self.revisions)
 
150
        for origin, text in tree.annotate_iter(file_id):
151
151
            rev_id = origin
152
 
            try:
153
 
                revision = revision_cache.get_revision(rev_id)
154
 
                revno = dotted.get(rev_id, 'merge')
155
 
                if len(revno) > 15:
156
 
                    revno = 'merge'
157
 
            except NoSuchRevision:
158
 
                revision = NoneRevision(rev_id)
159
 
                revno = "?"
 
152
            if rev_id == CURRENT_REVISION:
 
153
                revision = current_revision
 
154
                revno = current_revno
 
155
            else:
 
156
                try:
 
157
                    revision = revision_cache.get_revision(rev_id)
 
158
                    revno = self.dotted.get(rev_id, 'merge')
 
159
                    if len(revno) > 15:
 
160
                        revno = 'merge'
 
161
                except NoSuchRevision:
 
162
                    revision = FakeRevision(rev_id)
 
163
                    revno = "?"
160
164
 
161
165
            yield revision, revno, text
162
166
 
163
 
    def _set_oldest_newest(self):
164
 
        rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
165
 
        if len(rev_dates) == 0:
166
 
            return
167
 
        oldest = min(rev_dates)
168
 
        newest = max(rev_dates)
169
 
 
170
 
        span = self._span_from_seconds(time.time() - oldest)
171
 
        self.span_selector.set_to_oldest_span(span)
172
 
        
173
 
        span = self._span_from_seconds(newest - oldest)
174
 
        self.span_selector.set_newest_to_oldest_span(span)
175
 
 
176
 
    def _span_from_seconds(self, seconds):
177
 
        return (seconds / (24 * 60 * 60))
178
 
    
179
 
    def _span_changed_cb(self, w, span):
180
 
        self.annotate_colormap.set_span(span)
181
 
        now = time.time()
182
 
        self.annomodel.foreach(self._highlight_annotation, now)
183
 
 
184
167
    def _highlight_annotation(self, model, path, iter, now):
185
168
        revision_id, = model.get(iter, REVISION_ID_COL)
186
169
        revision = self.revisions[revision_id]
187
170
        model.set(iter, HIGHLIGHT_COLOR_COL,
188
171
                  self.annotate_colormap.get_color(revision, now))
189
172
 
190
 
    def _show_log(self, w):
 
173
    def _selected_revision(self):
191
174
        (path, col) = self.annoview.get_cursor()
192
175
        if path is None:
 
176
            return None
 
177
        return self.annomodel[path][REVISION_ID_COL]
 
178
 
 
179
    def _activate_selected_revision(self, w):
 
180
        rev_id = self._selected_revision()
 
181
        if not rev_id or rev_id == NULL_REVISION:
193
182
            return
194
 
        rev_id = self.annomodel[path][REVISION_ID_COL]
195
 
        self.logview.set_revision(self.revisions[rev_id])
 
183
        selected = self.revisions[rev_id]
 
184
        self.revisionview.set_revision(selected)
 
185
        if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
 
186
            self._no_back):
 
187
            enable_back = True
 
188
        else:
 
189
            enable_back = False
 
190
        self.back_button.set_sensitive(enable_back)
196
191
 
197
192
    def _create(self):
198
 
        self.logview = self._create_log_view()
 
193
        self.revisionview = self._create_log_view()
199
194
        self.annoview = self._create_annotate_view()
200
 
        self.span_selector = self._create_span_selector()
201
195
 
202
 
        vbox = gtk.VBox(False, 12)
203
 
        vbox.set_border_width(12)
 
196
        vbox = gtk.VBox(False)
204
197
        vbox.show()
205
198
 
206
199
        sw = gtk.ScrolledWindow()
209
202
        sw.add(self.annoview)
210
203
        self.annoview.gwindow = self
211
204
        sw.show()
 
205
 
 
206
        swbox = gtk.VBox()
 
207
        swbox.pack_start(sw)
 
208
        swbox.show()
 
209
 
 
210
        hbox = gtk.HBox(False, 6)
 
211
        self.back_button = self._create_back_button()
 
212
        hbox.pack_start(self.back_button, expand=False, fill=True)
 
213
        self.forward_button = self._create_forward_button()
 
214
        hbox.pack_start(self.forward_button, expand=False, fill=True)
 
215
        hbox.show()
 
216
        vbox.pack_start(hbox, expand=False, fill=True)
212
217
        
213
218
        self.pane = pane = gtk.VPaned()
214
 
        pane.add1(sw)
215
 
        pane.add2(self.logview)
 
219
        pane.add1(swbox)
 
220
        pane.add2(self.revisionview)
216
221
        pane.show()
217
222
        vbox.pack_start(pane, expand=True, fill=True)
218
 
        
219
 
        hbox = gtk.HBox(True, 6)
220
 
        hbox.pack_start(self.span_selector, expand=False, fill=True)
221
 
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
222
 
        hbox.show()
223
 
        vbox.pack_start(hbox, expand=False, fill=True)
 
223
 
 
224
        self._search = SearchBox()
 
225
        swbox.pack_start(self._search, expand=False, fill=True)
 
226
        accels = gtk.AccelGroup()
 
227
        accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
 
228
                             gtk.ACCEL_LOCKED,
 
229
                             self._search_by_text)
 
230
        accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
 
231
                             gtk.ACCEL_LOCKED,
 
232
                             self._search_by_line)
 
233
        self.add_accel_group(accels)
224
234
 
225
235
        self.add(vbox)
226
236
 
227
 
    def row_diff(self, tv, path, tvc):
 
237
    def _search_by_text(self, accel_group, window, key, modifiers):
 
238
        self._search.show_for('text')
 
239
        self._search.set_target(self.annoview, TEXT_LINE_COL)
 
240
 
 
241
    def _search_by_line(self, accel_group, window, key, modifiers):
 
242
        self._search.show_for('line')
 
243
        self._search.set_target(self.annoview, LINE_NUM_COL)
 
244
 
 
245
    def line_diff(self, tv, path, tvc):
228
246
        row = path[0]
229
247
        revision = self.annotations[row]
230
248
        repository = self.branch.repository
231
 
        tree1 = repository.revision_tree(revision.revision_id)
232
 
        if len(revision.parent_ids) > 0:
233
 
            tree2 = repository.revision_tree(revision.parent_ids[0])
 
249
        if revision.revision_id == CURRENT_REVISION:
 
250
            tree1 = self.tree
 
251
            tree2 = self.tree.basis_tree()
234
252
        else:
235
 
            tree2 = repository.revision_tree(NULL_REVISION)
236
 
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
 
253
            tree1 = repository.revision_tree(revision.revision_id)
 
254
            if len(revision.parent_ids) > 0:
 
255
                tree2 = repository.revision_tree(revision.parent_ids[0])
 
256
            else:
 
257
                tree2 = repository.revision_tree(NULL_REVISION)
 
258
        from bzrlib.plugins.gtk.diff import DiffWindow
237
259
        window = DiffWindow()
238
 
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
 
260
        window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
239
261
        window.set_file(tree1.id2path(self.file_id))
240
262
        window.show()
241
263
 
243
265
    def _create_annotate_view(self):
244
266
        tv = gtk.TreeView()
245
267
        tv.set_rules_hint(False)
246
 
        tv.connect("cursor-changed", self._show_log)
 
268
        tv.connect("cursor-changed", self._activate_selected_revision)
247
269
        tv.show()
248
 
        tv.connect("row-activated", self.row_diff)
 
270
        tv.connect("row-activated", self.line_diff)
249
271
 
250
272
        cell = gtk.CellRendererText()
251
273
        cell.set_property("xalign", 1.0)
292
314
        col.add_attribute(cell, "text", TEXT_LINE_COL)
293
315
        tv.append_column(col)
294
316
 
 
317
        # FIXME: Now that C-f is now used for search by text we
 
318
        # may as well disable the auto search.
295
319
        tv.set_search_column(LINE_NUM_COL)
296
 
        
 
320
 
297
321
        return tv
298
322
 
299
 
    def _create_span_selector(self):
300
 
        ss = SpanSelector()
301
 
        ss.connect("span-changed", self._span_changed_cb)
302
 
        ss.show()
303
 
 
304
 
        return ss
305
 
 
306
323
    def _create_log_view(self):
307
 
        lv = LogView()
 
324
        lv = RevisionView(self._branch)
308
325
        lv.show()
309
 
 
310
326
        return lv
311
327
 
312
 
    def _create_button_box(self):
313
 
        box = gtk.HButtonBox()
314
 
        box.set_layout(gtk.BUTTONBOX_END)
315
 
        box.show()
316
 
        
317
 
        button = gtk.Button()
318
 
        button.set_use_stock(True)
319
 
        button.set_label("gtk-close")
320
 
        button.connect("clicked", lambda w: self.destroy())
321
 
        button.show()
322
 
        
323
 
        box.pack_start(button, expand=False, fill=False)
324
 
 
325
 
        return box
326
 
 
327
 
 
328
 
class NoneRevision:
 
328
    def _create_back_button(self):
 
329
        button = gtk.Button()
 
330
        button.set_use_stock(True)
 
331
        button.set_label("gtk-go-back")
 
332
        button.connect("clicked", lambda w: self.go_back())
 
333
        button.set_relief(gtk.RELIEF_NONE)
 
334
        button.show()
 
335
        return button
 
336
 
 
337
    def _create_forward_button(self):
 
338
        button = gtk.Button()
 
339
        button.set_use_stock(True)
 
340
        button.set_label("gtk-go-forward")
 
341
        button.connect("clicked", lambda w: self.go_forward())
 
342
        button.set_relief(gtk.RELIEF_NONE)
 
343
        button.show()
 
344
        button.set_sensitive(False)
 
345
        return button
 
346
 
 
347
    def go_back(self):
 
348
        last_tree = self.tree
 
349
        rev_id = self._selected_revision()
 
350
        parent_id = self.revisions[rev_id].parent_ids[0]
 
351
        target_tree = self.branch.repository.revision_tree(parent_id)
 
352
        if self._go(target_tree):
 
353
            self.history.append(last_tree)
 
354
            self.forward_button.set_sensitive(True)
 
355
        else:
 
356
            self._no_back.add(parent_id)
 
357
            self.back_button.set_sensitive(False)
 
358
 
 
359
    def go_forward(self):
 
360
        if len(self.history) == 0:
 
361
            return
 
362
        target_tree = self.history.pop()
 
363
        if len(self.history) == 0:
 
364
            self.forward_button.set_sensitive(False)
 
365
        self._go(target_tree)
 
366
 
 
367
    def _go(self, target_tree):
 
368
        rev_id = self._selected_revision()
 
369
        if self.file_id in target_tree:
 
370
            offset = self.get_scroll_offset(target_tree)
 
371
            (row,), col = self.annoview.get_cursor()
 
372
            self.annotate(target_tree, self.branch, self.file_id)
 
373
            new_row = row+offset
 
374
            if new_row < 0:
 
375
                new_row = 0
 
376
            self.annoview.set_cursor(new_row)
 
377
            return True
 
378
        else:
 
379
            return False
 
380
 
 
381
    def get_scroll_offset(self, tree):
 
382
        old = self.tree.get_file(self.file_id)
 
383
        new = tree.get_file(self.file_id)
 
384
        (row,), col = self.annoview.get_cursor()
 
385
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
 
386
                                                       new.readlines())
 
387
        for i, j, n in matcher.get_matching_blocks():
 
388
            if i + n >= row:
 
389
                return j - i
 
390
 
 
391
 
 
392
class FakeRevision:
329
393
    """ A fake revision.
330
394
 
331
395
    For when a revision is referenced but not present.
332
396
    """
333
397
 
334
 
    def __init__(self, revision_id):
 
398
    def __init__(self, revision_id, committer='?', nick=None):
335
399
        self.revision_id = revision_id
336
400
        self.parent_ids = []
337
 
        self.committer = "?"
 
401
        self.committer = committer
338
402
        self.message = "?"
339
403
        self.timestamp = 0.0
340
404
        self.timezone = 0
 
405
        self.properties = {}
 
406
 
 
407
    def get_apparent_author(self):
 
408
        return self.committer
341
409
 
342
410
 
343
411
class RevisionCache(object):
344
412
    """A caching revision source"""
345
 
    def __init__(self, real_source):
 
413
    def __init__(self, real_source, seed_cache=None):
346
414
        self.__real_source = real_source
347
 
        self.__cache = {}
 
415
        if seed_cache is None:
 
416
            self.__cache = {}
 
417
        else:
 
418
            self.__cache = dict(seed_cache)
348
419
 
349
420
    def get_revision(self, revision_id):
350
421
        if revision_id not in self.__cache:
351
422
            revision = self.__real_source.get_revision(revision_id)
352
423
            self.__cache[revision_id] = revision
353
424
        return self.__cache[revision_id]
 
425
 
 
426
class SearchBox(gtk.HBox):
 
427
    """A button box for searching in text or lines of annotations"""
 
428
    def __init__(self):
 
429
        gtk.HBox.__init__(self, False, 6)
 
430
 
 
431
        # Close button
 
432
        button = gtk.Button()
 
433
        image = gtk.Image()
 
434
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
 
435
        button.set_image(image)
 
436
        button.set_relief(gtk.RELIEF_NONE)
 
437
        button.connect("clicked", lambda w: self.hide_all())
 
438
        self.pack_start(button, expand=False, fill=False)
 
439
 
 
440
        # Search entry
 
441
        label = gtk.Label()
 
442
        self._label = label
 
443
        self.pack_start(label, expand=False, fill=False)
 
444
 
 
445
        entry = gtk.Entry()
 
446
        self._entry = entry
 
447
        entry.connect("activate", lambda w, d: self._do_search(d),
 
448
                      'forward')
 
449
        self.pack_start(entry, expand=False, fill=False)
 
450
 
 
451
        # Next/previous buttons
 
452
        button = gtk.Button('_Next')
 
453
        image = gtk.Image()
 
454
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
 
455
        button.set_image(image)
 
456
        button.connect("clicked", lambda w, d: self._do_search(d),
 
457
                       'forward')
 
458
        self.pack_start(button, expand=False, fill=False)
 
459
 
 
460
        button = gtk.Button('_Previous')
 
461
        image = gtk.Image()
 
462
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
 
463
        button.set_image(image)
 
464
        button.connect("clicked", lambda w, d: self._do_search(d),
 
465
                       'backward')
 
466
        self.pack_start(button, expand=False, fill=False)
 
467
 
 
468
        # Search options
 
469
        check = gtk.CheckButton('Match case')
 
470
        self._match_case = check
 
471
        self.pack_start(check, expand=False, fill=False)
 
472
 
 
473
        check = gtk.CheckButton('Regexp')
 
474
        check.connect("toggled", lambda w: self._set_label())
 
475
        self._regexp = check
 
476
        self.pack_start(check, expand=False, fill=False)
 
477
 
 
478
        self._view = None
 
479
        self._column = None
 
480
        # Note that we stay hidden (we do not call self.show_all())
 
481
 
 
482
 
 
483
    def show_for(self, kind):
 
484
        self._kind = kind
 
485
        self.show_all()
 
486
        self._set_label()
 
487
        # Hide unrelated buttons
 
488
        if kind == 'line':
 
489
            self._match_case.hide()
 
490
            self._regexp.hide()
 
491
        # Be ready
 
492
        self._entry.grab_focus()
 
493
 
 
494
    def _set_label(self):
 
495
        if self._kind == 'line':
 
496
            self._label.set_text('Find Line: ')
 
497
        else:
 
498
            if self._regexp.get_active():
 
499
                self._label.set_text('Find Regexp: ')
 
500
            else:
 
501
                self._label.set_text('Find Text: ')
 
502
 
 
503
    def set_target(self, view,column):
 
504
        self._view = view
 
505
        self._column = column
 
506
 
 
507
    def _match(self, model, iterator, column):
 
508
        matching_case = self._match_case.get_active()
 
509
        string, = model.get(iterator, column)
 
510
        key = self._entry.get_text()
 
511
        if self._regexp.get_active():
 
512
            if matching_case:
 
513
                match = re.compile(key).search(string, 1)
 
514
            else:
 
515
                match = re.compile(key, re.I).search(string, 1)
 
516
        else:
 
517
            if not matching_case:
 
518
                string = string.lower()
 
519
                key = key.lower()
 
520
            match = string.find(key) != -1
 
521
 
 
522
        return match
 
523
 
 
524
    def _iterate_rows_forward(self, model, start):
 
525
        model_size = len(model)
 
526
        current = start + 1
 
527
        while model_size != 0:
 
528
            if current >= model_size: current =  0
 
529
            yield model.get_iter_from_string('%d' % current)
 
530
            if current == start: raise StopIteration
 
531
            current += 1
 
532
 
 
533
    def _iterate_rows_backward(self, model, start):
 
534
        model_size = len(model)
 
535
        current = start - 1
 
536
        while model_size != 0:
 
537
            if current < 0: current = model_size - 1
 
538
            yield model.get_iter_from_string('%d' % current)
 
539
            if current == start: raise StopIteration
 
540
            current -= 1
 
541
 
 
542
    def _do_search(self, direction):
 
543
        if direction == 'forward':
 
544
            iterate = self._iterate_rows_forward
 
545
        else:
 
546
            iterate = self._iterate_rows_backward
 
547
 
 
548
        model, sel = self._view.get_selection().get_selected()
 
549
        if sel is None:
 
550
            start = 0
 
551
        else:
 
552
            path = model.get_string_from_iter(sel)
 
553
            start = int(path)
 
554
 
 
555
        for row in iterate(model, start):
 
556
            if self._match(model, row, self._column):
 
557
                path = model.get_path(row)
 
558
                self._view.set_cursor(path)
 
559
                self._view.scroll_to_cell(path, use_align=True)
 
560
                break