/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
22
22
import gtk
23
23
import pango
24
24
 
 
25
from bzrlib import tsort
25
26
from bzrlib.errors import NoSuchRevision
26
 
from bzrlib.revision import NULL_REVISION
 
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
27
28
 
28
29
from colormap import AnnotateColorMap, AnnotateColorSaturation
29
30
from logview import LogView
54
55
 
55
56
        self._create()
56
57
 
57
 
        if self.plain:
58
 
            self.span_selector.hide()
59
 
 
60
 
    def annotate(self, branch, file_id):
 
58
    def annotate(self, tree, branch, file_id):
61
59
        self.revisions = {}
62
60
        self.annotations = []
63
61
        self.branch = branch
 
62
        self.tree = tree
64
63
        self.file_id = file_id
 
64
        self.revision_id = getattr(tree, 'get_revision_id', 
 
65
                                   lambda: CURRENT_REVISION)()
65
66
        
66
67
        # [revision id, line number, committer, revno, highlight color, line]
67
68
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
76
77
            branch.lock_read()
77
78
            branch.repository.lock_read()
78
79
            for line_no, (revision, revno, line)\
79
 
                    in enumerate(self._annotate(branch, file_id)):
 
80
                    in enumerate(self._annotate(tree, file_id)):
80
81
                if revision.revision_id == last_seen and not self.all:
81
82
                    revno = committer = ""
82
83
                else:
97
98
 
98
99
            if not self.plain:
99
100
                self._set_oldest_newest()
100
 
                # Recall that calling activate_default will emit "span-changed",
101
 
                # so self._span_changed_cb will take care of initial highlighting
102
 
                self.span_selector.activate_default()
 
101
                now = time.time()
 
102
                self.annomodel.foreach(self._highlight_annotation, now)
103
103
        finally:
104
104
            branch.repository.unlock()
105
105
            branch.unlock()
114
114
            # bar?
115
115
            print("gannotate: Line number %d does't exist. Defaulting to "
116
116
                  "line 1." % lineno)
 
117
            return
117
118
        else:
118
119
            row = lineno - 1
119
120
 
120
121
        self.annoview.set_cursor(row)
121
122
        self.annoview.scroll_to_cell(row, use_align=True)
122
123
 
123
 
    def _annotate(self, branch, file_id):
124
 
        rev_hist = branch.revision_history()
125
 
        repository = branch.repository
126
 
        rev_tree = repository.revision_tree(branch.last_revision())
127
 
        rev_id = rev_tree.inventory[file_id].revision
128
 
        weave = repository.weave_store.get_weave(file_id,
129
 
                                                 branch.get_transaction())
 
124
    def _dotted_revnos(self, repository, revision_id):
 
125
        """Return a dict of revision_id -> dotted revno
130
126
        
 
127
        :param repository: The repository to get the graph from
 
128
        :param revision_id: The last revision for which this info is needed
 
129
        """
 
130
        graph = repository.get_revision_graph(revision_id)
 
131
        dotted = {}
 
132
        for n, revision_id, d, revno, e in tsort.merge_sort(graph, 
 
133
            revision_id, generate_revno=True):
 
134
            dotted[revision_id] = '.'.join(str(num) for num in revno)
 
135
        return dotted
 
136
 
 
137
    def _annotate(self, tree, file_id):
 
138
        current_revision = FakeRevision(CURRENT_REVISION)
 
139
        current_revision.committer = self.branch.get_config().username()
 
140
        current_revision.timestamp = time.time()
 
141
        current_revision.message = '[Not yet committed]'
 
142
        current_revno = '%d?' % (self.branch.revno() + 1)
 
143
        repository = self.branch.repository
 
144
        if self.revision_id == CURRENT_REVISION:
 
145
            revision_id = self.branch.last_revision()
 
146
        else:
 
147
            revision_id = self.revision_id
 
148
        dotted = self._dotted_revnos(repository, revision_id)
131
149
        revision_cache = RevisionCache(repository)
132
 
        for origin, text in weave.annotate_iter(rev_id):
 
150
        for origin, text in tree.annotate_iter(file_id):
133
151
            rev_id = origin
134
152
            try:
135
153
                revision = revision_cache.get_revision(rev_id)
136
 
                if rev_id in rev_hist:
137
 
                    revno = branch.revision_id_to_revno(rev_id)
138
 
                else:
139
 
                    revno = "merge"
 
154
                revno = dotted.get(rev_id, 'merge')
 
155
                if len(revno) > 15:
 
156
                    revno = 'merge'
140
157
            except NoSuchRevision:
141
 
                revision = NoneRevision(rev_id)
142
 
                revno = "?"
 
158
                committer = "?"
 
159
                if rev_id == CURRENT_REVISION:
 
160
                    revision = current_revision
 
161
                    revno = current_revno
 
162
                else:
 
163
                    revision = FakeRevision(rev_id)
 
164
                    revno = "?"
143
165
 
144
166
            yield revision, revno, text
145
167
 
146
168
    def _set_oldest_newest(self):
147
169
        rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
 
170
        if len(rev_dates) == 0:
 
171
            return
148
172
        oldest = min(rev_dates)
149
173
        newest = max(rev_dates)
150
174
 
151
 
        span = self._span_from_seconds(time.time() - oldest)
152
 
        self.span_selector.set_to_oldest_span(span)
153
 
        
154
 
        span = self._span_from_seconds(newest - oldest)
155
 
        self.span_selector.set_newest_to_oldest_span(span)
156
 
 
157
 
    def _span_from_seconds(self, seconds):
158
 
        return (seconds / (24 * 60 * 60))
159
 
    
160
 
    def _span_changed_cb(self, w, span):
161
 
        self.annotate_colormap.set_span(span)
162
 
        now = time.time()
163
 
        self.annomodel.foreach(self._highlight_annotation, now)
164
 
 
165
175
    def _highlight_annotation(self, model, path, iter, now):
166
176
        revision_id, = model.get(iter, REVISION_ID_COL)
167
177
        revision = self.revisions[revision_id]
170
180
 
171
181
    def _show_log(self, w):
172
182
        (path, col) = self.annoview.get_cursor()
 
183
        if path is None:
 
184
            return
173
185
        rev_id = self.annomodel[path][REVISION_ID_COL]
174
186
        self.logview.set_revision(self.revisions[rev_id])
175
187
 
176
188
    def _create(self):
177
189
        self.logview = self._create_log_view()
178
190
        self.annoview = self._create_annotate_view()
179
 
        self.span_selector = self._create_span_selector()
180
191
 
181
192
        vbox = gtk.VBox(False, 12)
182
193
        vbox.set_border_width(12)
196
207
        vbox.pack_start(pane, expand=True, fill=True)
197
208
        
198
209
        hbox = gtk.HBox(True, 6)
199
 
        hbox.pack_start(self.span_selector, expand=False, fill=True)
200
210
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
201
211
        hbox.show()
202
212
        vbox.pack_start(hbox, expand=False, fill=True)
207
217
        row = path[0]
208
218
        revision = self.annotations[row]
209
219
        repository = self.branch.repository
210
 
        tree1 = repository.revision_tree(revision.revision_id)
211
 
        if len(revision.parent_ids) > 0:
212
 
            tree2 = repository.revision_tree(revision.parent_ids[0])
 
220
        if revision.revision_id == CURRENT_REVISION:
 
221
            tree1 = self.tree
 
222
            tree2 = self.tree.basis_tree()
213
223
        else:
214
 
            tree2 = repository.revision_tree(NULL_REVISION)
 
224
            tree1 = repository.revision_tree(revision.revision_id)
 
225
            if len(revision.parent_ids) > 0:
 
226
                tree2 = repository.revision_tree(revision.parent_ids[0])
 
227
            else:
 
228
                tree2 = repository.revision_tree(NULL_REVISION)
215
229
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
216
230
        window = DiffWindow()
217
231
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
275
289
        
276
290
        return tv
277
291
 
278
 
    def _create_span_selector(self):
279
 
        ss = SpanSelector()
280
 
        ss.connect("span-changed", self._span_changed_cb)
281
 
        ss.show()
282
 
 
283
 
        return ss
284
 
 
285
292
    def _create_log_view(self):
286
293
        lv = LogView()
287
294
        lv.show()
304
311
        return box
305
312
 
306
313
 
307
 
class NoneRevision:
 
314
class FakeRevision:
308
315
    """ A fake revision.
309
316
 
310
317
    For when a revision is referenced but not present.
311
318
    """
312
319
 
313
 
    def __init__(self, revision_id):
 
320
    def __init__(self, revision_id, committer='?'):
314
321
        self.revision_id = revision_id
315
322
        self.parent_ids = []
316
 
        self.committer = "?"
 
323
        self.committer = committer
317
324
        self.message = "?"
318
325
        self.timestamp = 0.0
319
326
        self.timezone = 0