/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-08-16 14:31:02 UTC
  • Revision ID: abentley@panoramicfeedback.com-20070816143102-27yzfhdgdv3ggo6e
Fix hue selection to use author in gannotate

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.revisionview import RevisionView
32
 
from bzrlib.plugins.gtk.window import Window
 
31
from bzrlib.plugins.gtk.logview import LogView
33
32
 
34
33
 
35
34
(
42
41
) = range(6)
43
42
 
44
43
 
45
 
class GAnnotateWindow(Window):
 
44
class GAnnotateWindow(gtk.Window):
46
45
    """Annotate window."""
47
46
 
48
 
    def __init__(self, all=False, plain=False, parent=None, branch=None):
 
47
    def __init__(self, all=False, plain=False):
49
48
        self.all = all
50
49
        self.plain = plain
51
 
        self._branch = branch
52
50
        
53
 
        Window.__init__(self, parent)
 
51
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
54
52
        
55
53
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
56
54
        self.annotate_colormap = AnnotateColorSaturation()
65
63
        self.branch = branch
66
64
        self.tree = tree
67
65
        self.file_id = file_id
68
 
        self.revisionview.set_file_id(file_id)
69
66
        self.revision_id = getattr(tree, 'get_revision_id', 
70
67
                                   lambda: CURRENT_REVISION)()
71
68
        
81
78
        try:
82
79
            branch.lock_read()
83
80
            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
81
            for line_no, (revision, revno, line)\
89
82
                    in enumerate(self._annotate(tree, file_id)):
90
83
                if revision.revision_id == last_seen and not self.all:
91
 
                    revno = author = ""
 
84
                    revno = committer = ""
92
85
                else:
93
86
                    last_seen = revision.revision_id
94
 
                    author = ", ".join(revision.get_apparent_authors())
 
87
                    committer = revision.properties.get('author',
 
88
                        revision.committer)
95
89
 
96
90
                if revision.revision_id not in self.revisions:
97
91
                    self.revisions[revision.revision_id] = revision
98
92
 
99
93
                self.annomodel.append([revision.revision_id,
100
94
                                       line_no + 1,
101
 
                                       author,
 
95
                                       committer,
102
96
                                       revno,
103
97
                                       None,
104
98
                                       line.rstrip("\r\n")
114
108
 
115
109
        self.annoview.set_model(self.annomodel)
116
110
        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
111
 
121
112
    def jump_to_line(self, lineno):
122
113
        if lineno > len(self.annomodel) or lineno < 1:
132
123
        self.annoview.set_cursor(row)
133
124
        self.annoview.scroll_to_cell(row, use_align=True)
134
125
 
 
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
135
138
 
136
139
    def _annotate(self, tree, file_id):
137
140
        current_revision = FakeRevision(CURRENT_REVISION)
139
142
        current_revision.timestamp = time.time()
140
143
        current_revision.message = '[Not yet committed]'
141
144
        current_revision.parent_ids = tree.get_parent_ids()
142
 
        current_revision.properties['branch-nick'] = self.branch._get_nick(local=True)
 
145
        current_revision.properties['branch-nick'] = self.branch.nick
143
146
        current_revno = '%d?' % (self.branch.revno() + 1)
144
147
        repository = self.branch.repository
145
148
        if self.revision_id == CURRENT_REVISION:
146
149
            revision_id = self.branch.last_revision()
147
150
        else:
148
151
            revision_id = self.revision_id
 
152
        dotted = self._dotted_revnos(repository, revision_id)
149
153
        revision_cache = RevisionCache(repository, self.revisions)
150
154
        for origin, text in tree.annotate_iter(file_id):
151
155
            rev_id = origin
155
159
            else:
156
160
                try:
157
161
                    revision = revision_cache.get_revision(rev_id)
158
 
                    revno = self.dotted.get(rev_id, 'merge')
 
162
                    revno = dotted.get(rev_id, 'merge')
159
163
                    if len(revno) > 15:
160
164
                        revno = 'merge'
161
165
                except NoSuchRevision:
178
182
 
179
183
    def _activate_selected_revision(self, w):
180
184
        rev_id = self._selected_revision()
181
 
        if not rev_id or rev_id == NULL_REVISION:
 
185
        if rev_id is None:
182
186
            return
183
187
        selected = self.revisions[rev_id]
184
 
        self.revisionview.set_revision(selected)
 
188
        self.logview.set_revision(selected)
185
189
        if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
186
190
            self._no_back):
187
191
            enable_back = True
190
194
        self.back_button.set_sensitive(enable_back)
191
195
 
192
196
    def _create(self):
193
 
        self.revisionview = self._create_log_view()
 
197
        self.logview = self._create_log_view()
194
198
        self.annoview = self._create_annotate_view()
195
199
 
196
200
        vbox = gtk.VBox(False)
212
216
        hbox.pack_start(self.back_button, expand=False, fill=True)
213
217
        self.forward_button = self._create_forward_button()
214
218
        hbox.pack_start(self.forward_button, expand=False, fill=True)
215
 
        self.find_button = self._create_find_button()
216
 
        hbox.pack_start(self.find_button, expand=False, fill=True)
217
 
        self.goto_button = self._create_goto_button()
218
 
        hbox.pack_start(self.goto_button, expand=False, fill=True)
219
219
        hbox.show()
220
220
        vbox.pack_start(hbox, expand=False, fill=True)
221
221
        
222
222
        self.pane = pane = gtk.VPaned()
223
223
        pane.add1(swbox)
224
 
        pane.add2(self.revisionview)
 
224
        pane.add2(self.logview)
225
225
        pane.show()
226
226
        vbox.pack_start(pane, expand=True, fill=True)
227
227
 
238
238
 
239
239
        self.add(vbox)
240
240
 
241
 
    def _search_by_text(self, *ignored): # (accel_group, window, key, modifiers):
 
241
    def _search_by_text(self, accel_group, window, key, modifiers):
242
242
        self._search.show_for('text')
243
243
        self._search.set_target(self.annoview, TEXT_LINE_COL)
244
244
 
245
 
    def _search_by_line(self, *ignored): # accel_group, window, key, modifiers):
 
245
    def _search_by_line(self, accel_group, window, key, modifiers):
246
246
        self._search.show_for('line')
247
247
        self._search.set_target(self.annoview, LINE_NUM_COL)
248
248
 
249
 
    def line_diff(self, tv, path, tvc):
 
249
    def row_diff(self, tv, path, tvc):
250
250
        row = path[0]
251
251
        revision = self.annotations[row]
252
252
        repository = self.branch.repository
261
261
                tree2 = repository.revision_tree(NULL_REVISION)
262
262
        from bzrlib.plugins.gtk.diff import DiffWindow
263
263
        window = DiffWindow()
264
 
        window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
 
264
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
265
265
        window.set_file(tree1.id2path(self.file_id))
266
266
        window.show()
267
267
 
271
271
        tv.set_rules_hint(False)
272
272
        tv.connect("cursor-changed", self._activate_selected_revision)
273
273
        tv.show()
274
 
        tv.connect("row-activated", self.line_diff)
 
274
        tv.connect("row-activated", self.row_diff)
275
275
 
276
276
        cell = gtk.CellRendererText()
277
277
        cell.set_property("xalign", 1.0)
325
325
        return tv
326
326
 
327
327
    def _create_log_view(self):
328
 
        lv = RevisionView(self._branch)
 
328
        lv = LogView()
329
329
        lv.show()
330
330
        return lv
331
331
 
348
348
        button.set_sensitive(False)
349
349
        return button
350
350
 
351
 
    def _create_find_button(self):
352
 
        button = gtk.Button()
353
 
        button.set_use_stock(True)
354
 
        button.set_label("gtk-find")
355
 
        button.set_tooltip_text("Search for text (Ctrl+F)")
356
 
        button.connect("clicked", self._search_by_text)
357
 
        button.set_relief(gtk.RELIEF_NONE)
358
 
        button.show()
359
 
        button.set_sensitive(True)
360
 
        return button
361
 
 
362
 
    def _create_goto_button(self):
363
 
        button = gtk.Button()
364
 
        button.set_label("Goto Line")
365
 
        button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
366
 
        button.connect("clicked", self._search_by_line)
367
 
        button.set_relief(gtk.RELIEF_NONE)
368
 
        button.show()
369
 
        button.set_sensitive(True)
370
 
        return button
371
 
 
372
351
    def go_back(self):
373
352
        last_tree = self.tree
374
353
        rev_id = self._selected_revision()
414
393
                return j - i
415
394
 
416
395
 
417
 
class FakeRevision(object):
 
396
 
 
397
class FakeRevision:
418
398
    """ A fake revision.
419
399
 
420
400
    For when a revision is referenced but not present.
429
409
        self.timezone = 0
430
410
        self.properties = {}
431
411
 
432
 
    def get_apparent_authors(self):
433
 
        return [self.committer]
434
 
 
435
412
 
436
413
class RevisionCache(object):
437
414
    """A caching revision source"""
438
 
 
439
415
    def __init__(self, real_source, seed_cache=None):
440
416
        self.__real_source = real_source
441
417
        if seed_cache is None: