/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: 2006-09-30 10:21:43 UTC
  • Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.

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
27
25
from bzrlib.errors import NoSuchRevision
28
 
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
26
from bzrlib.revision import NULL_REVISION
29
27
 
30
28
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
 
from bzrlib.plugins.gtk.logview import LogView
 
29
from logview import LogView
 
30
from spanselector import SpanSelector
32
31
 
33
32
 
34
33
(
54
53
        self.annotate_colormap = AnnotateColorSaturation()
55
54
 
56
55
        self._create()
 
56
 
 
57
        if self.plain:
 
58
            self.span_selector.hide()
 
59
 
 
60
    def annotate(self, branch, file_id):
57
61
        self.revisions = {}
58
 
 
59
 
    def annotate(self, tree, branch, file_id):
60
62
        self.annotations = []
61
63
        self.branch = branch
62
 
        self.tree = tree
63
64
        self.file_id = file_id
64
 
        self.revision_id = getattr(tree, 'get_revision_id', 
65
 
                                   lambda: CURRENT_REVISION)()
66
65
        
67
66
        # [revision id, line number, committer, revno, highlight color, line]
68
67
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
77
76
            branch.lock_read()
78
77
            branch.repository.lock_read()
79
78
            for line_no, (revision, revno, line)\
80
 
                    in enumerate(self._annotate(tree, file_id)):
 
79
                    in enumerate(self._annotate(branch, file_id)):
81
80
                if revision.revision_id == last_seen and not self.all:
82
81
                    revno = committer = ""
83
82
                else:
97
96
                self.annotations.append(revision)
98
97
 
99
98
            if not self.plain:
100
 
                now = time.time()
101
 
                self.annomodel.foreach(self._highlight_annotation, now)
 
99
                self._set_oldest_newest()
 
100
                # Recall that calling activate_default will emit "span-changed",
 
101
                # so self._span_changed_cb will take care of initial highlighting
 
102
                self.span_selector.activate_default()
102
103
        finally:
103
104
            branch.repository.unlock()
104
105
            branch.unlock()
120
121
        self.annoview.set_cursor(row)
121
122
        self.annoview.scroll_to_cell(row, use_align=True)
122
123
 
123
 
    def _dotted_revnos(self, repository, revision_id):
124
 
        """Return a dict of revision_id -> dotted revno
 
124
    def _annotate(self, branch, file_id):
 
125
        rev_hist = branch.revision_history()
 
126
        repository = branch.repository
 
127
        rev_tree = repository.revision_tree(branch.last_revision())
 
128
        rev_id = rev_tree.inventory[file_id].revision
 
129
        weave = repository.weave_store.get_weave(file_id,
 
130
                                                 branch.get_transaction())
125
131
        
126
 
        :param repository: The repository to get the graph from
127
 
        :param revision_id: The last revision for which this info is needed
128
 
        """
129
 
        graph = repository.get_revision_graph(revision_id)
130
 
        dotted = {}
131
 
        for n, revision_id, d, revno, e in tsort.merge_sort(graph, 
132
 
            revision_id, generate_revno=True):
133
 
            dotted[revision_id] = '.'.join(str(num) for num in revno)
134
 
        return dotted
135
 
 
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_revno = '%d?' % (self.branch.revno() + 1)
143
 
        repository = self.branch.repository
144
 
        if self.revision_id == CURRENT_REVISION:
145
 
            revision_id = self.branch.last_revision()
146
 
        else:
147
 
            revision_id = self.revision_id
148
 
        dotted = self._dotted_revnos(repository, revision_id)
149
 
        revision_cache = RevisionCache(repository, self.revisions)
150
 
        for origin, text in tree.annotate_iter(file_id):
 
132
        revision_cache = RevisionCache(repository)
 
133
        for origin, text in weave.annotate_iter(rev_id):
151
134
            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:
162
 
                    revision = FakeRevision(rev_id)
163
 
                    revno = "?"
 
135
            try:
 
136
                revision = revision_cache.get_revision(rev_id)
 
137
                if rev_id in rev_hist:
 
138
                    revno = branch.revision_id_to_revno(rev_id)
 
139
                else:
 
140
                    revno = "merge"
 
141
            except NoSuchRevision:
 
142
                revision = NoneRevision(rev_id)
 
143
                revno = "?"
164
144
 
165
145
            yield revision, revno, text
166
146
 
 
147
    def _set_oldest_newest(self):
 
148
        rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
 
149
        if len(rev_dates) == 0:
 
150
            return
 
151
        oldest = min(rev_dates)
 
152
        newest = max(rev_dates)
 
153
 
 
154
        span = self._span_from_seconds(time.time() - oldest)
 
155
        self.span_selector.set_to_oldest_span(span)
 
156
        
 
157
        span = self._span_from_seconds(newest - oldest)
 
158
        self.span_selector.set_newest_to_oldest_span(span)
 
159
 
 
160
    def _span_from_seconds(self, seconds):
 
161
        return (seconds / (24 * 60 * 60))
 
162
    
 
163
    def _span_changed_cb(self, w, span):
 
164
        self.annotate_colormap.set_span(span)
 
165
        now = time.time()
 
166
        self.annomodel.foreach(self._highlight_annotation, now)
 
167
 
167
168
    def _highlight_annotation(self, model, path, iter, now):
168
169
        revision_id, = model.get(iter, REVISION_ID_COL)
169
170
        revision = self.revisions[revision_id]
170
171
        model.set(iter, HIGHLIGHT_COLOR_COL,
171
172
                  self.annotate_colormap.get_color(revision, now))
172
173
 
173
 
    def _selected_revision(self):
 
174
    def _show_log(self, w):
174
175
        (path, col) = self.annoview.get_cursor()
175
176
        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
177
            return
 
178
        rev_id = self.annomodel[path][REVISION_ID_COL]
183
179
        self.logview.set_revision(self.revisions[rev_id])
184
180
 
185
181
    def _create(self):
186
182
        self.logview = self._create_log_view()
187
183
        self.annoview = self._create_annotate_view()
 
184
        self.span_selector = self._create_span_selector()
188
185
 
189
186
        vbox = gtk.VBox(False, 12)
190
187
        vbox.set_border_width(12)
202
199
        pane.add2(self.logview)
203
200
        pane.show()
204
201
        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
 
 
 
202
        
217
203
        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)
 
204
        hbox.pack_start(self.span_selector, expand=False, fill=True)
 
205
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
220
206
        hbox.show()
221
207
        vbox.pack_start(hbox, expand=False, fill=True)
222
208
 
223
209
        self.add(vbox)
224
210
 
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
211
    def row_diff(self, tv, path, tvc):
234
212
        row = path[0]
235
213
        revision = self.annotations[row]
236
214
        repository = self.branch.repository
237
 
        if revision.revision_id == CURRENT_REVISION:
238
 
            tree1 = self.tree
239
 
            tree2 = self.tree.basis_tree()
 
215
        tree1 = repository.revision_tree(revision.revision_id)
 
216
        if len(revision.parent_ids) > 0:
 
217
            tree2 = repository.revision_tree(revision.parent_ids[0])
240
218
        else:
241
 
            tree1 = repository.revision_tree(revision.revision_id)
242
 
            if len(revision.parent_ids) > 0:
243
 
                tree2 = repository.revision_tree(revision.parent_ids[0])
244
 
            else:
245
 
                tree2 = repository.revision_tree(NULL_REVISION)
246
 
        from bzrlib.plugins.gtk.diff import DiffWindow
 
219
            tree2 = repository.revision_tree(NULL_REVISION)
 
220
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
247
221
        window = DiffWindow()
248
222
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
249
223
        window.set_file(tree1.id2path(self.file_id))
302
276
        col.add_attribute(cell, "text", TEXT_LINE_COL)
303
277
        tv.append_column(col)
304
278
 
305
 
        # FIXME: Now that C-f is now used for search by text we
306
 
        # may as well disable the auto search.
307
279
        tv.set_search_column(LINE_NUM_COL)
308
 
 
 
280
        
309
281
        return tv
310
282
 
 
283
    def _create_span_selector(self):
 
284
        ss = SpanSelector()
 
285
        ss.connect("span-changed", self._span_changed_cb)
 
286
        ss.show()
 
287
 
 
288
        return ss
 
289
 
311
290
    def _create_log_view(self):
312
291
        lv = LogView()
313
292
        lv.show()
 
293
 
314
294
        return lv
315
295
 
316
296
    def _create_button_box(self):
317
297
        box = gtk.HButtonBox()
318
298
        box.set_layout(gtk.BUTTONBOX_END)
319
299
        box.show()
320
 
 
 
300
        
321
301
        button = gtk.Button()
322
302
        button.set_use_stock(True)
323
303
        button.set_label("gtk-close")
324
304
        button.connect("clicked", lambda w: self.destroy())
325
305
        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
306
        
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
307
        box.pack_start(button, expand=False, fill=False)
 
308
 
342
309
        return box
343
310
 
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
 
 
366
 
class FakeRevision:
 
311
 
 
312
class NoneRevision:
367
313
    """ A fake revision.
368
314
 
369
315
    For when a revision is referenced but not present.
370
316
    """
371
317
 
372
 
    def __init__(self, revision_id, committer='?'):
 
318
    def __init__(self, revision_id):
373
319
        self.revision_id = revision_id
374
320
        self.parent_ids = []
375
 
        self.committer = committer
 
321
        self.committer = "?"
376
322
        self.message = "?"
377
323
        self.timestamp = 0.0
378
324
        self.timezone = 0
379
 
        self.properties = []
380
325
 
381
326
 
382
327
class RevisionCache(object):
383
328
    """A caching revision source"""
384
 
    def __init__(self, real_source, seed_cache=None):
 
329
    def __init__(self, real_source):
385
330
        self.__real_source = real_source
386
 
        if seed_cache is None:
387
 
            self.__cache = {}
388
 
        else:
389
 
            self.__cache = dict(seed_cache)
 
331
        self.__cache = {}
390
332
 
391
333
    def get_revision(self, revision_id):
392
334
        if revision_id not in self.__cache:
393
335
            revision = self.__real_source.get_revision(revision_id)
394
336
            self.__cache[revision_id] = revision
395
337
        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