/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-07-31 15:52:43 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110731155243-ln8istmxbryhb4pz
Mechanical changes made by pygi.convert.sh.

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