/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

Commit messages never contain config options

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
16
16
 
17
17
import time
18
18
 
19
 
import pygtk
20
 
pygtk.require("2.0")
21
 
import gobject
22
 
import gtk
23
 
import pango
 
19
from gi.repository import GObject
 
20
from gi.repository import Gdk
 
21
from gi.repository import Gtk
 
22
from gi.repository import Pango
24
23
import re
25
24
 
26
25
from bzrlib import patiencediff
28
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
28
 
30
29
from bzrlib.plugins.gtk.annotate.colormap import AnnotateColorSaturation
 
30
from bzrlib.plugins.gtk.i18n import _i18n
31
31
from bzrlib.plugins.gtk.revisionview import RevisionView
32
32
from bzrlib.plugins.gtk.window import Window
33
33
 
50
50
        self.plain = plain
51
51
        self._branch = branch
52
52
 
53
 
        Window.__init__(self, parent)
 
53
        super(GAnnotateWindow, self).__init__(parent=parent)
54
54
 
55
 
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
 
55
        self.set_icon(
 
56
            self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
56
57
        self.annotate_colormap = AnnotateColorSaturation()
57
58
 
58
59
        self._create()
70
71
                                   lambda: CURRENT_REVISION)()
71
72
 
72
73
        # [revision id, line number, author, revno, highlight color, line]
73
 
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
74
 
                                       gobject.TYPE_INT,
75
 
                                       gobject.TYPE_STRING,
76
 
                                       gobject.TYPE_STRING,
77
 
                                       gobject.TYPE_STRING,
78
 
                                       gobject.TYPE_STRING)
 
74
        self.annomodel = Gtk.ListStore(GObject.TYPE_STRING,
 
75
                                       GObject.TYPE_INT,
 
76
                                       GObject.TYPE_STRING,
 
77
                                       GObject.TYPE_STRING,
 
78
                                       GObject.TYPE_STRING,
 
79
                                       GObject.TYPE_STRING)
79
80
 
80
81
        last_seen = None
81
82
        try:
129
130
        else:
130
131
            row = lineno - 1
131
132
 
132
 
        self.annoview.set_cursor(row)
133
 
        self.annoview.scroll_to_cell(row, use_align=True)
134
 
 
 
133
        tree_path = Gtk.TreePath(path=row)
 
134
        self.annoview.set_cursor(tree_path, None, False)
 
135
        self.annoview.scroll_to_cell(tree_path, use_align=True)
135
136
 
136
137
    def _annotate(self, tree, file_id):
137
138
        current_revision = FakeRevision(CURRENT_REVISION)
167
168
    def _highlight_annotation(self, model, path, iter, now):
168
169
        revision_id, = model.get(iter, REVISION_ID_COL)
169
170
        revision = self.revisions[revision_id]
170
 
        model.set(iter, HIGHLIGHT_COLOR_COL,
171
 
                  self.annotate_colormap.get_color(revision, now))
 
171
        # XXX sinzui 2011-08-12: What does get_color return?
 
172
        color = self.annotate_colormap.get_color(revision, now)
 
173
        model.set_value(iter, HIGHLIGHT_COLOR_COL, color)
172
174
 
173
175
    def _selected_revision(self):
174
176
        (path, col) = self.annoview.get_cursor()
193
195
        self.revisionview = self._create_log_view()
194
196
        self.annoview = self._create_annotate_view()
195
197
 
196
 
        vbox = gtk.VBox(False)
 
198
        vbox = Gtk.VBox(homogeneous=False, spacing=0)
197
199
        vbox.show()
198
200
 
199
 
        sw = gtk.ScrolledWindow()
200
 
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
201
 
        sw.set_shadow_type(gtk.SHADOW_IN)
 
201
        sw = Gtk.ScrolledWindow()
 
202
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
203
        sw.set_shadow_type(Gtk.ShadowType.IN)
202
204
        sw.add(self.annoview)
203
205
        self.annoview.gwindow = self
204
206
        sw.show()
205
207
 
206
 
        swbox = gtk.VBox()
207
 
        swbox.pack_start(sw)
 
208
        swbox = Gtk.VBox()
 
209
        swbox.pack_start(sw, True, True, 0)
208
210
        swbox.show()
209
211
 
210
 
        hbox = gtk.HBox(False, 6)
 
212
        hbox = Gtk.HBox(homogeneous=False, spacing=6)
211
213
        self.back_button = self._create_back_button()
212
 
        hbox.pack_start(self.back_button, expand=False, fill=True)
 
214
        hbox.pack_start(self.back_button, False, True, 0)
213
215
        self.forward_button = self._create_forward_button()
214
 
        hbox.pack_start(self.forward_button, expand=False, fill=True)
 
216
        hbox.pack_start(self.forward_button, False, True, 0)
215
217
        self.find_button = self._create_find_button()
216
 
        hbox.pack_start(self.find_button, expand=False, fill=True)
 
218
        hbox.pack_start(self.find_button, False, True, 0)
217
219
        self.goto_button = self._create_goto_button()
218
 
        hbox.pack_start(self.goto_button, expand=False, fill=True)
 
220
        hbox.pack_start(self.goto_button, False, True, 0)
219
221
        hbox.show()
220
 
        vbox.pack_start(hbox, expand=False, fill=True)
 
222
        vbox.pack_start(hbox, False, True, 0)
221
223
 
222
 
        self.pane = pane = gtk.VPaned()
 
224
        self.pane = pane = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
223
225
        pane.add1(swbox)
224
226
        pane.add2(self.revisionview)
225
227
        pane.show()
226
 
        vbox.pack_start(pane, expand=True, fill=True)
 
228
        vbox.pack_start(pane, True, True, 0)
227
229
 
228
230
        self._search = SearchBox()
229
 
        swbox.pack_start(self._search, expand=False, fill=True)
230
 
        accels = gtk.AccelGroup()
231
 
        accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
232
 
                             gtk.ACCEL_LOCKED,
 
231
        swbox.pack_start(self._search, False, True, 0)
 
232
        accels = Gtk.AccelGroup()
 
233
        accels.connect(Gdk.KEY_f, Gdk.ModifierType.CONTROL_MASK,
 
234
                             Gtk.AccelFlags.LOCKED,
233
235
                             self._search_by_text)
234
 
        accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
235
 
                             gtk.ACCEL_LOCKED,
 
236
        accels.connect(Gdk.KEY_g, Gdk.ModifierType.CONTROL_MASK,
 
237
                             Gtk.AccelFlags.LOCKED,
236
238
                             self._search_by_line)
237
239
        self.add_accel_group(accels)
238
240
 
247
249
        self._search.set_target(self.annoview, LINE_NUM_COL)
248
250
 
249
251
    def line_diff(self, tv, path, tvc):
250
 
        row = path[0]
 
252
        row = path.get_indices()[0]
251
253
        revision = self.annotations[row]
252
254
        repository = self.branch.repository
253
255
        if revision.revision_id == CURRENT_REVISION:
267
269
 
268
270
 
269
271
    def _create_annotate_view(self):
270
 
        tv = gtk.TreeView()
 
272
        tv = Gtk.TreeView()
271
273
        tv.set_rules_hint(False)
272
274
        tv.connect("cursor-changed", self._activate_selected_revision)
273
275
        tv.show()
274
276
        tv.connect("row-activated", self.line_diff)
275
277
 
276
 
        cell = gtk.CellRendererText()
 
278
        cell = Gtk.CellRendererText()
277
279
        cell.set_property("xalign", 1.0)
278
280
        cell.set_property("ypad", 0)
279
281
        cell.set_property("family", "Monospace")
280
 
        cell.set_property("cell-background-gdk",
281
 
                          tv.get_style().bg[gtk.STATE_NORMAL])
282
 
        col = gtk.TreeViewColumn()
 
282
        cell.set_property(
 
283
            "cell-background-rgba",
 
284
            tv.get_style_context().get_background_color(Gtk.StateType.NORMAL))
 
285
        col = Gtk.TreeViewColumn()
283
286
        col.set_resizable(False)
284
 
        col.pack_start(cell, expand=True)
 
287
        col.pack_start(cell, True)
285
288
        col.add_attribute(cell, "text", LINE_NUM_COL)
286
289
        tv.append_column(col)
287
290
 
288
 
        cell = gtk.CellRendererText()
 
291
        style_context = self.get_style_context()
 
292
 
 
293
        cell = Gtk.CellRendererText()
289
294
        cell.set_property("ypad", 0)
290
 
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
291
 
        cell.set_property("cell-background-gdk",
292
 
                          self.get_style().bg[gtk.STATE_NORMAL])
293
 
        col = gtk.TreeViewColumn("Committer")
 
295
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
 
296
        cell.set_property(
 
297
            "cell-background-rgba",
 
298
            style_context.get_background_color(Gtk.StateType.NORMAL))
 
299
        col = Gtk.TreeViewColumn("Committer")
294
300
        col.set_resizable(True)
295
 
        col.pack_start(cell, expand=True)
 
301
        col.pack_start(cell, True)
296
302
        col.add_attribute(cell, "text", COMMITTER_COL)
297
303
        tv.append_column(col)
298
304
 
299
 
        cell = gtk.CellRendererText()
 
305
        cell = Gtk.CellRendererText()
300
306
        cell.set_property("xalign", 1.0)
301
307
        cell.set_property("ypad", 0)
302
 
        cell.set_property("cell-background-gdk",
303
 
                          self.get_style().bg[gtk.STATE_NORMAL])
304
 
        col = gtk.TreeViewColumn("Revno")
 
308
        cell.set_property(
 
309
            "cell-background-rgba",
 
310
            style_context.get_background_color(Gtk.StateType.NORMAL))
 
311
        col = Gtk.TreeViewColumn("Revno")
305
312
        col.set_resizable(False)
306
 
        col.pack_start(cell, expand=True)
 
313
        col.pack_start(cell, True)
307
314
        col.add_attribute(cell, "markup", REVNO_COL)
308
315
        tv.append_column(col)
309
316
 
310
 
        cell = gtk.CellRendererText()
 
317
        cell = Gtk.CellRendererText()
311
318
        cell.set_property("ypad", 0)
312
319
        cell.set_property("family", "Monospace")
313
 
        col = gtk.TreeViewColumn()
 
320
        col = Gtk.TreeViewColumn()
314
321
        col.set_resizable(False)
315
 
        col.pack_start(cell, expand=True)
 
322
        col.pack_start(cell, True)
316
323
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
317
324
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
318
325
        col.add_attribute(cell, "text", TEXT_LINE_COL)
323
330
            return model.get_value(iter, TEXT_LINE_COL).lower().find(key.lower()) == -1
324
331
 
325
332
        tv.set_enable_search(True)
326
 
        tv.set_search_equal_func(search_equal_func)
 
333
        tv.set_search_equal_func(search_equal_func, None)
327
334
 
328
335
        return tv
329
336
 
333
340
        return lv
334
341
 
335
342
    def _create_back_button(self):
336
 
        button = gtk.Button()
 
343
        button = Gtk.Button()
337
344
        button.set_use_stock(True)
338
345
        button.set_label("gtk-go-back")
339
346
        button.connect("clicked", lambda w: self.go_back())
340
 
        button.set_relief(gtk.RELIEF_NONE)
 
347
        button.set_relief(Gtk.ReliefStyle.NONE)
341
348
        button.show()
342
349
        return button
343
350
 
344
351
    def _create_forward_button(self):
345
 
        button = gtk.Button()
 
352
        button = Gtk.Button()
346
353
        button.set_use_stock(True)
347
354
        button.set_label("gtk-go-forward")
348
355
        button.connect("clicked", lambda w: self.go_forward())
349
 
        button.set_relief(gtk.RELIEF_NONE)
 
356
        button.set_relief(Gtk.ReliefStyle.NONE)
350
357
        button.show()
351
358
        button.set_sensitive(False)
352
359
        return button
353
360
 
354
361
    def _create_find_button(self):
355
 
        button = gtk.Button()
 
362
        button = Gtk.Button()
356
363
        button.set_use_stock(True)
357
364
        button.set_label("gtk-find")
358
365
        button.set_tooltip_text("Search for text (Ctrl+F)")
359
366
        button.connect("clicked", self._search_by_text)
360
 
        button.set_relief(gtk.RELIEF_NONE)
 
367
        button.set_relief(Gtk.ReliefStyle.NONE)
361
368
        button.show()
362
369
        button.set_sensitive(True)
363
370
        return button
364
371
 
365
372
    def _create_goto_button(self):
366
 
        button = gtk.Button()
 
373
        button = Gtk.Button()
367
374
        button.set_label("Goto Line")
368
375
        button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
369
376
        button.connect("clicked", self._search_by_line)
370
 
        button.set_relief(gtk.RELIEF_NONE)
 
377
        button.set_relief(Gtk.ReliefStyle.NONE)
371
378
        button.show()
372
379
        button.set_sensitive(True)
373
380
        return button
396
403
        rev_id = self._selected_revision()
397
404
        if self.file_id in target_tree:
398
405
            offset = self.get_scroll_offset(target_tree)
399
 
            (row,), col = self.annoview.get_cursor()
 
406
            path, col = self.annoview.get_cursor()
 
407
            (row,) = path.get_indices()
400
408
            self.annotate(target_tree, self.branch, self.file_id)
401
409
            new_row = row+offset
402
410
            if new_row < 0:
403
411
                new_row = 0
404
 
            self.annoview.set_cursor(new_row)
 
412
            new_path = Gtk.TreePath(path=new_row)
 
413
            self.annoview.set_cursor(new_path, None, False)
405
414
            return True
406
415
        else:
407
416
            return False
409
418
    def get_scroll_offset(self, tree):
410
419
        old = self.tree.get_file(self.file_id)
411
420
        new = tree.get_file(self.file_id)
412
 
        (row,), col = self.annoview.get_cursor()
 
421
        path, col = self.annoview.get_cursor()
 
422
        (row,) = path.get_indices()
413
423
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
414
424
                                                       new.readlines())
415
425
        for i, j, n in matcher.get_matching_blocks():
452
462
            self.__cache[revision_id] = revision
453
463
        return self.__cache[revision_id]
454
464
 
455
 
class SearchBox(gtk.HBox):
 
465
 
 
466
class SearchBox(Gtk.HBox):
456
467
    """A button box for searching in text or lines of annotations"""
457
468
    def __init__(self):
458
 
        gtk.HBox.__init__(self, False, 6)
 
469
        super(SearchBox, self).__init__(homogeneous=False, spacing=6)
459
470
 
460
471
        # Close button
461
 
        button = gtk.Button()
462
 
        image = gtk.Image()
463
 
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
 
472
        button = Gtk.Button()
 
473
        image = Gtk.Image()
 
474
        image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
464
475
        button.set_image(image)
465
 
        button.set_relief(gtk.RELIEF_NONE)
466
 
        button.connect("clicked", lambda w: self.hide_all())
467
 
        self.pack_start(button, expand=False, fill=False)
 
476
        button.set_relief(Gtk.ReliefStyle.NONE)
 
477
        button.connect("clicked", lambda w: self.hide())
 
478
        self.pack_start(button, False, False, 0)
468
479
 
469
480
        # Search entry
470
 
        label = gtk.Label()
 
481
        label = Gtk.Label()
471
482
        self._label = label
472
 
        self.pack_start(label, expand=False, fill=False)
 
483
        self.pack_start(label, False, False, 0)
473
484
 
474
 
        entry = gtk.Entry()
 
485
        entry = Gtk.Entry()
475
486
        self._entry = entry
476
487
        entry.connect("activate", lambda w, d: self._do_search(d),
477
488
                      'forward')
478
 
        self.pack_start(entry, expand=False, fill=False)
 
489
        self.pack_start(entry, False, False, 0)
479
490
 
480
491
        # Next/previous buttons
481
 
        button = gtk.Button('_Next')
482
 
        image = gtk.Image()
483
 
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
 
492
        button = Gtk.Button(_i18n('_Next'), use_underline=True)
 
493
        image = Gtk.Image()
 
494
        image.set_from_stock('gtk-go-forward', Gtk.IconSize.BUTTON)
484
495
        button.set_image(image)
485
496
        button.connect("clicked", lambda w, d: self._do_search(d),
486
497
                       'forward')
487
 
        self.pack_start(button, expand=False, fill=False)
 
498
        self.pack_start(button, False, False, 0)
488
499
 
489
 
        button = gtk.Button('_Previous')
490
 
        image = gtk.Image()
491
 
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
 
500
        button = Gtk.Button(_i18n('_Previous'), use_underline=True)
 
501
        image = Gtk.Image()
 
502
        image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
492
503
        button.set_image(image)
493
504
        button.connect("clicked", lambda w, d: self._do_search(d),
494
505
                       'backward')
495
 
        self.pack_start(button, expand=False, fill=False)
 
506
        self.pack_start(button, False, False, 0)
496
507
 
497
508
        # Search options
498
 
        check = gtk.CheckButton('Match case')
 
509
        check = Gtk.CheckButton('Match case')
499
510
        self._match_case = check
500
 
        self.pack_start(check, expand=False, fill=False)
 
511
        self.pack_start(check, False, False, 0)
501
512
 
502
 
        check = gtk.CheckButton('Regexp')
 
513
        check = Gtk.CheckButton('Regexp')
503
514
        check.connect("toggled", lambda w: self._set_label())
504
515
        self._regexp = check
505
 
        self.pack_start(check, expand=False, fill=False)
 
516
        self.pack_start(check, False, False, 0)
506
517
 
507
518
        self._view = None
508
519
        self._column = None
588
599
        for row in iterate(model, start):
589
600
            if self._match(model, row, self._column):
590
601
                path = model.get_path(row)
591
 
                self._view.set_cursor(path)
 
602
                self._view.set_cursor(path, None, False)
592
603
                self._view.scroll_to_cell(path, use_align=True)
593
604
                break