/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

Merge from trunk.

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