/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: 2008-06-28 16:59:50 UTC
  • mto: This revision was merged to the branch mainline in revision 516.
  • Revision ID: jelmer@samba.org-20080628165950-18kv7bdykgf1f1jf
https://launchpad.net/bugs/223935
Fix import in olive.

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