/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: Curtis Hovey
  • Date: 2011-08-27 18:35:08 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110827183508-ugqbp58na4mtt1no
Updated the pixbuf calls to gtk3.

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
27
26
from bzrlib.errors import NoSuchRevision
28
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
29
28
 
30
 
from colormap import AnnotateColorSaturation
 
29
from bzrlib.plugins.gtk.annotate.colormap import AnnotateColorSaturation
31
30
from bzrlib.plugins.gtk.revisionview import RevisionView
32
31
from bzrlib.plugins.gtk.window import Window
33
32
 
52
51
 
53
52
        Window.__init__(self, parent)
54
53
 
55
 
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
 
54
        self.set_icon(
 
55
            self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
56
56
        self.annotate_colormap = AnnotateColorSaturation()
57
57
 
58
58
        self._create()
70
70
                                   lambda: CURRENT_REVISION)()
71
71
 
72
72
        # [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)
 
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)
79
79
 
80
80
        last_seen = None
81
81
        try:
129
129
        else:
130
130
            row = lineno - 1
131
131
 
132
 
        self.annoview.set_cursor(row)
133
 
        self.annoview.scroll_to_cell(row, use_align=True)
 
132
        tree_path = Gtk.TreePath(path=row)
 
133
        self.annoview.set_cursor(tree_path, None, False)
 
134
        self.annoview.scroll_to_cell(tree_path, use_align=True)
134
135
 
135
136
 
136
137
    def _annotate(self, tree, file_id):
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.VPaned()
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
282
        cell.set_property("cell-background-gdk",
281
 
                          tv.get_style().bg[gtk.STATE_NORMAL])
282
 
        col = gtk.TreeViewColumn()
 
283
                          tv.get_style().bg[Gtk.StateType.NORMAL])
 
284
        col = Gtk.TreeViewColumn()
283
285
        col.set_resizable(False)
284
 
        col.pack_start(cell, expand=True)
 
286
        col.pack_start(cell, True)
285
287
        col.add_attribute(cell, "text", LINE_NUM_COL)
286
288
        tv.append_column(col)
287
289
 
288
 
        cell = gtk.CellRendererText()
 
290
        cell = Gtk.CellRendererText()
289
291
        cell.set_property("ypad", 0)
290
 
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
292
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
291
293
        cell.set_property("cell-background-gdk",
292
 
                          self.get_style().bg[gtk.STATE_NORMAL])
293
 
        col = gtk.TreeViewColumn("Committer")
 
294
                          self.get_style().bg[Gtk.StateType.NORMAL])
 
295
        col = Gtk.TreeViewColumn("Committer")
294
296
        col.set_resizable(True)
295
 
        col.pack_start(cell, expand=True)
 
297
        col.pack_start(cell, True)
296
298
        col.add_attribute(cell, "text", COMMITTER_COL)
297
299
        tv.append_column(col)
298
300
 
299
 
        cell = gtk.CellRendererText()
 
301
        cell = Gtk.CellRendererText()
300
302
        cell.set_property("xalign", 1.0)
301
303
        cell.set_property("ypad", 0)
302
304
        cell.set_property("cell-background-gdk",
303
 
                          self.get_style().bg[gtk.STATE_NORMAL])
304
 
        col = gtk.TreeViewColumn("Revno")
 
305
                          self.get_style().bg[Gtk.StateType.NORMAL])
 
306
        col = Gtk.TreeViewColumn("Revno")
305
307
        col.set_resizable(False)
306
 
        col.pack_start(cell, expand=True)
 
308
        col.pack_start(cell, True)
307
309
        col.add_attribute(cell, "markup", REVNO_COL)
308
310
        tv.append_column(col)
309
311
 
310
 
        cell = gtk.CellRendererText()
 
312
        cell = Gtk.CellRendererText()
311
313
        cell.set_property("ypad", 0)
312
314
        cell.set_property("family", "Monospace")
313
 
        col = gtk.TreeViewColumn()
 
315
        col = Gtk.TreeViewColumn()
314
316
        col.set_resizable(False)
315
 
        col.pack_start(cell, expand=True)
 
317
        col.pack_start(cell, True)
316
318
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
317
319
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
318
320
        col.add_attribute(cell, "text", TEXT_LINE_COL)
319
321
        tv.append_column(col)
320
322
 
321
 
        # FIXME: Now that C-f is now used for search by text we
322
 
        # may as well disable the auto search.
323
 
        tv.set_search_column(LINE_NUM_COL)
 
323
        # interactive substring search
 
324
        def search_equal_func(model, column, key, iter):
 
325
            return model.get_value(iter, TEXT_LINE_COL).lower().find(key.lower()) == -1
 
326
 
 
327
        tv.set_enable_search(True)
 
328
        tv.set_search_equal_func(search_equal_func, None)
324
329
 
325
330
        return tv
326
331
 
330
335
        return lv
331
336
 
332
337
    def _create_back_button(self):
333
 
        button = gtk.Button()
 
338
        button = Gtk.Button()
334
339
        button.set_use_stock(True)
335
340
        button.set_label("gtk-go-back")
336
341
        button.connect("clicked", lambda w: self.go_back())
337
 
        button.set_relief(gtk.RELIEF_NONE)
 
342
        button.set_relief(Gtk.ReliefStyle.NONE)
338
343
        button.show()
339
344
        return button
340
345
 
341
346
    def _create_forward_button(self):
342
 
        button = gtk.Button()
 
347
        button = Gtk.Button()
343
348
        button.set_use_stock(True)
344
349
        button.set_label("gtk-go-forward")
345
350
        button.connect("clicked", lambda w: self.go_forward())
346
 
        button.set_relief(gtk.RELIEF_NONE)
 
351
        button.set_relief(Gtk.ReliefStyle.NONE)
347
352
        button.show()
348
353
        button.set_sensitive(False)
349
354
        return button
350
355
 
351
356
    def _create_find_button(self):
352
 
        button = gtk.Button()
 
357
        button = Gtk.Button()
353
358
        button.set_use_stock(True)
354
359
        button.set_label("gtk-find")
355
360
        button.set_tooltip_text("Search for text (Ctrl+F)")
356
361
        button.connect("clicked", self._search_by_text)
357
 
        button.set_relief(gtk.RELIEF_NONE)
 
362
        button.set_relief(Gtk.ReliefStyle.NONE)
358
363
        button.show()
359
364
        button.set_sensitive(True)
360
365
        return button
361
366
 
362
367
    def _create_goto_button(self):
363
 
        button = gtk.Button()
 
368
        button = Gtk.Button()
364
369
        button.set_label("Goto Line")
365
370
        button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
366
371
        button.connect("clicked", self._search_by_line)
367
 
        button.set_relief(gtk.RELIEF_NONE)
 
372
        button.set_relief(Gtk.ReliefStyle.NONE)
368
373
        button.show()
369
374
        button.set_sensitive(True)
370
375
        return button
393
398
        rev_id = self._selected_revision()
394
399
        if self.file_id in target_tree:
395
400
            offset = self.get_scroll_offset(target_tree)
396
 
            (row,), col = self.annoview.get_cursor()
 
401
            path, col = self.annoview.get_cursor()
 
402
            (row,) = path.get_indices()
397
403
            self.annotate(target_tree, self.branch, self.file_id)
398
404
            new_row = row+offset
399
405
            if new_row < 0:
400
406
                new_row = 0
401
 
            self.annoview.set_cursor(new_row)
 
407
            new_path = Gtk.TreePath(path=new_row)
 
408
            self.annoview.set_cursor(new_path, None, False)
402
409
            return True
403
410
        else:
404
411
            return False
406
413
    def get_scroll_offset(self, tree):
407
414
        old = self.tree.get_file(self.file_id)
408
415
        new = tree.get_file(self.file_id)
409
 
        (row,), col = self.annoview.get_cursor()
 
416
        path, col = self.annoview.get_cursor()
 
417
        (row,) = path.get_indices()
410
418
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
411
419
                                                       new.readlines())
412
420
        for i, j, n in matcher.get_matching_blocks():
449
457
            self.__cache[revision_id] = revision
450
458
        return self.__cache[revision_id]
451
459
 
452
 
class SearchBox(gtk.HBox):
 
460
class SearchBox(Gtk.HBox):
453
461
    """A button box for searching in text or lines of annotations"""
454
462
    def __init__(self):
455
 
        gtk.HBox.__init__(self, False, 6)
 
463
        Gtk.HBox.__init__(self, homogeneous=False, spacing=6)
456
464
 
457
465
        # Close button
458
 
        button = gtk.Button()
459
 
        image = gtk.Image()
460
 
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
 
466
        button = Gtk.Button()
 
467
        image = Gtk.Image()
 
468
        image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
461
469
        button.set_image(image)
462
 
        button.set_relief(gtk.RELIEF_NONE)
463
 
        button.connect("clicked", lambda w: self.hide_all())
464
 
        self.pack_start(button, expand=False, fill=False)
 
470
        button.set_relief(Gtk.ReliefStyle.NONE)
 
471
        button.connect("clicked", lambda w: self.hide())
 
472
        self.pack_start(button, False, False, 0)
465
473
 
466
474
        # Search entry
467
 
        label = gtk.Label()
 
475
        label = Gtk.Label()
468
476
        self._label = label
469
 
        self.pack_start(label, expand=False, fill=False)
 
477
        self.pack_start(label, False, False, 0)
470
478
 
471
 
        entry = gtk.Entry()
 
479
        entry = Gtk.Entry()
472
480
        self._entry = entry
473
481
        entry.connect("activate", lambda w, d: self._do_search(d),
474
482
                      'forward')
475
 
        self.pack_start(entry, expand=False, fill=False)
 
483
        self.pack_start(entry, False, False, 0)
476
484
 
477
485
        # Next/previous buttons
478
 
        button = gtk.Button('_Next')
479
 
        image = gtk.Image()
480
 
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
 
486
        button = Gtk.Button('_Next')
 
487
        image = Gtk.Image()
 
488
        image.set_from_stock('gtk-go-forward', Gtk.IconSize.BUTTON)
481
489
        button.set_image(image)
482
490
        button.connect("clicked", lambda w, d: self._do_search(d),
483
491
                       'forward')
484
 
        self.pack_start(button, expand=False, fill=False)
 
492
        self.pack_start(button, False, False, 0)
485
493
 
486
 
        button = gtk.Button('_Previous')
487
 
        image = gtk.Image()
488
 
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
 
494
        button = Gtk.Button('_Previous')
 
495
        image = Gtk.Image()
 
496
        image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
489
497
        button.set_image(image)
490
498
        button.connect("clicked", lambda w, d: self._do_search(d),
491
499
                       'backward')
492
 
        self.pack_start(button, expand=False, fill=False)
 
500
        self.pack_start(button, False, False, 0)
493
501
 
494
502
        # Search options
495
 
        check = gtk.CheckButton('Match case')
 
503
        check = Gtk.CheckButton('Match case')
496
504
        self._match_case = check
497
 
        self.pack_start(check, expand=False, fill=False)
 
505
        self.pack_start(check, False, False, 0)
498
506
 
499
 
        check = gtk.CheckButton('Regexp')
 
507
        check = Gtk.CheckButton('Regexp')
500
508
        check.connect("toggled", lambda w: self._set_label())
501
509
        self._regexp = check
502
 
        self.pack_start(check, expand=False, fill=False)
 
510
        self.pack_start(check, False, False, 0)
503
511
 
504
512
        self._view = None
505
513
        self._column = None
585
593
        for row in iterate(model, start):
586
594
            if self._match(model, row, self._column):
587
595
                path = model.get_path(row)
588
 
                self._view.set_cursor(path)
 
596
                self._view.set_cursor(path, None, False)
589
597
                self._view.scroll_to_cell(path, use_align=True)
590
598
                break