82
proc start_rev_list {view} {
83
global startmsecs
84
global commfd leftover tclencoding datemode
85
- global viewargs viewfiles commitidx
85
+ global viewargs viewfiles commitidx vnextroot
86
global lookingforhead showlocalchanges
87
88
set startmsecs [clock clicks -milliseconds]
89
set commitidx($view) 0
90
+ set vnextroot($view) 0
91
set order "--topo-order"
92
if {$datemode} {
93
set order "--date-order"
132
show_status "Reading commits..."
133
}
134
135
+# This makes a string representation of a positive integer which
136
+# sorts as a string in numerical order
137
+proc strrep {n} {
138
+ if {$n < 16} {
139
+ return [format "%x" $n]
140
+ } elseif {$n < 256} {
141
+ return [format "x%.2x" $n]
142
+ } elseif {$n < 65536} {
143
+ return [format "y%.4x" $n]
144
+ }
145
+ return [format "z%.8x" $n]
146
+}
147
+
148
proc getcommitlines {fd view} {
149
global commitlisted
150
global leftover commfd
151
global displayorder commitidx commitrow commitdata
152
global parentlist children curview hlview
153
global vparentlist vdisporder vcmitlisted
154
+ global ordertok vnextroot
155
156
set stuff [read $fd 500000]
157
# git log doesn't terminate the last commit with a null...
236
exit 1
237
}
238
set id [lindex $ids 0]
239
+ if {![info exists ordertok($view,$id)]} {
240
+ set otok "o[strrep $vnextroot($view)]"
241
+ incr vnextroot($view)
242
+ set ordertok($view,$id) $otok
243
+ } else {
244
+ set otok $ordertok($view,$id)
245
+ }
246
if {$listed} {
247
set olds [lrange $ids 1 end]
226
- set i 0
227
- foreach p $olds {
228
- if {$i == 0 || [lsearch -exact $olds $p] >= $i} {
229
- lappend children($view,$p) $id
248
+ if {[llength $olds] == 1} {
249
+ set p [lindex $olds 0]
250
+ lappend children($view,$p) $id
251
+ if {![info exists ordertok($view,$p)]} {
252
+ set ordertok($view,$p) $ordertok($view,$id)
253
+ }
254
+ } else {
255
+ set i 0
256
+ foreach p $olds {
257
+ if {$i == 0 || [lsearch -exact $olds $p] >= $i} {
258
+ lappend children($view,$p) $id
259
+ }
260
+ if {![info exists ordertok($view,$p)]} {
261
+ set ordertok($view,$p) "$otok[strrep $i]]"
262
+ }
263
+ incr i
264
}
231
- incr i
265
}
266
} else {
267
set olds {}
1854
1855
proc showview {n} {
1856
global curview viewdata viewfiles
1824
- global displayorder parentlist rowidlist rowoffsets
1857
+ global displayorder parentlist rowidlist
1858
global colormap rowtextx commitrow nextcolor canvxmax
1859
global numcommits rowrangelist commitlisted idrowranges rowchk
1860
global selectedline currentid canv canvy0
1892
set vcmitlisted($curview) $commitlisted
1893
if {$phase ne {}} {
1894
set viewdata($curview) \
1862
- [list $phase $rowidlist $rowoffsets $rowrangelist \
1895
+ [list $phase $rowidlist {} $rowrangelist \
1896
[flatten idrowranges] [flatten idinlist] \
1897
$rowlaidout $rowoptim $numcommits]
1898
} elseif {![info exists viewdata($curview)]
1899
|| [lindex $viewdata($curview) 0] ne {}} {
1900
set viewdata($curview) \
1868
- [list {} $rowidlist $rowoffsets $rowrangelist]
1901
+ [list {} $rowidlist {} $rowrangelist]
1902
}
1903
}
1904
catch {unset treediffs}
1927
set parentlist $vparentlist($n)
1928
set commitlisted $vcmitlisted($n)
1929
set rowidlist [lindex $v 1]
1897
- set rowoffsets [lindex $v 2]
1930
set rowrangelist [lindex $v 3]
1931
if {$phase eq {}} {
1932
set numcommits [llength $displayorder]
2574
return 0
2575
}
2576
2545
-proc sanity {row {full 0}} {
2546
- global rowidlist rowoffsets
2577
+# Work out where id should go in idlist so that order-token
2578
+# values increase from left to right
2579
+proc idcol {idlist id {i 0}} {
2580
+ global ordertok curview
2581
2548
- set col -1
2549
- set ids [lindex $rowidlist $row]
2550
- foreach id $ids {
2551
- incr col
2552
- if {$id eq {}} continue
2553
- if {$col < [llength $ids] - 1 &&
2554
- [lsearch -exact -start [expr {$col+1}] $ids $id] >= 0} {
2555
- puts "oops: [shortids $id] repeated in row $row col $col: {[shortids [lindex $rowidlist $row]]}"
2556
- }
2557
- set o [lindex $rowoffsets $row $col]
2558
- set y $row
2559
- set x $col
2560
- while {$o ne {}} {
2561
- incr y -1
2562
- incr x $o
2563
- if {[lindex $rowidlist $y $x] != $id} {
2564
- puts "oops: rowoffsets wrong at row [expr {$y+1}] col [expr {$x-$o}]"
2565
- puts " id=[shortids $id] check started at row $row"
2566
- for {set i $row} {$i >= $y} {incr i -1} {
2567
- puts " row $i ids={[shortids [lindex $rowidlist $i]]} offs={[lindex $rowoffsets $i]}"
2568
- }
2569
- break
2570
- }
2571
- if {!$full} break
2572
- set o [lindex $rowoffsets $y $x]
2582
+ set t $ordertok($curview,$id)
2583
+ if {$i >= [llength $idlist] ||
2584
+ $t < $ordertok($curview,[lindex $idlist $i])} {
2585
+ if {$i > [llength $idlist]} {
2586
+ set i [llength $idlist]
2587
+ }
2588
+ while {[incr i -1] >= 0 &&
2589
+ $t < $ordertok($curview,[lindex $idlist $i])} {}
2590
+ incr i
2591
+ } else {
2592
+ if {$t > $ordertok($curview,[lindex $idlist $i])} {
2593
+ while {[incr i] < [llength $idlist] &&
2594
+ $t >= $ordertok($curview,[lindex $idlist $i])} {}
2595
}
2596
}
2597
+ return $i
2598
}
2599
2577
-proc makeuparrow {oid x y z} {
2578
- global rowidlist rowoffsets uparrowlen idrowranges displayorder
2600
+proc makeuparrow {oid y x} {
2601
+ global rowidlist uparrowlen idrowranges displayorder
2602
2603
for {set i 1} {$i < $uparrowlen && $y > 1} {incr i} {
2604
incr y -1
2582
- incr x $z
2583
- set off0 [lindex $rowoffsets $y]
2584
- for {set x0 $x} {1} {incr x0} {
2585
- if {$x0 >= [llength $off0]} {
2586
- set x0 [llength [lindex $rowoffsets [expr {$y-1}]]]
2587
- break
2588
- }
2589
- set z [lindex $off0 $x0]
2590
- if {$z ne {}} {
2591
- incr x0 $z
2592
- break
2593
- }
2594
- }
2595
- set z [expr {$x0 - $x}]
2596
- lset rowidlist $y [linsert [lindex $rowidlist $y] $x $oid]
2597
- lset rowoffsets $y [linsert [lindex $rowoffsets $y] $x $z]
2605
+ set idl [lindex $rowidlist $y]
2606
+ set x [idcol $idl $oid $x]
2607
+ lset rowidlist $y [linsert $idl $x $oid]
2608
}
2599
- set tmp [lreplace [lindex $rowoffsets $y] $x $x {}]
2600
- lset rowoffsets $y [incrange $tmp [expr {$x+1}] -1]
2609
lappend idrowranges($oid) [lindex $displayorder $y]
2610
}
2611
2612
proc initlayout {} {
2605
- global rowidlist rowoffsets displayorder commitlisted
2613
+ global rowidlist displayorder commitlisted
2614
global rowlaidout rowoptim
2615
global idinlist rowchk rowrangelist idrowranges
2616
global numcommits canvxmax canv
2626
set rowrangelist {}
2627
set nextcolor 0
2628
set rowidlist {{}}
2621
- set rowoffsets {{}}
2629
catch {unset idinlist}
2630
catch {unset rowchk}
2631
set rowlaidout 0
2686
set nr [expr {$commitidx($curview) - $rowlaidout}]
2687
# may need to increase this threshold if uparrowlen or
2688
# mingaplen are increased...
2682
- if {$nr > 150} {
2683
- set nr 150
2689
+ if {$nr > 200} {
2690
+ set nr 200
2691
}
2692
set row $rowlaidout
2693
set rowlaidout [layoutrows $row [expr {$row + $nr}] $allread]
2868
}
2869
2870
proc layoutrows {row endrow last} {
2864
- global rowidlist rowoffsets displayorder
2871
+ global rowidlist displayorder
2872
global uparrowlen downarrowlen maxwidth mingaplen
2873
global children parentlist
2874
global idrowranges
2876
global idinlist rowchk rowrangelist
2877
2878
set idlist [lindex $rowidlist $row]
2872
- set offs [lindex $rowoffsets $row]
2879
while {$row < $endrow} {
2880
set id [lindex $displayorder $row]
2881
set oldolds {}
2882
set newolds {}
2877
- foreach p [lindex $parentlist $row] {
2883
+ set olds [lindex $parentlist $row]
2884
+ foreach p $olds {
2885
if {![info exists idinlist($p)]} {
2886
lappend newolds $p
2887
} elseif {!$idinlist($p)} {
2890
}
2891
set nev [expr {[llength $idlist] + [llength $newolds]
2892
+ [llength $oldolds] - $maxwidth + 1}]
2886
- if {$nev > 0} {
2893
+ if {1 || $nev > 0} {
2894
if {!$last &&
2895
$row + $uparrowlen + $mingaplen >= $commitidx($curview)} break
2896
for {set x [llength $idlist]} {[incr x -1] >= 0} {} {
2900
[expr {$row + $uparrowlen + $mingaplen}]]
2901
if {$r == 0} {
2902
set idlist [lreplace $idlist $x $x]
2896
- set offs [lreplace $offs $x $x]
2897
- set offs [incrange $offs $x 1]
2903
set idinlist($i) 0
2904
set rm1 [expr {$row - 1}]
2905
lappend idrowranges($i) [lindex $displayorder $rm1]
2901
- if {[incr nev -1] <= 0} break
2906
+ #if {[incr nev -1] <= 0} break
2907
continue
2908
}
2909
set rowchk($id) [expr {$row + $r}]
2910
}
2911
}
2912
lset rowidlist $row $idlist
2908
- lset rowoffsets $row $offs
2913
}
2914
set col [lsearch -exact $idlist $id]
2915
if {$col < 0} {
2912
- set col [llength $idlist]
2913
- lappend idlist $id
2916
+ set col [idcol $idlist $id]
2917
+ set idlist [linsert $idlist $col $id]
2918
lset rowidlist $row $idlist
2915
- set z {}
2919
if {$children($curview,$id) ne {}} {
2917
- set z [expr {[llength [lindex $rowidlist [expr {$row-1}]]] - $col}]
2920
unset idinlist($id)
2919
- }
2920
- lappend offs $z
2921
- lset rowoffsets $row $offs
2922
- if {$z ne {}} {
2923
- makeuparrow $id $col $row $z
2921
+ makeuparrow $id $row $col
2922
}
2923
} else {
2924
unset idinlist($id)
2931
}
2932
lappend rowrangelist $ranges
2933
incr row
2936
- set offs [ntimes [llength $idlist] 0]
2937
- set l [llength $newolds]
2938
- set idlist [eval lreplace \$idlist $col $col $newolds]
2939
- set o 0
2940
- if {$l != 1} {
2941
- set offs [lrange $offs 0 [expr {$col - 1}]]
2942
- foreach x $newolds {
2943
- lappend offs {}
2944
- incr o -1
2945
- }
2946
- incr o
2947
- set tmp [expr {[llength $idlist] - [llength $offs]}]
2948
- if {$tmp > 0} {
2949
- set offs [concat $offs [ntimes $tmp $o]]
2950
- }
2951
- } else {
2952
- lset offs $col {}
2953
- }
2934
+ set idlist [lreplace $idlist $col $col]
2935
+ set x $col
2936
foreach i $newolds {
2937
+ set x [idcol $idlist $i $x]
2938
+ set idlist [linsert $idlist $x $i]
2939
set idinlist($i) 1
2940
set idrowranges($i) $id
2941
}
2958
- incr col $l
2942
foreach oid $oldolds {
2943
set idinlist($oid) 1
2961
- set idlist [linsert $idlist $col $oid]
2962
- set offs [linsert $offs $col $o]
2963
- makeuparrow $oid $col $row $o
2964
- incr col
2944
+ set x [idcol $idlist $oid $x]
2945
+ set idlist [linsert $idlist $x $oid]
2946
+ makeuparrow $oid $row $x
2947
}
2948
lappend rowidlist $idlist
2967
- lappend rowoffsets $offs
2949
}
2950
return $row
2951
}
2970
}
2971
2972
proc layouttail {} {
2992
- global rowidlist rowoffsets idinlist commitidx curview
2973
+ global rowidlist idinlist commitidx curview
2974
global idrowranges rowrangelist
2975
2976
set row $commitidx($curview)
2984
lappend rowrangelist $idrowranges($id)
2985
unset idrowranges($id)
2986
incr row
3006
- set offs [ntimes $col 0]
2987
set idlist [lreplace $idlist $col $col]
2988
lappend rowidlist $idlist
3009
- lappend rowoffsets $offs
2989
}
2990
2991
foreach id [array names idinlist] {
2992
unset idinlist($id)
2993
addextraid $id $row
2994
lset rowidlist $row [list $id]
3016
- lset rowoffsets $row 0
3017
- makeuparrow $id 0 $row 0
2995
+ makeuparrow $id $row 0
2996
lappend idrowranges($id) $id
2997
lappend rowrangelist $idrowranges($id)
2998
unset idrowranges($id)
2999
incr row
3000
lappend rowidlist {}
3023
- lappend rowoffsets {}
3001
}
3002
}
3003
3004
proc insert_pad {row col npad} {
3028
- global rowidlist rowoffsets
3005
+ global rowidlist
3006
3007
set pad [ntimes $npad {}]
3008
lset rowidlist $row [eval linsert [list [lindex $rowidlist $row]] $col $pad]
3032
- set tmp [eval linsert [list [lindex $rowoffsets $row]] $col $pad]
3033
- lset rowoffsets $row [incrange $tmp [expr {$col + $npad}] [expr {-$npad}]]
3009
}
3010
3011
proc optimize_rows {row col endrow} {
3037
- global rowidlist rowoffsets displayorder
3012
+ global rowidlist displayorder
3013
3014
+ if {$row < 1} {
3015
+ set row 1
3016
+ }
3017
+ set idlist [lindex $rowidlist [expr {$row - 1}]]
3018
+ if {$row >= 2} {
3019
+ set previdlist [lindex $rowidlist [expr {$row - 2}]]
3020
+ } else {
3021
+ set previdlist {}
3022
+ }
3023
for {} {$row < $endrow} {incr row} {
3024
+ set pprevidlist $previdlist
3025
+ set previdlist $idlist
3026
set idlist [lindex $rowidlist $row]
3041
- set offs [lindex $rowoffsets $row]
3027
set haspad 0
3043
- for {} {$col < [llength $offs]} {incr col} {
3044
- if {[lindex $idlist $col] eq {}} {
3028
+ set y0 [expr {$row - 1}]
3029
+ set ym [expr {$row - 2}]
3030
+ set x0 -1
3031
+ set xm -1
3032
+ for {} {$col < [llength $idlist]} {incr col} {
3033
+ set id [lindex $idlist $col]
3034
+ if {[lindex $previdlist $col] eq $id} continue
3035
+ if {$id eq {}} {
3036
set haspad 1
3037
continue
3038
}
3048
- set z [lindex $offs $col]
3049
- if {$z eq {}} continue
3039
+ set x0 [lsearch -exact $previdlist $id]
3040
+ if {$x0 < 0} continue
3041
+ set z [expr {$x0 - $col}]
3042
set isarrow 0
3051
- set x0 [expr {$col + $z}]
3052
- set y0 [expr {$row - 1}]
3053
- set z0 [lindex $rowoffsets $y0 $x0]
3043
+ set z0 {}
3044
+ if {$ym >= 0} {
3045
+ set xm [lsearch -exact $pprevidlist $id]
3046
+ if {$xm >= 0} {
3047
+ set z0 [expr {$xm - $x0}]
3048
+ }
3049
+ }
3050
if {$z0 eq {}} {
3055
- set id [lindex $idlist $col]
3051
set ranges [rowranges $id]
3052
if {$ranges ne {} && $y0 > [lindex $ranges 0]} {
3053
set isarrow 1
3061
# Line currently goes left too much;
3062
# insert pads in the previous row, then optimize it
3063
set npad [expr {-1 - $z + $isarrow}]
3069
- set offs [incrange $offs $col $npad]
3064
insert_pad $y0 $x0 $npad
3065
if {$y0 > 0} {
3066
optimize_rows $y0 $x0 $row
3067
}
3074
- set z [lindex $offs $col]
3075
- set x0 [expr {$col + $z}]
3076
- set z0 [lindex $rowoffsets $y0 $x0]
3068
+ set previdlist [lindex $rowidlist $y0]
3069
+ set x0 [lsearch -exact $previdlist $id]
3070
+ set z [expr {$x0 - $col}]
3071
+ if {$z0 ne {}} {
3072
+ set pprevidlist [lindex $rowidlist $ym]
3073
+ set xm [lsearch -exact $pprevidlist $id]
3074
+ set z0 [expr {$xm - $x0}]
3075
+ }
3076
} elseif {$z > 1 || ($z > 0 && $isarrow)} {
3077
# Line currently goes right too much;
3079
- # insert pads in this line and adjust the next's rowoffsets
3078
+ # insert pads in this line
3079
set npad [expr {$z - 1 + $isarrow}]
3081
- set y1 [expr {$row + 1}]
3082
- set offs2 [lindex $rowoffsets $y1]
3083
- set x1 -1
3084
- foreach z $offs2 {
3085
- incr x1
3086
- if {$z eq {} || $x1 + $z < $col} continue
3087
- if {$x1 + $z > $col} {
3088
- incr npad
3089
- }
3090
- lset rowoffsets $y1 [incrange $offs2 $x1 $npad]
3091
- break
3092
- }
3080
set pad [ntimes $npad {}]
3081
set idlist [eval linsert \$idlist $col $pad]
3095
- set tmp [eval linsert \$offs $col $pad]
3082
incr col $npad
3097
- set offs [incrange $tmp $col [expr {-$npad}]]
3098
- set z [lindex $offs $col]
3083
+ set z [expr {$x0 - $col}]
3084
set haspad 1
3085
}
3101
- if {$z0 eq {} && !$isarrow} {
3086
+ if {$z0 eq {} && !$isarrow && $ym >= 0} {
3087
# this line links to its first child on row $row-2
3103
- set rm2 [expr {$row - 2}]
3104
- set id [lindex $displayorder $rm2]
3105
- set xc [lsearch -exact [lindex $rowidlist $rm2] $id]
3088
+ set id [lindex $displayorder $ym]
3089
+ set xc [lsearch -exact $pprevidlist $id]
3090
if {$xc >= 0} {
3091
set z0 [expr {$xc - $x0}]
3092
}
3094
# avoid lines jigging left then immediately right
3095
if {$z0 ne {} && $z < 0 && $z0 > 0} {
3096
insert_pad $y0 $x0 1
3113
- set offs [incrange $offs $col 1]
3114
- optimize_rows $y0 [expr {$x0 + 1}] $row
3097
+ incr x0
3098
+ optimize_rows $y0 $x0 $row
3099
+ set previdlist [lindex $rowidlist $y0]
3100
+ set pprevidlist [lindex $rowidlist $ym]
3101
}
3102
}
3103
if {!$haspad} {
3118
- set o {}
3104
# Find the first column that doesn't have a line going right
3105
for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
3121
- set o [lindex $offs $col]
3122
- if {$o eq {}} {
3106
+ set id [lindex $idlist $col]
3107
+ if {$id eq {}} break
3108
+ set x0 [lsearch -exact $previdlist $id]
3109
+ if {$x0 < 0} {
3110
# check if this is the link to the first child
3124
- set id [lindex $idlist $col]
3111
set ranges [rowranges $id]
3112
if {$ranges ne {} && $row == [lindex $ranges 0]} {
3113
# it is, work out offset to child
3128
- set y0 [expr {$row - 1}]
3114
set id [lindex $displayorder $y0]
3130
- set x0 [lsearch -exact [lindex $rowidlist $y0] $id]
3131
- if {$x0 >= 0} {
3132
- set o [expr {$x0 - $col}]
3133
- }
3115
+ set x0 [lsearch -exact $previdlist $id]
3116
}
3117
}
3136
- if {$o eq {} || $o <= 0} break
3118
+ if {$x0 <= $col} break
3119
}
3120
# Insert a pad at that column as long as it has a line and
3139
- # isn't the last column, and adjust the next row' offsets
3140
- if {$o ne {} && [incr col] < [llength $idlist]} {
3141
- set y1 [expr {$row + 1}]
3142
- set offs2 [lindex $rowoffsets $y1]
3143
- set x1 -1
3144
- foreach z $offs2 {
3145
- incr x1
3146
- if {$z eq {} || $x1 + $z < $col} continue
3147
- lset rowoffsets $y1 [incrange $offs2 $x1 1]
3148
- break
3149
- }
3121
+ # isn't the last column
3122
+ if {$x0 >= 0 && [incr col] < [llength $idlist]} {
3123
set idlist [linsert $idlist $col {}]
3151
- set tmp [linsert $offs $col {}]
3152
- incr col
3153
- set offs [incrange $tmp $col -1]
3124
}
3125
}
3126
lset rowidlist $row $idlist
3157
- lset rowoffsets $row $offs
3127
set col 0
3128
}
3129
}
3638
}
3639
3640
proc findcrossings {id} {
3672
- global rowidlist parentlist numcommits rowoffsets displayorder
3641
+ global rowidlist parentlist numcommits displayorder
3642
3643
set cross {}
3644
set ccross {}
3647
set e [expr {$numcommits - 1}]
3648
}
3649
if {$e <= $s} continue
3681
- set x [lsearch -exact [lindex $rowidlist $e] $id]
3682
- if {$x < 0} {
3683
- puts "findcrossings: oops, no [shortids $id] in row $e"
3684
- continue
3685
- }
3650
for {set row $e} {[incr row -1] >= $s} {} {
3651
+ set x [lsearch -exact [lindex $rowidlist $row] $id]
3652
+ if {$x < 0} break
3653
set olds [lindex $parentlist $row]
3654
set kid [lindex $displayorder $row]
3655
set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
3667
}
3668
}
3669
}
3704
- set inc [lindex $rowoffsets $row $x]
3705
- if {$inc eq {}} break
3706
- incr x $inc
3670
}
3671
}
3672
return [concat $ccross {{}} $cross]
3856
# on that row and below will move down one row.
3857
proc insertrow {row newcmit} {
3858
global displayorder parentlist commitlisted children
3896
- global commitrow curview rowidlist rowoffsets numcommits
3859
+ global commitrow curview rowidlist numcommits
3860
global rowrangelist rowlaidout rowoptim numcommits
3861
global selectedline rowchk commitidx
3862
3880
incr commitidx($curview)
3881
3882
set idlist [lindex $rowidlist $row]
3920
- set offs [lindex $rowoffsets $row]
3921
- set newoffs {}
3922
- foreach x $idlist {
3923
- if {$x eq {} || ($x eq $p && [llength $kids] == 1)} {
3924
- lappend newoffs {}
3925
- } else {
3926
- lappend newoffs 0
3927
- }
3928
- }
3883
if {[llength $kids] == 1} {
3884
set col [lsearch -exact $idlist $p]
3885
lset idlist $col $newcmit
3886
} else {
3887
set col [llength $idlist]
3888
lappend idlist $newcmit
3935
- lappend offs {}
3936
- lset rowoffsets $row $offs
3889
}
3890
set rowidlist [linsert $rowidlist $row $idlist]
3939
- set rowoffsets [linsert $rowoffsets [expr {$row+1}] $newoffs]
3891
3892
set rowrangelist [linsert $rowrangelist $row {}]
3893
if {[llength $kids] > 1} {
3916
# Remove a commit that was inserted with insertrow on row $row.
3917
proc removerow {row} {
3918
global displayorder parentlist commitlisted children
3968
- global commitrow curview rowidlist rowoffsets numcommits
3919
+ global commitrow curview rowidlist numcommits
3920
global rowrangelist idrowranges rowlaidout rowoptim numcommits
3921
global linesegends selectedline rowchk commitidx
3922
3944
incr commitidx($curview) -1
3945
3946
set rowidlist [lreplace $rowidlist $row $row]
3996
- set rowoffsets [lreplace $rowoffsets $rp1 $rp1]
3997
- if {$kids ne {}} {
3998
- set offs [lindex $rowoffsets $row]
3999
- set offs [lreplace $offs end end]
4000
- lset rowoffsets $row $offs
4001
- }
3947
3948
set rowrangelist [lreplace $rowrangelist $row $row]
3949
if {[llength $kids] > 0} {
7535
set maxwidth 16
7536
set revlistorder 0
7537
set fastdate 0
7593
-set uparrowlen 7
7594
-set downarrowlen 7
7595
-set mingaplen 30
7538
+set uparrowlen 5
7539
+set downarrowlen 5
7540
+set mingaplen 100
7541
set cmitmode "patch"
7542
set wrapcomment "none"
7543
set showneartags 1