def __init__(self, all=False, plain=False, parent=None, branch=None):
self.all = all
self.plain = plain
self._branch = branch
super(GAnnotateWindow, self).__init__(parent=parent)
self.set_icon(
self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
self.annotate_colormap = AnnotateColorSaturation()
self._create()
self.revisions = {}
self.history = []
self._no_back = set()
class GAnnotateWindow(Window):
"""Annotate window."""
def __init__(self, all=False, plain=False, parent=None, branch=None):
self.all = all
self.plain = plain
self._branch = branch
super(GAnnotateWindow, self).__init__(parent=parent)
self.set_icon(
self.render_icon_pixbuf(Gtk.STOCK_FIND, Gtk.IconSize.BUTTON))
self.annotate_colormap = AnnotateColorSaturation()
self._create()
self.revisions = {}
self.history = []
self._no_back = set()
def annotate(self, tree, branch, file_id):
self.annotations = []
self.branch = branch
self.tree = tree
self.file_id = file_id
self.revisionview.set_file_id(file_id)
self.revision_id = getattr(tree, 'get_revision_id',
lambda: CURRENT_REVISION)()
# [revision id, line number, author, revno, highlight color, line]
self.annomodel = Gtk.ListStore(GObject.TYPE_STRING,
GObject.TYPE_INT,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING)
last_seen = None
try:
branch.lock_read()
branch.repository.lock_read()
self.dotted = {}
revno_map = self.branch.get_revision_id_to_revno_map()
for revision_id, revno in revno_map.iteritems():
self.dotted[revision_id] = '.'.join(str(num) for num in revno)
for line_no, (revision, revno, line)\
in enumerate(self._annotate(tree, file_id)):
if revision.revision_id == last_seen and not self.all:
revno = author = ""
else:
last_seen = revision.revision_id
author = ", ".join(revision.get_apparent_authors())
if revision.revision_id not in self.revisions:
self.revisions[revision.revision_id] = revision
self.annomodel.append([revision.revision_id,
line_no + 1,
author,
revno,
None,
line.rstrip("\r\n")
])
self.annotations.append(revision)
if not self.plain:
now = time.time()
self.annomodel.foreach(self._highlight_annotation, now)
finally:
branch.repository.unlock()
branch.unlock()
self.annoview.set_model(self.annomodel)
self.annoview.grab_focus()
my_revno = self.dotted.get(self.revision_id, 'current')
title = '%s (%s) - gannotate' % (self.tree.id2path(file_id), my_revno)
self.set_title(title)
def jump_to_line(self, lineno):
if lineno > len(self.annomodel) or lineno < 1:
row = 0
# FIXME:should really deal with this in the gui. Perhaps a status
# bar?
print("gannotate: Line number %d does't exist. Defaulting to "
"line 1." % lineno)
return
else:
row = lineno - 1
tree_path = Gtk.TreePath(path=row)
self.annoview.set_cursor(tree_path, None, False)
self.annoview.scroll_to_cell(tree_path, use_align=True)
def _annotate(self, tree, file_id):
current_revision = FakeRevision(CURRENT_REVISION)
current_revision.committer = self.branch.get_config().username()
current_revision.timestamp = time.time()
current_revision.message = '[Not yet committed]'
current_revision.parent_ids = tree.get_parent_ids()
current_revision.properties['branch-nick'] = self.branch._get_nick(local=True)
current_revno = '%d?' % (self.branch.revno() + 1)
repository = self.branch.repository
if self.revision_id == CURRENT_REVISION:
revision_id = self.branch.last_revision()
else:
revision_id = self.revision_id
revision_cache = RevisionCache(repository, self.revisions)
for origin, text in tree.annotate_iter(file_id):
rev_id = origin
if rev_id == CURRENT_REVISION:
revision = current_revision
revno = current_revno
else:
try:
revision = revision_cache.get_revision(rev_id)
revno = self.dotted.get(rev_id, 'merge')
if len(revno) > 15:
revno = 'merge'
except NoSuchRevision:
revision = FakeRevision(rev_id)
revno = "?"
yield revision, revno, text
def _highlight_annotation(self, model, path, iter, now):
revision_id, = model.get(iter, REVISION_ID_COL)
revision = self.revisions[revision_id]
# XXX sinzui 2011-08-12: What does get_color return?
color = self.annotate_colormap.get_color(revision, now)
model.set_value(iter, HIGHLIGHT_COLOR_COL, color)
def _selected_revision(self):
(path, col) = self.annoview.get_cursor()
if path is None:
return None
return self.annomodel[path][REVISION_ID_COL]
def _activate_selected_revision(self, w):
rev_id = self._selected_revision()
if not rev_id or rev_id == NULL_REVISION:
return
selected = self.revisions[rev_id]
self.revisionview.set_revision(selected)
if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
self._no_back):
enable_back = True
else:
enable_back = False
self.back_button.set_sensitive(enable_back)
def _create(self):
self.revisionview = self._create_log_view()
self.annoview = self._create_annotate_view()
vbox = Gtk.VBox(homogeneous=False, spacing=0)
vbox.show()
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
sw.add(self.annoview)
self.annoview.gwindow = self
sw.show()
swbox = Gtk.VBox()
swbox.pack_start(sw, True, True, 0)
swbox.show()
hbox = Gtk.HBox(homogeneous=False, spacing=6)
self.back_button = self._create_back_button()
hbox.pack_start(self.back_button, False, True, 0)
self.forward_button = self._create_forward_button()
hbox.pack_start(self.forward_button, False, True, 0)
self.find_button = self._create_find_button()
hbox.pack_start(self.find_button, False, True, 0)
self.goto_button = self._create_goto_button()
hbox.pack_start(self.goto_button, False, True, 0)
hbox.show()
vbox.pack_start(hbox, False, True, 0)
self.pane = pane = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
pane.add1(swbox)
pane.add2(self.revisionview)
pane.show()
vbox.pack_start(pane, True, True, 0)
self._search = SearchBox()
swbox.pack_start(self._search, False, True, 0)
accels = Gtk.AccelGroup()
accels.connect(Gdk.KEY_f, Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.LOCKED,
self._search_by_text)
accels.connect(Gdk.KEY_g, Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.LOCKED,
self._search_by_line)
self.add_accel_group(accels)
self.add(vbox)
def _search_by_text(self, *ignored): # (accel_group, window, key, modifiers):
self._search.show_for('text')
self._search.set_target(self.annoview, TEXT_LINE_COL)
def _search_by_line(self, *ignored): # accel_group, window, key, modifiers):
self._search.show_for('line')
self._search.set_target(self.annoview, LINE_NUM_COL)
def line_diff(self, tv, path, tvc):
row = path.get_indices()[0]
revision = self.annotations[row]
repository = self.branch.repository
if revision.revision_id == CURRENT_REVISION:
tree1 = self.tree
tree2 = self.tree.basis_tree()
else:
tree1 = repository.revision_tree(revision.revision_id)
if len(revision.parent_ids) > 0:
tree2 = repository.revision_tree(revision.parent_ids[0])
else:
tree2 = repository.revision_tree(NULL_REVISION)
from bzrlib.plugins.gtk.diff import DiffWindow
window = DiffWindow(self)
window.set_diff("Diff for line %d" % (row+1), tree1, tree2)
window.set_file(tree1.id2path(self.file_id))
window.show()
def _create_annotate_view(self):
tv = Gtk.TreeView()
tv.set_rules_hint(False)
tv.connect("cursor-changed", self._activate_selected_revision)
tv.show()
tv.connect("row-activated", self.line_diff)
cell = Gtk.CellRendererText()
cell.set_property("xalign", 1.0)
cell.set_property("ypad", 0)
cell.set_property("family", "Monospace")
cell.set_property(
"cell-background-rgba",
tv.get_style_context().get_background_color(Gtk.StateType.NORMAL))
col = Gtk.TreeViewColumn()
col.set_resizable(False)
col.pack_start(cell, True)
col.add_attribute(cell, "text", LINE_NUM_COL)
tv.append_column(col)
style_context = self.get_style_context()
cell = Gtk.CellRendererText()
cell.set_property("ypad", 0)
cell.set_property("ellipsize", Pango.EllipsizeMode.END)
cell.set_property(
"cell-background-rgba",
style_context.get_background_color(Gtk.StateType.NORMAL))
col = Gtk.TreeViewColumn("Committer")
col.set_resizable(True)
col.pack_start(cell, True)
col.add_attribute(cell, "text", COMMITTER_COL)
tv.append_column(col)
cell = Gtk.CellRendererText()
cell.set_property("xalign", 1.0)
cell.set_property("ypad", 0)
cell.set_property(
"cell-background-rgba",
style_context.get_background_color(Gtk.StateType.NORMAL))
col = Gtk.TreeViewColumn("Revno")
col.set_resizable(False)
col.pack_start(cell, True)
col.add_attribute(cell, "markup", REVNO_COL)
tv.append_column(col)
cell = Gtk.CellRendererText()
cell.set_property("ypad", 0)
cell.set_property("family", "Monospace")
col = Gtk.TreeViewColumn()
col.set_resizable(False)
col.pack_start(cell, True)
# col.add_attribute(cell, "foreground", HIGHLIGHT_COLOR_COL)
col.add_attribute(cell, "background", HIGHLIGHT_COLOR_COL)
col.add_attribute(cell, "text", TEXT_LINE_COL)
tv.append_column(col)
# interactive substring search
def search_equal_func(model, column, key, iter):
return model.get_value(iter, TEXT_LINE_COL).lower().find(key.lower()) == -1
tv.set_enable_search(True)
tv.set_search_equal_func(search_equal_func, None)
return tv
def _create_log_view(self):
lv = RevisionView(self._branch)
lv.show()
return lv
def _create_back_button(self):
button = Gtk.Button()
button.set_use_stock(True)
button.set_label("gtk-go-back")
button.connect("clicked", lambda w: self.go_back())
button.set_relief(Gtk.ReliefStyle.NONE)
button.show()
return button
def _create_forward_button(self):
button = Gtk.Button()
button.set_use_stock(True)
button.set_label("gtk-go-forward")
button.connect("clicked", lambda w: self.go_forward())
button.set_relief(Gtk.ReliefStyle.NONE)
button.show()
button.set_sensitive(False)
return button
def _create_find_button(self):
button = Gtk.Button()
button.set_use_stock(True)
button.set_label("gtk-find")
button.set_tooltip_text("Search for text (Ctrl+F)")
button.connect("clicked", self._search_by_text)
button.set_relief(Gtk.ReliefStyle.NONE)
button.show()
button.set_sensitive(True)
return button
def _create_goto_button(self):
button = Gtk.Button()
button.set_label("Goto Line")
button.set_tooltip_text("Scroll to a line by entering its number (Ctrl+G)")
button.connect("clicked", self._search_by_line)
button.set_relief(Gtk.ReliefStyle.NONE)
button.show()
button.set_sensitive(True)
return button
def go_back(self):
last_tree = self.tree
rev_id = self._selected_revision()
parent_id = self.revisions[rev_id].parent_ids[0]
target_tree = self.branch.repository.revision_tree(parent_id)
if self._go(target_tree):
self.history.append(last_tree)
self.forward_button.set_sensitive(True)
else:
self._no_back.add(parent_id)
self.back_button.set_sensitive(False)
def go_forward(self):
if len(self.history) == 0:
return
target_tree = self.history.pop()
if len(self.history) == 0:
self.forward_button.set_sensitive(False)
self._go(target_tree)
def _go(self, target_tree):
rev_id = self._selected_revision()
if self.file_id in target_tree:
offset = self.get_scroll_offset(target_tree)
path, col = self.annoview.get_cursor()
(row,) = path.get_indices()
self.annotate(target_tree, self.branch, self.file_id)
new_row = row+offset
if new_row < 0:
new_row = 0
new_path = Gtk.TreePath(path=new_row)
self.annoview.set_cursor(new_path, None, False)
return True
else:
return False
def get_scroll_offset(self, tree):
old = self.tree.get_file(self.file_id)
new = tree.get_file(self.file_id)
path, col = self.annoview.get_cursor()
(row,) = path.get_indices()
matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
new.readlines())
for i, j, n in matcher.get_matching_blocks():
if i + n >= row:
return j - i
