/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

Merged an approved request (single clicking bookmark).

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
28
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
29
 
30
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
31
 
from bzrlib.plugins.gtk.logview import LogView
 
31
from bzrlib.plugins.gtk.revisionview import RevisionView
 
32
from bzrlib.plugins.gtk.window import Window
32
33
 
33
34
 
34
35
(
41
42
) = range(6)
42
43
 
43
44
 
44
 
class GAnnotateWindow(gtk.Window):
 
45
class GAnnotateWindow(Window):
45
46
    """Annotate window."""
46
47
 
47
 
    def __init__(self, all=False, plain=False):
 
48
    def __init__(self, all=False, plain=False, parent=None):
48
49
        self.all = all
49
50
        self.plain = plain
50
51
        
51
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
 
52
        Window.__init__(self, parent)
52
53
        
53
54
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
54
55
        self.annotate_colormap = AnnotateColorSaturation()
63
64
        self.branch = branch
64
65
        self.tree = tree
65
66
        self.file_id = file_id
 
67
        self.revisionview.set_file_id(file_id)
66
68
        self.revision_id = getattr(tree, 'get_revision_id', 
67
69
                                   lambda: CURRENT_REVISION)()
68
70
        
78
80
        try:
79
81
            branch.lock_read()
80
82
            branch.repository.lock_read()
 
83
            self.dotted = {}
 
84
            revno_map = self.branch.get_revision_id_to_revno_map()
 
85
            for revision_id, revno in revno_map.iteritems():
 
86
                self.dotted[revision_id] = '.'.join(str(num) for num in revno)
81
87
            for line_no, (revision, revno, line)\
82
88
                    in enumerate(self._annotate(tree, file_id)):
83
89
                if revision.revision_id == last_seen and not self.all:
84
 
                    revno = committer = ""
 
90
                    revno = author = ""
85
91
                else:
86
92
                    last_seen = revision.revision_id
87
 
                    committer = revision.properties.get('author',
88
 
                        revision.committer)
 
93
                    author = revision.get_apparent_author()
89
94
 
90
95
                if revision.revision_id not in self.revisions:
91
96
                    self.revisions[revision.revision_id] = revision
92
97
 
93
98
                self.annomodel.append([revision.revision_id,
94
99
                                       line_no + 1,
95
 
                                       committer,
 
100
                                       author,
96
101
                                       revno,
97
102
                                       None,
98
103
                                       line.rstrip("\r\n")
108
113
 
109
114
        self.annoview.set_model(self.annomodel)
110
115
        self.annoview.grab_focus()
 
116
        my_revno = self.dotted.get(self.revision_id, 'current')
 
117
        title = '%s (%s) - gannotate' % (self.tree.id2path(file_id), my_revno)
 
118
        self.set_title(title)
111
119
 
112
120
    def jump_to_line(self, lineno):
113
121
        if lineno > len(self.annomodel) or lineno < 1:
123
131
        self.annoview.set_cursor(row)
124
132
        self.annoview.scroll_to_cell(row, use_align=True)
125
133
 
126
 
    def _dotted_revnos(self, repository, revision_id):
127
 
        """Return a dict of revision_id -> dotted revno
128
 
        
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
134
 
139
135
    def _annotate(self, tree, file_id):
140
136
        current_revision = FakeRevision(CURRENT_REVISION)
149
145
            revision_id = self.branch.last_revision()
150
146
        else:
151
147
            revision_id = self.revision_id
152
 
        dotted = self._dotted_revnos(repository, revision_id)
153
148
        revision_cache = RevisionCache(repository, self.revisions)
154
149
        for origin, text in tree.annotate_iter(file_id):
155
150
            rev_id = origin
159
154
            else:
160
155
                try:
161
156
                    revision = revision_cache.get_revision(rev_id)
162
 
                    revno = dotted.get(rev_id, 'merge')
 
157
                    revno = self.dotted.get(rev_id, 'merge')
163
158
                    if len(revno) > 15:
164
159
                        revno = 'merge'
165
160
                except NoSuchRevision:
185
180
        if rev_id is None:
186
181
            return
187
182
        selected = self.revisions[rev_id]
188
 
        self.logview.set_revision(selected)
 
183
        self.revisionview.set_revision(selected)
189
184
        if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
190
185
            self._no_back):
191
186
            enable_back = True
194
189
        self.back_button.set_sensitive(enable_back)
195
190
 
196
191
    def _create(self):
197
 
        self.logview = self._create_log_view()
 
192
        self.revisionview = self._create_log_view()
198
193
        self.annoview = self._create_annotate_view()
199
194
 
200
195
        vbox = gtk.VBox(False)
221
216
        
222
217
        self.pane = pane = gtk.VPaned()
223
218
        pane.add1(swbox)
224
 
        pane.add2(self.logview)
 
219
        pane.add2(self.revisionview)
225
220
        pane.show()
226
221
        vbox.pack_start(pane, expand=True, fill=True)
227
222
 
246
241
        self._search.show_for('line')
247
242
        self._search.set_target(self.annoview, LINE_NUM_COL)
248
243
 
249
 
    def row_diff(self, tv, path, tvc):
 
244
    def line_diff(self, tv, path, tvc):
250
245
        row = path[0]
251
246
        revision = self.annotations[row]
252
247
        repository = self.branch.repository
261
256
                tree2 = repository.revision_tree(NULL_REVISION)
262
257
        from bzrlib.plugins.gtk.diff import DiffWindow
263
258
        window = DiffWindow()
264
 
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
 
259
        window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
265
260
        window.set_file(tree1.id2path(self.file_id))
266
261
        window.show()
267
262
 
271
266
        tv.set_rules_hint(False)
272
267
        tv.connect("cursor-changed", self._activate_selected_revision)
273
268
        tv.show()
274
 
        tv.connect("row-activated", self.row_diff)
 
269
        tv.connect("row-activated", self.line_diff)
275
270
 
276
271
        cell = gtk.CellRendererText()
277
272
        cell.set_property("xalign", 1.0)
325
320
        return tv
326
321
 
327
322
    def _create_log_view(self):
328
 
        lv = LogView()
 
323
        lv = RevisionView()
329
324
        lv.show()
330
325
        return lv
331
326
 
393
388
                return j - i
394
389
 
395
390
 
396
 
 
397
391
class FakeRevision:
398
392
    """ A fake revision.
399
393
 
409
403
        self.timezone = 0
410
404
        self.properties = {}
411
405
 
 
406
    def get_apparent_author(self):
 
407
        return self.committer
 
408
 
412
409
 
413
410
class RevisionCache(object):
414
411
    """A caching revision source"""