/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-02-03 14:19:44 UTC
  • Revision ID: jelmer@samba.org-20070203141944-oa6iqhetsy0slqo0
Fix references to dialog.

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
26
 
from bzrlib.revision import NULL_REVISION
 
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
27
29
 
28
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
29
 
from logview import LogView
30
 
from spanselector import SpanSelector
 
31
from bzrlib.plugins.gtk.logview import LogView
31
32
 
32
33
 
33
34
(
53
54
        self.annotate_colormap = AnnotateColorSaturation()
54
55
 
55
56
        self._create()
56
 
 
57
 
        if self.plain:
58
 
            self.span_selector.hide()
59
 
 
60
 
    def annotate(self, branch, file_id):
61
57
        self.revisions = {}
 
58
 
 
59
    def annotate(self, tree, branch, file_id):
62
60
        self.annotations = []
63
61
        self.branch = branch
 
62
        self.tree = tree
64
63
        self.file_id = file_id
 
64
        self.revision_id = getattr(tree, 'get_revision_id', 
 
65
                                   lambda: CURRENT_REVISION)()
65
66
        
66
67
        # [revision id, line number, committer, revno, highlight color, line]
67
68
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
76
77
            branch.lock_read()
77
78
            branch.repository.lock_read()
78
79
            for line_no, (revision, revno, line)\
79
 
                    in enumerate(self._annotate(branch, file_id)):
 
80
                    in enumerate(self._annotate(tree, file_id)):
80
81
                if revision.revision_id == last_seen and not self.all:
81
82
                    revno = committer = ""
82
83
                else:
96
97
                self.annotations.append(revision)
97
98
 
98
99
            if not self.plain:
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()
 
100
                now = time.time()
 
101
                self.annomodel.foreach(self._highlight_annotation, now)
103
102
        finally:
104
103
            branch.repository.unlock()
105
104
            branch.unlock()
121
120
        self.annoview.set_cursor(row)
122
121
        self.annoview.scroll_to_cell(row, use_align=True)
123
122
 
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())
 
123
    def _dotted_revnos(self, repository, revision_id):
 
124
        """Return a dict of revision_id -> dotted revno
131
125
        
132
 
        revision_cache = RevisionCache(repository)
133
 
        for origin, text in weave.annotate_iter(rev_id):
 
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):
134
151
            rev_id = origin
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 = "?"
 
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 = "?"
144
164
 
145
165
            yield revision, revno, text
146
166
 
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
 
 
168
167
    def _highlight_annotation(self, model, path, iter, now):
169
168
        revision_id, = model.get(iter, REVISION_ID_COL)
170
169
        revision = self.revisions[revision_id]
171
170
        model.set(iter, HIGHLIGHT_COLOR_COL,
172
171
                  self.annotate_colormap.get_color(revision, now))
173
172
 
174
 
    def _show_log(self, w):
 
173
    def _selected_revision(self):
175
174
        (path, col) = self.annoview.get_cursor()
176
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:
177
182
            return
178
 
        rev_id = self.annomodel[path][REVISION_ID_COL]
179
183
        self.logview.set_revision(self.revisions[rev_id])
180
184
 
181
185
    def _create(self):
182
186
        self.logview = self._create_log_view()
183
187
        self.annoview = self._create_annotate_view()
184
 
        self.span_selector = self._create_span_selector()
185
188
 
186
189
        vbox = gtk.VBox(False, 12)
187
190
        vbox.set_border_width(12)
199
202
        pane.add2(self.logview)
200
203
        pane.show()
201
204
        vbox.pack_start(pane, expand=True, fill=True)
202
 
        
 
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
 
203
217
        hbox = gtk.HBox(True, 6)
204
 
        hbox.pack_start(self.span_selector, expand=False, fill=True)
205
 
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
 
218
        hbox.pack_start(self._create_prev_button(), expand=False, fill=True)
 
219
        hbox.pack_end(self._create_button_box(), expand=False, fill=True)
206
220
        hbox.show()
207
221
        vbox.pack_start(hbox, expand=False, fill=True)
208
222
 
209
223
        self.add(vbox)
210
224
 
 
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
 
211
233
    def row_diff(self, tv, path, tvc):
212
234
        row = path[0]
213
235
        revision = self.annotations[row]
214
236
        repository = self.branch.repository
215
 
        tree1 = repository.revision_tree(revision.revision_id)
216
 
        if len(revision.parent_ids) > 0:
217
 
            tree2 = repository.revision_tree(revision.parent_ids[0])
 
237
        if revision.revision_id == CURRENT_REVISION:
 
238
            tree1 = self.tree
 
239
            tree2 = self.tree.basis_tree()
218
240
        else:
219
 
            tree2 = repository.revision_tree(NULL_REVISION)
220
 
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
 
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
221
247
        window = DiffWindow()
222
248
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
223
249
        window.set_file(tree1.id2path(self.file_id))
276
302
        col.add_attribute(cell, "text", TEXT_LINE_COL)
277
303
        tv.append_column(col)
278
304
 
 
305
        # FIXME: Now that C-f is now used for search by text we
 
306
        # may as well disable the auto search.
279
307
        tv.set_search_column(LINE_NUM_COL)
280
 
        
 
308
 
281
309
        return tv
282
310
 
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
 
 
290
311
    def _create_log_view(self):
291
312
        lv = LogView()
292
313
        lv.show()
293
 
 
294
314
        return lv
295
315
 
296
316
    def _create_button_box(self):
297
317
        box = gtk.HButtonBox()
298
318
        box.set_layout(gtk.BUTTONBOX_END)
299
319
        box.show()
300
 
        
 
320
 
301
321
        button = gtk.Button()
302
322
        button.set_use_stock(True)
303
323
        button.set_label("gtk-close")
304
324
        button.connect("clicked", lambda w: self.destroy())
305
325
        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()
306
335
        
 
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()
307
341
        box.pack_start(button, expand=False, fill=False)
308
 
 
309
342
        return box
310
343
 
311
 
 
312
 
class NoneRevision:
 
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:
313
367
    """ A fake revision.
314
368
 
315
369
    For when a revision is referenced but not present.
316
370
    """
317
371
 
318
 
    def __init__(self, revision_id):
 
372
    def __init__(self, revision_id, committer='?'):
319
373
        self.revision_id = revision_id
320
374
        self.parent_ids = []
321
 
        self.committer = "?"
 
375
        self.committer = committer
322
376
        self.message = "?"
323
377
        self.timestamp = 0.0
324
378
        self.timezone = 0
 
379
        self.properties = []
325
380
 
326
381
 
327
382
class RevisionCache(object):
328
383
    """A caching revision source"""
329
 
    def __init__(self, real_source):
 
384
    def __init__(self, real_source, seed_cache=None):
330
385
        self.__real_source = real_source
331
 
        self.__cache = {}
 
386
        if seed_cache is None:
 
387
            self.__cache = {}
 
388
        else:
 
389
            self.__cache = dict(seed_cache)
332
390
 
333
391
    def get_revision(self, revision_id):
334
392
        if revision_id not in self.__cache:
335
393
            revision = self.__real_source.get_revision(revision_id)
336
394
            self.__cache[revision_id] = revision
337
395
        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