/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-05-19 16:56:46 UTC
  • mfrom: (0.1.25 gannotate)
  • Revision ID: jelmer@samba.org-20060519165646-0d867938fdbc9097
Merge in Dan Loda's gannotate plugin and put it in annotate/

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