mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gitk: Establish and use global left-to-right ordering for commits

Browse Source 
This creates an "ordering token" for each commit which establishes
a total ordering for commits and is used to order the commits from
left to right on a row.  The ordering token is assigned when a commit
is first encountered or when it is first listed as a parent of some
other commit, whichever comes first.  The ordering token is a string
of variable length.  Parents that don't already have an ordering
token are assigned one by appending to the child's token; the first
parent gets a "0" on the end, the second "1" and so on.  As an
optimization, the "0" isn't appended if the child only has one parent.

When inserting a new commit into an element of rowidlist, it is
inserted in the position which makes the ordering tokens increase
from left to right.

This also simplifies the layout code by getting rid of the rowoffsets
variable, and terminates lines with an arrow after 5 rows if the line
would be longer than about 110 rows (rather than letting them go on
and terminating them later with an arrow if the graph gets too wide).

The effect of having the total ordering, and terminating the lines
early, is that it will be possible to lay out only a part of the graph
rather than having to do the whole thing top to bottom.

Signed-off-by: Paul Mackerras <paulus@samba.org>
This commit is contained in:
Paul Mackerras
2007-07-31 21:03:06 +10:00
parent 3244729aac
commit 6e8c870703
1 changed files with 148 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

351
gitk
View File

@ -82,11 +82,12 @@ proc dorunq {} {
proc start_rev_list {view} { proc start_rev_list {view} {
global startmsecs global startmsecs
global commfd leftover tclencoding datemode global commfd leftover tclencoding datemode
global viewargs viewfiles commitidx global viewargs viewfiles commitidx vnextroot
global lookingforhead showlocalchanges global lookingforhead showlocalchanges
set startmsecs [clock clicks -milliseconds] set startmsecs [clock clicks -milliseconds]
set commitidx($view) 0 set commitidx($view) 0
set vnextroot($view) 0
set order "--topo-order" set order "--topo-order"
if {$datemode} { if {$datemode} {
set order "--date-order" set order "--date-order"
@ -131,12 +132,26 @@ proc getcommits {} {
show_status "Reading commits..." show_status "Reading commits..."
} }
# This makes a string representation of a positive integer which
# sorts as a string in numerical order
proc strrep {n} {
if {$n < 16} {
return [format "%x" $n]
} elseif {$n < 256} {
return [format "x%.2x" $n]
} elseif {$n < 65536} {
return [format "y%.4x" $n]
}
return [format "z%.8x" $n]
}
proc getcommitlines {fd view} { proc getcommitlines {fd view} {
global commitlisted global commitlisted
global leftover commfd global leftover commfd
global displayorder commitidx commitrow commitdata global displayorder commitidx commitrow commitdata
global parentlist children curview hlview global parentlist children curview hlview
global vparentlist vdisporder vcmitlisted global vparentlist vdisporder vcmitlisted
global ordertok vnextroot
set stuff [read $fd 500000] set stuff [read $fd 500000]
# git log doesn't terminate the last commit with a null... # git log doesn't terminate the last commit with a null...
@ -221,14 +236,32 @@ proc getcommitlines {fd view} {
exit 1 exit 1
} }
set id [lindex $ids 0] set id [lindex $ids 0]
if {![info exists ordertok($view,$id)]} {
set otok "o[strrep $vnextroot($view)]"
incr vnextroot($view)
set ordertok($view,$id) $otok
} else {
set otok $ordertok($view,$id)
}
if {$listed} { if {$listed} {
set olds [lrange $ids 1 end] set olds [lrange $ids 1 end]
set i 0 if {[llength $olds] == 1} {
foreach p $olds { set p [lindex $olds 0]
if {$i == 0 || [lsearch -exact $olds $p] >= $i} { lappend children($view,$p) $id
lappend children($view,$p) $id if {![info exists ordertok($view,$p)]} {
set ordertok($view,$p) $ordertok($view,$id)
}
} else {
set i 0
foreach p $olds {
if {$i == 0 || [lsearch -exact $olds $p] >= $i} {
lappend children($view,$p) $id
}
if {![info exists ordertok($view,$p)]} {
set ordertok($view,$p) "$otok[strrep $i]]"
}
incr i
} }
incr i
} }
} else { } else {
set olds {} set olds {}
@ -1821,7 +1854,7 @@ proc unflatten {var l} {
proc showview {n} { proc showview {n} {
global curview viewdata viewfiles global curview viewdata viewfiles
global displayorder parentlist rowidlist rowoffsets global displayorder parentlist rowidlist
global colormap rowtextx commitrow nextcolor canvxmax global colormap rowtextx commitrow nextcolor canvxmax
global numcommits rowrangelist commitlisted idrowranges rowchk global numcommits rowrangelist commitlisted idrowranges rowchk
global selectedline currentid canv canvy0 global selectedline currentid canv canvy0
@ -1859,13 +1892,13 @@ proc showview {n} {
set vcmitlisted($curview) $commitlisted set vcmitlisted($curview) $commitlisted
if {$phase ne {}} { if {$phase ne {}} {
set viewdata($curview) \ set viewdata($curview) \
[list $phase $rowidlist $rowoffsets $rowrangelist \ [list $phase $rowidlist {} $rowrangelist \
[flatten idrowranges] [flatten idinlist] \ [flatten idrowranges] [flatten idinlist] \
$rowlaidout $rowoptim $numcommits] $rowlaidout $rowoptim $numcommits]
} elseif {![info exists viewdata($curview)] } elseif {![info exists viewdata($curview)]
|| [lindex $viewdata($curview) 0] ne {}} { || [lindex $viewdata($curview) 0] ne {}} {
set viewdata($curview) \ set viewdata($curview) \
[list {} $rowidlist $rowoffsets $rowrangelist] [list {} $rowidlist {} $rowrangelist]
} }
} }
catch {unset treediffs} catch {unset treediffs}
@ -1894,7 +1927,6 @@ proc showview {n} {
set parentlist $vparentlist($n) set parentlist $vparentlist($n)
set commitlisted $vcmitlisted($n) set commitlisted $vcmitlisted($n)
set rowidlist [lindex $v 1] set rowidlist [lindex $v 1]
set rowoffsets [lindex $v 2]
set rowrangelist [lindex $v 3] set rowrangelist [lindex $v 3]
if {$phase eq {}} { if {$phase eq {}} {
set numcommits [llength $displayorder] set numcommits [llength $displayorder]
@ -2542,67 +2574,43 @@ proc usedinrange {id l1 l2} {
return 0 return 0
} }
proc sanity {row {full 0}} { # Work out where id should go in idlist so that order-token
global rowidlist rowoffsets # values increase from left to right
proc idcol {idlist id {i 0}} {
global ordertok curview
set col -1 set t $ordertok($curview,$id)
set ids [lindex $rowidlist $row] if {$i >= [llength $idlist] ||
foreach id $ids { $t < $ordertok($curview,[lindex $idlist $i])} {
incr col if {$i > [llength $idlist]} {
if {$id eq {}} continue set i [llength $idlist]
if {$col < [llength $ids] - 1 &&
[lsearch -exact -start [expr {$col+1}] $ids $id] >= 0} {
puts "oops: [shortids $id] repeated in row $row col $col: {[shortids [lindex $rowidlist $row]]}"
} }
set o [lindex $rowoffsets $row $col] while {[incr i -1] >= 0 &&
set y $row $t < $ordertok($curview,[lindex $idlist $i])} {}
set x $col incr i
while {$o ne {}} { } else {
incr y -1 if {$t > $ordertok($curview,[lindex $idlist $i])} {
incr x $o while {[incr i] < [llength $idlist] &&
if {[lindex $rowidlist $y $x] != $id} { $t >= $ordertok($curview,[lindex $idlist $i])} {}
puts "oops: rowoffsets wrong at row [expr {$y+1}] col [expr {$x-$o}]"
puts " id=[shortids $id] check started at row $row"
for {set i $row} {$i >= $y} {incr i -1} {
puts " row $i ids={[shortids [lindex $rowidlist $i]]} offs={[lindex $rowoffsets $i]}"
}
break
}
if {!$full} break
set o [lindex $rowoffsets $y $x]
} }
} }
return $i
} }
proc makeuparrow {oid x y z} { proc makeuparrow {oid y x} {
global rowidlist rowoffsets uparrowlen idrowranges displayorder global rowidlist uparrowlen idrowranges displayorder
for {set i 1} {$i < $uparrowlen && $y > 1} {incr i} { for {set i 1} {$i < $uparrowlen && $y > 1} {incr i} {
incr y -1 incr y -1
incr x $z set idl [lindex $rowidlist $y]
set off0 [lindex $rowoffsets $y] set x [idcol $idl $oid $x]
for {set x0 $x} {1} {incr x0} { lset rowidlist $y [linsert $idl $x $oid]
if {$x0 >= [llength $off0]} {
set x0 [llength [lindex $rowoffsets [expr {$y-1}]]]
break
}
set z [lindex $off0 $x0]
if {$z ne {}} {
incr x0 $z
break
}
}
set z [expr {$x0 - $x}]
lset rowidlist $y [linsert [lindex $rowidlist $y] $x $oid]
lset rowoffsets $y [linsert [lindex $rowoffsets $y] $x $z]
} }
set tmp [lreplace [lindex $rowoffsets $y] $x $x {}]
lset rowoffsets $y [incrange $tmp [expr {$x+1}] -1]
lappend idrowranges($oid) [lindex $displayorder $y] lappend idrowranges($oid) [lindex $displayorder $y]
} }
proc initlayout {} { proc initlayout {} {
global rowidlist rowoffsets displayorder commitlisted global rowidlist displayorder commitlisted
global rowlaidout rowoptim global rowlaidout rowoptim
global idinlist rowchk rowrangelist idrowranges global idinlist rowchk rowrangelist idrowranges
global numcommits canvxmax canv global numcommits canvxmax canv
@ -2618,7 +2626,6 @@ proc initlayout {} {
set rowrangelist {} set rowrangelist {}
set nextcolor 0 set nextcolor 0
set rowidlist {{}} set rowidlist {{}}
set rowoffsets {{}}
catch {unset idinlist} catch {unset idinlist}
catch {unset rowchk} catch {unset rowchk}
set rowlaidout 0 set rowlaidout 0
@ -2679,8 +2686,8 @@ proc layoutmore {tmax allread} {
set nr [expr {$commitidx($curview) - $rowlaidout}] set nr [expr {$commitidx($curview) - $rowlaidout}]
# may need to increase this threshold if uparrowlen or # may need to increase this threshold if uparrowlen or
# mingaplen are increased... # mingaplen are increased...
if {$nr > 150} { if {$nr > 200} {
set nr 150 set nr 200
} }
set row $rowlaidout set row $rowlaidout
set rowlaidout [layoutrows $row [expr {$row + $nr}] $allread] set rowlaidout [layoutrows $row [expr {$row + $nr}] $allread]
@ -2861,7 +2868,7 @@ proc readdifffiles {fd serial} {
} }
proc layoutrows {row endrow last} { proc layoutrows {row endrow last} {
global rowidlist rowoffsets displayorder global rowidlist displayorder
global uparrowlen downarrowlen maxwidth mingaplen global uparrowlen downarrowlen maxwidth mingaplen
global children parentlist global children parentlist
global idrowranges global idrowranges
@ -2869,12 +2876,12 @@ proc layoutrows {row endrow last} {
global idinlist rowchk rowrangelist global idinlist rowchk rowrangelist
set idlist [lindex $rowidlist $row] set idlist [lindex $rowidlist $row]
set offs [lindex $rowoffsets $row]
while {$row < $endrow} { while {$row < $endrow} {
set id [lindex $displayorder $row] set id [lindex $displayorder $row]
set oldolds {} set oldolds {}
set newolds {} set newolds {}
foreach p [lindex $parentlist $row] { set olds [lindex $parentlist $row]
foreach p $olds {
if {![info exists idinlist($p)]} { if {![info exists idinlist($p)]} {
lappend newolds $p lappend newolds $p
} elseif {!$idinlist($p)} { } elseif {!$idinlist($p)} {
@ -2883,7 +2890,7 @@ proc layoutrows {row endrow last} {
} }
set nev [expr {[llength $idlist] + [llength $newolds] set nev [expr {[llength $idlist] + [llength $newolds]
+ [llength $oldolds] - $maxwidth + 1}] + [llength $oldolds] - $maxwidth + 1}]
if {$nev > 0} { if {1 || $nev > 0} {
if {!$last && if {!$last &&
$row + $uparrowlen + $mingaplen >= $commitidx($curview)} break $row + $uparrowlen + $mingaplen >= $commitidx($curview)} break
for {set x [llength $idlist]} {[incr x -1] >= 0} {} { for {set x [llength $idlist]} {[incr x -1] >= 0} {} {
@ -2893,34 +2900,25 @@ proc layoutrows {row endrow last} {
[expr {$row + $uparrowlen + $mingaplen}]] [expr {$row + $uparrowlen + $mingaplen}]]
if {$r == 0} { if {$r == 0} {
set idlist [lreplace $idlist $x $x] set idlist [lreplace $idlist $x $x]
set offs [lreplace $offs $x $x]
set offs [incrange $offs $x 1]
set idinlist($i) 0 set idinlist($i) 0
set rm1 [expr {$row - 1}] set rm1 [expr {$row - 1}]
lappend idrowranges($i) [lindex $displayorder $rm1] lappend idrowranges($i) [lindex $displayorder $rm1]
if {[incr nev -1] <= 0} break #if {[incr nev -1] <= 0} break
continue continue
} }
set rowchk($id) [expr {$row + $r}] set rowchk($id) [expr {$row + $r}]
} }
} }
lset rowidlist $row $idlist lset rowidlist $row $idlist
lset rowoffsets $row $offs
} }
set col [lsearch -exact $idlist $id] set col [lsearch -exact $idlist $id]
if {$col < 0} { if {$col < 0} {
set col [llength $idlist] set col [idcol $idlist $id]
lappend idlist $id set idlist [linsert $idlist $col $id]
lset rowidlist $row $idlist lset rowidlist $row $idlist
set z {}
if {$children($curview,$id) ne {}} { if {$children($curview,$id) ne {}} {
set z [expr {[llength [lindex $rowidlist [expr {$row-1}]]] - $col}]
unset idinlist($id) unset idinlist($id)
} makeuparrow $id $row $col
lappend offs $z
lset rowoffsets $row $offs
if {$z ne {}} {
makeuparrow $id $col $row $z
} }
} else { } else {
unset idinlist($id) unset idinlist($id)
@ -2933,38 +2931,21 @@ proc layoutrows {row endrow last} {
} }
lappend rowrangelist $ranges lappend rowrangelist $ranges
incr row incr row
set offs [ntimes [llength $idlist] 0] set idlist [lreplace $idlist $col $col]
set l [llength $newolds] set x $col
set idlist [eval lreplace \$idlist $col $col $newolds]
set o 0
if {$l != 1} {
set offs [lrange $offs 0 [expr {$col - 1}]]
foreach x $newolds {
lappend offs {}
incr o -1
}
incr o
set tmp [expr {[llength $idlist] - [llength $offs]}]
if {$tmp > 0} {
set offs [concat $offs [ntimes $tmp $o]]
}
} else {
lset offs $col {}
}
foreach i $newolds { foreach i $newolds {
set x [idcol $idlist $i $x]
set idlist [linsert $idlist $x $i]
set idinlist($i) 1 set idinlist($i) 1
set idrowranges($i) $id set idrowranges($i) $id
} }
incr col $l
foreach oid $oldolds { foreach oid $oldolds {
set idinlist($oid) 1 set idinlist($oid) 1
set idlist [linsert $idlist $col $oid] set x [idcol $idlist $oid $x]
set offs [linsert $offs $col $o] set idlist [linsert $idlist $x $oid]
makeuparrow $oid $col $row $o makeuparrow $oid $row $x
incr col
} }
lappend rowidlist $idlist lappend rowidlist $idlist
lappend rowoffsets $offs
} }
return $row return $row
} }
@ -2989,7 +2970,7 @@ proc addextraid {id row} {
} }
proc layouttail {} { proc layouttail {} {
global rowidlist rowoffsets idinlist commitidx curview global rowidlist idinlist commitidx curview
global idrowranges rowrangelist global idrowranges rowrangelist
set row $commitidx($curview) set row $commitidx($curview)
@ -3003,56 +2984,70 @@ proc layouttail {} {
lappend rowrangelist $idrowranges($id) lappend rowrangelist $idrowranges($id)
unset idrowranges($id) unset idrowranges($id)
incr row incr row
set offs [ntimes $col 0]
set idlist [lreplace $idlist $col $col] set idlist [lreplace $idlist $col $col]
lappend rowidlist $idlist lappend rowidlist $idlist
lappend rowoffsets $offs
} }
foreach id [array names idinlist] { foreach id [array names idinlist] {
unset idinlist($id) unset idinlist($id)
addextraid $id $row addextraid $id $row
lset rowidlist $row [list $id] lset rowidlist $row [list $id]
lset rowoffsets $row 0 makeuparrow $id $row 0
makeuparrow $id 0 $row 0
lappend idrowranges($id) $id lappend idrowranges($id) $id
lappend rowrangelist $idrowranges($id) lappend rowrangelist $idrowranges($id)
unset idrowranges($id) unset idrowranges($id)
incr row incr row
lappend rowidlist {} lappend rowidlist {}
lappend rowoffsets {}
} }
} }
proc insert_pad {row col npad} { proc insert_pad {row col npad} {
global rowidlist rowoffsets global rowidlist
set pad [ntimes $npad {}] set pad [ntimes $npad {}]
lset rowidlist $row [eval linsert [list [lindex $rowidlist $row]] $col $pad] lset rowidlist $row [eval linsert [list [lindex $rowidlist $row]] $col $pad]
set tmp [eval linsert [list [lindex $rowoffsets $row]] $col $pad]
lset rowoffsets $row [incrange $tmp [expr {$col + $npad}] [expr {-$npad}]]
} }
proc optimize_rows {row col endrow} { proc optimize_rows {row col endrow} {
global rowidlist rowoffsets displayorder global rowidlist displayorder
if {$row < 1} {
set row 1
}
set idlist [lindex $rowidlist [expr {$row - 1}]]
if {$row >= 2} {
set previdlist [lindex $rowidlist [expr {$row - 2}]]
} else {
set previdlist {}
}
for {} {$row < $endrow} {incr row} { for {} {$row < $endrow} {incr row} {
set pprevidlist $previdlist
set previdlist $idlist
set idlist [lindex $rowidlist $row] set idlist [lindex $rowidlist $row]
set offs [lindex $rowoffsets $row]
set haspad 0 set haspad 0
for {} {$col < [llength $offs]} {incr col} { set y0 [expr {$row - 1}]
if {[lindex $idlist $col] eq {}} { set ym [expr {$row - 2}]
set x0 -1
set xm -1
for {} {$col < [llength $idlist]} {incr col} {
set id [lindex $idlist $col]
if {[lindex $previdlist $col] eq $id} continue
if {$id eq {}} {
set haspad 1 set haspad 1
continue continue
} }
set z [lindex $offs $col] set x0 [lsearch -exact $previdlist $id]
if {$z eq {}} continue if {$x0 < 0} continue
set z [expr {$x0 - $col}]
set isarrow 0 set isarrow 0
set x0 [expr {$col + $z}] set z0 {}
set y0 [expr {$row - 1}] if {$ym >= 0} {
set z0 [lindex $rowoffsets $y0 $x0] set xm [lsearch -exact $pprevidlist $id]
if {$xm >= 0} {
set z0 [expr {$xm - $x0}]
}
}
if {$z0 eq {}} { if {$z0 eq {}} {
set id [lindex $idlist $col]
set ranges [rowranges $id] set ranges [rowranges $id]
if {$ranges ne {} && $y0 > [lindex $ranges 0]} { if {$ranges ne {} && $y0 > [lindex $ranges 0]} {
set isarrow 1 set isarrow 1
@ -3066,43 +3061,32 @@ proc optimize_rows {row col endrow} {
# Line currently goes left too much; # Line currently goes left too much;
# insert pads in the previous row, then optimize it # insert pads in the previous row, then optimize it
set npad [expr {-1 - $z + $isarrow}] set npad [expr {-1 - $z + $isarrow}]
set offs [incrange $offs $col $npad]
insert_pad $y0 $x0 $npad insert_pad $y0 $x0 $npad
if {$y0 > 0} { if {$y0 > 0} {
optimize_rows $y0 $x0 $row optimize_rows $y0 $x0 $row
} }
set z [lindex $offs $col] set previdlist [lindex $rowidlist $y0]
set x0 [expr {$col + $z}] set x0 [lsearch -exact $previdlist $id]
set z0 [lindex $rowoffsets $y0 $x0] set z [expr {$x0 - $col}]
if {$z0 ne {}} {
set pprevidlist [lindex $rowidlist $ym]
set xm [lsearch -exact $pprevidlist $id]
set z0 [expr {$xm - $x0}]
}
} elseif {$z > 1 || ($z > 0 && $isarrow)} { } elseif {$z > 1 || ($z > 0 && $isarrow)} {
# Line currently goes right too much; # Line currently goes right too much;
# insert pads in this line and adjust the next's rowoffsets # insert pads in this line
set npad [expr {$z - 1 + $isarrow}] set npad [expr {$z - 1 + $isarrow}]
set y1 [expr {$row + 1}]
set offs2 [lindex $rowoffsets $y1]
set x1 -1
foreach z $offs2 {
incr x1
if {$z eq {} || $x1 + $z < $col} continue
if {$x1 + $z > $col} {
incr npad
}
lset rowoffsets $y1 [incrange $offs2 $x1 $npad]
break
}
set pad [ntimes $npad {}] set pad [ntimes $npad {}]
set idlist [eval linsert \$idlist $col $pad] set idlist [eval linsert \$idlist $col $pad]
set tmp [eval linsert \$offs $col $pad]
incr col $npad incr col $npad
set offs [incrange $tmp $col [expr {-$npad}]] set z [expr {$x0 - $col}]
set z [lindex $offs $col]
set haspad 1 set haspad 1
} }
if {$z0 eq {} && !$isarrow} { if {$z0 eq {} && !$isarrow && $ym >= 0} {
# this line links to its first child on row $row-2 # this line links to its first child on row $row-2
set rm2 [expr {$row - 2}] set id [lindex $displayorder $ym]
set id [lindex $displayorder $rm2] set xc [lsearch -exact $pprevidlist $id]
set xc [lsearch -exact [lindex $rowidlist $rm2] $id]
if {$xc >= 0} { if {$xc >= 0} {
set z0 [expr {$xc - $x0}] set z0 [expr {$xc - $x0}]
} }
@ -3110,51 +3094,36 @@ proc optimize_rows {row col endrow} {
# avoid lines jigging left then immediately right # avoid lines jigging left then immediately right
if {$z0 ne {} && $z < 0 && $z0 > 0} { if {$z0 ne {} && $z < 0 && $z0 > 0} {
insert_pad $y0 $x0 1 insert_pad $y0 $x0 1
set offs [incrange $offs $col 1] incr x0
optimize_rows $y0 [expr {$x0 + 1}] $row optimize_rows $y0 $x0 $row
set previdlist [lindex $rowidlist $y0]
set pprevidlist [lindex $rowidlist $ym]
} }
} }
if {!$haspad} { if {!$haspad} {
set o {}
# Find the first column that doesn't have a line going right # Find the first column that doesn't have a line going right
for {set col [llength $idlist]} {[incr col -1] >= 0} {} { for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
set o [lindex $offs $col] set id [lindex $idlist $col]
if {$o eq {}} { if {$id eq {}} break
set x0 [lsearch -exact $previdlist $id]
if {$x0 < 0} {
# check if this is the link to the first child # check if this is the link to the first child
set id [lindex $idlist $col]
set ranges [rowranges $id] set ranges [rowranges $id]
if {$ranges ne {} && $row == [lindex $ranges 0]} { if {$ranges ne {} && $row == [lindex $ranges 0]} {
# it is, work out offset to child # it is, work out offset to child
set y0 [expr {$row - 1}]
set id [lindex $displayorder $y0] set id [lindex $displayorder $y0]
set x0 [lsearch -exact [lindex $rowidlist $y0] $id] set x0 [lsearch -exact $previdlist $id]
if {$x0 >= 0} {
set o [expr {$x0 - $col}]
}
} }
} }
if {$o eq {} || $o <= 0} break if {$x0 <= $col} break
} }
# Insert a pad at that column as long as it has a line and # Insert a pad at that column as long as it has a line and
# isn't the last column, and adjust the next row' offsets # isn't the last column
if {$o ne {} && [incr col] < [llength $idlist]} { if {$x0 >= 0 && [incr col] < [llength $idlist]} {
set y1 [expr {$row + 1}]
set offs2 [lindex $rowoffsets $y1]
set x1 -1
foreach z $offs2 {
incr x1
if {$z eq {} || $x1 + $z < $col} continue
lset rowoffsets $y1 [incrange $offs2 $x1 1]
break
}
set idlist [linsert $idlist $col {}] set idlist [linsert $idlist $col {}]
set tmp [linsert $offs $col {}]
incr col
set offs [incrange $tmp $col -1]
} }
} }
lset rowidlist $row $idlist lset rowidlist $row $idlist
lset rowoffsets $row $offs
set col 0 set col 0
} }
} }
@ -3669,7 +3638,7 @@ proc clear_display {} {
} }
proc findcrossings {id} { proc findcrossings {id} {
global rowidlist parentlist numcommits rowoffsets displayorder global rowidlist parentlist numcommits displayorder
set cross {} set cross {}
set ccross {} set ccross {}
@ -3678,12 +3647,9 @@ proc findcrossings {id} {
set e [expr {$numcommits - 1}] set e [expr {$numcommits - 1}]
} }
if {$e <= $s} continue if {$e <= $s} continue
set x [lsearch -exact [lindex $rowidlist $e] $id]
if {$x < 0} {
puts "findcrossings: oops, no [shortids $id] in row $e"
continue
}
for {set row $e} {[incr row -1] >= $s} {} { for {set row $e} {[incr row -1] >= $s} {} {
set x [lsearch -exact [lindex $rowidlist $row] $id]
if {$x < 0} break
set olds [lindex $parentlist $row] set olds [lindex $parentlist $row]
set kid [lindex $displayorder $row] set kid [lindex $displayorder $row]
set kidx [lsearch -exact [lindex $rowidlist $row] $kid] set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
@ -3701,9 +3667,6 @@ proc findcrossings {id} {
} }
} }
} }
set inc [lindex $rowoffsets $row $x]
if {$inc eq {}} break
incr x $inc
} }
} }
return [concat $ccross {{}} $cross] return [concat $ccross {{}} $cross]
@ -3893,7 +3856,7 @@ proc show_status {msg} {
# on that row and below will move down one row. # on that row and below will move down one row.
proc insertrow {row newcmit} { proc insertrow {row newcmit} {
global displayorder parentlist commitlisted children global displayorder parentlist commitlisted children
global commitrow curview rowidlist rowoffsets numcommits global commitrow curview rowidlist numcommits
global rowrangelist rowlaidout rowoptim numcommits global rowrangelist rowlaidout rowoptim numcommits
global selectedline rowchk commitidx global selectedline rowchk commitidx
@ -3917,26 +3880,14 @@ proc insertrow {row newcmit} {
incr commitidx($curview) incr commitidx($curview)
set idlist [lindex $rowidlist $row] set idlist [lindex $rowidlist $row]
set offs [lindex $rowoffsets $row]
set newoffs {}
foreach x $idlist {
if {$x eq {} || ($x eq $p && [llength $kids] == 1)} {
lappend newoffs {}
} else {
lappend newoffs 0
}
}
if {[llength $kids] == 1} { if {[llength $kids] == 1} {
set col [lsearch -exact $idlist $p] set col [lsearch -exact $idlist $p]
lset idlist $col $newcmit lset idlist $col $newcmit
} else { } else {
set col [llength $idlist] set col [llength $idlist]
lappend idlist $newcmit lappend idlist $newcmit
lappend offs {}
lset rowoffsets $row $offs
} }
set rowidlist [linsert $rowidlist $row $idlist] set rowidlist [linsert $rowidlist $row $idlist]
set rowoffsets [linsert $rowoffsets [expr {$row+1}] $newoffs]
set rowrangelist [linsert $rowrangelist $row {}] set rowrangelist [linsert $rowrangelist $row {}]
if {[llength $kids] > 1} { if {[llength $kids] > 1} {
@ -3965,7 +3916,7 @@ proc insertrow {row newcmit} {
# Remove a commit that was inserted with insertrow on row $row. # Remove a commit that was inserted with insertrow on row $row.
proc removerow {row} { proc removerow {row} {
global displayorder parentlist commitlisted children global displayorder parentlist commitlisted children
global commitrow curview rowidlist rowoffsets numcommits global commitrow curview rowidlist numcommits
global rowrangelist idrowranges rowlaidout rowoptim numcommits global rowrangelist idrowranges rowlaidout rowoptim numcommits
global linesegends selectedline rowchk commitidx global linesegends selectedline rowchk commitidx
@ -3993,12 +3944,6 @@ proc removerow {row} {
incr commitidx($curview) -1 incr commitidx($curview) -1
set rowidlist [lreplace $rowidlist $row $row] set rowidlist [lreplace $rowidlist $row $row]
set rowoffsets [lreplace $rowoffsets $rp1 $rp1]
if {$kids ne {}} {
set offs [lindex $rowoffsets $row]
set offs [lreplace $offs end end]
lset rowoffsets $row $offs
}
set rowrangelist [lreplace $rowrangelist $row $row] set rowrangelist [lreplace $rowrangelist $row $row]
if {[llength $kids] > 0} { if {[llength $kids] > 0} {
@ -7590,9 +7535,9 @@ set maxgraphpct 50
set maxwidth 16 set maxwidth 16
set revlistorder 0 set revlistorder 0
set fastdate 0 set fastdate 0
set uparrowlen 7 set uparrowlen 5
set downarrowlen 7 set downarrowlen 5
set mingaplen 30 set mingaplen 100
set cmitmode "patch" set cmitmode "patch"
set wrapcomment "none" set wrapcomment "none"
set showneartags 1 set showneartags 1