/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: Aaron Bentley
  • Date: 2007-01-17 06:42:55 UTC
  • mto: This revision was merged to the branch mainline in revision 129.
  • Revision ID: aaron.bentley@utoronto.ca-20070117064255-x4gznz5e0lyjq3gk
Remove usused span selector

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
25
24
 
26
 
from bzrlib import patiencediff, tsort
 
25
from bzrlib import tsort
27
26
from bzrlib.errors import NoSuchRevision
28
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
28
 
30
29
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
 
from bzrlib.plugins.gtk.logview import LogView
 
30
from logview import LogView
 
31
from spanselector import SpanSelector
32
32
 
33
33
 
34
34
(
54
54
        self.annotate_colormap = AnnotateColorSaturation()
55
55
 
56
56
        self._create()
 
57
 
 
58
    def annotate(self, tree, branch, file_id):
57
59
        self.revisions = {}
58
 
 
59
 
    def annotate(self, tree, branch, file_id):
60
60
        self.annotations = []
61
61
        self.branch = branch
62
62
        self.tree = tree
97
97
                self.annotations.append(revision)
98
98
 
99
99
            if not self.plain:
 
100
                self._set_oldest_newest()
100
101
                now = time.time()
101
102
                self.annomodel.foreach(self._highlight_annotation, now)
102
103
        finally:
138
139
        current_revision.committer = self.branch.get_config().username()
139
140
        current_revision.timestamp = time.time()
140
141
        current_revision.message = '[Not yet committed]'
141
 
        current_revision.parent_ids = tree.get_parent_ids()
142
142
        current_revno = '%d?' % (self.branch.revno() + 1)
143
143
        repository = self.branch.repository
144
144
        if self.revision_id == CURRENT_REVISION:
146
146
        else:
147
147
            revision_id = self.revision_id
148
148
        dotted = self._dotted_revnos(repository, revision_id)
149
 
        revision_cache = RevisionCache(repository, self.revisions)
 
149
        revision_cache = RevisionCache(repository)
150
150
        for origin, text in tree.annotate_iter(file_id):
151
151
            rev_id = origin
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 = dotted.get(rev_id, 'merge')
159
 
                    if len(revno) > 15:
160
 
                        revno = 'merge'
161
 
                except NoSuchRevision:
 
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
                committer = "?"
 
159
                if rev_id == CURRENT_REVISION:
 
160
                    revision = current_revision
 
161
                    revno = current_revno
 
162
                else:
162
163
                    revision = FakeRevision(rev_id)
163
164
                    revno = "?"
164
165
 
165
166
            yield revision, revno, text
166
167
 
 
168
    def _set_oldest_newest(self):
 
169
        rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
 
170
        if len(rev_dates) == 0:
 
171
            return
 
172
        oldest = min(rev_dates)
 
173
        newest = max(rev_dates)
 
174
 
167
175
    def _highlight_annotation(self, model, path, iter, now):
168
176
        revision_id, = model.get(iter, REVISION_ID_COL)
169
177
        revision = self.revisions[revision_id]
170
178
        model.set(iter, HIGHLIGHT_COLOR_COL,
171
179
                  self.annotate_colormap.get_color(revision, now))
172
180
 
173
 
    def _selected_revision(self):
 
181
    def _show_log(self, w):
174
182
        (path, col) = self.annoview.get_cursor()
175
183
        if path is None:
176
 
            return None
177
 
        return self.annomodel[path][REVISION_ID_COL]
178
 
 
179
 
    def _show_log(self, w):
180
 
        rev_id = self._selected_revision()
181
 
        if rev_id is None:
182
184
            return
 
185
        rev_id = self.annomodel[path][REVISION_ID_COL]
183
186
        self.logview.set_revision(self.revisions[rev_id])
184
187
 
185
188
    def _create(self):
202
205
        pane.add2(self.logview)
203
206
        pane.show()
204
207
        vbox.pack_start(pane, expand=True, fill=True)
205
 
 
206
 
        self._search = SearchBox()
207
 
        vbox.pack_start(self._search, expand=False, fill=True)
208
 
        accels = gtk.AccelGroup()
209
 
        accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
210
 
                             gtk.ACCEL_LOCKED,
211
 
                             self._search_by_text)
212
 
        accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
213
 
                             gtk.ACCEL_LOCKED,
214
 
                             self._search_by_line)
215
 
        self.add_accel_group(accels)
216
 
 
 
208
        
217
209
        hbox = gtk.HBox(True, 6)
218
 
        hbox.pack_start(self._create_prev_button(), expand=False, fill=True)
219
 
        hbox.pack_end(self._create_button_box(), expand=False, fill=True)
 
210
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
220
211
        hbox.show()
221
212
        vbox.pack_start(hbox, expand=False, fill=True)
222
213
 
223
214
        self.add(vbox)
224
215
 
225
 
    def _search_by_text(self, accel_group, window, key, modifiers):
226
 
        self._search.show_for('text')
227
 
        self._search.set_target(self.annoview, TEXT_LINE_COL)
228
 
 
229
 
    def _search_by_line(self, accel_group, window, key, modifiers):
230
 
        self._search.show_for('line')
231
 
        self._search.set_target(self.annoview, LINE_NUM_COL)
232
 
 
233
216
    def row_diff(self, tv, path, tvc):
234
217
        row = path[0]
235
218
        revision = self.annotations[row]
243
226
                tree2 = repository.revision_tree(revision.parent_ids[0])
244
227
            else:
245
228
                tree2 = repository.revision_tree(NULL_REVISION)
246
 
        from bzrlib.plugins.gtk.diff import DiffWindow
 
229
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
247
230
        window = DiffWindow()
248
231
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
249
232
        window.set_file(tree1.id2path(self.file_id))
302
285
        col.add_attribute(cell, "text", TEXT_LINE_COL)
303
286
        tv.append_column(col)
304
287
 
305
 
        # FIXME: Now that C-f is now used for search by text we
306
 
        # may as well disable the auto search.
307
288
        tv.set_search_column(LINE_NUM_COL)
308
 
 
 
289
        
309
290
        return tv
310
291
 
311
292
    def _create_log_view(self):
312
293
        lv = LogView()
313
294
        lv.show()
 
295
 
314
296
        return lv
315
297
 
316
298
    def _create_button_box(self):
317
299
        box = gtk.HButtonBox()
318
300
        box.set_layout(gtk.BUTTONBOX_END)
319
301
        box.show()
320
 
 
 
302
        
321
303
        button = gtk.Button()
322
304
        button.set_use_stock(True)
323
305
        button.set_label("gtk-close")
324
306
        button.connect("clicked", lambda w: self.destroy())
325
307
        button.show()
326
 
 
327
 
        box.pack_start(button, expand=False, fill=False)
328
 
 
329
 
        return box
330
 
 
331
 
    def _create_prev_button(self):
332
 
        box = gtk.HButtonBox()
333
 
        box.set_layout(gtk.BUTTONBOX_START)
334
 
        box.show()
335
308
        
336
 
        button = gtk.Button()
337
 
        button.set_use_stock(True)
338
 
        button.set_label("gtk-go-back")
339
 
        button.connect("clicked", lambda w: self.go_back())
340
 
        button.show()
341
309
        box.pack_start(button, expand=False, fill=False)
 
310
 
342
311
        return box
343
312
 
344
 
    def go_back(self):
345
 
        rev_id = self._selected_revision()
346
 
        parent_id = self.revisions[rev_id].parent_ids[0]
347
 
        tree = self.branch.repository.revision_tree(parent_id)
348
 
        if self.file_id in tree:
349
 
            offset = self.get_scroll_offset(tree)
350
 
            (row,), col = self.annoview.get_cursor()
351
 
            self.annotate(tree, self.branch, self.file_id)
352
 
            self.annoview.set_cursor(row+offset)
353
 
 
354
 
    def get_scroll_offset(self, tree):
355
 
        old = self.tree.get_file(self.file_id)
356
 
        new = tree.get_file(self.file_id)
357
 
        (row,), col = self.annoview.get_cursor()
358
 
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
359
 
                                                       new.readlines())
360
 
        for i, j, n in matcher.get_matching_blocks():
361
 
            if i + n >= row:
362
 
                return j - i
363
 
 
364
 
 
365
313
 
366
314
class FakeRevision:
367
315
    """ A fake revision.
376
324
        self.message = "?"
377
325
        self.timestamp = 0.0
378
326
        self.timezone = 0
379
 
        self.properties = []
380
327
 
381
328
 
382
329
class RevisionCache(object):
383
330
    """A caching revision source"""
384
 
    def __init__(self, real_source, seed_cache=None):
 
331
    def __init__(self, real_source):
385
332
        self.__real_source = real_source
386
 
        if seed_cache is None:
387
 
            self.__cache = {}
388
 
        else:
389
 
            self.__cache = dict(seed_cache)
 
333
        self.__cache = {}
390
334
 
391
335
    def get_revision(self, revision_id):
392
336
        if revision_id not in self.__cache:
393
337
            revision = self.__real_source.get_revision(revision_id)
394
338
            self.__cache[revision_id] = revision
395
339
        return self.__cache[revision_id]
396
 
 
397
 
class SearchBox(gtk.HBox):
398
 
    """A button box for searching in text or lines of annotations"""
399
 
    def __init__(self):
400
 
        gtk.HBox.__init__(self, False, 6)
401
 
 
402
 
        # Close button
403
 
        button = gtk.Button()
404
 
        image = gtk.Image()
405
 
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
406
 
        button.set_image(image)
407
 
        button.set_relief(gtk.RELIEF_NONE)
408
 
        button.connect("clicked", lambda w: self.hide_all())
409
 
        self.pack_start(button, expand=False, fill=False)
410
 
 
411
 
        # Search entry
412
 
        label = gtk.Label()
413
 
        self._label = label
414
 
        self.pack_start(label, expand=False, fill=False)
415
 
 
416
 
        entry = gtk.Entry()
417
 
        self._entry = entry
418
 
        entry.connect("activate", lambda w, d: self._do_search(d),
419
 
                      'forward')
420
 
        self.pack_start(entry, expand=False, fill=False)
421
 
 
422
 
        # Next/previous buttons
423
 
        button = gtk.Button('_Next')
424
 
        image = gtk.Image()
425
 
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
426
 
        button.set_image(image)
427
 
        button.connect("clicked", lambda w, d: self._do_search(d),
428
 
                       'forward')
429
 
        self.pack_start(button, expand=False, fill=False)
430
 
 
431
 
        button = gtk.Button('_Previous')
432
 
        image = gtk.Image()
433
 
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
434
 
        button.set_image(image)
435
 
        button.connect("clicked", lambda w, d: self._do_search(d),
436
 
                       'backward')
437
 
        self.pack_start(button, expand=False, fill=False)
438
 
 
439
 
        # Search options
440
 
        check = gtk.CheckButton('Match case')
441
 
        self._match_case = check
442
 
        self.pack_start(check, expand=False, fill=False)
443
 
 
444
 
        check = gtk.CheckButton('Regexp')
445
 
        check.connect("toggled", lambda w: self._set_label())
446
 
        self._regexp = check
447
 
        self.pack_start(check, expand=False, fill=False)
448
 
 
449
 
        self._view = None
450
 
        self._column = None
451
 
        # Note that we stay hidden (we do not call self.show_all())
452
 
 
453
 
 
454
 
    def show_for(self, kind):
455
 
        self._kind = kind
456
 
        self.show_all()
457
 
        self._set_label()
458
 
        # Hide unrelated buttons
459
 
        if kind == 'line':
460
 
            self._match_case.hide()
461
 
            self._regexp.hide()
462
 
        # Be ready
463
 
        self._entry.grab_focus()
464
 
 
465
 
    def _set_label(self):
466
 
        if self._kind == 'line':
467
 
            self._label.set_text('Find Line: ')
468
 
        else:
469
 
            if self._regexp.get_active():
470
 
                self._label.set_text('Find Regexp: ')
471
 
            else:
472
 
                self._label.set_text('Find Text: ')
473
 
 
474
 
    def set_target(self, view,column):
475
 
        self._view = view
476
 
        self._column = column
477
 
 
478
 
    def _match(self, model, iterator, column):
479
 
        matching_case = self._match_case.get_active()
480
 
        string, = model.get(iterator, column)
481
 
        key = self._entry.get_text()
482
 
        if self._regexp.get_active():
483
 
            if matching_case:
484
 
                match = re.compile(key).search(string, 1)
485
 
            else:
486
 
                match = re.compile(key, re.I).search(string, 1)
487
 
        else:
488
 
            if not matching_case:
489
 
                string = string.lower()
490
 
                key = key.lower()
491
 
            match = string.find(key) != -1
492
 
 
493
 
        return match
494
 
 
495
 
    def _iterate_rows_forward(self, model, start):
496
 
        model_size = len(model)
497
 
        current = start + 1
498
 
        while model_size != 0:
499
 
            if current >= model_size: current =  0
500
 
            yield model.get_iter_from_string('%d' % current)
501
 
            if current == start: raise StopIteration
502
 
            current += 1
503
 
 
504
 
    def _iterate_rows_backward(self, model, start):
505
 
        model_size = len(model)
506
 
        current = start - 1
507
 
        while model_size != 0:
508
 
            if current < 0: current = model_size - 1
509
 
            yield model.get_iter_from_string('%d' % current)
510
 
            if current == start: raise StopIteration
511
 
            current -= 1
512
 
 
513
 
    def _do_search(self, direction):
514
 
        if direction == 'forward':
515
 
            iterate = self._iterate_rows_forward
516
 
        else:
517
 
            iterate = self._iterate_rows_backward
518
 
 
519
 
        model, sel = self._view.get_selection().get_selected()
520
 
        if sel is None:
521
 
            start = 0
522
 
        else:
523
 
            path = model.get_string_from_iter(sel)
524
 
            start = int(path)
525
 
 
526
 
        for row in iterate(model, start):
527
 
            if self._match(model, row, self._column):
528
 
                path = model.get_path(row)
529
 
                self._view.set_cursor(path)
530
 
                self._view.scroll_to_cell(path, use_align=True)
531
 
                break