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