/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: Curtis Hovey
  • Date: 2011-09-03 01:25:04 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110903012504-0jr4diz9033g5df2
Menu fixes.

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.revisionview import RevisionView
 
31
from bzrlib.plugins.gtk.window import Window
 
32
 
 
33
 
 
34
(
 
35
    REVISION_ID_COL,
 
36
    LINE_NUM_COL,
 
37
    COMMITTER_COL,
 
38
    REVNO_COL,
 
39
    HIGHLIGHT_COLOR_COL,
 
40
    TEXT_LINE_COL
 
41
) = range(6)
 
42
 
 
43
 
 
44
class GAnnotateWindow(Window):
 
45
    """Annotate window."""
 
46
 
 
47
    def __init__(self, all=False, plain=False, parent=None, branch=None):
 
48
        self.all = all
 
49
        self.plain = plain
 
50
        self._branch = branch
 
51
 
 
52
        Window.__init__(self, parent)
 
53
 
 
54
        self.set_icon(
 
55
            self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
 
56
        self.annotate_colormap = AnnotateColorSaturation()
 
57
 
 
58
        self._create()
 
59
        self.revisions = {}
 
60
        self.history = []
 
61
        self._no_back = set()
 
62
 
 
63
    def annotate(self, tree, branch, file_id):
 
64
        self.annotations = []
 
65
        self.branch = branch
 
66
        self.tree = tree
 
67
        self.file_id = file_id
 
68
        self.revisionview.set_file_id(file_id)
 
69
        self.revision_id = getattr(tree, 'get_revision_id', 
 
70
                                   lambda: CURRENT_REVISION)()
 
71
 
 
72
        # [revision id, line number, author, revno, highlight color, line]
 
73
        self.annomodel = Gtk.ListStore(GObject.TYPE_STRING,
 
74
                                       GObject.TYPE_INT,
 
75
                                       GObject.TYPE_STRING,
 
76
                                       GObject.TYPE_STRING,
 
77
                                       GObject.TYPE_STRING,
 
78
                                       GObject.TYPE_STRING)
 
79
 
 
80
        last_seen = None
 
81
        try:
 
82
            branch.lock_read()
 
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)
 
88
            for line_no, (revision, revno, line)\
 
89
                in enumerate(self._annotate(tree, file_id)):
 
90
                if revision.revision_id == last_seen and not self.all:
 
91
                    revno = author = ""
 
92
                else:
 
93
                    last_seen = revision.revision_id
 
94
                    author = ", ".join(revision.get_apparent_authors())
 
95
 
 
96
                if revision.revision_id not in self.revisions:
 
97
                    self.revisions[revision.revision_id] = revision
 
98
 
 
99
                self.annomodel.append([revision.revision_id,
 
100
                                       line_no + 1,
 
101
                                       author,
 
102
                                       revno,
 
103
                                       None,
 
104
                                       line.rstrip("\r\n")
 
105
                                       ])
 
106
                self.annotations.append(revision)
 
107
 
 
108
            if not self.plain:
 
109
                now = time.time()
 
110
                self.annomodel.foreach(self._highlight_annotation, now)
 
111
        finally:
 
112
            branch.repository.unlock()
 
113
            branch.unlock()
 
114
 
 
115
        self.annoview.set_model(self.annomodel)
 
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)
 
120
 
 
121
    def jump_to_line(self, lineno):
 
122
        if lineno > len(self.annomodel) or lineno < 1:
 
123
            row = 0
 
124
            # FIXME:should really deal with this in the gui. Perhaps a status
 
125
            # bar?
 
126
            print("gannotate: Line number %d does't exist. Defaulting to "
 
127
                  "line 1." % lineno)
 
128
            return
 
129
        else:
 
130
            row = lineno - 1
 
131
 
 
132
        tree_path = Gtk.TreePath(path=row)
 
133
        self.annoview.set_cursor(tree_path, None, False)
 
134
        self.annoview.scroll_to_cell(tree_path, use_align=True)
 
135
 
 
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.VPaned()
 
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("cell-background-gdk",
 
283
                          tv.get_style().bg[Gtk.StateType.NORMAL])
 
284
        col = Gtk.TreeViewColumn()
 
285
        col.set_resizable(False)
 
286
        col.pack_start(cell, True)
 
287
        col.add_attribute(cell, "text", LINE_NUM_COL)
 
288
        tv.append_column(col)
 
289
 
 
290
        cell = Gtk.CellRendererText()
 
291
        cell.set_property("ypad", 0)
 
292
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
 
293
        cell.set_property("cell-background-gdk",
 
294
                          self.get_style().bg[Gtk.StateType.NORMAL])
 
295
        col = Gtk.TreeViewColumn("Committer")
 
296
        col.set_resizable(True)
 
297
        col.pack_start(cell, True)
 
298
        col.add_attribute(cell, "text", COMMITTER_COL)
 
299
        tv.append_column(col)
 
300
 
 
301
        cell = Gtk.CellRendererText()
 
302
        cell.set_property("xalign", 1.0)
 
303
        cell.set_property("ypad", 0)
 
304
        cell.set_property("cell-background-gdk",
 
305
                          self.get_style().bg[Gtk.StateType.NORMAL])
 
306
        col = Gtk.TreeViewColumn("Revno")
 
307
        col.set_resizable(False)
 
308
        col.pack_start(cell, True)
 
309
        col.add_attribute(cell, "markup", REVNO_COL)
 
310
        tv.append_column(col)
 
311
 
 
312
        cell = Gtk.CellRendererText()
 
313
        cell.set_property("ypad", 0)
 
314
        cell.set_property("family", "Monospace")
 
315
        col = Gtk.TreeViewColumn()
 
316
        col.set_resizable(False)
 
317
        col.pack_start(cell, True)
 
318
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
 
319
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
 
320
        col.add_attribute(cell, "text", TEXT_LINE_COL)
 
321
        tv.append_column(col)
 
322
 
 
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)
 
329
 
 
330
        return tv
 
331
 
 
332
    def _create_log_view(self):
 
333
        lv = RevisionView(self._branch)
 
334
        lv.show()
 
335
        return lv
 
336
 
 
337
    def _create_back_button(self):
 
338
        button = Gtk.Button()
 
339
        button.set_use_stock(True)
 
340
        button.set_label("gtk-go-back")
 
341
        button.connect("clicked", lambda w: self.go_back())
 
342
        button.set_relief(Gtk.ReliefStyle.NONE)
 
343
        button.show()
 
344
        return button
 
345
 
 
346
    def _create_forward_button(self):
 
347
        button = Gtk.Button()
 
348
        button.set_use_stock(True)
 
349
        button.set_label("gtk-go-forward")
 
350
        button.connect("clicked", lambda w: self.go_forward())
 
351
        button.set_relief(Gtk.ReliefStyle.NONE)
 
352
        button.show()
 
353
        button.set_sensitive(False)
 
354
        return button
 
355
 
 
356
    def _create_find_button(self):
 
357
        button = Gtk.Button()
 
358
        button.set_use_stock(True)
 
359
        button.set_label("gtk-find")
 
360
        button.set_tooltip_text("Search for text (Ctrl+F)")
 
361
        button.connect("clicked", self._search_by_text)
 
362
        button.set_relief(Gtk.ReliefStyle.NONE)
 
363
        button.show()
 
364
        button.set_sensitive(True)
 
365
        return button
 
366
 
 
367
    def _create_goto_button(self):
 
368
        button = Gtk.Button()
 
369
        button.set_label("Goto Line")
 
370
        button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
 
371
        button.connect("clicked", self._search_by_line)
 
372
        button.set_relief(Gtk.ReliefStyle.NONE)
 
373
        button.show()
 
374
        button.set_sensitive(True)
 
375
        return button
 
376
 
 
377
    def go_back(self):
 
378
        last_tree = self.tree
 
379
        rev_id = self._selected_revision()
 
380
        parent_id = self.revisions[rev_id].parent_ids[0]
 
381
        target_tree = self.branch.repository.revision_tree(parent_id)
 
382
        if self._go(target_tree):
 
383
            self.history.append(last_tree)
 
384
            self.forward_button.set_sensitive(True)
 
385
        else:
 
386
            self._no_back.add(parent_id)
 
387
            self.back_button.set_sensitive(False)
 
388
 
 
389
    def go_forward(self):
 
390
        if len(self.history) == 0:
 
391
            return
 
392
        target_tree = self.history.pop()
 
393
        if len(self.history) == 0:
 
394
            self.forward_button.set_sensitive(False)
 
395
        self._go(target_tree)
 
396
 
 
397
    def _go(self, target_tree):
 
398
        rev_id = self._selected_revision()
 
399
        if self.file_id in target_tree:
 
400
            offset = self.get_scroll_offset(target_tree)
 
401
            path, col = self.annoview.get_cursor()
 
402
            (row,) = path.get_indices()
 
403
            self.annotate(target_tree, self.branch, self.file_id)
 
404
            new_row = row+offset
 
405
            if new_row < 0:
 
406
                new_row = 0
 
407
            new_path = Gtk.TreePath(path=new_row)
 
408
            self.annoview.set_cursor(new_path, None, False)
 
409
            return True
 
410
        else:
 
411
            return False
 
412
 
 
413
    def get_scroll_offset(self, tree):
 
414
        old = self.tree.get_file(self.file_id)
 
415
        new = tree.get_file(self.file_id)
 
416
        path, col = self.annoview.get_cursor()
 
417
        (row,) = path.get_indices()
 
418
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
 
419
                                                       new.readlines())
 
420
        for i, j, n in matcher.get_matching_blocks():
 
421
            if i + n >= row:
 
422
                return j - i
 
423
 
 
424
 
 
425
class FakeRevision(object):
 
426
    """ A fake revision.
 
427
 
 
428
    For when a revision is referenced but not present.
 
429
    """
 
430
 
 
431
    def __init__(self, revision_id, committer='?', nick=None):
 
432
        self.revision_id = revision_id
 
433
        self.parent_ids = []
 
434
        self.committer = committer
 
435
        self.message = "?"
 
436
        self.timestamp = 0.0
 
437
        self.timezone = 0
 
438
        self.properties = {}
 
439
 
 
440
    def get_apparent_authors(self):
 
441
        return [self.committer]
 
442
 
 
443
 
 
444
class RevisionCache(object):
 
445
    """A caching revision source"""
 
446
 
 
447
    def __init__(self, real_source, seed_cache=None):
 
448
        self.__real_source = real_source
 
449
        if seed_cache is None:
 
450
            self.__cache = {}
 
451
        else:
 
452
            self.__cache = dict(seed_cache)
 
453
 
 
454
    def get_revision(self, revision_id):
 
455
        if revision_id not in self.__cache:
 
456
            revision = self.__real_source.get_revision(revision_id)
 
457
            self.__cache[revision_id] = revision
 
458
        return self.__cache[revision_id]
 
459
 
 
460
class SearchBox(Gtk.HBox):
 
461
    """A button box for searching in text or lines of annotations"""
 
462
    def __init__(self):
 
463
        Gtk.HBox.__init__(self, homogeneous=False, spacing=6)
 
464
 
 
465
        # Close button
 
466
        button = Gtk.Button()
 
467
        image = Gtk.Image()
 
468
        image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
 
469
        button.set_image(image)
 
470
        button.set_relief(Gtk.ReliefStyle.NONE)
 
471
        button.connect("clicked", lambda w: self.hide())
 
472
        self.pack_start(button, False, False, 0)
 
473
 
 
474
        # Search entry
 
475
        label = Gtk.Label()
 
476
        self._label = label
 
477
        self.pack_start(label, False, False, 0)
 
478
 
 
479
        entry = Gtk.Entry()
 
480
        self._entry = entry
 
481
        entry.connect("activate", lambda w, d: self._do_search(d),
 
482
                      'forward')
 
483
        self.pack_start(entry, False, False, 0)
 
484
 
 
485
        # Next/previous buttons
 
486
        button = Gtk.Button('_Next')
 
487
        image = Gtk.Image()
 
488
        image.set_from_stock('gtk-go-forward', Gtk.IconSize.BUTTON)
 
489
        button.set_image(image)
 
490
        button.connect("clicked", lambda w, d: self._do_search(d),
 
491
                       'forward')
 
492
        self.pack_start(button, False, False, 0)
 
493
 
 
494
        button = Gtk.Button('_Previous')
 
495
        image = Gtk.Image()
 
496
        image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
 
497
        button.set_image(image)
 
498
        button.connect("clicked", lambda w, d: self._do_search(d),
 
499
                       'backward')
 
500
        self.pack_start(button, False, False, 0)
 
501
 
 
502
        # Search options
 
503
        check = Gtk.CheckButton('Match case')
 
504
        self._match_case = check
 
505
        self.pack_start(check, False, False, 0)
 
506
 
 
507
        check = Gtk.CheckButton('Regexp')
 
508
        check.connect("toggled", lambda w: self._set_label())
 
509
        self._regexp = check
 
510
        self.pack_start(check, False, False, 0)
 
511
 
 
512
        self._view = None
 
513
        self._column = None
 
514
        # Note that we stay hidden (we do not call self.show_all())
 
515
 
 
516
 
 
517
    def show_for(self, kind):
 
518
        self._kind = kind
 
519
        self.show_all()
 
520
        self._set_label()
 
521
        # Hide unrelated buttons
 
522
        if kind == 'line':
 
523
            self._match_case.hide()
 
524
            self._regexp.hide()
 
525
        # Be ready
 
526
        self._entry.grab_focus()
 
527
 
 
528
    def _set_label(self):
 
529
        if self._kind == 'line':
 
530
            self._label.set_text('Find Line: ')
 
531
        else:
 
532
            if self._regexp.get_active():
 
533
                self._label.set_text('Find Regexp: ')
 
534
            else:
 
535
                self._label.set_text('Find Text: ')
 
536
 
 
537
    def set_target(self, view,column):
 
538
        self._view = view
 
539
        self._column = column
 
540
 
 
541
    def _match(self, model, iterator, column):
 
542
        matching_case = self._match_case.get_active()
 
543
        cell_value, = model.get(iterator, column)
 
544
        key = self._entry.get_text()
 
545
        if column == LINE_NUM_COL:
 
546
            # FIXME: For goto-line there are faster algorithms than searching 
 
547
            # every line til we find the right one! -- mbp 2011-01-27
 
548
            return key.strip() == str(cell_value)
 
549
        elif self._regexp.get_active():
 
550
            if matching_case:
 
551
                match = re.compile(key).search(cell_value, 1)
 
552
            else:
 
553
                match = re.compile(key, re.I).search(cell_value, 1)
 
554
        else:
 
555
            if not matching_case:
 
556
                cell_value = cell_value.lower()
 
557
                key = key.lower()
 
558
            match = cell_value.find(key) != -1
 
559
 
 
560
        return match
 
561
 
 
562
    def _iterate_rows_forward(self, model, start):
 
563
        model_size = len(model)
 
564
        current = start + 1
 
565
        while model_size != 0:
 
566
            if current >= model_size: current =  0
 
567
            yield model.get_iter_from_string('%d' % current)
 
568
            if current == start: raise StopIteration
 
569
            current += 1
 
570
 
 
571
    def _iterate_rows_backward(self, model, start):
 
572
        model_size = len(model)
 
573
        current = start - 1
 
574
        while model_size != 0:
 
575
            if current < 0: current = model_size - 1
 
576
            yield model.get_iter_from_string('%d' % current)
 
577
            if current == start: raise StopIteration
 
578
            current -= 1
 
579
 
 
580
    def _do_search(self, direction):
 
581
        if direction == 'forward':
 
582
            iterate = self._iterate_rows_forward
 
583
        else:
 
584
            iterate = self._iterate_rows_backward
 
585
 
 
586
        model, sel = self._view.get_selection().get_selected()
 
587
        if sel is None:
 
588
            start = 0
 
589
        else:
 
590
            path = model.get_string_from_iter(sel)
 
591
            start = int(path)
 
592
 
 
593
        for row in iterate(model, start):
 
594
            if self._match(model, row, self._column):
 
595
                path = model.get_path(row)
 
596
                self._view.set_cursor(path, None, False)
 
597
                self._view.scroll_to_cell(path, use_align=True)
 
598
                break