X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=gitk;h=f1ea4e1e432010f9a049fe91b305d09f44589280;hb=40a10462498bdd23d4e49f02867b8be50eb78704;hp=dd8f1f1494bab7c83121e31927b306cec2ea564e;hpb=73b6a6cbda9cd568e2544f2c7dd6c217e369cc37;p=git.git

diff --git a/gitk b/gitk
index dd8f1f14..f1ea4e1e 100755
--- a/gitk
+++ b/gitk
@@ -1,6 +1,6 @@
 #!/bin/sh
 # Tcl ignores the next line -*- tcl -*- \
-exec wish "$0" -- "${1+$@}"
+exec wish "$0" -- "$@"
 
 # Copyright (C) 2005 Paul Mackerras.  All rights reserved.
 # This program is free software; it may be used, copied, modified
@@ -18,7 +18,7 @@ proc gitdir {} {
 
 proc getcommits {rargs} {
     global commits commfd phase canv mainfont env
-    global startmsecs nextupdate
+    global startmsecs nextupdate ncmupdate
     global ctext maincursor textcursor leftover
 
     # check that we can find a .git directory somewhere...
@@ -31,6 +31,7 @@ proc getcommits {rargs} {
     set phase getcommits
     set startmsecs [clock clicks -milliseconds]
     set nextupdate [expr $startmsecs + 100]
+    set ncmupdate 1
     if [catch {
 	set parse_args [concat --default HEAD $rargs]
 	set parsed_args [split [eval exec git-rev-parse $parse_args] "\n"]
@@ -42,23 +43,23 @@ proc getcommits {rargs} {
 	set parsed_args $rargs
     }
     if [catch {
-	set commfd [open "|git-rev-list --header --topo-order $parsed_args" r]
+	set commfd [open "|git-rev-list --header --topo-order --parents $parsed_args" r]
     } err] {
 	puts stderr "Error executing git-rev-list: $err"
 	exit 1
     }
     set leftover {}
-    fconfigure $commfd -blocking 0 -translation binary
-    fileevent $commfd readable "getcommitlines $commfd"
+    fconfigure $commfd -blocking 0 -translation lf
+    fileevent $commfd readable [list getcommitlines $commfd]
     $canv delete all
     $canv create text 3 3 -anchor nw -text "Reading commits..." \
 	-font $mainfont -tags textitems
     . config -cursor watch
-    $ctext config -cursor watch
+    settextcursor watch
 }
 
 proc getcommitlines {commfd}  {
-    global commits parents cdate children nchildren
+    global commits parents cdate children
     global commitlisted phase commitinfo nextupdate
     global stopped redisplaying leftover
 
@@ -95,7 +96,19 @@ to allow selection of commits to be displayed.)}
 	    set leftover {}
 	}
 	set start [expr {$i + 1}]
-	if {![regexp {^([0-9a-f]{40})\n} $cmit match id]} {
+	set j [string first "\n" $cmit]
+	set ok 0
+	if {$j >= 0} {
+	    set ids [string range $cmit 0 [expr {$j - 1}]]
+	    set ok 1
+	    foreach id $ids {
+		if {![regexp {^[0-9a-f]{40}$} $id]} {
+		    set ok 0
+		    break
+		}
+	    }
+	}
+	if {!$ok} {
 	    set shortcmit $cmit
 	    if {[string length $shortcmit] > 80} {
 		set shortcmit "[string range $shortcmit 0 80]..."
@@ -103,13 +116,15 @@ to allow selection of commits to be displayed.)}
 	    error_popup "Can't parse git-rev-list output: {$shortcmit}"
 	    exit 1
 	}
-	set cmit [string range $cmit 41 end]
+	set id [lindex $ids 0]
+	set olds [lrange $ids 1 end]
+	set cmit [string range $cmit [expr {$j + 1}] end]
 	lappend commits $id
 	set commitlisted($id) 1
-	parsecommit $id $cmit 1
+	parsecommit $id $cmit 1 [lrange $ids 1 end]
 	drawcommit $id
 	if {[clock clicks -milliseconds] >= $nextupdate} {
-	    doupdate
+	    doupdate 1
 	}
 	while {$redisplaying} {
 	    set redisplaying 0
@@ -120,7 +135,7 @@ to allow selection of commits to be displayed.)}
 		    drawcommit $id
 		    if {$stopped} break
 		    if {[clock clicks -milliseconds] >= $nextupdate} {
-			doupdate
+			doupdate 1
 		    }
 		}
 	    }
@@ -128,21 +143,32 @@ to allow selection of commits to be displayed.)}
     }
 }
 
-proc doupdate {} {
-    global commfd nextupdate
+proc doupdate {reading} {
+    global commfd nextupdate numcommits ncmupdate
 
-    incr nextupdate 100
-    fileevent $commfd readable {}
+    if {$reading} {
+	fileevent $commfd readable {}
+    }
     update
-    fileevent $commfd readable "getcommitlines $commfd"
+    set nextupdate [expr {[clock clicks -milliseconds] + 100}]
+    if {$numcommits < 100} {
+	set ncmupdate [expr {$numcommits + 1}]
+    } elseif {$numcommits < 10000} {
+	set ncmupdate [expr {$numcommits + 10}]
+    } else {
+	set ncmupdate [expr {$numcommits + 100}]
+    }
+    if {$reading} {
+	fileevent $commfd readable [list getcommitlines $commfd]
+    }
 }
 
 proc readcommit {id} {
     if [catch {set contents [exec git-cat-file commit $id]}] return
-    parsecommit $id $contents 0
+    parsecommit $id $contents 0 {}
 }
 
-proc parsecommit {id contents listed} {
+proc parsecommit {id contents listed olds} {
     global commitinfo children nchildren parents nparents cdate ncleft
 
     set inhdr 1
@@ -157,30 +183,26 @@ proc parsecommit {id contents listed} {
 	set nchildren($id) 0
 	set ncleft($id) 0
     }
-    set parents($id) {}
-    set nparents($id) 0
+    set parents($id) $olds
+    set nparents($id) [llength $olds]
+    foreach p $olds {
+	if {![info exists nchildren($p)]} {
+	    set children($p) [list $id]
+	    set nchildren($p) 1
+	    set ncleft($p) 1
+	} elseif {[lsearch -exact $children($p) $id] < 0} {
+	    lappend children($p) $id
+	    incr nchildren($p)
+	    incr ncleft($p)
+	}
+    }
     foreach line [split $contents "\n"] {
 	if {$inhdr} {
 	    if {$line == {}} {
 		set inhdr 0
 	    } else {
 		set tag [lindex $line 0]
-		if {$tag == "parent"} {
-		    set p [lindex $line 1]
-		    if {![info exists nchildren($p)]} {
-			set children($p) {}
-			set nchildren($p) 0
-			set ncleft($p) 0
-		    }
-		    lappend parents($id) $p
-		    incr nparents($id)
-		    # sometimes we get a commit that lists a parent twice...
-		    if {$listed && [lsearch -exact $children($p) $id] < 0} {
-			lappend children($p) $id
-			incr nchildren($p)
-			incr ncleft($p)
-		    }
-		} elseif {$tag == "author"} {
+		if {$tag == "author"} {
 		    set x [expr {[llength $line] - 2}]
 		    set audate [lindex $line $x]
 		    set auname [lrange $line 1 [expr {$x - 1}]]
@@ -216,7 +238,8 @@ proc parsecommit {id contents listed} {
 }
 
 proc readrefs {} {
-    global tagids idtags headids idheads
+    global tagids idtags headids idheads tagcontents
+
     set tags [glob -nocomplain -types f [gitdir]/refs/tags/*]
     foreach f $tags {
 	catch {
@@ -226,7 +249,8 @@ proc readrefs {} {
 		set direct [file tail $f]
 		set tagids($direct) $id
 		lappend idtags($id) $direct
-		set contents [split [exec git-cat-file tag $id] "\n"]
+		set tagblob [exec git-cat-file tag $id]
+		set contents [split $tagblob "\n"]
 		set obj {}
 		set type {}
 		set tag {}
@@ -241,6 +265,7 @@ proc readrefs {} {
 		if {$obj != {} && $type == "commit" && $tag != {}} {
 		    set tagids($tag) $obj
 		    lappend idtags($obj) $tag
+		    set tagcontents($tag) $tagblob
 		}
 	    }
 	    close $fd
@@ -259,6 +284,32 @@ proc readrefs {} {
 	    close $fd
 	}
     }
+    readotherrefs refs {} {tags heads}
+}
+
+proc readotherrefs {base dname excl} {
+    global otherrefids idotherrefs
+
+    set git [gitdir]
+    set files [glob -nocomplain -types f [file join $git $base *]]
+    foreach f $files {
+	catch {
+	    set fd [open $f r]
+	    set line [read $fd 40]
+	    if {[regexp {^[0-9a-f]{40}} $line id]} {
+		set name "$dname[file tail $f]"
+		set otherrefids($name) $id
+		lappend idotherrefs($id) $name
+	    }
+	    close $fd
+	}
+    }
+    set dirs [glob -nocomplain -types d [file join $git $base *]]
+    foreach d $dirs {
+	set dir [file tail $d]
+	if {[lsearch -exact $excl $dir] >= 0} continue
+	readotherrefs [file join $base $dir] "$dname$dir/" {}
+    }
 }
 
 proc error_popup msg {
@@ -277,12 +328,13 @@ proc makewindow {} {
     global canv canv2 canv3 linespc charspc ctext cflist textfont
     global findtype findtypemenu findloc findstring fstring geometry
     global entries sha1entry sha1string sha1but
-    global maincursor textcursor
+    global maincursor textcursor curtextcursor
     global rowctxmenu gaudydiff mergemax
 
     menu .bar
     .bar add cascade -label "File" -menu .bar.file
     menu .bar.file
+    .bar.file add command -label "Reread references" -command rereadrefs
     .bar.file add command -label "Quit" -command doquit
     menu .bar.help
     .bar add cascade -label "Help" -menu .bar.help
@@ -339,6 +391,30 @@ proc makewindow {} {
     entry $sha1entry -width 40 -font $textfont -textvariable sha1string
     trace add variable sha1string write sha1change
     pack $sha1entry -side left -pady 2
+
+    image create bitmap bm-left -data {
+	#define left_width 16
+	#define left_height 16
+	static unsigned char left_bits[] = {
+	0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
+	0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
+	0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
+    }
+    image create bitmap bm-right -data {
+	#define right_width 16
+	#define right_height 16
+	static unsigned char right_bits[] = {
+	0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
+	0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
+	0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
+    }
+    button .ctop.top.bar.leftbut -image bm-left -command goback \
+	-state disabled -width 26
+    pack .ctop.top.bar.leftbut -side left -fill y
+    button .ctop.top.bar.rightbut -image bm-right -command goforw \
+	-state disabled -width 26
+    pack .ctop.top.bar.rightbut -side left -fill y
+
     button .ctop.top.bar.findbut -text "Find" -command dofind
     pack .ctop.top.bar.findbut -side left
     set findstring {}
@@ -363,7 +439,7 @@ proc makewindow {} {
     set ctext .ctop.cdet.left.ctext
     text $ctext -bg white -state disabled -font $textfont \
 	-width $geometry(ctextw) -height $geometry(ctexth) \
-	-yscrollcommand ".ctop.cdet.left.sb set"
+	-yscrollcommand ".ctop.cdet.left.sb set" -wrap none
     scrollbar .ctop.cdet.left.sb -command "$ctext yview"
     pack .ctop.cdet.left.sb -side right -fill y
     pack $ctext -side left -fill both -expand 1
@@ -410,6 +486,8 @@ proc makewindow {} {
     bindall <B2-Motion> "allcanvs scan dragto 0 %y"
     bind . <Key-Up> "selnextline -1"
     bind . <Key-Down> "selnextline 1"
+    bind . <Key-Right> "goforw"
+    bind . <Key-Left> "goback"
     bind . <Key-Prior> "allcanvs yview scroll -1 pages"
     bind . <Key-Next> "allcanvs yview scroll 1 pages"
     bindkey <Key-Delete> "$ctext yview scroll -1 pages"
@@ -417,6 +495,12 @@ proc makewindow {} {
     bindkey <Key-space> "$ctext yview scroll 1 pages"
     bindkey p "selnextline -1"
     bindkey n "selnextline 1"
+    bindkey z "goback"
+    bindkey x "goforw"
+    bindkey i "selnextline -1"
+    bindkey k "selnextline 1"
+    bindkey j "goback"
+    bindkey l "goforw"
     bindkey b "$ctext yview scroll -1 pages"
     bindkey d "$ctext yview scroll 18 units"
     bindkey u "$ctext yview scroll -18 units"
@@ -441,6 +525,7 @@ proc makewindow {} {
 
     set maincursor [. cget -cursor]
     set textcursor [$ctext cget -cursor]
+    set curtextcursor $textcursor
 
     set rowctxmenu .rowctxmenu
     menu $rowctxmenu -tearoff 0
@@ -480,7 +565,8 @@ proc click {w} {
 
 proc savestuff {w} {
     global canv canv2 canv3 ctext cflist mainfont textfont
-    global stuffsaved findmergefiles gaudydiff
+    global stuffsaved findmergefiles gaudydiff maxgraphpct
+    global maxwidth
 
     if {$stuffsaved} return
     if {![winfo viewable .]} return
@@ -490,6 +576,8 @@ proc savestuff {w} {
 	puts $f [list set textfont $textfont]
 	puts $f [list set findmergefiles $findmergefiles]
 	puts $f [list set gaudydiff $gaudydiff]
+	puts $f [list set maxgraphpct $maxgraphpct]
+	puts $f [list set maxwidth $maxwidth]
 	puts $f "set geometry(width) [winfo width .ctop]"
 	puts $f "set geometry(height) [winfo height .ctop]"
 	puts $f "set geometry(canv1) [expr [winfo width $canv]-2]"
@@ -666,21 +754,24 @@ proc assigncolor {id} {
 }
 
 proc initgraph {} {
-    global canvy canvy0 lineno numcommits lthickness nextcolor linespc
-    global mainline sidelines
+    global canvy canvy0 lineno numcommits nextcolor linespc
+    global mainline mainlinearrow sidelines
     global nchildren ncleft
+    global displist nhyperspace
 
     allcanvs delete all
     set nextcolor 0
     set canvy $canvy0
     set lineno -1
     set numcommits 0
-    set lthickness [expr {int($linespc / 9) + 1}]
     catch {unset mainline}
+    catch {unset mainlinearrow}
     catch {unset sidelines}
     foreach id [array names nchildren] {
 	set ncleft($id) $nchildren($id)
     }
+    set displist {}
+    set nhyperspace 0
 }
 
 proc bindline {t id} {
@@ -689,22 +780,50 @@ proc bindline {t id} {
     $canv bind $t <Enter> "lineenter %x %y $id"
     $canv bind $t <Motion> "linemotion %x %y $id"
     $canv bind $t <Leave> "lineleave $id"
-    $canv bind $t <Button-1> "lineclick %x %y $id"
+    $canv bind $t <Button-1> "lineclick %x %y $id 1"
+}
+
+proc drawlines {id xtra} {
+    global mainline mainlinearrow sidelines lthickness colormap canv
+
+    $canv delete lines.$id
+    if {[info exists mainline($id)]} {
+	set t [$canv create line $mainline($id) \
+		   -width [expr {($xtra + 1) * $lthickness}] \
+		   -fill $colormap($id) -tags lines.$id \
+		   -arrow $mainlinearrow($id)]
+	$canv lower $t
+	bindline $t $id
+    }
+    if {[info exists sidelines($id)]} {
+	foreach ls $sidelines($id) {
+	    set coords [lindex $ls 0]
+	    set thick [lindex $ls 1]
+	    set arrow [lindex $ls 2]
+	    set t [$canv create line $coords -fill $colormap($id) \
+		       -width [expr {($thick + $xtra) * $lthickness}] \
+		       -arrow $arrow -tags lines.$id]
+	    $canv lower $t
+	    bindline $t $id
+	}
+    }
 }
 
+# level here is an index in displist
 proc drawcommitline {level} {
-    global parents children nparents nchildren todo
-    global canv canv2 canv3 mainfont namefont canvx0 canvy linespc
+    global parents children nparents displist
+    global canv canv2 canv3 mainfont namefont canvy linespc
     global lineid linehtag linentag linedtag commitinfo
     global colormap numcommits currentparents dupparents
-    global oldlevel oldnlines oldtodo
-    global idtags idline idheads
-    global lineno lthickness mainline sidelines
-    global commitlisted rowtextx idpos
+    global idtags idline idheads idotherrefs
+    global lineno lthickness mainline mainlinearrow sidelines
+    global commitlisted rowtextx idpos lastuse displist
+    global oldnlines olddlevel olddisplist
 
     incr numcommits
     incr lineno
-    set id [lindex $todo $level]
+    set id [lindex $displist $level]
+    set lastuse($id) $lineno
     set lineid($lineno) $id
     set idline($id) $lineno
     set ofill [expr {[info exists commitlisted($id)]? "blue": "white"}]
@@ -728,41 +847,32 @@ proc drawcommitline {level} {
 	    }
 	}
     }
-    set x [expr $canvx0 + $level * $linespc]
+    set x [xcoord $level $level $lineno]
     set y1 $canvy
     set canvy [expr $canvy + $linespc]
     allcanvs conf -scrollregion \
 	[list 0 0 0 [expr $y1 + 0.5 * $linespc + 2]]
     if {[info exists mainline($id)]} {
 	lappend mainline($id) $x $y1
-	set t [$canv create line $mainline($id) \
-		   -width $lthickness -fill $colormap($id)]
-	$canv lower $t
-	bindline $t $id
-    }
-    if {[info exists sidelines($id)]} {
-	foreach ls $sidelines($id) {
-	    set coords [lindex $ls 0]
-	    set thick [lindex $ls 1]
-	    set t [$canv create line $coords -fill $colormap($id) \
-		       -width [expr {$thick * $lthickness}]]
-	    $canv lower $t
-	    bindline $t $id
+	if {$mainlinearrow($id) ne "none"} {
+	    set mainline($id) [trimdiagstart $mainline($id)]
 	}
     }
+    drawlines $id 0
     set orad [expr {$linespc / 3}]
     set t [$canv create oval [expr $x - $orad] [expr $y1 - $orad] \
 	       [expr $x + $orad - 1] [expr $y1 + $orad - 1] \
 	       -fill $ofill -outline black -width 1]
     $canv raise $t
     $canv bind $t <1> {selcanvline {} %x %y}
-    set xt [expr $canvx0 + [llength $todo] * $linespc]
+    set xt [xcoord [llength $displist] $level $lineno]
     if {[llength $currentparents] > 2} {
 	set xt [expr {$xt + ([llength $currentparents] - 2) * $linespc}]
     }
     set rowtextx($lineno) $xt
     set idpos($id) [list $x $xt $y1]
-    if {[info exists idtags($id)] || [info exists idheads($id)]} {
+    if {[info exists idtags($id)] || [info exists idheads($id)]
+	|| [info exists idotherrefs($id)]} {
 	set xt [drawtags $id $x $xt $y1]
     }
     set headline [lindex $commitinfo($id) 0]
@@ -775,21 +885,30 @@ proc drawcommitline {level} {
 			       -text $name -font $namefont]
     set linedtag($lineno) [$canv3 create text 3 $y1 -anchor w \
 			       -text $date -font $mainfont]
+
+    set olddlevel $level
+    set olddisplist $displist
+    set oldnlines [llength $displist]
 }
 
 proc drawtags {id x xt y1} {
-    global idtags idheads
+    global idtags idheads idotherrefs
     global linespc lthickness
-    global canv mainfont
+    global canv mainfont idline rowtextx
 
     set marks {}
     set ntags 0
+    set nheads 0
     if {[info exists idtags($id)]} {
 	set marks $idtags($id)
 	set ntags [llength $marks]
     }
     if {[info exists idheads($id)]} {
 	set marks [concat $marks $idheads($id)]
+	set nheads [llength $idheads($id)]
+    }
+    if {[info exists idotherrefs($id)]} {
+	set marks [concat $marks $idotherrefs($id)]
     }
     if {$marks eq {}} {
 	return $xt
@@ -814,60 +933,36 @@ proc drawtags {id x xt y1} {
 	set xr [expr $x + $delta + $wid + $lthickness]
 	if {[incr ntags -1] >= 0} {
 	    # draw a tag
-	    $canv create polygon $x [expr $yt + $delta] $xl $yt\
-		$xr $yt $xr $yb $xl $yb $x [expr $yb - $delta] \
-		-width 1 -outline black -fill yellow -tags tag.$id
+	    set t [$canv create polygon $x [expr $yt + $delta] $xl $yt \
+		       $xr $yt $xr $yb $xl $yb $x [expr $yb - $delta] \
+		       -width 1 -outline black -fill yellow -tags tag.$id]
+	    $canv bind $t <1> [list showtag $tag 1]
+	    set rowtextx($idline($id)) [expr {$xr + $linespc}]
 	} else {
-	    # draw a head
+	    # draw a head or other ref
+	    if {[incr nheads -1] >= 0} {
+		set col green
+	    } else {
+		set col "#ddddff"
+	    }
 	    set xl [expr $xl - $delta/2]
 	    $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
-		-width 1 -outline black -fill green -tags tag.$id
-	}
-	$canv create text $xl $y1 -anchor w -text $tag \
-	    -font $mainfont -tags tag.$id
-    }
-    return $xt
-}
-
-proc updatetodo {level noshortcut} {
-    global currentparents ncleft todo
-    global mainline oldlevel oldtodo oldnlines
-    global canvx0 canvy linespc mainline
-    global commitinfo
-
-    set oldlevel $level
-    set oldtodo $todo
-    set oldnlines [llength $todo]
-    if {!$noshortcut && [llength $currentparents] == 1} {
-	set p [lindex $currentparents 0]
-	if {$ncleft($p) == 1 && [lsearch -exact $todo $p] < 0} {
-	    set ncleft($p) 0
-	    set x [expr $canvx0 + $level * $linespc]
-	    set y [expr $canvy - $linespc]
-	    set mainline($p) [list $x $y]
-	    set todo [lreplace $todo $level $level $p]
-	    return 0
+		-width 1 -outline black -fill $col -tags tag.$id
 	}
-    }
-
-    set todo [lreplace $todo $level $level]
-    set i $level
-    foreach p $currentparents {
-	incr ncleft($p) -1
-	set k [lsearch -exact $todo $p]
-	if {$k < 0} {
-	    set todo [linsert $todo $i $p]
-	    incr i
+	set t [$canv create text $xl $y1 -anchor w -text $tag \
+		   -font $mainfont -tags tag.$id]
+	if {$ntags >= 0} {
+	    $canv bind $t <1> [list showtag $tag 1]
 	}
     }
-    return 1
+    return $xt
 }
 
 proc notecrossings {id lo hi corner} {
-    global oldtodo crossings cornercrossings
+    global olddisplist crossings cornercrossings
 
     for {set i $lo} {[incr i] < $hi} {} {
-	set p [lindex $oldtodo $i]
+	set p [lindex $olddisplist $i]
 	if {$p == {}} continue
 	if {$i == $corner} {
 	    if {![info exists cornercrossings($id)]
@@ -891,71 +986,427 @@ proc notecrossings {id lo hi corner} {
     }
 }
 
-proc drawslants {} {
-    global canv mainline sidelines canvx0 canvy linespc
-    global oldlevel oldtodo todo currentparents dupparents
-    global lthickness linespc canvy colormap
+proc xcoord {i level ln} {
+    global canvx0 xspc1 xspc2
+
+    set x [expr {$canvx0 + $i * $xspc1($ln)}]
+    if {$i > 0 && $i == $level} {
+	set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
+    } elseif {$i > $level} {
+	set x [expr {$x + $xspc2 - $xspc1($ln)}]
+    }
+    return $x
+}
+
+# it seems Tk can't draw arrows on the end of diagonal line segments...
+proc trimdiagend {line} {
+    while {[llength $line] > 4} {
+	set x1 [lindex $line end-3]
+	set y1 [lindex $line end-2]
+	set x2 [lindex $line end-1]
+	set y2 [lindex $line end]
+	if {($x1 == $x2) != ($y1 == $y2)} break
+	set line [lreplace $line end-1 end]
+    }
+    return $line
+}
+
+proc trimdiagstart {line} {
+    while {[llength $line] > 4} {
+	set x1 [lindex $line 0]
+	set y1 [lindex $line 1]
+	set x2 [lindex $line 2]
+	set y2 [lindex $line 3]
+	if {($x1 == $x2) != ($y1 == $y2)} break
+	set line [lreplace $line 0 1]
+    }
+    return $line
+}
 
-    set y1 [expr $canvy - $linespc]
+proc drawslants {id needonscreen nohs} {
+    global canv mainline mainlinearrow sidelines
+    global canvx0 canvy xspc1 xspc2 lthickness
+    global currentparents dupparents
+    global lthickness linespc canvy colormap lineno geometry
+    global maxgraphpct maxwidth
+    global displist onscreen lastuse
+    global parents commitlisted
+    global oldnlines olddlevel olddisplist
+    global nhyperspace numcommits nnewparents
+
+    if {$lineno < 0} {
+	lappend displist $id
+	set onscreen($id) 1
+	return 0
+    }
+
+    set y1 [expr {$canvy - $linespc}]
     set y2 $canvy
+
+    # work out what we need to get back on screen
+    set reins {}
+    if {$onscreen($id) < 0} {
+	# next to do isn't displayed, better get it on screen...
+	lappend reins [list $id 0]
+    }
+    # make sure all the previous commits's parents are on the screen
+    foreach p $currentparents {
+	if {$onscreen($p) < 0} {
+	    lappend reins [list $p 0]
+	}
+    }
+    # bring back anything requested by caller
+    if {$needonscreen ne {}} {
+	lappend reins $needonscreen
+    }
+
+    # try the shortcut
+    if {$currentparents == $id && $onscreen($id) == 0 && $reins eq {}} {
+	set dlevel $olddlevel
+	set x [xcoord $dlevel $dlevel $lineno]
+	set mainline($id) [list $x $y1]
+	set mainlinearrow($id) none
+	set lastuse($id) $lineno
+	set displist [lreplace $displist $dlevel $dlevel $id]
+	set onscreen($id) 1
+	set xspc1([expr {$lineno + 1}]) $xspc1($lineno)
+	return $dlevel
+    }
+
+    # update displist
+    set displist [lreplace $displist $olddlevel $olddlevel]
+    set j $olddlevel
+    foreach p $currentparents {
+	set lastuse($p) $lineno
+	if {$onscreen($p) == 0} {
+	    set displist [linsert $displist $j $p]
+	    set onscreen($p) 1
+	    incr j
+	}
+    }
+    if {$onscreen($id) == 0} {
+	lappend displist $id
+	set onscreen($id) 1
+    }
+
+    # remove the null entry if present
+    set nullentry [lsearch -exact $displist {}]
+    if {$nullentry >= 0} {
+	set displist [lreplace $displist $nullentry $nullentry]
+    }
+
+    # bring back the ones we need now (if we did it earlier
+    # it would change displist and invalidate olddlevel)
+    foreach pi $reins {
+	# test again in case of duplicates in reins
+	set p [lindex $pi 0]
+	if {$onscreen($p) < 0} {
+	    set onscreen($p) 1
+	    set lastuse($p) $lineno
+	    set displist [linsert $displist [lindex $pi 1] $p]
+	    incr nhyperspace -1
+	}
+    }
+
+    set lastuse($id) $lineno
+
+    # see if we need to make any lines jump off into hyperspace
+    set displ [llength $displist]
+    if {$displ > $maxwidth} {
+	set ages {}
+	foreach x $displist {
+	    lappend ages [list $lastuse($x) $x]
+	}
+	set ages [lsort -integer -index 0 $ages]
+	set k 0
+	while {$displ > $maxwidth} {
+	    set use [lindex $ages $k 0]
+	    set victim [lindex $ages $k 1]
+	    if {$use >= $lineno - 5} break
+	    incr k
+	    if {[lsearch -exact $nohs $victim] >= 0} continue
+	    set i [lsearch -exact $displist $victim]
+	    set displist [lreplace $displist $i $i]
+	    set onscreen($victim) -1
+	    incr nhyperspace
+	    incr displ -1
+	    if {$i < $nullentry} {
+		incr nullentry -1
+	    }
+	    set x [lindex $mainline($victim) end-1]
+	    lappend mainline($victim) $x $y1
+	    set line [trimdiagend $mainline($victim)]
+	    set arrow "last"
+	    if {$mainlinearrow($victim) ne "none"} {
+		set line [trimdiagstart $line]
+		set arrow "both"
+	    }
+	    lappend sidelines($victim) [list $line 1 $arrow]
+	    unset mainline($victim)
+	}
+    }
+
+    set dlevel [lsearch -exact $displist $id]
+
+    # If we are reducing, put in a null entry
+    if {$displ < $oldnlines} {
+	# does the next line look like a merge?
+	# i.e. does it have > 1 new parent?
+	if {$nnewparents($id) > 1} {
+	    set i [expr {$dlevel + 1}]
+	} elseif {$nnewparents([lindex $olddisplist $olddlevel]) == 0} {
+	    set i $olddlevel
+	    if {$nullentry >= 0 && $nullentry < $i} {
+		incr i -1
+	    }
+	} elseif {$nullentry >= 0} {
+	    set i $nullentry
+	    while {$i < $displ
+		   && [lindex $olddisplist $i] == [lindex $displist $i]} {
+		incr i
+	    }
+	} else {
+	    set i $olddlevel
+	    if {$dlevel >= $i} {
+		incr i
+	    }
+	}
+	if {$i < $displ} {
+	    set displist [linsert $displist $i {}]
+	    incr displ
+	    if {$dlevel >= $i} {
+		incr dlevel
+	    }
+	}
+    }
+
+    # decide on the line spacing for the next line
+    set lj [expr {$lineno + 1}]
+    set maxw [expr {$maxgraphpct * $geometry(canv1) / 100}]
+    if {$displ <= 1 || $canvx0 + $displ * $xspc2 <= $maxw} {
+	set xspc1($lj) $xspc2
+    } else {
+	set xspc1($lj) [expr {($maxw - $canvx0 - $xspc2) / ($displ - 1)}]
+	if {$xspc1($lj) < $lthickness} {
+	    set xspc1($lj) $lthickness
+	}
+    }
+
+    foreach idi $reins {
+	set id [lindex $idi 0]
+	set j [lsearch -exact $displist $id]
+	set xj [xcoord $j $dlevel $lj]
+	set mainline($id) [list $xj $y2]
+	set mainlinearrow($id) first
+    }
+
     set i -1
-    foreach id $oldtodo {
+    foreach id $olddisplist {
 	incr i
 	if {$id == {}} continue
-	set xi [expr {$canvx0 + $i * $linespc}]
-	if {$i == $oldlevel} {
+	if {$onscreen($id) <= 0} continue
+	set xi [xcoord $i $olddlevel $lineno]
+	if {$i == $olddlevel} {
 	    foreach p $currentparents {
-		set j [lsearch -exact $todo $p]
+		set j [lsearch -exact $displist $p]
 		set coords [list $xi $y1]
-		set xj [expr {$canvx0 + $j * $linespc}]
-		if {$j < $i - 1} {
-		    lappend coords [expr $xj + $linespc] $y1
+		set xj [xcoord $j $dlevel $lj]
+		if {$xj < $xi - $linespc} {
+		    lappend coords [expr {$xj + $linespc}] $y1
 		    notecrossings $p $j $i [expr {$j + 1}]
-		} elseif {$j > $i + 1} {
-		    lappend coords [expr $xj - $linespc] $y1
+		} elseif {$xj > $xi + $linespc} {
+		    lappend coords [expr {$xj - $linespc}] $y1
 		    notecrossings $p $i $j [expr {$j - 1}]
 		}
 		if {[lsearch -exact $dupparents $p] >= 0} {
 		    # draw a double-width line to indicate the doubled parent
 		    lappend coords $xj $y2
-		    lappend sidelines($p) [list $coords 2]
+		    lappend sidelines($p) [list $coords 2 none]
 		    if {![info exists mainline($p)]} {
 			set mainline($p) [list $xj $y2]
+			set mainlinearrow($p) none
 		    }
 		} else {
 		    # normal case, no parent duplicated
+		    set yb $y2
+		    set dx [expr {abs($xi - $xj)}]
+		    if {0 && $dx < $linespc} {
+			set yb [expr {$y1 + $dx}]
+		    }
 		    if {![info exists mainline($p)]} {
-			if {$i != $j} {
-			    lappend coords $xj $y2
+			if {$xi != $xj} {
+			    lappend coords $xj $yb
 			}
 			set mainline($p) $coords
+			set mainlinearrow($p) none
 		    } else {
-			lappend coords $xj $y2
-			lappend sidelines($p) [list $coords 1]
+			lappend coords $xj $yb
+			if {$yb < $y2} {
+			    lappend coords $xj $y2
+			}
+			lappend sidelines($p) [list $coords 1 none]
 		    }
 		}
 	    }
-	} elseif {[lindex $todo $i] != $id} {
-	    set j [lsearch -exact $todo $id]
-	    set xj [expr {$canvx0 + $j * $linespc}]
-	    lappend mainline($id) $xi $y1 $xj $y2
+	} else {
+	    set j $i
+	    if {[lindex $displist $i] != $id} {
+		set j [lsearch -exact $displist $id]
+	    }
+	    if {$j != $i || $xspc1($lineno) != $xspc1($lj)
+		|| ($olddlevel < $i && $i < $dlevel)
+		|| ($dlevel < $i && $i < $olddlevel)} {
+		set xj [xcoord $j $dlevel $lj]
+		lappend mainline($id) $xi $y1 $xj $y2
+	    }
+	}
+    }
+    return $dlevel
+}
+
+# search for x in a list of lists
+proc llsearch {llist x} {
+    set i 0
+    foreach l $llist {
+	if {$l == $x || [lsearch -exact $l $x] >= 0} {
+	    return $i
+	}
+	incr i
+    }
+    return -1
+}
+
+proc drawmore {reading} {
+    global displayorder numcommits ncmupdate nextupdate
+    global stopped nhyperspace parents commitlisted
+    global maxwidth onscreen displist currentparents olddlevel
+
+    set n [llength $displayorder]
+    while {$numcommits < $n} {
+	set id [lindex $displayorder $numcommits]
+	set ctxend [expr {$numcommits + 10}]
+	if {!$reading && $ctxend > $n} {
+	    set ctxend $n
+	}
+	set dlist {}
+	if {$numcommits > 0} {
+	    set dlist [lreplace $displist $olddlevel $olddlevel]
+	    set i $olddlevel
+	    foreach p $currentparents {
+		if {$onscreen($p) == 0} {
+		    set dlist [linsert $dlist $i $p]
+		    incr i
+		}
+	    }
+	}
+	set nohs {}
+	set reins {}
+	set isfat [expr {[llength $dlist] > $maxwidth}]
+	if {$nhyperspace > 0 || $isfat} {
+	    if {$ctxend > $n} break
+	    # work out what to bring back and
+	    # what we want to don't want to send into hyperspace
+	    set room 1
+	    for {set k $numcommits} {$k < $ctxend} {incr k} {
+		set x [lindex $displayorder $k]
+		set i [llsearch $dlist $x]
+		if {$i < 0} {
+		    set i [llength $dlist]
+		    lappend dlist $x
+		}
+		if {[lsearch -exact $nohs $x] < 0} {
+		    lappend nohs $x
+		}
+		if {$reins eq {} && $onscreen($x) < 0 && $room} {
+		    set reins [list $x $i]
+		}
+		set newp {}
+		if {[info exists commitlisted($x)]} {
+		    set right 0
+		    foreach p $parents($x) {
+			if {[llsearch $dlist $p] < 0} {
+			    lappend newp $p
+			    if {[lsearch -exact $nohs $p] < 0} {
+				lappend nohs $p
+			    }
+			    if {$reins eq {} && $onscreen($p) < 0 && $room} {
+				set reins [list $p [expr {$i + $right}]]
+			    }
+			}
+			set right 1
+		    }
+		}
+		set l [lindex $dlist $i]
+		if {[llength $l] == 1} {
+		    set l $newp
+		} else {
+		    set j [lsearch -exact $l $x]
+		    set l [concat [lreplace $l $j $j] $newp]
+		}
+		set dlist [lreplace $dlist $i $i $l]
+		if {$room && $isfat && [llength $newp] <= 1} {
+		    set room 0
+		}
+	    }
+	}
+
+	set dlevel [drawslants $id $reins $nohs]
+	drawcommitline $dlevel
+	if {[clock clicks -milliseconds] >= $nextupdate
+	    && $numcommits >= $ncmupdate} {
+	    doupdate $reading
+	    if {$stopped} break
+	}
+    }
+}
+
+# level here is an index in todo
+proc updatetodo {level noshortcut} {
+    global ncleft todo nnewparents
+    global commitlisted parents onscreen
+
+    set id [lindex $todo $level]
+    set olds {}
+    if {[info exists commitlisted($id)]} {
+	foreach p $parents($id) {
+	    if {[lsearch -exact $olds $p] < 0} {
+		lappend olds $p
+	    }
+	}
+    }
+    if {!$noshortcut && [llength $olds] == 1} {
+	set p [lindex $olds 0]
+	if {$ncleft($p) == 1 && [lsearch -exact $todo $p] < 0} {
+	    set ncleft($p) 0
+	    set todo [lreplace $todo $level $level $p]
+	    set onscreen($p) 0
+	    set nnewparents($id) 1
+	    return 0
+	}
+    }
+
+    set todo [lreplace $todo $level $level]
+    set i $level
+    set n 0
+    foreach p $olds {
+	incr ncleft($p) -1
+	set k [lsearch -exact $todo $p]
+	if {$k < 0} {
+	    set todo [linsert $todo $i $p]
+	    set onscreen($p) 0
+	    incr i
+	    incr n
 	}
     }
+    set nnewparents($id) $n
+
+    return 1
 }
 
 proc decidenext {{noread 0}} {
-    global parents children nchildren ncleft todo
-    global canv canv2 canv3 mainfont namefont canvx0 canvy linespc
+    global ncleft todo
     global datemode cdate
     global commitinfo
-    global currentparents oldlevel oldnlines oldtodo
-    global lineno lthickness
-
-    # remove the null entry if present
-    set nullentry [lsearch -exact $todo {}]
-    if {$nullentry >= 0} {
-	set todo [lreplace $todo $nullentry $nullentry]
-    }
 
     # choose which one to do next time around
     set todol [llength $todo]
@@ -991,72 +1442,43 @@ proc decidenext {{noread 0}} {
 	return -1
     }
 
-    # If we are reducing, put in a null entry
-    if {$todol < $oldnlines} {
-	if {$nullentry >= 0} {
-	    set i $nullentry
-	    while {$i < $todol
-		   && [lindex $oldtodo $i] == [lindex $todo $i]} {
-		incr i
-	    }
-	} else {
-	    set i $oldlevel
-	    if {$level >= $i} {
-		incr i
-	    }
-	}
-	if {$i < $todol} {
-	    set todo [linsert $todo $i {}]
-	    if {$level >= $i} {
-		incr level
-	    }
-	}
-    }
     return $level
 }
 
 proc drawcommit {id} {
     global phase todo nchildren datemode nextupdate
-    global startcommits
+    global numcommits ncmupdate displayorder todo onscreen
 
     if {$phase != "incrdraw"} {
 	set phase incrdraw
-	set todo $id
-	set startcommits $id
+	set displayorder {}
+	set todo {}
 	initgraph
-	drawcommitline 0
-	updatetodo 0 $datemode
-    } else {
-	if {$nchildren($id) == 0} {
-	    lappend todo $id
-	    lappend startcommits $id
-	}
-	set level [decidenext 1]
-	if {$level == {} || $id != [lindex $todo $level]} {
-	    return
+    }
+    if {$nchildren($id) == 0} {
+	lappend todo $id
+	set onscreen($id) 0
+    }
+    set level [decidenext 1]
+    if {$level == {} || $id != [lindex $todo $level]} {
+	return
+    }
+    while 1 {
+	lappend displayorder [lindex $todo $level]
+	if {[updatetodo $level $datemode]} {
+	    set level [decidenext 1]
+	    if {$level == {}} break
 	}
-	while 1 {
-	    drawslants
-	    drawcommitline $level
-	    if {[updatetodo $level $datemode]} {
-		set level [decidenext 1]
-		if {$level == {}} break
-	    }
-	    set id [lindex $todo $level]
-	    if {![info exists commitlisted($id)]} {
-		break
-	    }
-	    if {[clock clicks -milliseconds] >= $nextupdate} {
-		doupdate
-		if {$stopped} break
-	    }
+	set id [lindex $todo $level]
+	if {![info exists commitlisted($id)]} {
+	    break
 	}
     }
+    drawmore 1
 }
 
 proc finishcommits {} {
     global phase
-    global startcommits
     global canv mainfont ctext maincursor textcursor
 
     if {$phase != "incrdraw"} {
@@ -1065,69 +1487,63 @@ proc finishcommits {} {
 	    -font $mainfont -tags textitems
 	set phase {}
     } else {
-	drawslants
-	set level [decidenext]
-	drawrest $level [llength $startcommits]
+	drawrest
     }
     . config -cursor $maincursor
-    $ctext config -cursor $textcursor
+    settextcursor $textcursor
+}
+
+# Don't change the text pane cursor if it is currently the hand cursor,
+# showing that we are over a sha1 ID link.
+proc settextcursor {c} {
+    global ctext curtextcursor
+
+    if {[$ctext cget -cursor] == $curtextcursor} {
+	$ctext config -cursor $c
+    }
+    set curtextcursor $c
 }
 
 proc drawgraph {} {
-    global nextupdate startmsecs startcommits todo
+    global nextupdate startmsecs ncmupdate
+    global displayorder onscreen
 
-    if {$startcommits == {}} return
+    if {$displayorder == {}} return
     set startmsecs [clock clicks -milliseconds]
     set nextupdate [expr $startmsecs + 100]
+    set ncmupdate 1
     initgraph
-    set todo [lindex $startcommits 0]
-    drawrest 0 1
+    foreach id $displayorder {
+	set onscreen($id) 0
+    }
+    drawmore 0
 }
 
-proc drawrest {level startix} {
+proc drawrest {} {
     global phase stopped redisplaying selectedline
-    global datemode currentparents todo
-    global numcommits
-    global nextupdate startmsecs startcommits idline
+    global datemode todo displayorder
+    global numcommits ncmupdate
+    global nextupdate startmsecs
 
+    set level [decidenext]
     if {$level >= 0} {
 	set phase drawgraph
-	set startid [lindex $startcommits $startix]
-	set startline -1
-	if {$startid != {}} {
-	    set startline $idline($startid)
-	}
 	while 1 {
-	    if {$stopped} break
-	    drawcommitline $level
+	    lappend displayorder [lindex $todo $level]
 	    set hard [updatetodo $level $datemode]
-	    if {$numcommits == $startline} {
-		lappend todo $startid
-		set hard 1
-		incr startix
-		set startid [lindex $startcommits $startix]
-		set startline -1
-		if {$startid != {}} {
-		    set startline $idline($startid)
-		}
-	    }
 	    if {$hard} {
 		set level [decidenext]
 		if {$level < 0} break
-		drawslants
-	    }
-	    if {[clock clicks -milliseconds] >= $nextupdate} {
-		update
-		incr nextupdate 100
 	    }
 	}
+	drawmore 0
     }
     set phase {}
     set drawmsecs [expr [clock clicks -milliseconds] - $startmsecs]
     #puts "overall $drawmsecs ms for $numcommits commits"
     if {$redisplaying} {
 	if {$stopped == 0 && [info exists selectedline]} {
-	    selectline $selectedline
+	    selectline $selectedline 0
 	}
 	if {$stopped == 1} {
 	    set stopped 0
@@ -1226,7 +1642,7 @@ proc dofind {} {
 
 proc findselectline {l} {
     global findloc commentend ctext
-    selectline $l
+    selectline $l 1
     if {$findloc == "All fields" || $findloc == "Comments"} {
 	# highlight the matches in the comments
 	set f [$ctext get 1.0 $commentend]
@@ -1305,7 +1721,7 @@ proc stopfindproc {{done 0}} {
 	unset findinprogress
 	if {$phase != "incrdraw"} {
 	    . config -cursor $maincursor
-	    $ctext config -cursor $textcursor
+	    settextcursor $textcursor
 	}
     }
 }
@@ -1348,7 +1764,7 @@ proc findpatches {} {
     fileevent $f readable readfindproc
     set finddidsel 0
     . config -cursor watch
-    $ctext config -cursor watch
+    settextcursor watch
     set findinprogress 1
 }
 
@@ -1453,7 +1869,7 @@ proc findfiles {} {
     set id $lineid($l)
     set p [lindex $parents($id) 0]
     . config -cursor watch
-    $ctext config -cursor watch
+    settextcursor watch
     set findinprogress 1
     findcont [list $id $p]
     update
@@ -1603,7 +2019,7 @@ proc unmarkmatches {} {
 }
 
 proc selcanvline {w x y} {
-    global canv canvy0 ctext linespc selectedline
+    global canv canvy0 ctext linespc
     global lineid linehtag linentag linedtag rowtextx
     set ymax [lindex [$canv cget -scrollregion] 3]
     if {$ymax == {}} return
@@ -1617,16 +2033,52 @@ proc selcanvline {w x y} {
 	if {![info exists rowtextx($l)] || $x < $rowtextx($l)} return
     }
     unmarkmatches
-    selectline $l
+    selectline $l 1
+}
+
+proc commit_descriptor {p} {
+    global commitinfo
+    set l "..."
+    if {[info exists commitinfo($p)]} {
+	set l [lindex $commitinfo($p) 0]
+    }
+    return "$p ($l)"
 }
 
-proc selectline {l} {
+# append some text to the ctext widget, and make any SHA1 ID
+# that we know about be a clickable link.
+proc appendwithlinks {text} {
+    global ctext idline linknum
+
+    set start [$ctext index "end - 1c"]
+    $ctext insert end $text
+    $ctext insert end "\n"
+    set links [regexp -indices -all -inline {[0-9a-f]{40}} $text]
+    foreach l $links {
+	set s [lindex $l 0]
+	set e [lindex $l 1]
+	set linkid [string range $text $s $e]
+	if {![info exists idline($linkid)]} continue
+	incr e
+	$ctext tag add link "$start + $s c" "$start + $e c"
+	$ctext tag add link$linknum "$start + $s c" "$start + $e c"
+	$ctext tag bind link$linknum <1> [list selectline $idline($linkid) 1]
+	incr linknum
+    }
+    $ctext tag conf link -foreground blue -underline 1
+    $ctext tag bind link <Enter> { %W configure -cursor hand2 }
+    $ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
+}
+
+proc selectline {l isnew} {
     global canv canv2 canv3 ctext commitinfo selectedline
     global lineid linehtag linentag linedtag
-    global canvy0 linespc parents nparents
+    global canvy0 linespc parents nparents children
     global cflist currentid sha1entry
-    global commentend idtags
+    global commentend idtags idline linknum
+
     $canv delete hover
+    normalline
     if {![info exists lineid($l)] || ![info exists linehtag($l)]} return
     $canv delete secsel
     set t [eval $canv create rect [$canv bbox $linehtag($l)] -outline {{}} \
@@ -1674,6 +2126,11 @@ proc selectline {l} {
 	}
 	allcanvs yview moveto [expr $newtop * 1.0 / $ymax]
     }
+
+    if {$isnew} {
+	addtohistory [list selectline $l 0]
+    }
+
     set selectedline $l
 
     set id $lineid($l)
@@ -1685,6 +2142,7 @@ proc selectline {l} {
 
     $ctext conf -state normal
     $ctext delete 0.0 end
+    set linknum 0
     $ctext mark set fmark.0 0.0
     $ctext mark gravity fmark.0 left
     set info $commitinfo($id)
@@ -1697,9 +2155,24 @@ proc selectline {l} {
 	}
 	$ctext insert end "\n"
     }
-    $ctext insert end "\n"
-    $ctext insert end [lindex $info 5]
-    $ctext insert end "\n"
+ 
+    set comment {}
+    if {[info exists parents($id)]} {
+	foreach p $parents($id) {
+	    append comment "Parent: [commit_descriptor $p]\n"
+	}
+    }
+    if {[info exists children($id)]} {
+	foreach c $children($id) {
+	    append comment "Child:  [commit_descriptor $c]\n"
+	}
+    }
+    append comment "\n"
+    append comment [lindex $info 5]
+
+    # make anything that looks like a SHA1 ID be a clickable link
+    appendwithlinks $comment
+
     $ctext tag delete Comments
     $ctext tag remove found 1.0 end
     $ctext conf -state disabled
@@ -1719,7 +2192,64 @@ proc selnextline {dir} {
     if {![info exists selectedline]} return
     set l [expr $selectedline + $dir]
     unmarkmatches
-    selectline $l
+    selectline $l 1
+}
+
+proc unselectline {} {
+    global selectedline
+
+    catch {unset selectedline}
+    allcanvs delete secsel
+}
+
+proc addtohistory {cmd} {
+    global history historyindex
+
+    if {$historyindex > 0
+	&& [lindex $history [expr {$historyindex - 1}]] == $cmd} {
+	return
+    }
+
+    if {$historyindex < [llength $history]} {
+	set history [lreplace $history $historyindex end $cmd]
+    } else {
+	lappend history $cmd
+    }
+    incr historyindex
+    if {$historyindex > 1} {
+	.ctop.top.bar.leftbut conf -state normal
+    } else {
+	.ctop.top.bar.leftbut conf -state disabled
+    }
+    .ctop.top.bar.rightbut conf -state disabled
+}
+
+proc goback {} {
+    global history historyindex
+
+    if {$historyindex > 1} {
+	incr historyindex -1
+	set cmd [lindex $history [expr {$historyindex - 1}]]
+	eval $cmd
+	.ctop.top.bar.rightbut conf -state normal
+    }
+    if {$historyindex <= 1} {
+	.ctop.top.bar.leftbut conf -state disabled
+    }
+}
+
+proc goforw {} {
+    global history historyindex
+
+    if {$historyindex < [llength $history]} {
+	set cmd [lindex $history $historyindex]
+	incr historyindex
+	eval $cmd
+	.ctop.top.bar.leftbut conf -state normal
+    }
+    if {$historyindex >= [llength $history]} {
+	.ctop.top.bar.rightbut conf -state disabled
+    }
 }
 
 proc mergediff {id} {
@@ -1729,7 +2259,9 @@ proc mergediff {id} {
     set diffpindex -1
     set diffmergegca [findgca $parents($id)]
     if {[info exists mergefilelist($id)]} {
-	showmergediff
+	if {$mergefilelist($id) ne {}} {
+	    showmergediff
+	}
     } else {
 	contmergediff {}
     }
@@ -1753,7 +2285,7 @@ proc findgca {ids} {
 
 proc contmergediff {ids} {
     global diffmergeid diffpindex parents nparents diffmergegca
-    global treediffs mergefilelist diffids
+    global treediffs mergefilelist diffids treepending
 
     # diff the child against each of the parents, and diff
     # each of the parents against the GCA.
@@ -1814,8 +2346,8 @@ proc contmergediff {ids} {
 
 proc showmergediff {} {
     global cflist diffmergeid mergefilelist parents
-    global diffopts diffinhunk currentfile diffblocked
-    global groupfilelast mergefds
+    global diffopts diffinhunk currentfile currenthunk filelines
+    global diffblocked groupfilelast mergefds groupfilenum grouphunks
 
     set files $mergefilelist($diffmergeid)
     foreach f $files {
@@ -1826,6 +2358,8 @@ proc showmergediff {} {
     catch {unset currentfile}
     catch {unset currenthunk}
     catch {unset filelines}
+    catch {unset groupfilenum}
+    catch {unset grouphunks}
     set groupfilelast -1
     foreach p $parents($diffmergeid) {
 	set cmd [list | git-diff-tree -p $p $diffmergeid]
@@ -2054,7 +2588,6 @@ proc processgroup {} {
     set pnum 0
     foreach p $parents($id) {
 	set startline [expr {$grouplinestart + $diffoffset($p)}]
-	set offset($p) $diffoffset($p)
 	set ol $startline
 	set nl $grouplinestart
 	if {[info exists grouphunks($p)]} {
@@ -2098,9 +2631,8 @@ proc processgroup {} {
     set events [lsort -integer -index 0 $events]
     set nevents [llength $events]
     set nmerge $nparents($diffmergeid)
-    set i 0
     set l $grouplinestart
-    while {$i < $nevents} {
+    for {set i 0} {$i < $nevents} {set i $j} {
 	set nl [lindex $events $i 0]
 	while {$l < $nl} {
 	    $ctext insert end " $filelines($id,$f,$l)\n"
@@ -2129,7 +2661,9 @@ proc processgroup {} {
 	}
 	set nlc [expr {$enl - $l}]
 	set ncol mresult
+	set bestpn -1
 	if {[llength $active] == $nmerge - 1} {
+	    # no diff for one of the parents, i.e. it's identical
 	    for {set pnum 0} {$pnum < $nmerge} {incr pnum} {
 		if {![info exists delta($pnum)]} {
 		    if {$pnum < $mergemax} {
@@ -2140,11 +2674,25 @@ proc processgroup {} {
 		    break
 		}
 	    }
+	} elseif {[llength $active] == $nmerge} {
+	    # all parents are different, see if one is very similar
+	    set bestsim 30
+	    for {set pnum 0} {$pnum < $nmerge} {incr pnum} {
+		set sim [similarity $pnum $l $nlc $f \
+			     [lrange $events $i [expr {$j-1}]]]
+		if {$sim > $bestsim} {
+		    set bestsim $sim
+		    set bestpn $pnum
+		}
+	    }
+	    if {$bestpn >= 0} {
+		lappend ncol m$bestpn
+	    }
 	}
 	set pnum -1
 	foreach p $parents($id) {
 	    incr pnum
-	    if {![info exists delta($pnum)]} continue
+	    if {![info exists delta($pnum)] || $pnum == $bestpn} continue
 	    set olc [expr {$nlc + $delta($pnum)}]
 	    set ol [expr {$l + $diffoffset($p)}]
 	    incr diffoffset($p) $delta($pnum)
@@ -2154,11 +2702,35 @@ proc processgroup {} {
 		incr ol
 	    }
 	}
-	for {} {$nlc > 0} {incr nlc -1} {
+	set endl [expr {$l + $nlc}]
+	if {$bestpn >= 0} {
+	    # show this pretty much as a normal diff
+	    set p [lindex $parents($id) $bestpn]
+	    set ol [expr {$l + $diffoffset($p)}]
+	    incr diffoffset($p) $delta($bestpn)
+	    unset delta($bestpn)
+	    for {set k $i} {$k < $j} {incr k} {
+		set e [lindex $events $k]
+		if {[lindex $e 2] != $bestpn} continue
+		set nl [lindex $e 0]
+		set ol [expr {$ol + $nl - $l}]
+		for {} {$l < $nl} {incr l} {
+		    $ctext insert end "+$filelines($id,$f,$l)\n" $ncol
+		}
+		set c [lindex $e 3]
+		for {} {$c > 0} {incr c -1} {
+		    $ctext insert end "-$filelines($p,$f,$ol)\n" m$bestpn
+		    incr ol
+		}
+		set nl [lindex $e 1]
+		for {} {$l < $nl} {incr l} {
+		    $ctext insert end "+$filelines($id,$f,$l)\n" mresult
+		}
+	    }
+	}
+	for {} {$l < $endl} {incr l} {
 	    $ctext insert end "+$filelines($id,$f,$l)\n" $ncol
-	    incr l
 	}
-	set i $j
     }
     while {$l < $grouplineend} {
 	$ctext insert end " $filelines($id,$f,$l)\n"
@@ -2167,6 +2739,45 @@ proc processgroup {} {
     $ctext conf -state disabled
 }
 
+proc similarity {pnum l nlc f events} {
+    global diffmergeid parents diffoffset filelines
+
+    set id $diffmergeid
+    set p [lindex $parents($id) $pnum]
+    set ol [expr {$l + $diffoffset($p)}]
+    set endl [expr {$l + $nlc}]
+    set same 0
+    set diff 0
+    foreach e $events {
+	if {[lindex $e 2] != $pnum} continue
+	set nl [lindex $e 0]
+	set ol [expr {$ol + $nl - $l}]
+	for {} {$l < $nl} {incr l} {
+	    incr same [string length $filelines($id,$f,$l)]
+	    incr same
+	}
+	set oc [lindex $e 3]
+	for {} {$oc > 0} {incr oc -1} {
+	    incr diff [string length $filelines($p,$f,$ol)]
+	    incr diff
+	    incr ol
+	}
+	set nl [lindex $e 1]
+	for {} {$l < $nl} {incr l} {
+	    incr diff [string length $filelines($id,$f,$l)]
+	    incr diff
+	}
+    }
+    for {} {$l < $endl} {incr l} {
+	incr same [string length $filelines($id,$f,$l)]
+	incr same
+    }
+    if {$same == 0} {
+	return 0
+    }
+    return [expr {200 * $same / (2 * $same + $diff)}]
+}
+
 proc startdiff {ids} {
     global treediffs diffids treepending diffmergeid
 
@@ -2370,14 +2981,19 @@ proc listboxsel {} {
 
 proc setcoords {} {
     global linespc charspc canvx0 canvy0 mainfont
+    global xspc1 xspc2 lthickness
+
     set linespc [font metrics $mainfont -linespace]
     set charspc [font measure $mainfont "m"]
     set canvy0 [expr 3 + 0.5 * $linespc]
     set canvx0 [expr 3 + 0.5 * $linespc]
+    set lthickness [expr {int($linespc / 9) + 1}]
+    set xspc1(0) $linespc
+    set xspc2 $linespc
 }
 
 proc redisplay {} {
-    global selectedline stopped redisplaying phase
+    global stopped redisplaying phase
     if {$stopped > 1} return
     if {$phase == "getcommits"} return
     set redisplaying 1
@@ -2389,7 +3005,7 @@ proc redisplay {} {
 }
 
 proc incrfont {inc} {
-    global mainfont namefont textfont selectedline ctext canv phase
+    global mainfont namefont textfont ctext canv phase
     global stopped entries
     unmarkmatches
     set mainfont [lreplace $mainfont 1 1 [expr {[lindex $mainfont 1] + $inc}]]
@@ -2457,7 +3073,7 @@ proc gotocommit {} {
 	}
     }
     if {[info exists idline($id)]} {
-	selectline $idline($id)
+	selectline $idline($id) 1
 	return
     }
     if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
@@ -2531,34 +3147,127 @@ proc linehover {} {
     $canv raise $t
 }
 
-proc lineclick {x y id} {
-    global ctext commitinfo children cflist canv
+proc clickisonarrow {id y} {
+    global mainline mainlinearrow sidelines lthickness
+
+    set thresh [expr {2 * $lthickness + 6}]
+    if {[info exists mainline($id)]} {
+	if {$mainlinearrow($id) ne "none"} {
+	    if {abs([lindex $mainline($id) 1] - $y) < $thresh} {
+		return "up"
+	    }
+	}
+    }
+    if {[info exists sidelines($id)]} {
+	foreach ls $sidelines($id) {
+	    set coords [lindex $ls 0]
+	    set arrow [lindex $ls 2]
+	    if {$arrow eq "first" || $arrow eq "both"} {
+		if {abs([lindex $coords 1] - $y) < $thresh} {
+		    return "up"
+		}
+	    }
+	    if {$arrow eq "last" || $arrow eq "both"} {
+		if {abs([lindex $coords end] - $y) < $thresh} {
+		    return "down"
+		}
+	    }
+	}
+    }
+    return {}
+}
+
+proc arrowjump {id dirn y} {
+    global mainline sidelines canv
+
+    set yt {}
+    if {$dirn eq "down"} {
+	if {[info exists mainline($id)]} {
+	    set y1 [lindex $mainline($id) 1]
+	    if {$y1 > $y} {
+		set yt $y1
+	    }
+	}
+	if {[info exists sidelines($id)]} {
+	    foreach ls $sidelines($id) {
+		set y1 [lindex $ls 0 1]
+		if {$y1 > $y && ($yt eq {} || $y1 < $yt)} {
+		    set yt $y1
+		}
+	    }
+	}
+    } else {
+	if {[info exists sidelines($id)]} {
+	    foreach ls $sidelines($id) {
+		set y1 [lindex $ls 0 end]
+		if {$y1 < $y && ($yt eq {} || $y1 > $yt)} {
+		    set yt $y1
+		}
+	    }
+	}
+    }
+    if {$yt eq {}} return
+    set ymax [lindex [$canv cget -scrollregion] 3]
+    if {$ymax eq {} || $ymax <= 0} return
+    set view [$canv yview]
+    set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
+    set yfrac [expr {$yt / $ymax - $yspan / 2}]
+    if {$yfrac < 0} {
+	set yfrac 0
+    }
+    $canv yview moveto $yfrac
+}
+
+proc lineclick {x y id isnew} {
+    global ctext commitinfo children cflist canv thickerline
 
     unmarkmatches
+    unselectline
+    normalline
     $canv delete hover
+    # draw this line thicker than normal
+    drawlines $id 1
+    set thickerline $id
+    if {$isnew} {
+	set ymax [lindex [$canv cget -scrollregion] 3]
+	if {$ymax eq {}} return
+	set yfrac [lindex [$canv yview] 0]
+	set y [expr {$y + $yfrac * $ymax}]
+    }
+    set dirn [clickisonarrow $id $y]
+    if {$dirn ne {}} {
+	arrowjump $id $dirn $y
+	return
+    }
+
+    if {$isnew} {
+	addtohistory [list lineclick $x $y $id 0]
+    }
     # fill the details pane with info about this line
     $ctext conf -state normal
     $ctext delete 0.0 end
-    $ctext insert end "Parent:\n "
-    catch {destroy $ctext.$id}
-    button $ctext.$id -text "Go:" -command "selbyid $id" \
-	-padx 4 -pady 0
-    $ctext window create end -window $ctext.$id -align center
+    $ctext tag conf link -foreground blue -underline 1
+    $ctext tag bind link <Enter> { %W configure -cursor hand2 }
+    $ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
+    $ctext insert end "Parent:\t"
+    $ctext insert end $id [list link link0]
+    $ctext tag bind link0 <1> [list selbyid $id]
     set info $commitinfo($id)
-    $ctext insert end "\t[lindex $info 0]\n"
+    $ctext insert end "\n\t[lindex $info 0]\n"
     $ctext insert end "\tAuthor:\t[lindex $info 1]\n"
     $ctext insert end "\tDate:\t[lindex $info 2]\n"
-    $ctext insert end "\tID:\t$id\n"
     if {[info exists children($id)]} {
 	$ctext insert end "\nChildren:"
+	set i 0
 	foreach child $children($id) {
-	    $ctext insert end "\n "
-	    catch {destroy $ctext.$child}
-	    button $ctext.$child -text "Go:" -command "selbyid $child" \
-		-padx 4 -pady 0
-	    $ctext window create end -window $ctext.$child -align center
+	    incr i
 	    set info $commitinfo($child)
-	    $ctext insert end "\t[lindex $info 0]"
+	    $ctext insert end "\n\t"
+	    $ctext insert end $child [list link link$i]
+	    $ctext tag bind link$i <1> [list selbyid $child]
+	    $ctext insert end "\n\t[lindex $info 0]"
+	    $ctext insert end "\n\tAuthor:\t[lindex $info 1]"
+	    $ctext insert end "\n\tDate:\t[lindex $info 2]\n"
 	}
     }
     $ctext conf -state disabled
@@ -2566,10 +3275,18 @@ proc lineclick {x y id} {
     $cflist delete 0 end
 }
 
+proc normalline {} {
+    global thickerline
+    if {[info exists thickerline]} {
+	drawlines $thickerline 0
+	unset thickerline
+    }
+}
+
 proc selbyid {id} {
     global idline
     if {[info exists idline($id)]} {
-	selectline $idline($id)
+	selectline $idline($id) 1
     }
 }
 
@@ -2598,8 +3315,6 @@ proc rowmenu {x y id} {
 
 proc diffvssel {dirn} {
     global rowmenuid selectedline lineid
-    global ctext cflist
-    global commitinfo
 
     if {![info exists selectedline]} return
     if {$dirn} {
@@ -2609,21 +3324,38 @@ proc diffvssel {dirn} {
 	set oldid $rowmenuid
 	set newid $lineid($selectedline)
     }
+    addtohistory [list doseldiff $oldid $newid]
+    doseldiff $oldid $newid
+}
+
+proc doseldiff {oldid newid} {
+    global ctext cflist
+    global commitinfo
+
     $ctext conf -state normal
     $ctext delete 0.0 end
     $ctext mark set fmark.0 0.0
     $ctext mark gravity fmark.0 left
     $cflist delete 0 end
     $cflist insert end "Top"
-    $ctext insert end "From $oldid\n     "
+    $ctext insert end "From "
+    $ctext tag conf link -foreground blue -underline 1
+    $ctext tag bind link <Enter> { %W configure -cursor hand2 }
+    $ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
+    $ctext tag bind link0 <1> [list selbyid $oldid]
+    $ctext insert end $oldid [list link link0]
+    $ctext insert end "\n     "
     $ctext insert end [lindex $commitinfo($oldid) 0]
-    $ctext insert end "\n\nTo   $newid\n     "
+    $ctext insert end "\n\nTo   "
+    $ctext tag bind link1 <1> [list selbyid $newid]
+    $ctext insert end $newid [list link link1]
+    $ctext insert end "\n     "
     $ctext insert end [lindex $commitinfo($newid) 0]
     $ctext insert end "\n"
     $ctext conf -state disabled
     $ctext tag delete Comments
     $ctext tag remove found 1.0 end
-    startdiff $newid [list $oldid]
+    startdiff [list $newid $oldid]
 }
 
 proc mkpatch {} {
@@ -2744,7 +3476,6 @@ proc mktag {} {
 
 proc domktag {} {
     global mktagtop env tagids idtags
-    global idpos idline linehtag canv selectedline
 
     set id [$mktagtop.sha1 get]
     set tag [$mktagtop.tag get]
@@ -2769,11 +3500,18 @@ proc domktag {} {
 
     set tagids($tag) $id
     lappend idtags($id) $tag
+    redrawtags $id
+}
+
+proc redrawtags {id} {
+    global canv linehtag idline idpos selectedline
+
+    if {![info exists idline($id)]} return
     $canv delete tag.$id
     set xt [eval drawtags $id $idpos($id)]
     $canv coords $linehtag($idline($id)) $xt [lindex $idpos($id) 2]
     if {[info exists selectedline] && $selectedline == $idline($id)} {
-	selectline $selectedline
+	selectline $selectedline 0
     }
 }
 
@@ -2844,6 +3582,68 @@ proc wrcomcan {} {
     unset wrcomtop
 }
 
+proc listrefs {id} {
+    global idtags idheads idotherrefs
+
+    set x {}
+    if {[info exists idtags($id)]} {
+	set x $idtags($id)
+    }
+    set y {}
+    if {[info exists idheads($id)]} {
+	set y $idheads($id)
+    }
+    set z {}
+    if {[info exists idotherrefs($id)]} {
+	set z $idotherrefs($id)
+    }
+    return [list $x $y $z]
+}
+
+proc rereadrefs {} {
+    global idtags idheads idotherrefs
+    global tagids headids otherrefids
+
+    set refids [concat [array names idtags] \
+		    [array names idheads] [array names idotherrefs]]
+    foreach id $refids {
+	if {![info exists ref($id)]} {
+	    set ref($id) [listrefs $id]
+	}
+    }
+    foreach v {tagids idtags headids idheads otherrefids idotherrefs} {
+	catch {unset $v}
+    }
+    readrefs
+    set refids [lsort -unique [concat $refids [array names idtags] \
+			[array names idheads] [array names idotherrefs]]]
+    foreach id $refids {
+	set v [listrefs $id]
+	if {![info exists ref($id)] || $ref($id) != $v} {
+	    redrawtags $id
+	}
+    }
+}
+
+proc showtag {tag isnew} {
+    global ctext cflist tagcontents tagids linknum
+
+    if {$isnew} {
+	addtohistory [list showtag $tag 0]
+    }
+    $ctext conf -state normal
+    $ctext delete 0.0 end
+    set linknum 0
+    if {[info exists tagcontents($tag)]} {
+	set text $tagcontents($tag)
+    } else {
+	set text "Tag: $tag\nId:  $tagids($tag)"
+    }
+    appendwithlinks $text
+    $ctext conf -state disabled
+    $cflist delete 0 end
+}
+
 proc doquit {} {
     global stopped
     set stopped 100
@@ -2860,6 +3660,8 @@ set mainfont {Helvetica 9}
 set textfont {Courier 9}
 set findmergefiles 0
 set gaudydiff 0
+set maxgraphpct 50
+set maxwidth 16
 
 set colors {green red blue magenta darkgrey brown orange}
 
@@ -2882,6 +3684,9 @@ foreach arg $argv {
     }
 }
 
+set history {}
+set historyindex 0
+
 set stopped 0
 set redisplaying 0
 set stuffsaved 0