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