/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: Aaron Bentley
  • Date: 2007-01-17 06:42:55 UTC
  • mto: This revision was merged to the branch mainline in revision 129.
  • Revision ID: aaron.bentley@utoronto.ca-20070117064255-x4gznz5e0lyjq3gk
Remove usused span selector

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
 
25
from bzrlib import tsort
27
26
from bzrlib.errors import NoSuchRevision
28
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
28
 
30
29
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
 
from bzrlib.plugins.gtk.logview import LogView
 
30
from logview import LogView
 
31
from spanselector import SpanSelector
32
32
 
33
33
 
34
34
(
54
54
        self.annotate_colormap = AnnotateColorSaturation()
55
55
 
56
56
        self._create()
 
57
 
 
58
    def annotate(self, tree, branch, file_id):
57
59
        self.revisions = {}
58
 
        self.history = []
59
 
        self._no_back = set()
60
 
 
61
 
    def annotate(self, tree, branch, file_id):
62
60
        self.annotations = []
63
61
        self.branch = branch
64
62
        self.tree = tree
66
64
        self.revision_id = getattr(tree, 'get_revision_id', 
67
65
                                   lambda: CURRENT_REVISION)()
68
66
        
69
 
        # [revision id, line number, author, revno, highlight color, line]
 
67
        # [revision id, line number, committer, revno, highlight color, line]
70
68
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
71
69
                                       gobject.TYPE_STRING,
72
70
                                       gobject.TYPE_STRING,
84
82
                    revno = committer = ""
85
83
                else:
86
84
                    last_seen = revision.revision_id
87
 
                    committer = revision.properties.get('author',
88
 
                        revision.committer)
 
85
                    committer = revision.committer
89
86
 
90
87
                if revision.revision_id not in self.revisions:
91
88
                    self.revisions[revision.revision_id] = revision
100
97
                self.annotations.append(revision)
101
98
 
102
99
            if not self.plain:
 
100
                self._set_oldest_newest()
103
101
                now = time.time()
104
102
                self.annomodel.foreach(self._highlight_annotation, now)
105
103
        finally:
141
139
        current_revision.committer = self.branch.get_config().username()
142
140
        current_revision.timestamp = time.time()
143
141
        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
142
        current_revno = '%d?' % (self.branch.revno() + 1)
147
143
        repository = self.branch.repository
148
144
        if self.revision_id == CURRENT_REVISION:
150
146
        else:
151
147
            revision_id = self.revision_id
152
148
        dotted = self._dotted_revnos(repository, revision_id)
153
 
        revision_cache = RevisionCache(repository, self.revisions)
 
149
        revision_cache = RevisionCache(repository)
154
150
        for origin, text in tree.annotate_iter(file_id):
155
151
            rev_id = origin
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:
 
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:
166
163
                    revision = FakeRevision(rev_id)
167
164
                    revno = "?"
168
165
 
169
166
            yield revision, revno, text
170
167
 
 
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
 
171
175
    def _highlight_annotation(self, model, path, iter, now):
172
176
        revision_id, = model.get(iter, REVISION_ID_COL)
173
177
        revision = self.revisions[revision_id]
174
178
        model.set(iter, HIGHLIGHT_COLOR_COL,
175
179
                  self.annotate_colormap.get_color(revision, now))
176
180
 
177
 
    def _selected_revision(self):
 
181
    def _show_log(self, w):
178
182
        (path, col) = self.annoview.get_cursor()
179
183
        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
184
            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)
 
185
        rev_id = self.annomodel[path][REVISION_ID_COL]
 
186
        self.logview.set_revision(self.revisions[rev_id])
195
187
 
196
188
    def _create(self):
197
189
        self.logview = self._create_log_view()
198
190
        self.annoview = self._create_annotate_view()
199
191
 
200
 
        vbox = gtk.VBox(False)
 
192
        vbox = gtk.VBox(False, 12)
 
193
        vbox.set_border_width(12)
201
194
        vbox.show()
202
195
 
203
196
        sw = gtk.ScrolledWindow()
206
199
        sw.add(self.annoview)
207
200
        self.annoview.gwindow = self
208
201
        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)
221
202
        
222
203
        self.pane = pane = gtk.VPaned()
223
 
        pane.add1(swbox)
 
204
        pane.add1(sw)
224
205
        pane.add2(self.logview)
225
206
        pane.show()
226
207
        vbox.pack_start(pane, expand=True, 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)
 
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)
238
213
 
239
214
        self.add(vbox)
240
215
 
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
216
    def row_diff(self, tv, path, tvc):
250
217
        row = path[0]
251
218
        revision = self.annotations[row]
259
226
                tree2 = repository.revision_tree(revision.parent_ids[0])
260
227
            else:
261
228
                tree2 = repository.revision_tree(NULL_REVISION)
262
 
        from bzrlib.plugins.gtk.diff import DiffWindow
 
229
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
263
230
        window = DiffWindow()
264
231
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
265
232
        window.set_file(tree1.id2path(self.file_id))
269
236
    def _create_annotate_view(self):
270
237
        tv = gtk.TreeView()
271
238
        tv.set_rules_hint(False)
272
 
        tv.connect("cursor-changed", self._activate_selected_revision)
 
239
        tv.connect("cursor-changed", self._show_log)
273
240
        tv.show()
274
241
        tv.connect("row-activated", self.row_diff)
275
242
 
318
285
        col.add_attribute(cell, "text", TEXT_LINE_COL)
319
286
        tv.append_column(col)
320
287
 
321
 
        # FIXME: Now that C-f is now used for search by text we
322
 
        # may as well disable the auto search.
323
288
        tv.set_search_column(LINE_NUM_COL)
324
 
 
 
289
        
325
290
        return tv
326
291
 
327
292
    def _create_log_view(self):
328
293
        lv = LogView()
329
294
        lv.show()
 
295
 
330
296
        return lv
331
297
 
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
 
 
 
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
395
312
 
396
313
 
397
314
class FakeRevision:
400
317
    For when a revision is referenced but not present.
401
318
    """
402
319
 
403
 
    def __init__(self, revision_id, committer='?', nick=None):
 
320
    def __init__(self, revision_id, committer='?'):
404
321
        self.revision_id = revision_id
405
322
        self.parent_ids = []
406
323
        self.committer = committer
407
324
        self.message = "?"
408
325
        self.timestamp = 0.0
409
326
        self.timezone = 0
410
 
        self.properties = {}
411
327
 
412
328
 
413
329
class RevisionCache(object):
414
330
    """A caching revision source"""
415
 
    def __init__(self, real_source, seed_cache=None):
 
331
    def __init__(self, real_source):
416
332
        self.__real_source = real_source
417
 
        if seed_cache is None:
418
 
            self.__cache = {}
419
 
        else:
420
 
            self.__cache = dict(seed_cache)
 
333
        self.__cache = {}
421
334
 
422
335
    def get_revision(self, revision_id):
423
336
        if revision_id not in self.__cache:
424
337
            revision = self.__real_source.get_revision(revision_id)
425
338
            self.__cache[revision_id] = revision
426
339
        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