/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
 
 
59
 
    def annotate(self, tree, branch, file_id):
60
 
        self.annotations = []
61
 
        self.branch = branch
62
 
        self.tree = tree
63
 
        self.file_id = file_id
64
 
        self.revision_id = getattr(tree, 'get_revision_id', 
65
 
                                   lambda: CURRENT_REVISION)()
66
61
        
67
62
        # [revision id, line number, committer, revno, highlight color, line]
68
63
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
77
72
            branch.lock_read()
78
73
            branch.repository.lock_read()
79
74
            for line_no, (revision, revno, line)\
80
 
                    in enumerate(self._annotate(tree, file_id)):
 
75
                    in enumerate(self._annotate(branch, file_id)):
81
76
                if revision.revision_id == last_seen and not self.all:
82
77
                    revno = committer = ""
83
78
                else:
94
89
                                       None,
95
90
                                       line.rstrip("\r\n")
96
91
                                      ])
97
 
                self.annotations.append(revision)
98
92
 
99
93
            if not self.plain:
100
 
                now = time.time()
101
 
                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()
102
98
        finally:
103
99
            branch.repository.unlock()
104
100
            branch.unlock()
113
109
            # bar?
114
110
            print("gannotate: Line number %d does't exist. Defaulting to "
115
111
                  "line 1." % lineno)
116
 
            return
117
112
        else:
118
113
            row = lineno - 1
119
114
 
120
115
        self.annoview.set_cursor(row)
121
 
        self.annoview.scroll_to_cell(row, use_align=True)
122
116
 
123
 
    def _dotted_revnos(self, repository, revision_id):
124
 
        """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())
125
124
        
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):
 
125
        revision_cache = RevisionCache(repository)
 
126
        for origin, text in weave.annotate_iter(rev_id):
151
127
            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 = "?"
 
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 = "?"
164
137
 
165
138
            yield revision, revno, text
166
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
 
167
159
    def _highlight_annotation(self, model, path, iter, now):
168
160
        revision_id, = model.get(iter, REVISION_ID_COL)
169
161
        revision = self.revisions[revision_id]
170
162
        model.set(iter, HIGHLIGHT_COLOR_COL,
171
163
                  self.annotate_colormap.get_color(revision, now))
172
164
 
173
 
    def _selected_revision(self):
 
165
    def _show_log(self, w):
174
166
        (path, col) = self.annoview.get_cursor()
175
 
        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
 
            return
 
167
        rev_id = self.annomodel[path][REVISION_ID_COL]
183
168
        self.logview.set_revision(self.revisions[rev_id])
184
169
 
185
170
    def _create(self):
186
171
        self.logview = self._create_log_view()
187
172
        self.annoview = self._create_annotate_view()
 
173
        self.span_selector = self._create_span_selector()
188
174
 
189
175
        vbox = gtk.VBox(False, 12)
190
176
        vbox.set_border_width(12)
194
180
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
195
181
        sw.set_shadow_type(gtk.SHADOW_IN)
196
182
        sw.add(self.annoview)
197
 
        self.annoview.gwindow = self
198
183
        sw.show()
199
184
        
200
185
        self.pane = pane = gtk.VPaned()
202
187
        pane.add2(self.logview)
203
188
        pane.show()
204
189
        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
 
 
 
190
        
217
191
        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)
 
192
        hbox.pack_start(self.span_selector, expand=False, fill=True)
 
193
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
220
194
        hbox.show()
221
195
        vbox.pack_start(hbox, expand=False, fill=True)
222
196
 
223
197
        self.add(vbox)
224
198
 
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
 
    def row_diff(self, tv, path, tvc):
234
 
        row = path[0]
235
 
        revision = self.annotations[row]
236
 
        repository = self.branch.repository
237
 
        if revision.revision_id == CURRENT_REVISION:
238
 
            tree1 = self.tree
239
 
            tree2 = self.tree.basis_tree()
240
 
        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
247
 
        window = DiffWindow()
248
 
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
249
 
        window.set_file(tree1.id2path(self.file_id))
250
 
        window.show()
251
 
 
252
 
 
253
199
    def _create_annotate_view(self):
254
200
        tv = gtk.TreeView()
255
201
        tv.set_rules_hint(False)
256
202
        tv.connect("cursor-changed", self._show_log)
257
203
        tv.show()
258
 
        tv.connect("row-activated", self.row_diff)
259
204
 
260
205
        cell = gtk.CellRendererText()
261
206
        cell.set_property("xalign", 1.0)
302
247
        col.add_attribute(cell, "text", TEXT_LINE_COL)
303
248
        tv.append_column(col)
304
249
 
305
 
        # FIXME: Now that C-f is now used for search by text we
306
 
        # may as well disable the auto search.
307
250
        tv.set_search_column(LINE_NUM_COL)
308
 
 
 
251
        
309
252
        return tv
310
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
 
311
261
    def _create_log_view(self):
312
262
        lv = LogView()
313
263
        lv.show()
 
264
 
314
265
        return lv
315
266
 
316
267
    def _create_button_box(self):
317
268
        box = gtk.HButtonBox()
318
269
        box.set_layout(gtk.BUTTONBOX_END)
319
270
        box.show()
320
 
 
 
271
        
321
272
        button = gtk.Button()
322
273
        button.set_use_stock(True)
323
274
        button.set_label("gtk-close")
324
275
        button.connect("clicked", lambda w: self.destroy())
325
276
        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
277
        
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
278
        box.pack_start(button, expand=False, fill=False)
 
279
 
342
280
        return box
343
281
 
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:
 
282
 
 
283
class NoneRevision:
367
284
    """ A fake revision.
368
285
 
369
286
    For when a revision is referenced but not present.
370
287
    """
371
288
 
372
 
    def __init__(self, revision_id, committer='?'):
 
289
    def __init__(self, revision_id):
373
290
        self.revision_id = revision_id
374
291
        self.parent_ids = []
375
 
        self.committer = committer
 
292
        self.committer = "?"
376
293
        self.message = "?"
377
294
        self.timestamp = 0.0
378
295
        self.timezone = 0
379
 
        self.properties = []
380
296
 
381
297
 
382
298
class RevisionCache(object):
383
299
    """A caching revision source"""
384
 
    def __init__(self, real_source, seed_cache=None):
 
300
    def __init__(self, real_source):
385
301
        self.__real_source = real_source
386
 
        if seed_cache is None:
387
 
            self.__cache = {}
388
 
        else:
389
 
            self.__cache = dict(seed_cache)
 
302
        self.__cache = {}
390
303
 
391
304
    def get_revision(self, revision_id):
392
305
        if revision_id not in self.__cache:
393
306
            revision = self.__real_source.get_revision(revision_id)
394
307
            self.__cache[revision_id] = revision
395
308
        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