/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: 2008-06-29 19:07:23 UTC
  • mto: This revision was merged to the branch mainline in revision 515.
  • Revision ID: jelmer@samba.org-20080629190723-l8mzg9x4oec0lhsl
Return cleartext from seahorse module

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
 
1
# Copyright (C) 2005 Dan Loda <danloda@gmail.com>
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import time
 
18
 
 
19
import pygtk
 
20
pygtk.require("2.0")
 
21
import gobject
 
22
import gtk
 
23
import pango
 
24
import re
 
25
 
 
26
from bzrlib import patiencediff, tsort
 
27
from bzrlib.errors import NoSuchRevision
 
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
29
 
 
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
 
31
from bzrlib.plugins.gtk.revisionview import RevisionView
 
32
from bzrlib.plugins.gtk.window import Window
 
33
 
 
34
 
 
35
(
 
36
    REVISION_ID_COL,
 
37
    LINE_NUM_COL,
 
38
    COMMITTER_COL,
 
39
    REVNO_COL,
 
40
    HIGHLIGHT_COLOR_COL,
 
41
    TEXT_LINE_COL
 
42
) = range(6)
 
43
 
 
44
 
 
45
class GAnnotateWindow(Window):
 
46
    """Annotate window."""
 
47
 
 
48
    def __init__(self, all=False, plain=False, parent=None, branch=None):
 
49
        self.all = all
 
50
        self.plain = plain
 
51
        self._branch = branch
 
52
        
 
53
        Window.__init__(self, parent)
 
54
        
 
55
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
 
56
        self.annotate_colormap = AnnotateColorSaturation()
 
57
 
 
58
        self._create()
 
59
        self.revisions = {}
 
60
        self.history = []
 
61
        self._no_back = set()
 
62
 
 
63
    def annotate(self, tree, branch, file_id):
 
64
        self.annotations = []
 
65
        self.branch = branch
 
66
        self.tree = tree
 
67
        self.file_id = file_id
 
68
        self.revisionview.set_file_id(file_id)
 
69
        self.revision_id = getattr(tree, 'get_revision_id', 
 
70
                                   lambda: CURRENT_REVISION)()
 
71
        
 
72
        # [revision id, line number, author, revno, highlight color, line]
 
73
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
 
74
                                       gobject.TYPE_STRING,
 
75
                                       gobject.TYPE_STRING,
 
76
                                       gobject.TYPE_STRING,
 
77
                                       gobject.TYPE_STRING,
 
78
                                       gobject.TYPE_STRING)
 
79
        
 
80
        last_seen = None
 
81
        try:
 
82
            branch.lock_read()
 
83
            branch.repository.lock_read()
 
84
            self.dotted = {}
 
85
            revno_map = self.branch.get_revision_id_to_revno_map()
 
86
            for revision_id, revno in revno_map.iteritems():
 
87
                self.dotted[revision_id] = '.'.join(str(num) for num in revno)
 
88
            for line_no, (revision, revno, line)\
 
89
                    in enumerate(self._annotate(tree, file_id)):
 
90
                if revision.revision_id == last_seen and not self.all:
 
91
                    revno = author = ""
 
92
                else:
 
93
                    last_seen = revision.revision_id
 
94
                    author = revision.get_apparent_author()
 
95
 
 
96
                if revision.revision_id not in self.revisions:
 
97
                    self.revisions[revision.revision_id] = revision
 
98
 
 
99
                self.annomodel.append([revision.revision_id,
 
100
                                       line_no + 1,
 
101
                                       author,
 
102
                                       revno,
 
103
                                       None,
 
104
                                       line.rstrip("\r\n")
 
105
                                      ])
 
106
                self.annotations.append(revision)
 
107
 
 
108
            if not self.plain:
 
109
                now = time.time()
 
110
                self.annomodel.foreach(self._highlight_annotation, now)
 
111
        finally:
 
112
            branch.repository.unlock()
 
113
            branch.unlock()
 
114
 
 
115
        self.annoview.set_model(self.annomodel)
 
116
        self.annoview.grab_focus()
 
117
        my_revno = self.dotted.get(self.revision_id, 'current')
 
118
        title = '%s (%s) - gannotate' % (self.tree.id2path(file_id), my_revno)
 
119
        self.set_title(title)
 
120
 
 
121
    def jump_to_line(self, lineno):
 
122
        if lineno > len(self.annomodel) or lineno < 1:
 
123
            row = 0
 
124
            # FIXME:should really deal with this in the gui. Perhaps a status
 
125
            # bar?
 
126
            print("gannotate: Line number %d does't exist. Defaulting to "
 
127
                  "line 1." % lineno)
 
128
            return
 
129
        else:
 
130
            row = lineno - 1
 
131
 
 
132
        self.annoview.set_cursor(row)
 
133
        self.annoview.scroll_to_cell(row, use_align=True)
 
134
 
 
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_revision.properties['branch-nick'] = self.branch.nick
 
143
        current_revno = '%d?' % (self.branch.revno() + 1)
 
144
        repository = self.branch.repository
 
145
        if self.revision_id == CURRENT_REVISION:
 
146
            revision_id = self.branch.last_revision()
 
147
        else:
 
148
            revision_id = self.revision_id
 
149
        revision_cache = RevisionCache(repository, self.revisions)
 
150
        for origin, text in tree.annotate_iter(file_id):
 
151
            rev_id = origin
 
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 = self.dotted.get(rev_id, 'merge')
 
159
                    if len(revno) > 15:
 
160
                        revno = 'merge'
 
161
                except NoSuchRevision:
 
162
                    revision = FakeRevision(rev_id)
 
163
                    revno = "?"
 
164
 
 
165
            yield revision, revno, text
 
166
 
 
167
    def _highlight_annotation(self, model, path, iter, now):
 
168
        revision_id, = model.get(iter, REVISION_ID_COL)
 
169
        revision = self.revisions[revision_id]
 
170
        model.set(iter, HIGHLIGHT_COLOR_COL,
 
171
                  self.annotate_colormap.get_color(revision, now))
 
172
 
 
173
    def _selected_revision(self):
 
174
        (path, col) = self.annoview.get_cursor()
 
175
        if path is None:
 
176
            return None
 
177
        return self.annomodel[path][REVISION_ID_COL]
 
178
 
 
179
    def _activate_selected_revision(self, w):
 
180
        rev_id = self._selected_revision()
 
181
        if not rev_id or rev_id == NULL_REVISION:
 
182
            return
 
183
        selected = self.revisions[rev_id]
 
184
        self.revisionview.set_revision(selected)
 
185
        if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
 
186
            self._no_back):
 
187
            enable_back = True
 
188
        else:
 
189
            enable_back = False
 
190
        self.back_button.set_sensitive(enable_back)
 
191
 
 
192
    def _create(self):
 
193
        self.revisionview = self._create_log_view()
 
194
        self.annoview = self._create_annotate_view()
 
195
 
 
196
        vbox = gtk.VBox(False)
 
197
        vbox.show()
 
198
 
 
199
        sw = gtk.ScrolledWindow()
 
200
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
201
        sw.set_shadow_type(gtk.SHADOW_IN)
 
202
        sw.add(self.annoview)
 
203
        self.annoview.gwindow = self
 
204
        sw.show()
 
205
 
 
206
        swbox = gtk.VBox()
 
207
        swbox.pack_start(sw)
 
208
        swbox.show()
 
209
 
 
210
        hbox = gtk.HBox(False, 6)
 
211
        self.back_button = self._create_back_button()
 
212
        hbox.pack_start(self.back_button, expand=False, fill=True)
 
213
        self.forward_button = self._create_forward_button()
 
214
        hbox.pack_start(self.forward_button, expand=False, fill=True)
 
215
        hbox.show()
 
216
        vbox.pack_start(hbox, expand=False, fill=True)
 
217
        
 
218
        self.pane = pane = gtk.VPaned()
 
219
        pane.add1(swbox)
 
220
        pane.add2(self.revisionview)
 
221
        pane.show()
 
222
        vbox.pack_start(pane, expand=True, fill=True)
 
223
 
 
224
        self._search = SearchBox()
 
225
        swbox.pack_start(self._search, expand=False, fill=True)
 
226
        accels = gtk.AccelGroup()
 
227
        accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
 
228
                             gtk.ACCEL_LOCKED,
 
229
                             self._search_by_text)
 
230
        accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
 
231
                             gtk.ACCEL_LOCKED,
 
232
                             self._search_by_line)
 
233
        self.add_accel_group(accels)
 
234
 
 
235
        self.add(vbox)
 
236
 
 
237
    def _search_by_text(self, accel_group, window, key, modifiers):
 
238
        self._search.show_for('text')
 
239
        self._search.set_target(self.annoview, TEXT_LINE_COL)
 
240
 
 
241
    def _search_by_line(self, accel_group, window, key, modifiers):
 
242
        self._search.show_for('line')
 
243
        self._search.set_target(self.annoview, LINE_NUM_COL)
 
244
 
 
245
    def line_diff(self, tv, path, tvc):
 
246
        row = path[0]
 
247
        revision = self.annotations[row]
 
248
        repository = self.branch.repository
 
249
        if revision.revision_id == CURRENT_REVISION:
 
250
            tree1 = self.tree
 
251
            tree2 = self.tree.basis_tree()
 
252
        else:
 
253
            tree1 = repository.revision_tree(revision.revision_id)
 
254
            if len(revision.parent_ids) > 0:
 
255
                tree2 = repository.revision_tree(revision.parent_ids[0])
 
256
            else:
 
257
                tree2 = repository.revision_tree(NULL_REVISION)
 
258
        from bzrlib.plugins.gtk.diff import DiffWindow
 
259
        window = DiffWindow()
 
260
        window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
 
261
        window.set_file(tree1.id2path(self.file_id))
 
262
        window.show()
 
263
 
 
264
 
 
265
    def _create_annotate_view(self):
 
266
        tv = gtk.TreeView()
 
267
        tv.set_rules_hint(False)
 
268
        tv.connect("cursor-changed", self._activate_selected_revision)
 
269
        tv.show()
 
270
        tv.connect("row-activated", self.line_diff)
 
271
 
 
272
        cell = gtk.CellRendererText()
 
273
        cell.set_property("xalign", 1.0)
 
274
        cell.set_property("ypad", 0)
 
275
        cell.set_property("family", "Monospace")
 
276
        cell.set_property("cell-background-gdk",
 
277
                          tv.get_style().bg[gtk.STATE_NORMAL])
 
278
        col = gtk.TreeViewColumn()
 
279
        col.set_resizable(False)
 
280
        col.pack_start(cell, expand=True)
 
281
        col.add_attribute(cell, "text", LINE_NUM_COL)
 
282
        tv.append_column(col)
 
283
 
 
284
        cell = gtk.CellRendererText()
 
285
        cell.set_property("ypad", 0)
 
286
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
287
        cell.set_property("cell-background-gdk",
 
288
                          self.get_style().bg[gtk.STATE_NORMAL])
 
289
        col = gtk.TreeViewColumn("Committer")
 
290
        col.set_resizable(True)
 
291
        col.pack_start(cell, expand=True)
 
292
        col.add_attribute(cell, "text", COMMITTER_COL)
 
293
        tv.append_column(col)
 
294
 
 
295
        cell = gtk.CellRendererText()
 
296
        cell.set_property("xalign", 1.0)
 
297
        cell.set_property("ypad", 0)
 
298
        cell.set_property("cell-background-gdk",
 
299
                          self.get_style().bg[gtk.STATE_NORMAL])
 
300
        col = gtk.TreeViewColumn("Revno")
 
301
        col.set_resizable(False)
 
302
        col.pack_start(cell, expand=True)
 
303
        col.add_attribute(cell, "markup", REVNO_COL)
 
304
        tv.append_column(col)
 
305
 
 
306
        cell = gtk.CellRendererText()
 
307
        cell.set_property("ypad", 0)
 
308
        cell.set_property("family", "Monospace")
 
309
        col = gtk.TreeViewColumn()
 
310
        col.set_resizable(False)
 
311
        col.pack_start(cell, expand=True)
 
312
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
 
313
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
 
314
        col.add_attribute(cell, "text", TEXT_LINE_COL)
 
315
        tv.append_column(col)
 
316
 
 
317
        # FIXME: Now that C-f is now used for search by text we
 
318
        # may as well disable the auto search.
 
319
        tv.set_search_column(LINE_NUM_COL)
 
320
 
 
321
        return tv
 
322
 
 
323
    def _create_log_view(self):
 
324
        lv = RevisionView(self._branch)
 
325
        lv.show()
 
326
        return lv
 
327
 
 
328
    def _create_back_button(self):
 
329
        button = gtk.Button()
 
330
        button.set_use_stock(True)
 
331
        button.set_label("gtk-go-back")
 
332
        button.connect("clicked", lambda w: self.go_back())
 
333
        button.set_relief(gtk.RELIEF_NONE)
 
334
        button.show()
 
335
        return button
 
336
 
 
337
    def _create_forward_button(self):
 
338
        button = gtk.Button()
 
339
        button.set_use_stock(True)
 
340
        button.set_label("gtk-go-forward")
 
341
        button.connect("clicked", lambda w: self.go_forward())
 
342
        button.set_relief(gtk.RELIEF_NONE)
 
343
        button.show()
 
344
        button.set_sensitive(False)
 
345
        return button
 
346
 
 
347
    def go_back(self):
 
348
        last_tree = self.tree
 
349
        rev_id = self._selected_revision()
 
350
        parent_id = self.revisions[rev_id].parent_ids[0]
 
351
        target_tree = self.branch.repository.revision_tree(parent_id)
 
352
        if self._go(target_tree):
 
353
            self.history.append(last_tree)
 
354
            self.forward_button.set_sensitive(True)
 
355
        else:
 
356
            self._no_back.add(parent_id)
 
357
            self.back_button.set_sensitive(False)
 
358
 
 
359
    def go_forward(self):
 
360
        if len(self.history) == 0:
 
361
            return
 
362
        target_tree = self.history.pop()
 
363
        if len(self.history) == 0:
 
364
            self.forward_button.set_sensitive(False)
 
365
        self._go(target_tree)
 
366
 
 
367
    def _go(self, target_tree):
 
368
        rev_id = self._selected_revision()
 
369
        if self.file_id in target_tree:
 
370
            offset = self.get_scroll_offset(target_tree)
 
371
            (row,), col = self.annoview.get_cursor()
 
372
            self.annotate(target_tree, self.branch, self.file_id)
 
373
            new_row = row+offset
 
374
            if new_row < 0:
 
375
                new_row = 0
 
376
            self.annoview.set_cursor(new_row)
 
377
            return True
 
378
        else:
 
379
            return False
 
380
 
 
381
    def get_scroll_offset(self, tree):
 
382
        old = self.tree.get_file(self.file_id)
 
383
        new = tree.get_file(self.file_id)
 
384
        (row,), col = self.annoview.get_cursor()
 
385
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
 
386
                                                       new.readlines())
 
387
        for i, j, n in matcher.get_matching_blocks():
 
388
            if i + n >= row:
 
389
                return j - i
 
390
 
 
391
 
 
392
class FakeRevision:
 
393
    """ A fake revision.
 
394
 
 
395
    For when a revision is referenced but not present.
 
396
    """
 
397
 
 
398
    def __init__(self, revision_id, committer='?', nick=None):
 
399
        self.revision_id = revision_id
 
400
        self.parent_ids = []
 
401
        self.committer = committer
 
402
        self.message = "?"
 
403
        self.timestamp = 0.0
 
404
        self.timezone = 0
 
405
        self.properties = {}
 
406
 
 
407
    def get_apparent_author(self):
 
408
        return self.committer
 
409
 
 
410
 
 
411
class RevisionCache(object):
 
412
    """A caching revision source"""
 
413
    def __init__(self, real_source, seed_cache=None):
 
414
        self.__real_source = real_source
 
415
        if seed_cache is None:
 
416
            self.__cache = {}
 
417
        else:
 
418
            self.__cache = dict(seed_cache)
 
419
 
 
420
    def get_revision(self, revision_id):
 
421
        if revision_id not in self.__cache:
 
422
            revision = self.__real_source.get_revision(revision_id)
 
423
            self.__cache[revision_id] = revision
 
424
        return self.__cache[revision_id]
 
425
 
 
426
class SearchBox(gtk.HBox):
 
427
    """A button box for searching in text or lines of annotations"""
 
428
    def __init__(self):
 
429
        gtk.HBox.__init__(self, False, 6)
 
430
 
 
431
        # Close button
 
432
        button = gtk.Button()
 
433
        image = gtk.Image()
 
434
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
 
435
        button.set_image(image)
 
436
        button.set_relief(gtk.RELIEF_NONE)
 
437
        button.connect("clicked", lambda w: self.hide_all())
 
438
        self.pack_start(button, expand=False, fill=False)
 
439
 
 
440
        # Search entry
 
441
        label = gtk.Label()
 
442
        self._label = label
 
443
        self.pack_start(label, expand=False, fill=False)
 
444
 
 
445
        entry = gtk.Entry()
 
446
        self._entry = entry
 
447
        entry.connect("activate", lambda w, d: self._do_search(d),
 
448
                      'forward')
 
449
        self.pack_start(entry, expand=False, fill=False)
 
450
 
 
451
        # Next/previous buttons
 
452
        button = gtk.Button('_Next')
 
453
        image = gtk.Image()
 
454
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
 
455
        button.set_image(image)
 
456
        button.connect("clicked", lambda w, d: self._do_search(d),
 
457
                       'forward')
 
458
        self.pack_start(button, expand=False, fill=False)
 
459
 
 
460
        button = gtk.Button('_Previous')
 
461
        image = gtk.Image()
 
462
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
 
463
        button.set_image(image)
 
464
        button.connect("clicked", lambda w, d: self._do_search(d),
 
465
                       'backward')
 
466
        self.pack_start(button, expand=False, fill=False)
 
467
 
 
468
        # Search options
 
469
        check = gtk.CheckButton('Match case')
 
470
        self._match_case = check
 
471
        self.pack_start(check, expand=False, fill=False)
 
472
 
 
473
        check = gtk.CheckButton('Regexp')
 
474
        check.connect("toggled", lambda w: self._set_label())
 
475
        self._regexp = check
 
476
        self.pack_start(check, expand=False, fill=False)
 
477
 
 
478
        self._view = None
 
479
        self._column = None
 
480
        # Note that we stay hidden (we do not call self.show_all())
 
481
 
 
482
 
 
483
    def show_for(self, kind):
 
484
        self._kind = kind
 
485
        self.show_all()
 
486
        self._set_label()
 
487
        # Hide unrelated buttons
 
488
        if kind == 'line':
 
489
            self._match_case.hide()
 
490
            self._regexp.hide()
 
491
        # Be ready
 
492
        self._entry.grab_focus()
 
493
 
 
494
    def _set_label(self):
 
495
        if self._kind == 'line':
 
496
            self._label.set_text('Find Line: ')
 
497
        else:
 
498
            if self._regexp.get_active():
 
499
                self._label.set_text('Find Regexp: ')
 
500
            else:
 
501
                self._label.set_text('Find Text: ')
 
502
 
 
503
    def set_target(self, view,column):
 
504
        self._view = view
 
505
        self._column = column
 
506
 
 
507
    def _match(self, model, iterator, column):
 
508
        matching_case = self._match_case.get_active()
 
509
        string, = model.get(iterator, column)
 
510
        key = self._entry.get_text()
 
511
        if self._regexp.get_active():
 
512
            if matching_case:
 
513
                match = re.compile(key).search(string, 1)
 
514
            else:
 
515
                match = re.compile(key, re.I).search(string, 1)
 
516
        else:
 
517
            if not matching_case:
 
518
                string = string.lower()
 
519
                key = key.lower()
 
520
            match = string.find(key) != -1
 
521
 
 
522
        return match
 
523
 
 
524
    def _iterate_rows_forward(self, model, start):
 
525
        model_size = len(model)
 
526
        current = start + 1
 
527
        while model_size != 0:
 
528
            if current >= model_size: current =  0
 
529
            yield model.get_iter_from_string('%d' % current)
 
530
            if current == start: raise StopIteration
 
531
            current += 1
 
532
 
 
533
    def _iterate_rows_backward(self, model, start):
 
534
        model_size = len(model)
 
535
        current = start - 1
 
536
        while model_size != 0:
 
537
            if current < 0: current = model_size - 1
 
538
            yield model.get_iter_from_string('%d' % current)
 
539
            if current == start: raise StopIteration
 
540
            current -= 1
 
541
 
 
542
    def _do_search(self, direction):
 
543
        if direction == 'forward':
 
544
            iterate = self._iterate_rows_forward
 
545
        else:
 
546
            iterate = self._iterate_rows_backward
 
547
 
 
548
        model, sel = self._view.get_selection().get_selected()
 
549
        if sel is None:
 
550
            start = 0
 
551
        else:
 
552
            path = model.get_string_from_iter(sel)
 
553
            start = int(path)
 
554
 
 
555
        for row in iterate(model, start):
 
556
            if self._match(model, row, self._column):
 
557
                path = model.get_path(row)
 
558
                self._view.set_cursor(path)
 
559
                self._view.scroll_to_cell(path, use_align=True)
 
560
                break