/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: 2007-07-15 15:22:29 UTC
  • Revision ID: jelmer@samba.org-20070715152229-clmlen0vpd8d2pzx
Add docstrings, remove unused code.

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
 
 
26
from bzrlib import patiencediff, tsort
25
27
from bzrlib.errors import NoSuchRevision
 
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
26
29
 
27
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
28
 
from logview import LogView
29
 
from spanselector import SpanSelector
 
31
from bzrlib.plugins.gtk.logview import LogView
30
32
 
31
33
 
32
34
(
52
54
        self.annotate_colormap = AnnotateColorSaturation()
53
55
 
54
56
        self._create()
55
 
 
56
 
        if self.plain:
57
 
            self.span_selector.hide()
58
 
 
59
 
    def annotate(self, branch, file_id):
60
57
        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)()
61
68
        
62
69
        # [revision id, line number, committer, revno, highlight color, line]
63
70
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
72
79
            branch.lock_read()
73
80
            branch.repository.lock_read()
74
81
            for line_no, (revision, revno, line)\
75
 
                    in enumerate(self._annotate(branch, file_id)):
 
82
                    in enumerate(self._annotate(tree, file_id)):
76
83
                if revision.revision_id == last_seen and not self.all:
77
84
                    revno = committer = ""
78
85
                else:
89
96
                                       None,
90
97
                                       line.rstrip("\r\n")
91
98
                                      ])
 
99
                self.annotations.append(revision)
92
100
 
93
101
            if not self.plain:
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()
 
102
                now = time.time()
 
103
                self.annomodel.foreach(self._highlight_annotation, now)
98
104
        finally:
99
105
            branch.repository.unlock()
100
106
            branch.unlock()
109
115
            # bar?
110
116
            print("gannotate: Line number %d does't exist. Defaulting to "
111
117
                  "line 1." % lineno)
 
118
            return
112
119
        else:
113
120
            row = lineno - 1
114
121
 
115
122
        self.annoview.set_cursor(row)
 
123
        self.annoview.scroll_to_cell(row, use_align=True)
116
124
 
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())
 
125
    def _dotted_revnos(self, repository, revision_id):
 
126
        """Return a dict of revision_id -> dotted revno
124
127
        
125
 
        revision_cache = RevisionCache(repository)
126
 
        for origin, text in weave.annotate_iter(rev_id):
 
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):
127
154
            rev_id = origin
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 = "?"
 
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 = "?"
137
167
 
138
168
            yield revision, revno, text
139
169
 
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
 
 
159
170
    def _highlight_annotation(self, model, path, iter, now):
160
171
        revision_id, = model.get(iter, REVISION_ID_COL)
161
172
        revision = self.revisions[revision_id]
162
173
        model.set(iter, HIGHLIGHT_COLOR_COL,
163
174
                  self.annotate_colormap.get_color(revision, now))
164
175
 
165
 
    def _show_log(self, w):
 
176
    def _selected_revision(self):
166
177
        (path, col) = self.annoview.get_cursor()
167
 
        rev_id = self.annomodel[path][REVISION_ID_COL]
168
 
        self.logview.set_revision(self.revisions[rev_id])
 
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)
169
194
 
170
195
    def _create(self):
171
196
        self.logview = self._create_log_view()
172
197
        self.annoview = self._create_annotate_view()
173
 
        self.span_selector = self._create_span_selector()
174
198
 
175
 
        vbox = gtk.VBox(False, 12)
176
 
        vbox.set_border_width(12)
 
199
        vbox = gtk.VBox(False)
177
200
        vbox.show()
178
201
 
179
202
        sw = gtk.ScrolledWindow()
180
203
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
181
204
        sw.set_shadow_type(gtk.SHADOW_IN)
182
205
        sw.add(self.annoview)
 
206
        self.annoview.gwindow = self
183
207
        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)
184
220
        
185
221
        self.pane = pane = gtk.VPaned()
186
 
        pane.add1(sw)
 
222
        pane.add1(swbox)
187
223
        pane.add2(self.logview)
188
224
        pane.show()
189
225
        vbox.pack_start(pane, expand=True, fill=True)
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)
 
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)
196
237
 
197
238
        self.add(vbox)
198
239
 
 
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
 
199
268
    def _create_annotate_view(self):
200
269
        tv = gtk.TreeView()
201
270
        tv.set_rules_hint(False)
202
 
        tv.connect("cursor-changed", self._show_log)
 
271
        tv.connect("cursor-changed", self._activate_selected_revision)
203
272
        tv.show()
 
273
        tv.connect("row-activated", self.row_diff)
204
274
 
205
275
        cell = gtk.CellRendererText()
206
276
        cell.set_property("xalign", 1.0)
247
317
        col.add_attribute(cell, "text", TEXT_LINE_COL)
248
318
        tv.append_column(col)
249
319
 
 
320
        # FIXME: Now that C-f is now used for search by text we
 
321
        # may as well disable the auto search.
250
322
        tv.set_search_column(LINE_NUM_COL)
251
 
        
 
323
 
252
324
        return tv
253
325
 
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
 
 
261
326
    def _create_log_view(self):
262
327
        lv = LogView()
263
328
        lv.show()
264
 
 
265
329
        return lv
266
330
 
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:
 
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:
284
397
    """ A fake revision.
285
398
 
286
399
    For when a revision is referenced but not present.
287
400
    """
288
401
 
289
 
    def __init__(self, revision_id):
 
402
    def __init__(self, revision_id, committer='?', nick=None):
290
403
        self.revision_id = revision_id
291
404
        self.parent_ids = []
292
 
        self.committer = "?"
 
405
        self.committer = committer
293
406
        self.message = "?"
294
407
        self.timestamp = 0.0
295
408
        self.timezone = 0
 
409
        self.properties = {}
296
410
 
297
411
 
298
412
class RevisionCache(object):
299
413
    """A caching revision source"""
300
 
    def __init__(self, real_source):
 
414
    def __init__(self, real_source, seed_cache=None):
301
415
        self.__real_source = real_source
302
 
        self.__cache = {}
 
416
        if seed_cache is None:
 
417
            self.__cache = {}
 
418
        else:
 
419
            self.__cache = dict(seed_cache)
303
420
 
304
421
    def get_revision(self, revision_id):
305
422
        if revision_id not in self.__cache:
306
423
            revision = self.__real_source.get_revision(revision_id)
307
424
            self.__cache[revision_id] = revision
308
425
        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