/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: Jelmer Vernooij
  • Date: 2012-03-29 13:15:14 UTC
  • mfrom: (786.1.1 register-lazy)
  • Revision ID: jelmer@samba.org-20120329131514-knrl1w2wzntx89rv
Use lazy registration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
17
17
import time
18
18
 
19
19
from gi.repository import GObject
 
20
from gi.repository import Gdk
20
21
from gi.repository import Gtk
21
22
from gi.repository import Pango
22
23
import re
26
27
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
27
28
 
28
29
from bzrlib.plugins.gtk.annotate.colormap import AnnotateColorSaturation
 
30
from bzrlib.plugins.gtk.i18n import _i18n
29
31
from bzrlib.plugins.gtk.revisionview import RevisionView
30
32
from bzrlib.plugins.gtk.window import Window
31
33
 
48
50
        self.plain = plain
49
51
        self._branch = branch
50
52
 
51
 
        Window.__init__(self, parent)
 
53
        super(GAnnotateWindow, self).__init__(parent=parent)
52
54
 
53
 
        self.set_icon(self.render_icon(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
 
55
        self.set_icon(
 
56
            self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
54
57
        self.annotate_colormap = AnnotateColorSaturation()
55
58
 
56
59
        self._create()
127
130
        else:
128
131
            row = lineno - 1
129
132
 
130
 
        self.annoview.set_cursor(row)
131
 
        self.annoview.scroll_to_cell(row, use_align=True)
132
 
 
 
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)
133
136
 
134
137
    def _annotate(self, tree, file_id):
135
138
        current_revision = FakeRevision(CURRENT_REVISION)
165
168
    def _highlight_annotation(self, model, path, iter, now):
166
169
        revision_id, = model.get(iter, REVISION_ID_COL)
167
170
        revision = self.revisions[revision_id]
168
 
        model.set(iter, HIGHLIGHT_COLOR_COL,
169
 
                  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)
170
174
 
171
175
    def _selected_revision(self):
172
176
        (path, col) = self.annoview.get_cursor()
191
195
        self.revisionview = self._create_log_view()
192
196
        self.annoview = self._create_annotate_view()
193
197
 
194
 
        vbox = Gtk.VBox(False)
 
198
        vbox = Gtk.VBox(homogeneous=False, spacing=0)
195
199
        vbox.show()
196
200
 
197
201
        sw = Gtk.ScrolledWindow()
205
209
        swbox.pack_start(sw, True, True, 0)
206
210
        swbox.show()
207
211
 
208
 
        hbox = Gtk.HBox(False, 6)
 
212
        hbox = Gtk.HBox(homogeneous=False, spacing=6)
209
213
        self.back_button = self._create_back_button()
210
 
        hbox.pack_start(self.back_button, expand=False, fill=True)
 
214
        hbox.pack_start(self.back_button, False, True, 0)
211
215
        self.forward_button = self._create_forward_button()
212
 
        hbox.pack_start(self.forward_button, expand=False, fill=True)
 
216
        hbox.pack_start(self.forward_button, False, True, 0)
213
217
        self.find_button = self._create_find_button()
214
 
        hbox.pack_start(self.find_button, expand=False, fill=True)
 
218
        hbox.pack_start(self.find_button, False, True, 0)
215
219
        self.goto_button = self._create_goto_button()
216
 
        hbox.pack_start(self.goto_button, expand=False, fill=True)
 
220
        hbox.pack_start(self.goto_button, False, True, 0)
217
221
        hbox.show()
218
 
        vbox.pack_start(hbox, expand=False, fill=True)
 
222
        vbox.pack_start(hbox, False, True, 0)
219
223
 
220
 
        self.pane = pane = Gtk.VPaned()
 
224
        self.pane = pane = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
221
225
        pane.add1(swbox)
222
226
        pane.add2(self.revisionview)
223
227
        pane.show()
224
 
        vbox.pack_start(pane, expand=True, fill=True)
 
228
        vbox.pack_start(pane, True, True, 0)
225
229
 
226
230
        self._search = SearchBox()
227
 
        swbox.pack_start(self._search, expand=False, fill=True)
 
231
        swbox.pack_start(self._search, False, True, 0)
228
232
        accels = Gtk.AccelGroup()
229
 
        accels.connect_group(Gdk.KEY_f, Gdk.EventMask.CONTROL_MASK,
230
 
                             Gtk.ACCEL_LOCKED,
 
233
        accels.connect(Gdk.KEY_f, Gdk.ModifierType.CONTROL_MASK,
 
234
                             Gtk.AccelFlags.LOCKED,
231
235
                             self._search_by_text)
232
 
        accels.connect_group(Gdk.KEY_g, Gdk.EventMask.CONTROL_MASK,
233
 
                             Gtk.ACCEL_LOCKED,
 
236
        accels.connect(Gdk.KEY_g, Gdk.ModifierType.CONTROL_MASK,
 
237
                             Gtk.AccelFlags.LOCKED,
234
238
                             self._search_by_line)
235
239
        self.add_accel_group(accels)
236
240
 
245
249
        self._search.set_target(self.annoview, LINE_NUM_COL)
246
250
 
247
251
    def line_diff(self, tv, path, tvc):
248
 
        row = path[0]
 
252
        row = path.get_indices()[0]
249
253
        revision = self.annotations[row]
250
254
        repository = self.branch.repository
251
255
        if revision.revision_id == CURRENT_REVISION:
279
283
                          tv.get_style().bg[Gtk.StateType.NORMAL])
280
284
        col = Gtk.TreeViewColumn()
281
285
        col.set_resizable(False)
282
 
        col.pack_start(cell, True, True, 0)
 
286
        col.pack_start(cell, True)
283
287
        col.add_attribute(cell, "text", LINE_NUM_COL)
284
288
        tv.append_column(col)
285
289
 
290
294
                          self.get_style().bg[Gtk.StateType.NORMAL])
291
295
        col = Gtk.TreeViewColumn("Committer")
292
296
        col.set_resizable(True)
293
 
        col.pack_start(cell, True, True, 0)
 
297
        col.pack_start(cell, True)
294
298
        col.add_attribute(cell, "text", COMMITTER_COL)
295
299
        tv.append_column(col)
296
300
 
301
305
                          self.get_style().bg[Gtk.StateType.NORMAL])
302
306
        col = Gtk.TreeViewColumn("Revno")
303
307
        col.set_resizable(False)
304
 
        col.pack_start(cell, True, True, 0)
 
308
        col.pack_start(cell, True)
305
309
        col.add_attribute(cell, "markup", REVNO_COL)
306
310
        tv.append_column(col)
307
311
 
310
314
        cell.set_property("family", "Monospace")
311
315
        col = Gtk.TreeViewColumn()
312
316
        col.set_resizable(False)
313
 
        col.pack_start(cell, True, True, 0)
 
317
        col.pack_start(cell, True)
314
318
#        col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
315
319
        col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
316
320
        col.add_attribute(cell, "text", TEXT_LINE_COL)
321
325
            return model.get_value(iter, TEXT_LINE_COL).lower().find(key.lower()) == -1
322
326
 
323
327
        tv.set_enable_search(True)
324
 
        tv.set_search_equal_func(search_equal_func)
 
328
        tv.set_search_equal_func(search_equal_func, None)
325
329
 
326
330
        return tv
327
331
 
394
398
        rev_id = self._selected_revision()
395
399
        if self.file_id in target_tree:
396
400
            offset = self.get_scroll_offset(target_tree)
397
 
            (row,), col = self.annoview.get_cursor()
 
401
            path, col = self.annoview.get_cursor()
 
402
            (row,) = path.get_indices()
398
403
            self.annotate(target_tree, self.branch, self.file_id)
399
404
            new_row = row+offset
400
405
            if new_row < 0:
401
406
                new_row = 0
402
 
            self.annoview.set_cursor(new_row)
 
407
            new_path = Gtk.TreePath(path=new_row)
 
408
            self.annoview.set_cursor(new_path, None, False)
403
409
            return True
404
410
        else:
405
411
            return False
407
413
    def get_scroll_offset(self, tree):
408
414
        old = self.tree.get_file(self.file_id)
409
415
        new = tree.get_file(self.file_id)
410
 
        (row,), col = self.annoview.get_cursor()
 
416
        path, col = self.annoview.get_cursor()
 
417
        (row,) = path.get_indices()
411
418
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
412
419
                                                       new.readlines())
413
420
        for i, j, n in matcher.get_matching_blocks():
450
457
            self.__cache[revision_id] = revision
451
458
        return self.__cache[revision_id]
452
459
 
 
460
 
453
461
class SearchBox(Gtk.HBox):
454
462
    """A button box for searching in text or lines of annotations"""
455
463
    def __init__(self):
456
 
        GObject.GObject.__init__(self, False, 6)
 
464
        super(SearchBox, self).__init__(homogeneous=False, spacing=6)
457
465
 
458
466
        # Close button
459
467
        button = Gtk.Button()
461
469
        image.set_from_stock('gtk-stop', Gtk.IconSize.BUTTON)
462
470
        button.set_image(image)
463
471
        button.set_relief(Gtk.ReliefStyle.NONE)
464
 
        button.connect("clicked", lambda w: self.hide_all())
465
 
        self.pack_start(button, expand=False, fill=False)
 
472
        button.connect("clicked", lambda w: self.hide())
 
473
        self.pack_start(button, False, False, 0)
466
474
 
467
475
        # Search entry
468
476
        label = Gtk.Label()
469
477
        self._label = label
470
 
        self.pack_start(label, expand=False, fill=False)
 
478
        self.pack_start(label, False, False, 0)
471
479
 
472
480
        entry = Gtk.Entry()
473
481
        self._entry = entry
474
482
        entry.connect("activate", lambda w, d: self._do_search(d),
475
483
                      'forward')
476
 
        self.pack_start(entry, expand=False, fill=False)
 
484
        self.pack_start(entry, False, False, 0)
477
485
 
478
486
        # Next/previous buttons
479
 
        button = Gtk.Button('_Next')
 
487
        button = Gtk.Button(_i18n('_Next'), use_underline=True)
480
488
        image = Gtk.Image()
481
489
        image.set_from_stock('gtk-go-forward', Gtk.IconSize.BUTTON)
482
490
        button.set_image(image)
483
491
        button.connect("clicked", lambda w, d: self._do_search(d),
484
492
                       'forward')
485
 
        self.pack_start(button, expand=False, fill=False)
 
493
        self.pack_start(button, False, False, 0)
486
494
 
487
 
        button = Gtk.Button('_Previous')
 
495
        button = Gtk.Button(_i18n('_Previous'), use_underline=True)
488
496
        image = Gtk.Image()
489
497
        image.set_from_stock('gtk-go-back', Gtk.IconSize.BUTTON)
490
498
        button.set_image(image)
491
499
        button.connect("clicked", lambda w, d: self._do_search(d),
492
500
                       'backward')
493
 
        self.pack_start(button, expand=False, fill=False)
 
501
        self.pack_start(button, False, False, 0)
494
502
 
495
503
        # Search options
496
504
        check = Gtk.CheckButton('Match case')
497
505
        self._match_case = check
498
 
        self.pack_start(check, expand=False, fill=False)
 
506
        self.pack_start(check, False, False, 0)
499
507
 
500
508
        check = Gtk.CheckButton('Regexp')
501
509
        check.connect("toggled", lambda w: self._set_label())
502
510
        self._regexp = check
503
 
        self.pack_start(check, expand=False, fill=False)
 
511
        self.pack_start(check, False, False, 0)
504
512
 
505
513
        self._view = None
506
514
        self._column = None
586
594
        for row in iterate(model, start):
587
595
            if self._match(model, row, self._column):
588
596
                path = model.get_path(row)
589
 
                self._view.set_cursor(path)
 
597
                self._view.set_cursor(path, None, False)
590
598
                self._view.scroll_to_cell(path, use_align=True)
591
599
                break