/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: matkor
  • Date: 2007-08-23 10:17:40 UTC
  • mto: This revision was merged to the branch mainline in revision 265.
  • Revision ID: matkor@laptop-hp-20070823101740-s17kf9qa383wiuje
Code for "branch update" menuitem and toolbox. Typo fix

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