mirror of
https://github.com/git/git
synced 2024-08-24 18:26:02 +00:00
![Masanari Iida](/assets/img/avatar_default.png)
Signed-off-by: Masanari Iida <standby24x7@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
1306 lines
38 KiB
Python
Executable file
1306 lines
38 KiB
Python
Executable file
#! /usr/bin/env python
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
""" gitview
|
|
GUI browser for git repository
|
|
This program is based on bzrk by Scott James Remnant <scott@ubuntu.com>
|
|
"""
|
|
__copyright__ = "Copyright (C) 2006 Hewlett-Packard Development Company, L.P."
|
|
__copyright__ = "Copyright (C) 2007 Aneesh Kumar K.V <aneesh.kumar@gmail.com"
|
|
__author__ = "Aneesh Kumar K.V <aneesh.kumar@gmail.com>"
|
|
|
|
|
|
import sys
|
|
import os
|
|
import gtk
|
|
import pygtk
|
|
import pango
|
|
import re
|
|
import time
|
|
import gobject
|
|
import cairo
|
|
import math
|
|
import string
|
|
import fcntl
|
|
|
|
have_gtksourceview2 = False
|
|
have_gtksourceview = False
|
|
try:
|
|
import gtksourceview2
|
|
have_gtksourceview2 = True
|
|
except ImportError:
|
|
try:
|
|
import gtksourceview
|
|
have_gtksourceview = True
|
|
except ImportError:
|
|
print "Running without gtksourceview2 or gtksourceview module"
|
|
|
|
re_ident = re.compile('(author|committer) (?P<ident>.*) (?P<epoch>\d+) (?P<tz>[+-]\d{4})')
|
|
|
|
def list_to_string(args, skip):
|
|
count = len(args)
|
|
i = skip
|
|
str_arg=" "
|
|
while (i < count ):
|
|
str_arg = str_arg + args[i]
|
|
str_arg = str_arg + " "
|
|
i = i+1
|
|
|
|
return str_arg
|
|
|
|
def show_date(epoch, tz):
|
|
secs = float(epoch)
|
|
tzsecs = float(tz[1:3]) * 3600
|
|
tzsecs += float(tz[3:5]) * 60
|
|
if (tz[0] == "+"):
|
|
secs += tzsecs
|
|
else:
|
|
secs -= tzsecs
|
|
|
|
return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(secs))
|
|
|
|
def get_source_buffer_and_view():
|
|
if have_gtksourceview2:
|
|
buffer = gtksourceview2.Buffer()
|
|
slm = gtksourceview2.LanguageManager()
|
|
gsl = slm.get_language("diff")
|
|
buffer.set_highlight_syntax(True)
|
|
buffer.set_language(gsl)
|
|
view = gtksourceview2.View(buffer)
|
|
elif have_gtksourceview:
|
|
buffer = gtksourceview.SourceBuffer()
|
|
slm = gtksourceview.SourceLanguagesManager()
|
|
gsl = slm.get_language_from_mime_type("text/x-patch")
|
|
buffer.set_highlight(True)
|
|
buffer.set_language(gsl)
|
|
view = gtksourceview.SourceView(buffer)
|
|
else:
|
|
buffer = gtk.TextBuffer()
|
|
view = gtk.TextView(buffer)
|
|
return (buffer, view)
|
|
|
|
|
|
class CellRendererGraph(gtk.GenericCellRenderer):
|
|
"""Cell renderer for directed graph.
|
|
|
|
This module contains the implementation of a custom GtkCellRenderer that
|
|
draws part of the directed graph based on the lines suggested by the code
|
|
in graph.py.
|
|
|
|
Because we're shiny, we use Cairo to do this, and because we're naughty
|
|
we cheat and draw over the bits of the TreeViewColumn that are supposed to
|
|
just be for the background.
|
|
|
|
Properties:
|
|
node (column, colour, [ names ]) tuple to draw revision node,
|
|
in_lines (start, end, colour) tuple list to draw inward lines,
|
|
out_lines (start, end, colour) tuple list to draw outward lines.
|
|
"""
|
|
|
|
__gproperties__ = {
|
|
"node": ( gobject.TYPE_PYOBJECT, "node",
|
|
"revision node instruction",
|
|
gobject.PARAM_WRITABLE
|
|
),
|
|
"in-lines": ( gobject.TYPE_PYOBJECT, "in-lines",
|
|
"instructions to draw lines into the cell",
|
|
gobject.PARAM_WRITABLE
|
|
),
|
|
"out-lines": ( gobject.TYPE_PYOBJECT, "out-lines",
|
|
"instructions to draw lines out of the cell",
|
|
gobject.PARAM_WRITABLE
|
|
),
|
|
}
|
|
|
|
def do_set_property(self, property, value):
|
|
"""Set properties from GObject properties."""
|
|
if property.name == "node":
|
|
self.node = value
|
|
elif property.name == "in-lines":
|
|
self.in_lines = value
|
|
elif property.name == "out-lines":
|
|
self.out_lines = value
|
|
else:
|
|
raise AttributeError, "no such property: '%s'" % property.name
|
|
|
|
def box_size(self, widget):
|
|
"""Calculate box size based on widget's font.
|
|
|
|
Cache this as it's probably expensive to get. It ensures that we
|
|
draw the graph at least as large as the text.
|
|
"""
|
|
try:
|
|
return self._box_size
|
|
except AttributeError:
|
|
pango_ctx = widget.get_pango_context()
|
|
font_desc = widget.get_style().font_desc
|
|
metrics = pango_ctx.get_metrics(font_desc)
|
|
|
|
ascent = pango.PIXELS(metrics.get_ascent())
|
|
descent = pango.PIXELS(metrics.get_descent())
|
|
|
|
self._box_size = ascent + descent + 6
|
|
return self._box_size
|
|
|
|
def set_colour(self, ctx, colour, bg, fg):
|
|
"""Set the context source colour.
|
|
|
|
Picks a distinct colour based on an internal wheel; the bg
|
|
parameter provides the value that should be assigned to the 'zero'
|
|
colours and the fg parameter provides the multiplier that should be
|
|
applied to the foreground colours.
|
|
"""
|
|
colours = [
|
|
( 1.0, 0.0, 0.0 ),
|
|
( 1.0, 1.0, 0.0 ),
|
|
( 0.0, 1.0, 0.0 ),
|
|
( 0.0, 1.0, 1.0 ),
|
|
( 0.0, 0.0, 1.0 ),
|
|
( 1.0, 0.0, 1.0 ),
|
|
]
|
|
|
|
colour %= len(colours)
|
|
red = (colours[colour][0] * fg) or bg
|
|
green = (colours[colour][1] * fg) or bg
|
|
blue = (colours[colour][2] * fg) or bg
|
|
|
|
ctx.set_source_rgb(red, green, blue)
|
|
|
|
def on_get_size(self, widget, cell_area):
|
|
"""Return the size we need for this cell.
|
|
|
|
Each cell is drawn individually and is only as wide as it needs
|
|
to be, we let the TreeViewColumn take care of making them all
|
|
line up.
|
|
"""
|
|
box_size = self.box_size(widget)
|
|
|
|
cols = self.node[0]
|
|
for start, end, colour in self.in_lines + self.out_lines:
|
|
cols = int(max(cols, start, end))
|
|
|
|
(column, colour, names) = self.node
|
|
names_len = 0
|
|
if (len(names) != 0):
|
|
for item in names:
|
|
names_len += len(item)
|
|
|
|
width = box_size * (cols + 1 ) + names_len
|
|
height = box_size
|
|
|
|
# FIXME I have no idea how to use cell_area properly
|
|
return (0, 0, width, height)
|
|
|
|
def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
|
|
"""Render an individual cell.
|
|
|
|
Draws the cell contents using cairo, taking care to clip what we
|
|
do to within the background area so we don't draw over other cells.
|
|
Note that we're a bit naughty there and should really be drawing
|
|
in the cell_area (or even the exposed area), but we explicitly don't
|
|
want any gutter.
|
|
|
|
We try and be a little clever, if the line we need to draw is going
|
|
to cross other columns we actually draw it as in the .---' style
|
|
instead of a pure diagonal ... this reduces confusion by an
|
|
incredible amount.
|
|
"""
|
|
ctx = window.cairo_create()
|
|
ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
|
|
ctx.clip()
|
|
|
|
box_size = self.box_size(widget)
|
|
|
|
ctx.set_line_width(box_size / 8)
|
|
ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
|
|
|
|
# Draw lines into the cell
|
|
for start, end, colour in self.in_lines:
|
|
ctx.move_to(cell_area.x + box_size * start + box_size / 2,
|
|
bg_area.y - bg_area.height / 2)
|
|
|
|
if start - end > 1:
|
|
ctx.line_to(cell_area.x + box_size * start, bg_area.y)
|
|
ctx.line_to(cell_area.x + box_size * end + box_size, bg_area.y)
|
|
elif start - end < -1:
|
|
ctx.line_to(cell_area.x + box_size * start + box_size,
|
|
bg_area.y)
|
|
ctx.line_to(cell_area.x + box_size * end, bg_area.y)
|
|
|
|
ctx.line_to(cell_area.x + box_size * end + box_size / 2,
|
|
bg_area.y + bg_area.height / 2)
|
|
|
|
self.set_colour(ctx, colour, 0.0, 0.65)
|
|
ctx.stroke()
|
|
|
|
# Draw lines out of the cell
|
|
for start, end, colour in self.out_lines:
|
|
ctx.move_to(cell_area.x + box_size * start + box_size / 2,
|
|
bg_area.y + bg_area.height / 2)
|
|
|
|
if start - end > 1:
|
|
ctx.line_to(cell_area.x + box_size * start,
|
|
bg_area.y + bg_area.height)
|
|
ctx.line_to(cell_area.x + box_size * end + box_size,
|
|
bg_area.y + bg_area.height)
|
|
elif start - end < -1:
|
|
ctx.line_to(cell_area.x + box_size * start + box_size,
|
|
bg_area.y + bg_area.height)
|
|
ctx.line_to(cell_area.x + box_size * end,
|
|
bg_area.y + bg_area.height)
|
|
|
|
ctx.line_to(cell_area.x + box_size * end + box_size / 2,
|
|
bg_area.y + bg_area.height / 2 + bg_area.height)
|
|
|
|
self.set_colour(ctx, colour, 0.0, 0.65)
|
|
ctx.stroke()
|
|
|
|
# Draw the revision node in the right column
|
|
(column, colour, names) = self.node
|
|
ctx.arc(cell_area.x + box_size * column + box_size / 2,
|
|
cell_area.y + cell_area.height / 2,
|
|
box_size / 4, 0, 2 * math.pi)
|
|
|
|
|
|
self.set_colour(ctx, colour, 0.0, 0.5)
|
|
ctx.stroke_preserve()
|
|
|
|
self.set_colour(ctx, colour, 0.5, 1.0)
|
|
ctx.fill_preserve()
|
|
|
|
if (len(names) != 0):
|
|
name = " "
|
|
for item in names:
|
|
name = name + item + " "
|
|
|
|
ctx.set_font_size(13)
|
|
if (flags & 1):
|
|
self.set_colour(ctx, colour, 0.5, 1.0)
|
|
else:
|
|
self.set_colour(ctx, colour, 0.0, 0.5)
|
|
ctx.show_text(name)
|
|
|
|
class Commit(object):
|
|
""" This represent a commit object obtained after parsing the git-rev-list
|
|
output """
|
|
|
|
__slots__ = ['children_sha1', 'message', 'author', 'date', 'committer',
|
|
'commit_date', 'commit_sha1', 'parent_sha1']
|
|
|
|
children_sha1 = {}
|
|
|
|
def __init__(self, commit_lines):
|
|
self.message = ""
|
|
self.author = ""
|
|
self.date = ""
|
|
self.committer = ""
|
|
self.commit_date = ""
|
|
self.commit_sha1 = ""
|
|
self.parent_sha1 = [ ]
|
|
self.parse_commit(commit_lines)
|
|
|
|
|
|
def parse_commit(self, commit_lines):
|
|
|
|
# First line is the sha1 lines
|
|
line = string.strip(commit_lines[0])
|
|
sha1 = re.split(" ", line)
|
|
self.commit_sha1 = sha1[0]
|
|
self.parent_sha1 = sha1[1:]
|
|
|
|
#build the child list
|
|
for parent_id in self.parent_sha1:
|
|
try:
|
|
Commit.children_sha1[parent_id].append(self.commit_sha1)
|
|
except KeyError:
|
|
Commit.children_sha1[parent_id] = [self.commit_sha1]
|
|
|
|
# IF we don't have parent
|
|
if (len(self.parent_sha1) == 0):
|
|
self.parent_sha1 = [0]
|
|
|
|
for line in commit_lines[1:]:
|
|
m = re.match("^ ", line)
|
|
if (m != None):
|
|
# First line of the commit message used for short log
|
|
if self.message == "":
|
|
self.message = string.strip(line)
|
|
continue
|
|
|
|
m = re.match("tree", line)
|
|
if (m != None):
|
|
continue
|
|
|
|
m = re.match("parent", line)
|
|
if (m != None):
|
|
continue
|
|
|
|
m = re_ident.match(line)
|
|
if (m != None):
|
|
date = show_date(m.group('epoch'), m.group('tz'))
|
|
if m.group(1) == "author":
|
|
self.author = m.group('ident')
|
|
self.date = date
|
|
elif m.group(1) == "committer":
|
|
self.committer = m.group('ident')
|
|
self.commit_date = date
|
|
|
|
continue
|
|
|
|
def get_message(self, with_diff=0):
|
|
if (with_diff == 1):
|
|
message = self.diff_tree()
|
|
else:
|
|
fp = os.popen("git cat-file commit " + self.commit_sha1)
|
|
message = fp.read()
|
|
fp.close()
|
|
|
|
return message
|
|
|
|
def diff_tree(self):
|
|
fp = os.popen("git diff-tree --pretty --cc -v -p --always " + self.commit_sha1)
|
|
diff = fp.read()
|
|
fp.close()
|
|
return diff
|
|
|
|
class AnnotateWindow(object):
|
|
"""Annotate window.
|
|
This object represents and manages a single window containing the
|
|
annotate information of the file
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
|
self.window.set_border_width(0)
|
|
self.window.set_title("Git repository browser annotation window")
|
|
self.prev_read = ""
|
|
|
|
# Use two thirds of the screen by default
|
|
screen = self.window.get_screen()
|
|
monitor = screen.get_monitor_geometry(0)
|
|
width = int(monitor.width * 0.66)
|
|
height = int(monitor.height * 0.66)
|
|
self.window.set_default_size(width, height)
|
|
|
|
def add_file_data(self, filename, commit_sha1, line_num):
|
|
fp = os.popen("git cat-file blob " + commit_sha1 +":"+filename)
|
|
i = 1;
|
|
for line in fp.readlines():
|
|
line = string.rstrip(line)
|
|
self.model.append(None, ["HEAD", filename, line, i])
|
|
i = i+1
|
|
fp.close()
|
|
|
|
# now set the cursor position
|
|
self.treeview.set_cursor(line_num-1)
|
|
self.treeview.grab_focus()
|
|
|
|
def _treeview_cursor_cb(self, *args):
|
|
"""Callback for when the treeview cursor changes."""
|
|
(path, col) = self.treeview.get_cursor()
|
|
commit_sha1 = self.model[path][0]
|
|
commit_msg = ""
|
|
fp = os.popen("git cat-file commit " + commit_sha1)
|
|
for line in fp.readlines():
|
|
commit_msg = commit_msg + line
|
|
fp.close()
|
|
|
|
self.commit_buffer.set_text(commit_msg)
|
|
|
|
def _treeview_row_activated(self, *args):
|
|
"""Callback for when the treeview row gets selected."""
|
|
(path, col) = self.treeview.get_cursor()
|
|
commit_sha1 = self.model[path][0]
|
|
filename = self.model[path][1]
|
|
line_num = self.model[path][3]
|
|
|
|
window = AnnotateWindow();
|
|
fp = os.popen("git rev-parse "+ commit_sha1 + "~1")
|
|
commit_sha1 = string.strip(fp.readline())
|
|
fp.close()
|
|
window.annotate(filename, commit_sha1, line_num)
|
|
|
|
def data_ready(self, source, condition):
|
|
while (1):
|
|
try :
|
|
# A simple readline doesn't work
|
|
# a readline bug ??
|
|
buffer = source.read(100)
|
|
|
|
except:
|
|
# resource temporary not available
|
|
return True
|
|
|
|
if (len(buffer) == 0):
|
|
gobject.source_remove(self.io_watch_tag)
|
|
source.close()
|
|
return False
|
|
|
|
if (self.prev_read != ""):
|
|
buffer = self.prev_read + buffer
|
|
self.prev_read = ""
|
|
|
|
if (buffer[len(buffer) -1] != '\n'):
|
|
try:
|
|
newline_index = buffer.rindex("\n")
|
|
except ValueError:
|
|
newline_index = 0
|
|
|
|
self.prev_read = buffer[newline_index:(len(buffer))]
|
|
buffer = buffer[0:newline_index]
|
|
|
|
for buff in buffer.split("\n"):
|
|
annotate_line = re.compile('^([0-9a-f]{40}) (.+) (.+) (.+)$')
|
|
m = annotate_line.match(buff)
|
|
if not m:
|
|
annotate_line = re.compile('^(filename) (.+)$')
|
|
m = annotate_line.match(buff)
|
|
if not m:
|
|
continue
|
|
filename = m.group(2)
|
|
else:
|
|
self.commit_sha1 = m.group(1)
|
|
self.source_line = int(m.group(2))
|
|
self.result_line = int(m.group(3))
|
|
self.count = int(m.group(4))
|
|
#set the details only when we have the file name
|
|
continue
|
|
|
|
while (self.count > 0):
|
|
# set at result_line + count-1 the sha1 as commit_sha1
|
|
self.count = self.count - 1
|
|
iter = self.model.iter_nth_child(None, self.result_line + self.count-1)
|
|
self.model.set(iter, 0, self.commit_sha1, 1, filename, 3, self.source_line)
|
|
|
|
|
|
def annotate(self, filename, commit_sha1, line_num):
|
|
# verify the commit_sha1 specified has this filename
|
|
|
|
fp = os.popen("git ls-tree "+ commit_sha1 + " -- " + filename)
|
|
line = string.strip(fp.readline())
|
|
if line == '':
|
|
# pop up the message the file is not there as a part of the commit
|
|
fp.close()
|
|
dialog = gtk.MessageDialog(parent=None, flags=0,
|
|
type=gtk.MESSAGE_WARNING, buttons=gtk.BUTTONS_CLOSE,
|
|
message_format=None)
|
|
dialog.set_markup("The file %s is not present in the parent commit %s" % (filename, commit_sha1))
|
|
dialog.run()
|
|
dialog.destroy()
|
|
return
|
|
|
|
fp.close()
|
|
|
|
vpan = gtk.VPaned();
|
|
self.window.add(vpan);
|
|
vpan.show()
|
|
|
|
scrollwin = gtk.ScrolledWindow()
|
|
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
scrollwin.set_shadow_type(gtk.SHADOW_IN)
|
|
vpan.pack1(scrollwin, True, True);
|
|
scrollwin.show()
|
|
|
|
self.model = gtk.TreeStore(str, str, str, int)
|
|
self.treeview = gtk.TreeView(self.model)
|
|
self.treeview.set_rules_hint(True)
|
|
self.treeview.set_search_column(0)
|
|
self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
|
|
self.treeview.connect("row-activated", self._treeview_row_activated)
|
|
scrollwin.add(self.treeview)
|
|
self.treeview.show()
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("width-chars", 10)
|
|
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
|
|
column = gtk.TreeViewColumn("Commit")
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 0)
|
|
self.treeview.append_column(column)
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("width-chars", 20)
|
|
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
|
|
column = gtk.TreeViewColumn("File Name")
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 1)
|
|
self.treeview.append_column(column)
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("width-chars", 20)
|
|
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
|
|
column = gtk.TreeViewColumn("Data")
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 2)
|
|
self.treeview.append_column(column)
|
|
|
|
# The commit message window
|
|
scrollwin = gtk.ScrolledWindow()
|
|
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
scrollwin.set_shadow_type(gtk.SHADOW_IN)
|
|
vpan.pack2(scrollwin, True, True);
|
|
scrollwin.show()
|
|
|
|
commit_text = gtk.TextView()
|
|
self.commit_buffer = gtk.TextBuffer()
|
|
commit_text.set_buffer(self.commit_buffer)
|
|
scrollwin.add(commit_text)
|
|
commit_text.show()
|
|
|
|
self.window.show()
|
|
|
|
self.add_file_data(filename, commit_sha1, line_num)
|
|
|
|
fp = os.popen("git blame --incremental -C -C -- " + filename + " " + commit_sha1)
|
|
flags = fcntl.fcntl(fp.fileno(), fcntl.F_GETFL)
|
|
fcntl.fcntl(fp.fileno(), fcntl.F_SETFL, flags | os.O_NONBLOCK)
|
|
self.io_watch_tag = gobject.io_add_watch(fp, gobject.IO_IN, self.data_ready)
|
|
|
|
|
|
class DiffWindow(object):
|
|
"""Diff window.
|
|
This object represents and manages a single window containing the
|
|
differences between two revisions on a branch.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
|
self.window.set_border_width(0)
|
|
self.window.set_title("Git repository browser diff window")
|
|
|
|
# Use two thirds of the screen by default
|
|
screen = self.window.get_screen()
|
|
monitor = screen.get_monitor_geometry(0)
|
|
width = int(monitor.width * 0.66)
|
|
height = int(monitor.height * 0.66)
|
|
self.window.set_default_size(width, height)
|
|
|
|
|
|
self.construct()
|
|
|
|
def construct(self):
|
|
"""Construct the window contents."""
|
|
vbox = gtk.VBox()
|
|
self.window.add(vbox)
|
|
vbox.show()
|
|
|
|
menu_bar = gtk.MenuBar()
|
|
save_menu = gtk.ImageMenuItem(gtk.STOCK_SAVE)
|
|
save_menu.connect("activate", self.save_menu_response, "save")
|
|
save_menu.show()
|
|
menu_bar.append(save_menu)
|
|
vbox.pack_start(menu_bar, expand=False, fill=True)
|
|
menu_bar.show()
|
|
|
|
hpan = gtk.HPaned()
|
|
|
|
scrollwin = gtk.ScrolledWindow()
|
|
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
scrollwin.set_shadow_type(gtk.SHADOW_IN)
|
|
hpan.pack1(scrollwin, True, True)
|
|
scrollwin.show()
|
|
|
|
(self.buffer, sourceview) = get_source_buffer_and_view()
|
|
|
|
sourceview.set_editable(False)
|
|
sourceview.modify_font(pango.FontDescription("Monospace"))
|
|
scrollwin.add(sourceview)
|
|
sourceview.show()
|
|
|
|
# The file hierarchy: a scrollable treeview
|
|
scrollwin = gtk.ScrolledWindow()
|
|
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
scrollwin.set_shadow_type(gtk.SHADOW_IN)
|
|
scrollwin.set_size_request(20, -1)
|
|
hpan.pack2(scrollwin, True, True)
|
|
scrollwin.show()
|
|
|
|
self.model = gtk.TreeStore(str, str, str)
|
|
self.treeview = gtk.TreeView(self.model)
|
|
self.treeview.set_search_column(1)
|
|
self.treeview.connect("cursor-changed", self._treeview_clicked)
|
|
scrollwin.add(self.treeview)
|
|
self.treeview.show()
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("width-chars", 20)
|
|
column = gtk.TreeViewColumn("Select to annotate")
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 0)
|
|
self.treeview.append_column(column)
|
|
|
|
vbox.pack_start(hpan, expand=True, fill=True)
|
|
hpan.show()
|
|
|
|
def _treeview_clicked(self, *args):
|
|
"""Callback for when the treeview cursor changes."""
|
|
(path, col) = self.treeview.get_cursor()
|
|
specific_file = self.model[path][1]
|
|
commit_sha1 = self.model[path][2]
|
|
if specific_file == None :
|
|
return
|
|
elif specific_file == "" :
|
|
specific_file = None
|
|
|
|
window = AnnotateWindow();
|
|
window.annotate(specific_file, commit_sha1, 1)
|
|
|
|
|
|
def commit_files(self, commit_sha1, parent_sha1):
|
|
self.model.clear()
|
|
add = self.model.append(None, [ "Added", None, None])
|
|
dele = self.model.append(None, [ "Deleted", None, None])
|
|
mod = self.model.append(None, [ "Modified", None, None])
|
|
diff_tree = re.compile('^(:.{6}) (.{6}) (.{40}) (.{40}) (A|D|M)\s(.+)$')
|
|
fp = os.popen("git diff-tree -r --no-commit-id " + parent_sha1 + " " + commit_sha1)
|
|
while 1:
|
|
line = string.strip(fp.readline())
|
|
if line == '':
|
|
break
|
|
m = diff_tree.match(line)
|
|
if not m:
|
|
continue
|
|
|
|
attr = m.group(5)
|
|
filename = m.group(6)
|
|
if attr == "A":
|
|
self.model.append(add, [filename, filename, commit_sha1])
|
|
elif attr == "D":
|
|
self.model.append(dele, [filename, filename, commit_sha1])
|
|
elif attr == "M":
|
|
self.model.append(mod, [filename, filename, commit_sha1])
|
|
fp.close()
|
|
|
|
self.treeview.expand_all()
|
|
|
|
def set_diff(self, commit_sha1, parent_sha1, encoding):
|
|
"""Set the differences showed by this window.
|
|
Compares the two trees and populates the window with the
|
|
differences.
|
|
"""
|
|
# Diff with the first commit or the last commit shows nothing
|
|
if (commit_sha1 == 0 or parent_sha1 == 0 ):
|
|
return
|
|
|
|
fp = os.popen("git diff-tree -p " + parent_sha1 + " " + commit_sha1)
|
|
self.buffer.set_text(unicode(fp.read(), encoding).encode('utf-8'))
|
|
fp.close()
|
|
self.commit_files(commit_sha1, parent_sha1)
|
|
self.window.show()
|
|
|
|
def save_menu_response(self, widget, string):
|
|
dialog = gtk.FileChooserDialog("Save..", None, gtk.FILE_CHOOSER_ACTION_SAVE,
|
|
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
|
|
gtk.STOCK_SAVE, gtk.RESPONSE_OK))
|
|
dialog.set_default_response(gtk.RESPONSE_OK)
|
|
response = dialog.run()
|
|
if response == gtk.RESPONSE_OK:
|
|
patch_buffer = self.buffer.get_text(self.buffer.get_start_iter(),
|
|
self.buffer.get_end_iter())
|
|
fp = open(dialog.get_filename(), "w")
|
|
fp.write(patch_buffer)
|
|
fp.close()
|
|
dialog.destroy()
|
|
|
|
class GitView(object):
|
|
""" This is the main class
|
|
"""
|
|
version = "0.9"
|
|
|
|
def __init__(self, with_diff=0):
|
|
self.with_diff = with_diff
|
|
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
|
self.window.set_border_width(0)
|
|
self.window.set_title("Git repository browser")
|
|
|
|
self.get_encoding()
|
|
self.get_bt_sha1()
|
|
|
|
# Use three-quarters of the screen by default
|
|
screen = self.window.get_screen()
|
|
monitor = screen.get_monitor_geometry(0)
|
|
width = int(monitor.width * 0.75)
|
|
height = int(monitor.height * 0.75)
|
|
self.window.set_default_size(width, height)
|
|
|
|
# FIXME AndyFitz!
|
|
icon = self.window.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
|
|
self.window.set_icon(icon)
|
|
|
|
self.accel_group = gtk.AccelGroup()
|
|
self.window.add_accel_group(self.accel_group)
|
|
self.accel_group.connect_group(0xffc2, 0, gtk.ACCEL_LOCKED, self.refresh);
|
|
self.accel_group.connect_group(0xffc1, 0, gtk.ACCEL_LOCKED, self.maximize);
|
|
self.accel_group.connect_group(0xffc8, 0, gtk.ACCEL_LOCKED, self.fullscreen);
|
|
self.accel_group.connect_group(0xffc9, 0, gtk.ACCEL_LOCKED, self.unfullscreen);
|
|
|
|
self.window.add(self.construct())
|
|
|
|
def refresh(self, widget, event=None, *arguments, **keywords):
|
|
self.get_encoding()
|
|
self.get_bt_sha1()
|
|
Commit.children_sha1 = {}
|
|
self.set_branch(sys.argv[without_diff:])
|
|
self.window.show()
|
|
return True
|
|
|
|
def maximize(self, widget, event=None, *arguments, **keywords):
|
|
self.window.maximize()
|
|
return True
|
|
|
|
def fullscreen(self, widget, event=None, *arguments, **keywords):
|
|
self.window.fullscreen()
|
|
return True
|
|
|
|
def unfullscreen(self, widget, event=None, *arguments, **keywords):
|
|
self.window.unfullscreen()
|
|
return True
|
|
|
|
def get_bt_sha1(self):
|
|
""" Update the bt_sha1 dictionary with the
|
|
respective sha1 details """
|
|
|
|
self.bt_sha1 = { }
|
|
ls_remote = re.compile('^(.{40})\trefs/([^^]+)(?:\\^(..))?$');
|
|
fp = os.popen('git ls-remote "${GIT_DIR-.git}"')
|
|
while 1:
|
|
line = string.strip(fp.readline())
|
|
if line == '':
|
|
break
|
|
m = ls_remote.match(line)
|
|
if not m:
|
|
continue
|
|
(sha1, name) = (m.group(1), m.group(2))
|
|
if not self.bt_sha1.has_key(sha1):
|
|
self.bt_sha1[sha1] = []
|
|
self.bt_sha1[sha1].append(name)
|
|
fp.close()
|
|
|
|
def get_encoding(self):
|
|
fp = os.popen("git config --get i18n.commitencoding")
|
|
self.encoding=string.strip(fp.readline())
|
|
fp.close()
|
|
if (self.encoding == ""):
|
|
self.encoding = "utf-8"
|
|
|
|
|
|
def construct(self):
|
|
"""Construct the window contents."""
|
|
vbox = gtk.VBox()
|
|
paned = gtk.VPaned()
|
|
paned.pack1(self.construct_top(), resize=False, shrink=True)
|
|
paned.pack2(self.construct_bottom(), resize=False, shrink=True)
|
|
menu_bar = gtk.MenuBar()
|
|
menu_bar.set_pack_direction(gtk.PACK_DIRECTION_RTL)
|
|
help_menu = gtk.MenuItem("Help")
|
|
menu = gtk.Menu()
|
|
about_menu = gtk.MenuItem("About")
|
|
menu.append(about_menu)
|
|
about_menu.connect("activate", self.about_menu_response, "about")
|
|
about_menu.show()
|
|
help_menu.set_submenu(menu)
|
|
help_menu.show()
|
|
menu_bar.append(help_menu)
|
|
menu_bar.show()
|
|
vbox.pack_start(menu_bar, expand=False, fill=True)
|
|
vbox.pack_start(paned, expand=True, fill=True)
|
|
paned.show()
|
|
vbox.show()
|
|
return vbox
|
|
|
|
|
|
def construct_top(self):
|
|
"""Construct the top-half of the window."""
|
|
vbox = gtk.VBox(spacing=6)
|
|
vbox.set_border_width(12)
|
|
vbox.show()
|
|
|
|
|
|
scrollwin = gtk.ScrolledWindow()
|
|
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
scrollwin.set_shadow_type(gtk.SHADOW_IN)
|
|
vbox.pack_start(scrollwin, expand=True, fill=True)
|
|
scrollwin.show()
|
|
|
|
self.treeview = gtk.TreeView()
|
|
self.treeview.set_rules_hint(True)
|
|
self.treeview.set_search_column(4)
|
|
self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
|
|
scrollwin.add(self.treeview)
|
|
self.treeview.show()
|
|
|
|
cell = CellRendererGraph()
|
|
column = gtk.TreeViewColumn()
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "node", 1)
|
|
column.add_attribute(cell, "in-lines", 2)
|
|
column.add_attribute(cell, "out-lines", 3)
|
|
self.treeview.append_column(column)
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("width-chars", 65)
|
|
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
|
|
column = gtk.TreeViewColumn("Message")
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 4)
|
|
self.treeview.append_column(column)
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("width-chars", 40)
|
|
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
|
|
column = gtk.TreeViewColumn("Author")
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 5)
|
|
self.treeview.append_column(column)
|
|
|
|
cell = gtk.CellRendererText()
|
|
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
|
|
column = gtk.TreeViewColumn("Date")
|
|
column.set_resizable(True)
|
|
column.pack_start(cell, expand=True)
|
|
column.add_attribute(cell, "text", 6)
|
|
self.treeview.append_column(column)
|
|
|
|
return vbox
|
|
|
|
def about_menu_response(self, widget, string):
|
|
dialog = gtk.AboutDialog()
|
|
dialog.set_name("Gitview")
|
|
dialog.set_version(GitView.version)
|
|
dialog.set_authors(["Aneesh Kumar K.V <aneesh.kumar@gmail.com>"])
|
|
dialog.set_website("http://www.kernel.org/pub/software/scm/git/")
|
|
dialog.set_copyright("Use and distribute under the terms of the GNU General Public License")
|
|
dialog.set_wrap_license(True)
|
|
dialog.run()
|
|
dialog.destroy()
|
|
|
|
|
|
def construct_bottom(self):
|
|
"""Construct the bottom half of the window."""
|
|
vbox = gtk.VBox(False, spacing=6)
|
|
vbox.set_border_width(12)
|
|
(width, height) = self.window.get_size()
|
|
vbox.set_size_request(width, int(height / 2.5))
|
|
vbox.show()
|
|
|
|
self.table = gtk.Table(rows=4, columns=4)
|
|
self.table.set_row_spacings(6)
|
|
self.table.set_col_spacings(6)
|
|
vbox.pack_start(self.table, expand=False, fill=True)
|
|
self.table.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
label = gtk.Label()
|
|
label.set_markup("<b>Revision:</b>")
|
|
align.add(label)
|
|
self.table.attach(align, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
|
|
label.show()
|
|
align.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
self.revid_label = gtk.Label()
|
|
self.revid_label.set_selectable(True)
|
|
align.add(self.revid_label)
|
|
self.table.attach(align, 1, 2, 0, 1, gtk.EXPAND | gtk.FILL, gtk.FILL)
|
|
self.revid_label.show()
|
|
align.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
label = gtk.Label()
|
|
label.set_markup("<b>Committer:</b>")
|
|
align.add(label)
|
|
self.table.attach(align, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
|
|
label.show()
|
|
align.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
self.committer_label = gtk.Label()
|
|
self.committer_label.set_selectable(True)
|
|
align.add(self.committer_label)
|
|
self.table.attach(align, 1, 2, 1, 2, gtk.EXPAND | gtk.FILL, gtk.FILL)
|
|
self.committer_label.show()
|
|
align.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
label = gtk.Label()
|
|
label.set_markup("<b>Timestamp:</b>")
|
|
align.add(label)
|
|
self.table.attach(align, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
|
|
label.show()
|
|
align.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
self.timestamp_label = gtk.Label()
|
|
self.timestamp_label.set_selectable(True)
|
|
align.add(self.timestamp_label)
|
|
self.table.attach(align, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL, gtk.FILL)
|
|
self.timestamp_label.show()
|
|
align.show()
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
label = gtk.Label()
|
|
label.set_markup("<b>Parents:</b>")
|
|
align.add(label)
|
|
self.table.attach(align, 0, 1, 3, 4, gtk.FILL, gtk.FILL)
|
|
label.show()
|
|
align.show()
|
|
self.parents_widgets = []
|
|
|
|
align = gtk.Alignment(0.0, 0.5)
|
|
label = gtk.Label()
|
|
label.set_markup("<b>Children:</b>")
|
|
align.add(label)
|
|
self.table.attach(align, 2, 3, 3, 4, gtk.FILL, gtk.FILL)
|
|
label.show()
|
|
align.show()
|
|
self.children_widgets = []
|
|
|
|
scrollwin = gtk.ScrolledWindow()
|
|
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
scrollwin.set_shadow_type(gtk.SHADOW_IN)
|
|
vbox.pack_start(scrollwin, expand=True, fill=True)
|
|
scrollwin.show()
|
|
|
|
(self.message_buffer, sourceview) = get_source_buffer_and_view()
|
|
|
|
sourceview.set_editable(False)
|
|
sourceview.modify_font(pango.FontDescription("Monospace"))
|
|
scrollwin.add(sourceview)
|
|
sourceview.show()
|
|
|
|
return vbox
|
|
|
|
def _treeview_cursor_cb(self, *args):
|
|
"""Callback for when the treeview cursor changes."""
|
|
(path, col) = self.treeview.get_cursor()
|
|
commit = self.model[path][0]
|
|
|
|
if commit.committer is not None:
|
|
committer = commit.committer
|
|
timestamp = commit.commit_date
|
|
message = commit.get_message(self.with_diff)
|
|
revid_label = commit.commit_sha1
|
|
else:
|
|
committer = ""
|
|
timestamp = ""
|
|
message = ""
|
|
revid_label = ""
|
|
|
|
self.revid_label.set_text(revid_label)
|
|
self.committer_label.set_text(committer)
|
|
self.timestamp_label.set_text(timestamp)
|
|
self.message_buffer.set_text(unicode(message, self.encoding).encode('utf-8'))
|
|
|
|
for widget in self.parents_widgets:
|
|
self.table.remove(widget)
|
|
|
|
self.parents_widgets = []
|
|
self.table.resize(4 + len(commit.parent_sha1) - 1, 4)
|
|
for idx, parent_id in enumerate(commit.parent_sha1):
|
|
self.table.set_row_spacing(idx + 3, 0)
|
|
|
|
align = gtk.Alignment(0.0, 0.0)
|
|
self.parents_widgets.append(align)
|
|
self.table.attach(align, 1, 2, idx + 3, idx + 4,
|
|
gtk.EXPAND | gtk.FILL, gtk.FILL)
|
|
align.show()
|
|
|
|
hbox = gtk.HBox(False, 0)
|
|
align.add(hbox)
|
|
hbox.show()
|
|
|
|
label = gtk.Label(parent_id)
|
|
label.set_selectable(True)
|
|
hbox.pack_start(label, expand=False, fill=True)
|
|
label.show()
|
|
|
|
image = gtk.Image()
|
|
image.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
|
|
image.show()
|
|
|
|
button = gtk.Button()
|
|
button.add(image)
|
|
button.set_relief(gtk.RELIEF_NONE)
|
|
button.connect("clicked", self._go_clicked_cb, parent_id)
|
|
hbox.pack_start(button, expand=False, fill=True)
|
|
button.show()
|
|
|
|
image = gtk.Image()
|
|
image.set_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
|
|
image.show()
|
|
|
|
button = gtk.Button()
|
|
button.add(image)
|
|
button.set_relief(gtk.RELIEF_NONE)
|
|
button.set_sensitive(True)
|
|
button.connect("clicked", self._show_clicked_cb,
|
|
commit.commit_sha1, parent_id, self.encoding)
|
|
hbox.pack_start(button, expand=False, fill=True)
|
|
button.show()
|
|
|
|
# Populate with child details
|
|
for widget in self.children_widgets:
|
|
self.table.remove(widget)
|
|
|
|
self.children_widgets = []
|
|
try:
|
|
child_sha1 = Commit.children_sha1[commit.commit_sha1]
|
|
except KeyError:
|
|
# We don't have child
|
|
child_sha1 = [ 0 ]
|
|
|
|
if ( len(child_sha1) > len(commit.parent_sha1)):
|
|
self.table.resize(4 + len(child_sha1) - 1, 4)
|
|
|
|
for idx, child_id in enumerate(child_sha1):
|
|
self.table.set_row_spacing(idx + 3, 0)
|
|
|
|
align = gtk.Alignment(0.0, 0.0)
|
|
self.children_widgets.append(align)
|
|
self.table.attach(align, 3, 4, idx + 3, idx + 4,
|
|
gtk.EXPAND | gtk.FILL, gtk.FILL)
|
|
align.show()
|
|
|
|
hbox = gtk.HBox(False, 0)
|
|
align.add(hbox)
|
|
hbox.show()
|
|
|
|
label = gtk.Label(child_id)
|
|
label.set_selectable(True)
|
|
hbox.pack_start(label, expand=False, fill=True)
|
|
label.show()
|
|
|
|
image = gtk.Image()
|
|
image.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
|
|
image.show()
|
|
|
|
button = gtk.Button()
|
|
button.add(image)
|
|
button.set_relief(gtk.RELIEF_NONE)
|
|
button.connect("clicked", self._go_clicked_cb, child_id)
|
|
hbox.pack_start(button, expand=False, fill=True)
|
|
button.show()
|
|
|
|
image = gtk.Image()
|
|
image.set_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
|
|
image.show()
|
|
|
|
button = gtk.Button()
|
|
button.add(image)
|
|
button.set_relief(gtk.RELIEF_NONE)
|
|
button.set_sensitive(True)
|
|
button.connect("clicked", self._show_clicked_cb,
|
|
child_id, commit.commit_sha1, self.encoding)
|
|
hbox.pack_start(button, expand=False, fill=True)
|
|
button.show()
|
|
|
|
def _destroy_cb(self, widget):
|
|
"""Callback for when a window we manage is destroyed."""
|
|
self.quit()
|
|
|
|
|
|
def quit(self):
|
|
"""Stop the GTK+ main loop."""
|
|
gtk.main_quit()
|
|
|
|
def run(self, args):
|
|
self.set_branch(args)
|
|
self.window.connect("destroy", self._destroy_cb)
|
|
self.window.show()
|
|
gtk.main()
|
|
|
|
def set_branch(self, args):
|
|
"""Fill in different windows with info from the reposiroty"""
|
|
fp = os.popen("git rev-parse --sq --default HEAD " + list_to_string(args, 1))
|
|
git_rev_list_cmd = fp.read()
|
|
fp.close()
|
|
fp = os.popen("git rev-list --header --topo-order --parents " + git_rev_list_cmd)
|
|
self.update_window(fp)
|
|
|
|
def update_window(self, fp):
|
|
commit_lines = []
|
|
|
|
self.model = gtk.ListStore(gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT,
|
|
gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, str, str, str)
|
|
|
|
# used for cursor positioning
|
|
self.index = {}
|
|
|
|
self.colours = {}
|
|
self.nodepos = {}
|
|
self.incomplete_line = {}
|
|
self.commits = []
|
|
|
|
index = 0
|
|
last_colour = 0
|
|
last_nodepos = -1
|
|
out_line = []
|
|
input_line = fp.readline()
|
|
while (input_line != ""):
|
|
# The commit header ends with '\0'
|
|
# This NULL is immediately followed by the sha1 of the
|
|
# next commit
|
|
if (input_line[0] != '\0'):
|
|
commit_lines.append(input_line)
|
|
input_line = fp.readline()
|
|
continue;
|
|
|
|
commit = Commit(commit_lines)
|
|
if (commit != None ):
|
|
self.commits.append(commit)
|
|
|
|
# Skip the '\0
|
|
commit_lines = []
|
|
commit_lines.append(input_line[1:])
|
|
input_line = fp.readline()
|
|
|
|
fp.close()
|
|
|
|
for commit in self.commits:
|
|
(out_line, last_colour, last_nodepos) = self.draw_graph(commit,
|
|
index, out_line,
|
|
last_colour,
|
|
last_nodepos)
|
|
self.index[commit.commit_sha1] = index
|
|
index += 1
|
|
|
|
self.treeview.set_model(self.model)
|
|
self.treeview.show()
|
|
|
|
def draw_graph(self, commit, index, out_line, last_colour, last_nodepos):
|
|
in_line=[]
|
|
|
|
# | -> outline
|
|
# X
|
|
# |\ <- inline
|
|
|
|
# Reset nodepostion
|
|
if (last_nodepos > 5):
|
|
last_nodepos = -1
|
|
|
|
# Add the incomplete lines of the last cell in this
|
|
try:
|
|
colour = self.colours[commit.commit_sha1]
|
|
except KeyError:
|
|
self.colours[commit.commit_sha1] = last_colour+1
|
|
last_colour = self.colours[commit.commit_sha1]
|
|
colour = self.colours[commit.commit_sha1]
|
|
|
|
try:
|
|
node_pos = self.nodepos[commit.commit_sha1]
|
|
except KeyError:
|
|
self.nodepos[commit.commit_sha1] = last_nodepos+1
|
|
last_nodepos = self.nodepos[commit.commit_sha1]
|
|
node_pos = self.nodepos[commit.commit_sha1]
|
|
|
|
#The first parent always continue on the same line
|
|
try:
|
|
# check we already have the value
|
|
tmp_node_pos = self.nodepos[commit.parent_sha1[0]]
|
|
except KeyError:
|
|
self.colours[commit.parent_sha1[0]] = colour
|
|
self.nodepos[commit.parent_sha1[0]] = node_pos
|
|
|
|
for sha1 in self.incomplete_line.keys():
|
|
if (sha1 != commit.commit_sha1):
|
|
self.draw_incomplete_line(sha1, node_pos,
|
|
out_line, in_line, index)
|
|
else:
|
|
del self.incomplete_line[sha1]
|
|
|
|
|
|
for parent_id in commit.parent_sha1:
|
|
try:
|
|
tmp_node_pos = self.nodepos[parent_id]
|
|
except KeyError:
|
|
self.colours[parent_id] = last_colour+1
|
|
last_colour = self.colours[parent_id]
|
|
self.nodepos[parent_id] = last_nodepos+1
|
|
last_nodepos = self.nodepos[parent_id]
|
|
|
|
in_line.append((node_pos, self.nodepos[parent_id],
|
|
self.colours[parent_id]))
|
|
self.add_incomplete_line(parent_id)
|
|
|
|
try:
|
|
branch_tag = self.bt_sha1[commit.commit_sha1]
|
|
except KeyError:
|
|
branch_tag = [ ]
|
|
|
|
|
|
node = (node_pos, colour, branch_tag)
|
|
|
|
self.model.append([commit, node, out_line, in_line,
|
|
commit.message, commit.author, commit.date])
|
|
|
|
return (in_line, last_colour, last_nodepos)
|
|
|
|
def add_incomplete_line(self, sha1):
|
|
try:
|
|
self.incomplete_line[sha1].append(self.nodepos[sha1])
|
|
except KeyError:
|
|
self.incomplete_line[sha1] = [self.nodepos[sha1]]
|
|
|
|
def draw_incomplete_line(self, sha1, node_pos, out_line, in_line, index):
|
|
for idx, pos in enumerate(self.incomplete_line[sha1]):
|
|
if(pos == node_pos):
|
|
#remove the straight line and add a slash
|
|
if ((pos, pos, self.colours[sha1]) in out_line):
|
|
out_line.remove((pos, pos, self.colours[sha1]))
|
|
out_line.append((pos, pos+0.5, self.colours[sha1]))
|
|
self.incomplete_line[sha1][idx] = pos = pos+0.5
|
|
try:
|
|
next_commit = self.commits[index+1]
|
|
if (next_commit.commit_sha1 == sha1 and pos != int(pos)):
|
|
# join the line back to the node point
|
|
# This need to be done only if we modified it
|
|
in_line.append((pos, pos-0.5, self.colours[sha1]))
|
|
continue;
|
|
except IndexError:
|
|
pass
|
|
in_line.append((pos, pos, self.colours[sha1]))
|
|
|
|
|
|
def _go_clicked_cb(self, widget, revid):
|
|
"""Callback for when the go button for a parent is clicked."""
|
|
try:
|
|
self.treeview.set_cursor(self.index[revid])
|
|
except KeyError:
|
|
dialog = gtk.MessageDialog(parent=None, flags=0,
|
|
type=gtk.MESSAGE_WARNING, buttons=gtk.BUTTONS_CLOSE,
|
|
message_format=None)
|
|
dialog.set_markup("Revision <b>%s</b> not present in the list" % revid)
|
|
# revid == 0 is the parent of the first commit
|
|
if (revid != 0 ):
|
|
dialog.format_secondary_text("Try running gitview without any options")
|
|
dialog.run()
|
|
dialog.destroy()
|
|
|
|
self.treeview.grab_focus()
|
|
|
|
def _show_clicked_cb(self, widget, commit_sha1, parent_sha1, encoding):
|
|
"""Callback for when the show button for a parent is clicked."""
|
|
window = DiffWindow()
|
|
window.set_diff(commit_sha1, parent_sha1, encoding)
|
|
self.treeview.grab_focus()
|
|
|
|
without_diff = 0
|
|
if __name__ == "__main__":
|
|
|
|
if (len(sys.argv) > 1 ):
|
|
if (sys.argv[1] == "--without-diff"):
|
|
without_diff = 1
|
|
|
|
view = GitView( without_diff != 1)
|
|
view.run(sys.argv[without_diff:])
|