/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: 2011-11-30 21:45:54 UTC
  • Revision ID: jelmer@samba.org-20111130214554-5kfx0b5y7t5zh033
Extend branch preferences, show location widget.

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