contrib/gitview/gitview

   1 #! /usr/bin/env python
   2
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 2 of the License, or
   6 # (at your option) any later version.
   7
   8 """ gitview
   9 GUI browser for git repository
  10 This program is based on bzrk by Scott James Remnant <scott@ubuntu.com>
  11 """
  12 __copyright__ = "Copyright (C) 2006 Hewlett-Packard Development Company, L.P."
  13 __copyright__ = "Copyright (C) 2007 Aneesh Kumar K.V <aneesh.kumar@gmail.com"
  14 __author__    = "Aneesh Kumar K.V <aneesh.kumar@gmail.com>"
  15
  16
  17 import sys
  18 import os
  19 import gtk
  20 import pygtk
  21 import pango
  22 import re
  23 import time
  24 import gobject
  25 import cairo
  26 import math
  27 import string
  28 import fcntl
  29
  30 have_gtksourceview2 = False
  31 have_gtksourceview = False
  32 try:
  33     import gtksourceview2
  34     have_gtksourceview2 = True
  35 except ImportError:
  36     try:
  37         import gtksourceview
  38         have_gtksourceview = True
  39     except ImportError:
  40         print "Running without gtksourceview2 or gtksourceview module"
  41
  42 re_ident = re.compile('(author|committer) (?P<ident>.*) (?P<epoch>\d+) (?P<tz>[+-]\d{4})')
  43
  44 def list_to_string(args, skip):
  45         count = len(args)
  46         i = skip
  47         str_arg=" "
  48         while (i < count ):
  49                 str_arg = str_arg + args[i]
  50                 str_arg = str_arg + " "
  51                 i = i+1
  52
  53         return str_arg
  54
  55 def show_date(epoch, tz):
  56         secs = float(epoch)
  57         tzsecs = float(tz[1:3]) * 3600
  58         tzsecs += float(tz[3:5]) * 60
  59         if (tz[0] == "+"):
  60                 secs += tzsecs
  61         else:
  62                 secs -= tzsecs
  63
  64         return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(secs))
  65
  66 def get_source_buffer_and_view():
  67         if have_gtksourceview2:
  68                 buffer = gtksourceview2.Buffer()
  69                 slm = gtksourceview2.LanguageManager()
  70                 gsl = slm.get_language("diff")
  71                 buffer.set_highlight_syntax(True)
  72                 buffer.set_language(gsl)
  73                 view = gtksourceview2.View(buffer)
  74         elif have_gtksourceview:
  75                 buffer = gtksourceview.SourceBuffer()
  76                 slm = gtksourceview.SourceLanguagesManager()
  77                 gsl = slm.get_language_from_mime_type("text/x-patch")
  78                 buffer.set_highlight(True)
  79                 buffer.set_language(gsl)
  80                 view = gtksourceview.SourceView(buffer)
  81         else:
  82                 buffer = gtk.TextBuffer()
  83                 view = gtk.TextView(buffer)
  84         return (buffer, view)
  85
  86
  87 class CellRendererGraph(gtk.GenericCellRenderer):
  88         """Cell renderer for directed graph.
  89
  90         This module contains the implementation of a custom GtkCellRenderer that
  91         draws part of the directed graph based on the lines suggested by the code
  92         in graph.py.
  93
  94         Because we're shiny, we use Cairo to do this, and because we're naughty
  95         we cheat and draw over the bits of the TreeViewColumn that are supposed to
  96         just be for the background.
  97
  98         Properties:
  99         node              (column, colour, [ names ]) tuple to draw revision node,
 100         in_lines          (start, end, colour) tuple list to draw inward lines,
 101         out_lines         (start, end, colour) tuple list to draw outward lines.
 102         """
 103
 104         __gproperties__ = {
 105         "node":         ( gobject.TYPE_PYOBJECT, "node",
 106                           "revision node instruction",
 107                           gobject.PARAM_WRITABLE
 108                         ),
 109         "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
 110                           "instructions to draw lines into the cell",
 111                           gobject.PARAM_WRITABLE
 112                         ),
 113         "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
 114                           "instructions to draw lines out of the cell",
 115                           gobject.PARAM_WRITABLE
 116                         ),
 117         }
 118
 119         def do_set_property(self, property, value):
 120                 """Set properties from GObject properties."""
 121                 if property.name == "node":
 122                         self.node = value
 123                 elif property.name == "in-lines":
 124                         self.in_lines = value
 125                 elif property.name == "out-lines":
 126                         self.out_lines = value
 127                 else:
 128                         raise AttributeError, "no such property: '%s'" % property.name
 129
 130         def box_size(self, widget):
 131                 """Calculate box size based on widget's font.
 132
 133                 Cache this as it's probably expensive to get.  It ensures that we
 134                 draw the graph at least as large as the text.
 135                 """
 136                 try:
 137                         return self._box_size
 138                 except AttributeError:
 139                         pango_ctx = widget.get_pango_context()
 140                         font_desc = widget.get_style().font_desc
 141                         metrics = pango_ctx.get_metrics(font_desc)
 142
 143                         ascent = pango.PIXELS(metrics.get_ascent())
 144                         descent = pango.PIXELS(metrics.get_descent())
 145
 146                         self._box_size = ascent + descent + 6
 147                         return self._box_size
 148
 149         def set_colour(self, ctx, colour, bg, fg):
 150                 """Set the context source colour.
 151
 152                 Picks a distinct colour based on an internal wheel; the bg
 153                 parameter provides the value that should be assigned to the 'zero'
 154                 colours and the fg parameter provides the multiplier that should be
 155                 applied to the foreground colours.
 156                 """
 157                 colours = [
 158                     ( 1.0, 0.0, 0.0 ),
 159                     ( 1.0, 1.0, 0.0 ),
 160                     ( 0.0, 1.0, 0.0 ),
 161                     ( 0.0, 1.0, 1.0 ),
 162                     ( 0.0, 0.0, 1.0 ),
 163                     ( 1.0, 0.0, 1.0 ),
 164                     ]
 165
 166                 colour %= len(colours)
 167                 red   = (colours[colour][0] * fg) or bg
 168                 green = (colours[colour][1] * fg) or bg
 169                 blue  = (colours[colour][2] * fg) or bg
 170
 171                 ctx.set_source_rgb(red, green, blue)
 172
 173         def on_get_size(self, widget, cell_area):
 174                 """Return the size we need for this cell.
 175
 176                 Each cell is drawn individually and is only as wide as it needs
 177                 to be, we let the TreeViewColumn take care of making them all
 178                 line up.
 179                 """
 180                 box_size = self.box_size(widget)
 181
 182                 cols = self.node[0]
 183                 for start, end, colour in self.in_lines + self.out_lines:
 184                         cols = int(max(cols, start, end))
 185
 186                 (column, colour, names) = self.node
 187                 names_len = 0
 188                 if (len(names) != 0):
 189                         for item in names:
 190                                 names_len += len(item)
 191
 192                 width = box_size * (cols + 1 ) + names_len
 193                 height = box_size
 194
 195                 # FIXME I have no idea how to use cell_area properly
 196                 return (0, 0, width, height)
 197
 198         def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
 199                 """Render an individual cell.
 200
 201                 Draws the cell contents using cairo, taking care to clip what we
 202                 do to within the background area so we don't draw over other cells.
 203                 Note that we're a bit naughty there and should really be drawing
 204                 in the cell_area (or even the exposed area), but we explicitly don't
 205                 want any gutter.
 206
 207                 We try and be a little clever, if the line we need to draw is going
 208                 to cross other columns we actually draw it as in the .---' style
 209                 instead of a pure diagonal ... this reduces confusion by an
 210                 incredible amount.
 211                 """
 212                 ctx = window.cairo_create()
 213                 ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
 214                 ctx.clip()
 215
 216                 box_size = self.box_size(widget)
 217
 218                 ctx.set_line_width(box_size / 8)
 219                 ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
 220
 221                 # Draw lines into the cell
 222                 for start, end, colour in self.in_lines:
 223                         ctx.move_to(cell_area.x + box_size * start + box_size / 2,
 224                                         bg_area.y - bg_area.height / 2)
 225
 226                         if start - end > 1:
 227                                 ctx.line_to(cell_area.x + box_size * start, bg_area.y)
 228                                 ctx.line_to(cell_area.x + box_size * end + box_size, bg_area.y)
 229                         elif start - end < -1:
 230                                 ctx.line_to(cell_area.x + box_size * start + box_size,
 231                                                 bg_area.y)
 232                                 ctx.line_to(cell_area.x + box_size * end, bg_area.y)
 233
 234                         ctx.line_to(cell_area.x + box_size * end + box_size / 2,
 235                                         bg_area.y + bg_area.height / 2)
 236
 237                         self.set_colour(ctx, colour, 0.0, 0.65)
 238                         ctx.stroke()
 239
 240                 # Draw lines out of the cell
 241                 for start, end, colour in self.out_lines:
 242                         ctx.move_to(cell_area.x + box_size * start + box_size / 2,
 243                                         bg_area.y + bg_area.height / 2)
 244
 245                         if start - end > 1:
 246                                 ctx.line_to(cell_area.x + box_size * start,
 247                                                 bg_area.y + bg_area.height)
 248                                 ctx.line_to(cell_area.x + box_size * end + box_size,
 249                                                 bg_area.y + bg_area.height)
 250                         elif start - end < -1:
 251                                 ctx.line_to(cell_area.x + box_size * start + box_size,
 252                                                 bg_area.y + bg_area.height)
 253                                 ctx.line_to(cell_area.x + box_size * end,
 254                                                 bg_area.y + bg_area.height)
 255
 256                         ctx.line_to(cell_area.x + box_size * end + box_size / 2,
 257                                         bg_area.y + bg_area.height / 2 + bg_area.height)
 258
 259                         self.set_colour(ctx, colour, 0.0, 0.65)
 260                         ctx.stroke()
 261
 262                 # Draw the revision node in the right column
 263                 (column, colour, names) = self.node
 264                 ctx.arc(cell_area.x + box_size * column + box_size / 2,
 265                                 cell_area.y + cell_area.height / 2,
 266                                 box_size / 4, 0, 2 * math.pi)
 267
 268
 269                 self.set_colour(ctx, colour, 0.0, 0.5)
 270                 ctx.stroke_preserve()
 271
 272                 self.set_colour(ctx, colour, 0.5, 1.0)
 273                 ctx.fill_preserve()
 274
 275                 if (len(names) != 0):
 276                         name = " "
 277                         for item in names:
 278                                 name = name + item + " "
 279
 280                         ctx.set_font_size(13)
 281                         if (flags & 1):
 282                                 self.set_colour(ctx, colour, 0.5, 1.0)
 283                         else:
 284                                 self.set_colour(ctx, colour, 0.0, 0.5)
 285                         ctx.show_text(name)
 286
 287 class Commit(object):
 288         """ This represent a commit object obtained after parsing the git-rev-list
 289         output """
 290
 291         __slots__ = ['children_sha1', 'message', 'author', 'date', 'committer',
 292                                  'commit_date', 'commit_sha1', 'parent_sha1']
 293
 294         children_sha1 = {}
 295
 296         def __init__(self, commit_lines):
 297                 self.message            = ""
 298                 self.author             = ""
 299                 self.date               = ""
 300                 self.committer          = ""
 301                 self.commit_date        = ""
 302                 self.commit_sha1        = ""
 303                 self.parent_sha1        = [ ]
 304                 self.parse_commit(commit_lines)
 305
 306
 307         def parse_commit(self, commit_lines):
 308
 309                 # First line is the sha1 lines
 310                 line = string.strip(commit_lines[0])
 311                 sha1 = re.split(" ", line)
 312                 self.commit_sha1 = sha1[0]
 313                 self.parent_sha1 = sha1[1:]
 314
 315                 #build the child list
 316                 for parent_id in self.parent_sha1:
 317                         try:
 318                                 Commit.children_sha1[parent_id].append(self.commit_sha1)
 319                         except KeyError:
 320                                 Commit.children_sha1[parent_id] = [self.commit_sha1]
 321
 322                 # IF we don't have parent
 323                 if (len(self.parent_sha1) == 0):
 324                         self.parent_sha1 = [0]
 325
 326                 for line in commit_lines[1:]:
 327                         m = re.match("^ ", line)
 328                         if (m != None):
 329                                 # First line of the commit message used for short log
 330                                 if self.message == "":
 331                                         self.message = string.strip(line)
 332                                 continue
 333
 334                         m = re.match("tree", line)
 335                         if (m != None):
 336                                 continue
 337
 338                         m = re.match("parent", line)
 339                         if (m != None):
 340                                 continue
 341
 342                         m = re_ident.match(line)
 343                         if (m != None):
 344                                 date = show_date(m.group('epoch'), m.group('tz'))
 345                                 if m.group(1) == "author":
 346                                         self.author = m.group('ident')
 347                                         self.date = date
 348                                 elif m.group(1) == "committer":
 349                                         self.committer = m.group('ident')
 350                                         self.commit_date = date
 351
 352                                 continue
 353
 354         def get_message(self, with_diff=0):
 355                 if (with_diff == 1):
 356                         message = self.diff_tree()
 357                 else:
 358                         fp = os.popen("git cat-file commit " + self.commit_sha1)
 359                         message = fp.read()
 360                         fp.close()
 361
 362                 return message
 363
 364         def diff_tree(self):
 365                 fp = os.popen("git diff-tree --pretty --cc  -v -p --always " +  self.commit_sha1)
 366                 diff = fp.read()
 367                 fp.close()
 368                 return diff
 369
 370 class AnnotateWindow(object):
 371         """Annotate window.
 372         This object represents and manages a single window containing the
 373         annotate information of the file
 374         """
 375
 376         def __init__(self):
 377                 self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 378                 self.window.set_border_width(0)
 379                 self.window.set_title("Git repository browser annotation window")
 380                 self.prev_read = ""
 381
 382                 # Use two thirds of the screen by default
 383                 screen = self.window.get_screen()
 384                 monitor = screen.get_monitor_geometry(0)
 385                 width = int(monitor.width * 0.66)
 386                 height = int(monitor.height * 0.66)
 387                 self.window.set_default_size(width, height)
 388
 389         def add_file_data(self, filename, commit_sha1, line_num):
 390                 fp = os.popen("git cat-file blob " + commit_sha1 +":"+filename)
 391                 i = 1;
 392                 for line in fp.readlines():
 393                         line = string.rstrip(line)
 394                         self.model.append(None, ["HEAD", filename, line, i])
 395                         i = i+1
 396                 fp.close()
 397
 398                 # now set the cursor position
 399                 self.treeview.set_cursor(line_num-1)
 400                 self.treeview.grab_focus()
 401
 402         def _treeview_cursor_cb(self, *args):
 403                 """Callback for when the treeview cursor changes."""
 404                 (path, col) = self.treeview.get_cursor()
 405                 commit_sha1 = self.model[path][0]
 406                 commit_msg = ""
 407                 fp = os.popen("git cat-file commit " + commit_sha1)
 408                 for line in fp.readlines():
 409                         commit_msg =  commit_msg + line
 410                 fp.close()
 411
 412                 self.commit_buffer.set_text(commit_msg)
 413
 414         def _treeview_row_activated(self, *args):
 415                 """Callback for when the treeview row gets selected."""
 416                 (path, col) = self.treeview.get_cursor()
 417                 commit_sha1 = self.model[path][0]
 418                 filename    = self.model[path][1]
 419                 line_num    = self.model[path][3]
 420
 421                 window = AnnotateWindow();
 422                 fp = os.popen("git rev-parse "+ commit_sha1 + "~1")
 423                 commit_sha1 = string.strip(fp.readline())
 424                 fp.close()
 425                 window.annotate(filename, commit_sha1, line_num)
 426
 427         def data_ready(self, source, condition):
 428                 while (1):
 429                         try :
 430                                 # A simple readline doesn't work
 431                                 # a readline bug ??
 432                                 buffer = source.read(100)
 433
 434                         except:
 435                                 # resource temporary not available
 436                                 return True
 437
 438                         if (len(buffer) == 0):
 439                                 gobject.source_remove(self.io_watch_tag)
 440                                 source.close()
 441                                 return False
 442
 443                         if (self.prev_read != ""):
 444                                 buffer = self.prev_read + buffer
 445                                 self.prev_read = ""
 446
 447                         if (buffer[len(buffer) -1] != '\n'):
 448                                 try:
 449                                         newline_index = buffer.rindex("\n")
 450                                 except ValueError:
 451                                         newline_index = 0
 452
 453                                 self.prev_read = buffer[newline_index:(len(buffer))]
 454                                 buffer = buffer[0:newline_index]
 455
 456                         for buff in buffer.split("\n"):
 457                                 annotate_line = re.compile('^([0-9a-f]{40}) (.+) (.+) (.+)$')
 458                                 m = annotate_line.match(buff)
 459                                 if not m:
 460                                         annotate_line = re.compile('^(filename) (.+)$')
 461                                         m = annotate_line.match(buff)
 462                                         if not m:
 463                                                 continue
 464                                         filename = m.group(2)
 465                                 else:
 466                                         self.commit_sha1 = m.group(1)
 467                                         self.source_line = int(m.group(2))
 468                                         self.result_line = int(m.group(3))
 469                                         self.count          = int(m.group(4))
 470                                         #set the details only when we have the file name
 471                                         continue
 472
 473                                 while (self.count > 0):
 474                                         # set at result_line + count-1 the sha1 as commit_sha1
 475                                         self.count = self.count - 1
 476                                         iter = self.model.iter_nth_child(None, self.result_line + self.count-1)
 477                                         self.model.set(iter, 0, self.commit_sha1, 1, filename, 3, self.source_line)
 478
 479
 480         def annotate(self, filename, commit_sha1, line_num):
 481                 # verify the commit_sha1 specified has this filename
 482
 483                 fp = os.popen("git ls-tree "+ commit_sha1 + " -- " + filename)
 484                 line = string.strip(fp.readline())
 485                 if line == '':
 486                         # pop up the message the file is not there as a part of the commit
 487                         fp.close()
 488                         dialog = gtk.MessageDialog(parent=None, flags=0,
 489                                         type=gtk.MESSAGE_WARNING, buttons=gtk.BUTTONS_CLOSE,
 490                                         message_format=None)
 491                         dialog.set_markup("The file %s is not present in the parent commit %s" % (filename, commit_sha1))
 492                         dialog.run()
 493                         dialog.destroy()
 494                         return
 495
 496                 fp.close()
 497
 498                 vpan = gtk.VPaned();
 499                 self.window.add(vpan);
 500                 vpan.show()
 501
 502                 scrollwin = gtk.ScrolledWindow()
 503                 scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 504                 scrollwin.set_shadow_type(gtk.SHADOW_IN)
 505                 vpan.pack1(scrollwin, True, True);
 506                 scrollwin.show()
 507
 508                 self.model = gtk.TreeStore(str, str, str, int)
 509                 self.treeview = gtk.TreeView(self.model)
 510                 self.treeview.set_rules_hint(True)
 511                 self.treeview.set_search_column(0)
 512                 self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
 513                 self.treeview.connect("row-activated", self._treeview_row_activated)
 514                 scrollwin.add(self.treeview)
 515                 self.treeview.show()
 516
 517                 cell = gtk.CellRendererText()
 518                 cell.set_property("width-chars", 10)
 519                 cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 520                 column = gtk.TreeViewColumn("Commit")
 521                 column.set_resizable(True)
 522                 column.pack_start(cell, expand=True)
 523                 column.add_attribute(cell, "text", 0)
 524                 self.treeview.append_column(column)
 525
 526                 cell = gtk.CellRendererText()
 527                 cell.set_property("width-chars", 20)
 528                 cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 529                 column = gtk.TreeViewColumn("File Name")
 530                 column.set_resizable(True)
 531                 column.pack_start(cell, expand=True)
 532                 column.add_attribute(cell, "text", 1)
 533                 self.treeview.append_column(column)
 534
 535                 cell = gtk.CellRendererText()
 536                 cell.set_property("width-chars", 20)
 537                 cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 538                 column = gtk.TreeViewColumn("Data")
 539                 column.set_resizable(True)
 540                 column.pack_start(cell, expand=True)
 541                 column.add_attribute(cell, "text", 2)
 542                 self.treeview.append_column(column)
 543
 544                 # The commit message window
 545                 scrollwin = gtk.ScrolledWindow()
 546                 scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 547                 scrollwin.set_shadow_type(gtk.SHADOW_IN)
 548                 vpan.pack2(scrollwin, True, True);
 549                 scrollwin.show()
 550
 551                 commit_text = gtk.TextView()
 552                 self.commit_buffer = gtk.TextBuffer()
 553                 commit_text.set_buffer(self.commit_buffer)
 554                 scrollwin.add(commit_text)
 555                 commit_text.show()
 556
 557                 self.window.show()
 558
 559                 self.add_file_data(filename, commit_sha1, line_num)
 560
 561                 fp = os.popen("git blame --incremental -C -C -- " + filename + " " + commit_sha1)
 562                 flags = fcntl.fcntl(fp.fileno(), fcntl.F_GETFL)
 563                 fcntl.fcntl(fp.fileno(), fcntl.F_SETFL, flags | os.O_NONBLOCK)
 564                 self.io_watch_tag = gobject.io_add_watch(fp, gobject.IO_IN, self.data_ready)
 565
 566
 567 class DiffWindow(object):
 568         """Diff window.
 569         This object represents and manages a single window containing the
 570         differences between two revisions on a branch.
 571         """
 572
 573         def __init__(self):
 574                 self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 575                 self.window.set_border_width(0)
 576                 self.window.set_title("Git repository browser diff window")
 577
 578                 # Use two thirds of the screen by default
 579                 screen = self.window.get_screen()
 580                 monitor = screen.get_monitor_geometry(0)
 581                 width = int(monitor.width * 0.66)
 582                 height = int(monitor.height * 0.66)
 583                 self.window.set_default_size(width, height)
 584
 585
 586                 self.construct()
 587
 588         def construct(self):
 589                 """Construct the window contents."""
 590                 vbox = gtk.VBox()
 591                 self.window.add(vbox)
 592                 vbox.show()
 593
 594                 menu_bar = gtk.MenuBar()
 595                 save_menu = gtk.ImageMenuItem(gtk.STOCK_SAVE)
 596                 save_menu.connect("activate", self.save_menu_response, "save")
 597                 save_menu.show()
 598                 menu_bar.append(save_menu)
 599                 vbox.pack_start(menu_bar, expand=False, fill=True)
 600                 menu_bar.show()
 601
 602                 hpan = gtk.HPaned()
 603
 604                 scrollwin = gtk.ScrolledWindow()
 605                 scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 606                 scrollwin.set_shadow_type(gtk.SHADOW_IN)
 607                 hpan.pack1(scrollwin, True, True)
 608                 scrollwin.show()
 609
 610                 (self.buffer, sourceview) = get_source_buffer_and_view()
 611
 612                 sourceview.set_editable(False)
 613                 sourceview.modify_font(pango.FontDescription("Monospace"))
 614                 scrollwin.add(sourceview)
 615                 sourceview.show()
 616
 617                 # The file hierarchy: a scrollable treeview
 618                 scrollwin = gtk.ScrolledWindow()
 619                 scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 620                 scrollwin.set_shadow_type(gtk.SHADOW_IN)
 621                 scrollwin.set_size_request(20, -1)
 622                 hpan.pack2(scrollwin, True, True)
 623                 scrollwin.show()
 624
 625                 self.model = gtk.TreeStore(str, str, str)
 626                 self.treeview = gtk.TreeView(self.model)
 627                 self.treeview.set_search_column(1)
 628                 self.treeview.connect("cursor-changed", self._treeview_clicked)
 629                 scrollwin.add(self.treeview)
 630                 self.treeview.show()
 631
 632                 cell = gtk.CellRendererText()
 633                 cell.set_property("width-chars", 20)
 634                 column = gtk.TreeViewColumn("Select to annotate")
 635                 column.pack_start(cell, expand=True)
 636                 column.add_attribute(cell, "text", 0)
 637                 self.treeview.append_column(column)
 638
 639                 vbox.pack_start(hpan, expand=True, fill=True)
 640                 hpan.show()
 641
 642         def _treeview_clicked(self, *args):
 643                 """Callback for when the treeview cursor changes."""
 644                 (path, col) = self.treeview.get_cursor()
 645                 specific_file = self.model[path][1]
 646                 commit_sha1 =  self.model[path][2]
 647                 if specific_file ==  None :
 648                         return
 649                 elif specific_file ==  "" :
 650                         specific_file =  None
 651
 652                 window = AnnotateWindow();
 653                 window.annotate(specific_file, commit_sha1, 1)
 654
 655
 656         def commit_files(self, commit_sha1, parent_sha1):
 657                 self.model.clear()
 658                 add  = self.model.append(None, [ "Added", None, None])
 659                 dele = self.model.append(None, [ "Deleted", None, None])
 660                 mod  = self.model.append(None, [ "Modified", None, None])
 661                 diff_tree = re.compile('^(:.{6}) (.{6}) (.{40}) (.{40}) (A|D|M)\s(.+)$')
 662                 fp = os.popen("git diff-tree -r --no-commit-id " + parent_sha1 + " " + commit_sha1)
 663                 while 1:
 664                         line = string.strip(fp.readline())
 665                         if line == '':
 666                                 break
 667                         m = diff_tree.match(line)
 668                         if not m:
 669                                 continue
 670
 671                         attr = m.group(5)
 672                         filename = m.group(6)
 673                         if attr == "A":
 674                                 self.model.append(add,  [filename, filename, commit_sha1])
 675                         elif attr == "D":
 676                                 self.model.append(dele, [filename, filename, commit_sha1])
 677                         elif attr == "M":
 678                                 self.model.append(mod,  [filename, filename, commit_sha1])
 679                 fp.close()
 680
 681                 self.treeview.expand_all()
 682
 683         def set_diff(self, commit_sha1, parent_sha1, encoding):
 684                 """Set the differences showed by this window.
 685                 Compares the two trees and populates the window with the
 686                 differences.
 687                 """
 688                 # Diff with the first commit or the last commit shows nothing
 689                 if (commit_sha1 == 0 or parent_sha1 == 0 ):
 690                         return
 691
 692                 fp = os.popen("git diff-tree -p " + parent_sha1 + " " + commit_sha1)
 693                 self.buffer.set_text(unicode(fp.read(), encoding).encode('utf-8'))
 694                 fp.close()
 695                 self.commit_files(commit_sha1, parent_sha1)
 696                 self.window.show()
 697
 698         def save_menu_response(self, widget, string):
 699                 dialog = gtk.FileChooserDialog("Save..", None, gtk.FILE_CHOOSER_ACTION_SAVE,
 700                                 (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
 701                                         gtk.STOCK_SAVE, gtk.RESPONSE_OK))
 702                 dialog.set_default_response(gtk.RESPONSE_OK)
 703                 response = dialog.run()
 704                 if response == gtk.RESPONSE_OK:
 705                         patch_buffer = self.buffer.get_text(self.buffer.get_start_iter(),
 706                                         self.buffer.get_end_iter())
 707                         fp = open(dialog.get_filename(), "w")
 708                         fp.write(patch_buffer)
 709                         fp.close()
 710                 dialog.destroy()
 711
 712 class GitView(object):
 713         """ This is the main class
 714         """
 715         version = "0.9"
 716
 717         def __init__(self, with_diff=0):
 718                 self.with_diff = with_diff
 719                 self.window =   gtk.Window(gtk.WINDOW_TOPLEVEL)
 720                 self.window.set_border_width(0)
 721                 self.window.set_title("Git repository browser")
 722
 723                 self.get_encoding()
 724                 self.get_bt_sha1()
 725
 726                 # Use three-quarters of the screen by default
 727                 screen = self.window.get_screen()
 728                 monitor = screen.get_monitor_geometry(0)
 729                 width = int(monitor.width * 0.75)
 730                 height = int(monitor.height * 0.75)
 731                 self.window.set_default_size(width, height)
 732
 733                 # FIXME AndyFitz!
 734                 icon = self.window.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
 735                 self.window.set_icon(icon)
 736
 737                 self.accel_group = gtk.AccelGroup()
 738                 self.window.add_accel_group(self.accel_group)
 739                 self.accel_group.connect_group(0xffc2, 0, gtk.ACCEL_LOCKED, self.refresh);
 740                 self.accel_group.connect_group(0xffc1, 0, gtk.ACCEL_LOCKED, self.maximize);
 741                 self.accel_group.connect_group(0xffc8, 0, gtk.ACCEL_LOCKED, self.fullscreen);
 742                 self.accel_group.connect_group(0xffc9, 0, gtk.ACCEL_LOCKED, self.unfullscreen);
 743
 744                 self.window.add(self.construct())
 745
 746         def refresh(self, widget, event=None, *arguments, **keywords):
 747                 self.get_encoding()
 748                 self.get_bt_sha1()
 749                 Commit.children_sha1 = {}
 750                 self.set_branch(sys.argv[without_diff:])
 751                 self.window.show()
 752                 return True
 753
 754         def maximize(self, widget, event=None, *arguments, **keywords):
 755                 self.window.maximize()
 756                 return True
 757
 758         def fullscreen(self, widget, event=None, *arguments, **keywords):
 759                 self.window.fullscreen()
 760                 return True
 761
 762         def unfullscreen(self, widget, event=None, *arguments, **keywords):
 763                 self.window.unfullscreen()
 764                 return True
 765
 766         def get_bt_sha1(self):
 767                 """ Update the bt_sha1 dictionary with the
 768                 respective sha1 details """
 769
 770                 self.bt_sha1 = { }
 771                 ls_remote = re.compile('^(.{40})\trefs/([^^]+)(?:\\^(..))?$');
 772                 fp = os.popen('git ls-remote "${GIT_DIR-.git}"')
 773                 while 1:
 774                         line = string.strip(fp.readline())
 775                         if line == '':
 776                                 break
 777                         m = ls_remote.match(line)
 778                         if not m:
 779                                 continue
 780                         (sha1, name) = (m.group(1), m.group(2))
 781                         if not self.bt_sha1.has_key(sha1):
 782                                 self.bt_sha1[sha1] = []
 783                         self.bt_sha1[sha1].append(name)
 784                 fp.close()
 785
 786         def get_encoding(self):
 787                 fp = os.popen("git config --get i18n.commitencoding")
 788                 self.encoding=string.strip(fp.readline())
 789                 fp.close()
 790                 if (self.encoding == ""):
 791                         self.encoding = "utf-8"
 792
 793
 794         def construct(self):
 795                 """Construct the window contents."""
 796                 vbox = gtk.VBox()
 797                 paned = gtk.VPaned()
 798                 paned.pack1(self.construct_top(), resize=False, shrink=True)
 799                 paned.pack2(self.construct_bottom(), resize=False, shrink=True)
 800                 menu_bar = gtk.MenuBar()
 801                 menu_bar.set_pack_direction(gtk.PACK_DIRECTION_RTL)
 802                 help_menu = gtk.MenuItem("Help")
 803                 menu = gtk.Menu()
 804                 about_menu = gtk.MenuItem("About")
 805                 menu.append(about_menu)
 806                 about_menu.connect("activate", self.about_menu_response, "about")
 807                 about_menu.show()
 808                 help_menu.set_submenu(menu)
 809                 help_menu.show()
 810                 menu_bar.append(help_menu)
 811                 menu_bar.show()
 812                 vbox.pack_start(menu_bar, expand=False, fill=True)
 813                 vbox.pack_start(paned, expand=True, fill=True)
 814                 paned.show()
 815                 vbox.show()
 816                 return vbox
 817
 818
 819         def construct_top(self):
 820                 """Construct the top-half of the window."""
 821                 vbox = gtk.VBox(spacing=6)
 822                 vbox.set_border_width(12)
 823                 vbox.show()
 824
 825
 826                 scrollwin = gtk.ScrolledWindow()
 827                 scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 828                 scrollwin.set_shadow_type(gtk.SHADOW_IN)
 829                 vbox.pack_start(scrollwin, expand=True, fill=True)
 830                 scrollwin.show()
 831
 832                 self.treeview = gtk.TreeView()
 833                 self.treeview.set_rules_hint(True)
 834                 self.treeview.set_search_column(4)
 835                 self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
 836                 scrollwin.add(self.treeview)
 837                 self.treeview.show()
 838
 839                 cell = CellRendererGraph()
 840                 column = gtk.TreeViewColumn()
 841                 column.set_resizable(True)
 842                 column.pack_start(cell, expand=True)
 843                 column.add_attribute(cell, "node", 1)
 844                 column.add_attribute(cell, "in-lines", 2)
 845                 column.add_attribute(cell, "out-lines", 3)
 846                 self.treeview.append_column(column)
 847
 848                 cell = gtk.CellRendererText()
 849                 cell.set_property("width-chars", 65)
 850                 cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 851                 column = gtk.TreeViewColumn("Message")
 852                 column.set_resizable(True)
 853                 column.pack_start(cell, expand=True)
 854                 column.add_attribute(cell, "text", 4)
 855                 self.treeview.append_column(column)
 856
 857                 cell = gtk.CellRendererText()
 858                 cell.set_property("width-chars", 40)
 859                 cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 860                 column = gtk.TreeViewColumn("Author")
 861                 column.set_resizable(True)
 862                 column.pack_start(cell, expand=True)
 863                 column.add_attribute(cell, "text", 5)
 864                 self.treeview.append_column(column)
 865
 866                 cell = gtk.CellRendererText()
 867                 cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 868                 column = gtk.TreeViewColumn("Date")
 869                 column.set_resizable(True)
 870                 column.pack_start(cell, expand=True)
 871                 column.add_attribute(cell, "text", 6)
 872                 self.treeview.append_column(column)
 873
 874                 return vbox
 875
 876         def about_menu_response(self, widget, string):
 877                 dialog = gtk.AboutDialog()
 878                 dialog.set_name("Gitview")
 879                 dialog.set_version(GitView.version)
 880                 dialog.set_authors(["Aneesh Kumar K.V <aneesh.kumar@gmail.com>"])
 881                 dialog.set_website("http://www.kernel.org/pub/software/scm/git/")
 882                 dialog.set_copyright("Use and distribute under the terms of the GNU General Public License")
 883                 dialog.set_wrap_license(True)
 884                 dialog.run()
 885                 dialog.destroy()
 886
 887
 888         def construct_bottom(self):
 889                 """Construct the bottom half of the window."""
 890                 vbox = gtk.VBox(False, spacing=6)
 891                 vbox.set_border_width(12)
 892                 (width, height) = self.window.get_size()
 893                 vbox.set_size_request(width, int(height / 2.5))
 894                 vbox.show()
 895
 896                 self.table = gtk.Table(rows=4, columns=4)
 897                 self.table.set_row_spacings(6)
 898                 self.table.set_col_spacings(6)
 899                 vbox.pack_start(self.table, expand=False, fill=True)
 900                 self.table.show()
 901
 902                 align = gtk.Alignment(0.0, 0.5)
 903                 label = gtk.Label()
 904                 label.set_markup("<b>Revision:</b>")
 905                 align.add(label)
 906                 self.table.attach(align, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
 907                 label.show()
 908                 align.show()
 909
 910                 align = gtk.Alignment(0.0, 0.5)
 911                 self.revid_label = gtk.Label()
 912                 self.revid_label.set_selectable(True)
 913                 align.add(self.revid_label)
 914                 self.table.attach(align, 1, 2, 0, 1, gtk.EXPAND | gtk.FILL, gtk.FILL)
 915                 self.revid_label.show()
 916                 align.show()
 917
 918                 align = gtk.Alignment(0.0, 0.5)
 919                 label = gtk.Label()
 920                 label.set_markup("<b>Committer:</b>")
 921                 align.add(label)
 922                 self.table.attach(align, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
 923                 label.show()
 924                 align.show()
 925
 926                 align = gtk.Alignment(0.0, 0.5)
 927                 self.committer_label = gtk.Label()
 928                 self.committer_label.set_selectable(True)
 929                 align.add(self.committer_label)
 930                 self.table.attach(align, 1, 2, 1, 2, gtk.EXPAND | gtk.FILL, gtk.FILL)
 931                 self.committer_label.show()
 932                 align.show()
 933
 934                 align = gtk.Alignment(0.0, 0.5)
 935                 label = gtk.Label()
 936                 label.set_markup("<b>Timestamp:</b>")
 937                 align.add(label)
 938                 self.table.attach(align, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
 939                 label.show()
 940                 align.show()
 941
 942                 align = gtk.Alignment(0.0, 0.5)
 943                 self.timestamp_label = gtk.Label()
 944                 self.timestamp_label.set_selectable(True)
 945                 align.add(self.timestamp_label)
 946                 self.table.attach(align, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL, gtk.FILL)
 947                 self.timestamp_label.show()
 948                 align.show()
 949
 950                 align = gtk.Alignment(0.0, 0.5)
 951                 label = gtk.Label()
 952                 label.set_markup("<b>Parents:</b>")
 953                 align.add(label)
 954                 self.table.attach(align, 0, 1, 3, 4, gtk.FILL, gtk.FILL)
 955                 label.show()
 956                 align.show()
 957                 self.parents_widgets = []
 958
 959                 align = gtk.Alignment(0.0, 0.5)
 960                 label = gtk.Label()
 961                 label.set_markup("<b>Children:</b>")
 962                 align.add(label)
 963                 self.table.attach(align, 2, 3, 3, 4, gtk.FILL, gtk.FILL)
 964                 label.show()
 965                 align.show()
 966                 self.children_widgets = []
 967
 968                 scrollwin = gtk.ScrolledWindow()
 969                 scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 970                 scrollwin.set_shadow_type(gtk.SHADOW_IN)
 971                 vbox.pack_start(scrollwin, expand=True, fill=True)
 972                 scrollwin.show()
 973
 974                 (self.message_buffer, sourceview) = get_source_buffer_and_view()
 975
 976                 sourceview.set_editable(False)
 977                 sourceview.modify_font(pango.FontDescription("Monospace"))
 978                 scrollwin.add(sourceview)
 979                 sourceview.show()
 980
 981                 return vbox
 982
 983         def _treeview_cursor_cb(self, *args):
 984                 """Callback for when the treeview cursor changes."""
 985                 (path, col) = self.treeview.get_cursor()
 986                 commit = self.model[path][0]
 987
 988                 if commit.committer is not None:
 989                         committer = commit.committer
 990                         timestamp = commit.commit_date
 991                         message   =  commit.get_message(self.with_diff)
 992                         revid_label = commit.commit_sha1
 993                 else:
 994                         committer = ""
 995                         timestamp = ""
 996                         message = ""
 997                         revid_label = ""
 998
 999                 self.revid_label.set_text(revid_label)
1000                 self.committer_label.set_text(committer)
1001                 self.timestamp_label.set_text(timestamp)
1002                 self.message_buffer.set_text(unicode(message, self.encoding).encode('utf-8'))
1003
1004                 for widget in self.parents_widgets:
1005                         self.table.remove(widget)
1006
1007                 self.parents_widgets = []
1008                 self.table.resize(4 + len(commit.parent_sha1) - 1, 4)
1009                 for idx, parent_id in enumerate(commit.parent_sha1):
1010                         self.table.set_row_spacing(idx + 3, 0)
1011
1012                         align = gtk.Alignment(0.0, 0.0)
1013                         self.parents_widgets.append(align)
1014                         self.table.attach(align, 1, 2, idx + 3, idx + 4,
1015                                         gtk.EXPAND | gtk.FILL, gtk.FILL)
1016                         align.show()
1017
1018                         hbox = gtk.HBox(False, 0)
1019                         align.add(hbox)
1020                         hbox.show()
1021
1022                         label = gtk.Label(parent_id)
1023                         label.set_selectable(True)
1024                         hbox.pack_start(label, expand=False, fill=True)
1025                         label.show()
1026
1027                         image = gtk.Image()
1028                         image.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
1029                         image.show()
1030
1031                         button = gtk.Button()
1032                         button.add(image)
1033                         button.set_relief(gtk.RELIEF_NONE)
1034                         button.connect("clicked", self._go_clicked_cb, parent_id)
1035                         hbox.pack_start(button, expand=False, fill=True)
1036                         button.show()
1037
1038                         image = gtk.Image()
1039                         image.set_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
1040                         image.show()
1041
1042                         button = gtk.Button()
1043                         button.add(image)
1044                         button.set_relief(gtk.RELIEF_NONE)
1045                         button.set_sensitive(True)
1046                         button.connect("clicked", self._show_clicked_cb,
1047                                         commit.commit_sha1, parent_id, self.encoding)
1048                         hbox.pack_start(button, expand=False, fill=True)
1049                         button.show()
1050
1051                 # Populate with child details
1052                 for widget in self.children_widgets:
1053                         self.table.remove(widget)
1054
1055                 self.children_widgets = []
1056                 try:
1057                         child_sha1 = Commit.children_sha1[commit.commit_sha1]
1058                 except KeyError:
1059                         # We don't have child
1060                         child_sha1 = [ 0 ]
1061
1062                 if ( len(child_sha1) > len(commit.parent_sha1)):
1063                         self.table.resize(4 + len(child_sha1) - 1, 4)
1064
1065                 for idx, child_id in enumerate(child_sha1):
1066                         self.table.set_row_spacing(idx + 3, 0)
1067
1068                         align = gtk.Alignment(0.0, 0.0)
1069                         self.children_widgets.append(align)
1070                         self.table.attach(align, 3, 4, idx + 3, idx + 4,
1071                                         gtk.EXPAND | gtk.FILL, gtk.FILL)
1072                         align.show()
1073
1074                         hbox = gtk.HBox(False, 0)
1075                         align.add(hbox)
1076                         hbox.show()
1077
1078                         label = gtk.Label(child_id)
1079                         label.set_selectable(True)
1080                         hbox.pack_start(label, expand=False, fill=True)
1081                         label.show()
1082
1083                         image = gtk.Image()
1084                         image.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
1085                         image.show()
1086
1087                         button = gtk.Button()
1088                         button.add(image)
1089                         button.set_relief(gtk.RELIEF_NONE)
1090                         button.connect("clicked", self._go_clicked_cb, child_id)
1091                         hbox.pack_start(button, expand=False, fill=True)
1092                         button.show()
1093
1094                         image = gtk.Image()
1095                         image.set_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
1096                         image.show()
1097
1098                         button = gtk.Button()
1099                         button.add(image)
1100                         button.set_relief(gtk.RELIEF_NONE)
1101                         button.set_sensitive(True)
1102                         button.connect("clicked", self._show_clicked_cb,
1103                                         child_id, commit.commit_sha1, self.encoding)
1104                         hbox.pack_start(button, expand=False, fill=True)
1105                         button.show()
1106
1107         def _destroy_cb(self, widget):
1108                 """Callback for when a window we manage is destroyed."""
1109                 self.quit()
1110
1111
1112         def quit(self):
1113                 """Stop the GTK+ main loop."""
1114                 gtk.main_quit()
1115
1116         def run(self, args):
1117                 self.set_branch(args)
1118                 self.window.connect("destroy", self._destroy_cb)
1119                 self.window.show()
1120                 gtk.main()
1121
1122         def set_branch(self, args):
1123                 """Fill in different windows with info from the reposiroty"""
1124                 fp = os.popen("git rev-parse --sq --default HEAD " + list_to_string(args, 1))
1125                 git_rev_list_cmd = fp.read()
1126                 fp.close()
1127                 fp = os.popen("git rev-list  --header --topo-order --parents " + git_rev_list_cmd)
1128                 self.update_window(fp)
1129
1130         def update_window(self, fp):
1131                 commit_lines = []
1132
1133                 self.model = gtk.ListStore(gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT,
1134                                 gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, str, str, str)
1135
1136                 # used for cursor positioning
1137                 self.index = {}
1138
1139                 self.colours = {}
1140                 self.nodepos = {}
1141                 self.incomplete_line = {}
1142                 self.commits = []
1143
1144                 index = 0
1145                 last_colour = 0
1146                 last_nodepos = -1
1147                 out_line = []
1148                 input_line = fp.readline()
1149                 while (input_line != ""):
1150                         # The commit header ends with '\0'
1151                         # This NULL is immediately followed by the sha1 of the
1152                         # next commit
1153                         if (input_line[0] != '\0'):
1154                                 commit_lines.append(input_line)
1155                                 input_line = fp.readline()
1156                                 continue;
1157
1158                         commit = Commit(commit_lines)
1159                         if (commit != None ):
1160                                 self.commits.append(commit)
1161
1162                         # Skip the '\0
1163                         commit_lines = []
1164                         commit_lines.append(input_line[1:])
1165                         input_line = fp.readline()
1166
1167                 fp.close()
1168
1169                 for commit in self.commits:
1170                         (out_line, last_colour, last_nodepos) = self.draw_graph(commit,
1171                                                                                 index, out_line,
1172                                                                                 last_colour,
1173                                                                                 last_nodepos)
1174                         self.index[commit.commit_sha1] = index
1175                         index += 1
1176
1177                 self.treeview.set_model(self.model)
1178                 self.treeview.show()
1179
1180         def draw_graph(self, commit, index, out_line, last_colour, last_nodepos):
1181                 in_line=[]
1182
1183                 #   |   -> outline
1184                 #   X
1185                 #   |\  <- inline
1186
1187                 # Reset nodepostion
1188                 if (last_nodepos > 5):
1189                         last_nodepos = -1
1190
1191                 # Add the incomplete lines of the last cell in this
1192                 try:
1193                         colour = self.colours[commit.commit_sha1]
1194                 except KeyError:
1195                         self.colours[commit.commit_sha1] = last_colour+1
1196                         last_colour = self.colours[commit.commit_sha1]
1197                         colour =   self.colours[commit.commit_sha1]
1198
1199                 try:
1200                         node_pos = self.nodepos[commit.commit_sha1]
1201                 except KeyError:
1202                         self.nodepos[commit.commit_sha1] = last_nodepos+1
1203                         last_nodepos = self.nodepos[commit.commit_sha1]
1204                         node_pos =  self.nodepos[commit.commit_sha1]
1205
1206                 #The first parent always continue on the same line
1207                 try:
1208                         # check we already have the value
1209                         tmp_node_pos = self.nodepos[commit.parent_sha1[0]]
1210                 except KeyError:
1211                         self.colours[commit.parent_sha1[0]] = colour
1212                         self.nodepos[commit.parent_sha1[0]] = node_pos
1213
1214                 for sha1 in self.incomplete_line.keys():
1215                         if (sha1 != commit.commit_sha1):
1216                                 self.draw_incomplete_line(sha1, node_pos,
1217                                                 out_line, in_line, index)
1218                         else:
1219                                 del self.incomplete_line[sha1]
1220
1221
1222                 for parent_id in commit.parent_sha1:
1223                         try:
1224                                 tmp_node_pos = self.nodepos[parent_id]
1225                         except KeyError:
1226                                 self.colours[parent_id] = last_colour+1
1227                                 last_colour = self.colours[parent_id]
1228                                 self.nodepos[parent_id] = last_nodepos+1
1229                                 last_nodepos = self.nodepos[parent_id]
1230
1231                         in_line.append((node_pos, self.nodepos[parent_id],
1232                                                 self.colours[parent_id]))
1233                         self.add_incomplete_line(parent_id)
1234
1235                 try:
1236                         branch_tag = self.bt_sha1[commit.commit_sha1]
1237                 except KeyError:
1238                         branch_tag = [ ]
1239
1240
1241                 node = (node_pos, colour, branch_tag)
1242
1243                 self.model.append([commit, node, out_line, in_line,
1244                                 commit.message, commit.author, commit.date])
1245
1246                 return (in_line, last_colour, last_nodepos)
1247
1248         def add_incomplete_line(self, sha1):
1249                 try:
1250                         self.incomplete_line[sha1].append(self.nodepos[sha1])
1251                 except KeyError:
1252                         self.incomplete_line[sha1] = [self.nodepos[sha1]]
1253
1254         def draw_incomplete_line(self, sha1, node_pos, out_line, in_line, index):
1255                 for idx, pos in enumerate(self.incomplete_line[sha1]):
1256                         if(pos == node_pos):
1257                                 #remove the straight line and add a slash
1258                                 if ((pos, pos, self.colours[sha1]) in out_line):
1259                                         out_line.remove((pos, pos, self.colours[sha1]))
1260                                 out_line.append((pos, pos+0.5, self.colours[sha1]))
1261                                 self.incomplete_line[sha1][idx] = pos = pos+0.5
1262                         try:
1263                                 next_commit = self.commits[index+1]
1264                                 if (next_commit.commit_sha1 == sha1 and pos != int(pos)):
1265                                 # join the line back to the node point
1266                                 # This need to be done only if we modified it
1267                                         in_line.append((pos, pos-0.5, self.colours[sha1]))
1268                                         continue;
1269                         except IndexError:
1270                                 pass
1271                         in_line.append((pos, pos, self.colours[sha1]))
1272
1273
1274         def _go_clicked_cb(self, widget, revid):
1275                 """Callback for when the go button for a parent is clicked."""
1276                 try:
1277                         self.treeview.set_cursor(self.index[revid])
1278                 except KeyError:
1279                         dialog = gtk.MessageDialog(parent=None, flags=0,
1280                                         type=gtk.MESSAGE_WARNING, buttons=gtk.BUTTONS_CLOSE,
1281                                         message_format=None)
1282                         dialog.set_markup("Revision <b>%s</b> not present in the list" % revid)
1283                         # revid == 0 is the parent of the first commit
1284                         if (revid != 0 ):
1285                                 dialog.format_secondary_text("Try running gitview without any options")
1286                         dialog.run()
1287                         dialog.destroy()
1288
1289                 self.treeview.grab_focus()
1290
1291         def _show_clicked_cb(self, widget,  commit_sha1, parent_sha1, encoding):
1292                 """Callback for when the show button for a parent is clicked."""
1293                 window = DiffWindow()
1294                 window.set_diff(commit_sha1, parent_sha1, encoding)
1295                 self.treeview.grab_focus()
1296
1297 without_diff = 0
1298 if __name__ == "__main__":
1299
1300         if (len(sys.argv) > 1 ):
1301                 if (sys.argv[1] == "--without-diff"):
1302                         without_diff = 1
1303
1304         view = GitView( without_diff != 1)
1305         view.run(sys.argv[without_diff:])