/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
 
25
 
from bzrlib import tsort
 
26
from bzrlib import patiencediff, tsort
26
27
from bzrlib.errors import NoSuchRevision
27
 
from bzrlib.revision import NULL_REVISION
 
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.logview import LogView
32
32
 
33
33
 
34
34
(
54
54
        self.annotate_colormap = AnnotateColorSaturation()
55
55
 
56
56
        self._create()
57
 
 
58
 
        if self.plain:
59
 
            self.span_selector.hide()
60
 
 
61
 
    def annotate(self, branch, file_id, revision_id=None):
62
57
        self.revisions = {}
 
58
 
 
59
    def annotate(self, tree, branch, file_id):
63
60
        self.annotations = []
64
61
        self.branch = branch
 
62
        self.tree = tree
65
63
        self.file_id = file_id
66
 
        self.revision_id = revision_id
 
64
        self.revision_id = getattr(tree, 'get_revision_id', 
 
65
                                   lambda: CURRENT_REVISION)()
67
66
        
68
67
        # [revision id, line number, committer, revno, highlight color, line]
69
68
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
78
77
            branch.lock_read()
79
78
            branch.repository.lock_read()
80
79
            for line_no, (revision, revno, line)\
81
 
                    in enumerate(self._annotate(branch, file_id, revision_id)):
 
80
                    in enumerate(self._annotate(tree, file_id)):
82
81
                if revision.revision_id == last_seen and not self.all:
83
82
                    revno = committer = ""
84
83
                else:
98
97
                self.annotations.append(revision)
99
98
 
100
99
            if not self.plain:
101
 
                self._set_oldest_newest()
102
 
                # Recall that calling activate_default will emit "span-changed",
103
 
                # so self._span_changed_cb will take care of initial highlighting
104
 
                self.span_selector.activate_default()
 
100
                now = time.time()
 
101
                self.annomodel.foreach(self._highlight_annotation, now)
105
102
        finally:
106
103
            branch.repository.unlock()
107
104
            branch.unlock()
136
133
            dotted[revision_id] = '.'.join(str(num) for num in revno)
137
134
        return dotted
138
135
 
139
 
    def _annotate(self, branch, file_id, revision_id):
140
 
        repository = branch.repository
141
 
        if revision_id is None:
142
 
            revision_id = branch.last_revision()
 
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
143
148
        dotted = self._dotted_revnos(repository, revision_id)
144
 
        rev_tree = repository.revision_tree(revision_id)
145
 
        revision_id = rev_tree.inventory[file_id].revision
146
 
        weave = repository.weave_store.get_weave(file_id,
147
 
                                                 branch.get_transaction())
148
 
        
149
 
        revision_cache = RevisionCache(repository)
150
 
        for origin, text in weave.annotate_iter(revision_id):
 
149
        revision_cache = RevisionCache(repository, self.revisions)
 
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
 
                revision = NoneRevision(rev_id)
159
 
                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 = "?"
160
164
 
161
165
            yield revision, revno, text
162
166
 
163
 
    def _set_oldest_newest(self):
164
 
        rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
165
 
        if len(rev_dates) == 0:
166
 
            return
167
 
        oldest = min(rev_dates)
168
 
        newest = max(rev_dates)
169
 
 
170
 
        span = self._span_from_seconds(time.time() - oldest)
171
 
        self.span_selector.set_to_oldest_span(span)
172
 
        
173
 
        span = self._span_from_seconds(newest - oldest)
174
 
        self.span_selector.set_newest_to_oldest_span(span)
175
 
 
176
 
    def _span_from_seconds(self, seconds):
177
 
        return (seconds / (24 * 60 * 60))
178
 
    
179
 
    def _span_changed_cb(self, w, span):
180
 
        self.annotate_colormap.set_span(span)
181
 
        now = time.time()
182
 
        self.annomodel.foreach(self._highlight_annotation, now)
183
 
 
184
167
    def _highlight_annotation(self, model, path, iter, now):
185
168
        revision_id, = model.get(iter, REVISION_ID_COL)
186
169
        revision = self.revisions[revision_id]
187
170
        model.set(iter, HIGHLIGHT_COLOR_COL,
188
171
                  self.annotate_colormap.get_color(revision, now))
189
172
 
190
 
    def _show_log(self, w):
 
173
    def _selected_revision(self):
191
174
        (path, col) = self.annoview.get_cursor()
192
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:
193
182
            return
194
 
        rev_id = self.annomodel[path][REVISION_ID_COL]
195
183
        self.logview.set_revision(self.revisions[rev_id])
196
184
 
197
185
    def _create(self):
198
186
        self.logview = self._create_log_view()
199
187
        self.annoview = self._create_annotate_view()
200
 
        self.span_selector = self._create_span_selector()
201
188
 
202
189
        vbox = gtk.VBox(False, 12)
203
190
        vbox.set_border_width(12)
215
202
        pane.add2(self.logview)
216
203
        pane.show()
217
204
        vbox.pack_start(pane, expand=True, fill=True)
218
 
        
 
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
 
219
217
        hbox = gtk.HBox(True, 6)
220
 
        hbox.pack_start(self.span_selector, expand=False, fill=True)
221
 
        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)
222
220
        hbox.show()
223
221
        vbox.pack_start(hbox, expand=False, fill=True)
224
222
 
225
223
        self.add(vbox)
226
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
 
227
233
    def row_diff(self, tv, path, tvc):
228
234
        row = path[0]
229
235
        revision = self.annotations[row]
230
236
        repository = self.branch.repository
231
 
        tree1 = repository.revision_tree(revision.revision_id)
232
 
        if len(revision.parent_ids) > 0:
233
 
            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()
234
240
        else:
235
 
            tree2 = repository.revision_tree(NULL_REVISION)
236
 
        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
237
247
        window = DiffWindow()
238
248
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
239
249
        window.set_file(tree1.id2path(self.file_id))
292
302
        col.add_attribute(cell, "text", TEXT_LINE_COL)
293
303
        tv.append_column(col)
294
304
 
 
305
        # FIXME: Now that C-f is now used for search by text we
 
306
        # may as well disable the auto search.
295
307
        tv.set_search_column(LINE_NUM_COL)
296
 
        
 
308
 
297
309
        return tv
298
310
 
299
 
    def _create_span_selector(self):
300
 
        ss = SpanSelector()
301
 
        ss.connect("span-changed", self._span_changed_cb)
302
 
        ss.show()
303
 
 
304
 
        return ss
305
 
 
306
311
    def _create_log_view(self):
307
312
        lv = LogView()
308
313
        lv.show()
309
 
 
310
314
        return lv
311
315
 
312
316
    def _create_button_box(self):
313
317
        box = gtk.HButtonBox()
314
318
        box.set_layout(gtk.BUTTONBOX_END)
315
319
        box.show()
316
 
        
 
320
 
317
321
        button = gtk.Button()
318
322
        button.set_use_stock(True)
319
323
        button.set_label("gtk-close")
320
324
        button.connect("clicked", lambda w: self.destroy())
321
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()
322
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()
323
341
        box.pack_start(button, expand=False, fill=False)
324
 
 
325
342
        return box
326
343
 
327
 
 
328
 
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:
329
367
    """ A fake revision.
330
368
 
331
369
    For when a revision is referenced but not present.
332
370
    """
333
371
 
334
 
    def __init__(self, revision_id):
 
372
    def __init__(self, revision_id, committer='?'):
335
373
        self.revision_id = revision_id
336
374
        self.parent_ids = []
337
 
        self.committer = "?"
 
375
        self.committer = committer
338
376
        self.message = "?"
339
377
        self.timestamp = 0.0
340
378
        self.timezone = 0
 
379
        self.properties = []
341
380
 
342
381
 
343
382
class RevisionCache(object):
344
383
    """A caching revision source"""
345
 
    def __init__(self, real_source):
 
384
    def __init__(self, real_source, seed_cache=None):
346
385
        self.__real_source = real_source
347
 
        self.__cache = {}
 
386
        if seed_cache is None:
 
387
            self.__cache = {}
 
388
        else:
 
389
            self.__cache = dict(seed_cache)
348
390
 
349
391
    def get_revision(self, revision_id):
350
392
        if revision_id not in self.__cache:
351
393
            revision = self.__real_source.get_revision(revision_id)
352
394
            self.__cache[revision_id] = revision
353
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