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