2 # Tcl ignores the next line -*- tcl -*- \
5 # Copyright © 2005-2008 Paul Mackerras. All rights reserved.
6 # This program is free software; it may be used, copied, modified
7 # and distributed under the terms of the GNU General Public Licence,
8 # either version 2, or (at your option) any later version.
12 if {[info exists env
(GIT_DIR
)]} {
15 return [exec git rev-parse
--git-dir]
19 # A simple scheduler for compute-intensive stuff.
20 # The aim is to make sure that event handlers for GUI actions can
21 # run at least every 50-100 ms. Unfortunately fileevent handlers are
22 # run before X event handlers, so reading from a fast source can
23 # make the GUI completely unresponsive.
25 global isonrunq runq currunq
28 if {[info exists isonrunq
($script)]} return
29 if {$runq eq
{} && ![info exists currunq
]} {
32 lappend runq
[list
{} $script]
33 set isonrunq
($script) 1
36 proc filerun
{fd
script} {
37 fileevent
$fd readable
[list filereadable
$fd $script]
40 proc filereadable
{fd
script} {
43 fileevent
$fd readable
{}
44 if {$runq eq
{} && ![info exists currunq
]} {
47 lappend runq
[list
$fd $script]
53 for {set i
0} {$i < [llength
$runq]} {} {
54 if {[lindex
$runq $i 0] eq
$fd} {
55 set runq
[lreplace
$runq $i $i]
63 global isonrunq runq currunq
65 set tstart
[clock clicks
-milliseconds]
67 while {[llength
$runq] > 0} {
68 set fd
[lindex
$runq 0 0]
69 set script [lindex
$runq 0 1]
70 set currunq
[lindex
$runq 0]
71 set runq
[lrange
$runq 1 end
]
72 set repeat
[eval $script]
74 set t1
[clock clicks
-milliseconds]
75 set t
[expr {$t1 - $t0}]
76 if {$repeat ne
{} && $repeat} {
77 if {$fd eq
{} ||
$repeat == 2} {
78 # script returns 1 if it wants to be readded
79 # file readers return 2 if they could do more straight away
80 lappend runq
[list
$fd $script]
82 fileevent
$fd readable
[list filereadable
$fd $script]
84 } elseif
{$fd eq
{}} {
85 unset isonrunq
($script)
88 if {$t1 - $tstart >= 80} break
95 proc reg_instance
{fd
} {
96 global commfd leftover loginstance
98 set i
[incr loginstance
]
104 proc unmerged_files
{files
} {
107 # find the list of unmerged files
111 set fd
[open
"| git ls-files -u" r
]
113 show_error
{} .
"[mc "Couldn
't get list of unmerged files:"] $err"
116 while {[gets $fd line] >= 0} {
117 set i [string first "\t" $line]
119 set fname [string range $line [expr {$i+1}] end]
120 if {[lsearch -exact $mlist $fname] >= 0} continue
122 if {$files eq {} || [path_filter $files $fname]} {
130 proc parseviewargs {n arglist} {
131 global vdatemode vmergeonly vflags vdflags vrevs vfiltered vorigargs
139 set origargs $arglist
143 foreach arg $arglist {
150 switch -glob -- $arg {
154 # remove from origargs in case we hit an unknown option
155 set origargs [lreplace $origargs $i $i]
158 # These request or affect diff output, which we don't want.
159 # Some could be used to set our defaults for diff display.
161 "--no-renames" - "--full-index" - "--binary" - "--abbrev=*" -
162 "--find-copies-harder" - "-l*" - "--ext-diff" - "--no-ext-diff" -
163 "--src-prefix=*" - "--dst-prefix=*" - "--no-prefix" -
164 "-O*" - "--text" - "--full-diff" - "--ignore-space-at-eol" -
165 "--ignore-space-change" - "-U*" - "--unified=*" {
166 lappend diffargs
$arg
168 # These cause our parsing of git log's output to fail, or else
169 # they're options we want to set ourselves, so ignore them.
170 "--raw" - "--patch-with-raw" - "--patch-with-stat" -
171 "--name-only" - "--name-status" - "--color" - "--color-words" -
172 "--log-size" - "--pretty=*" - "--decorate" - "--abbrev-commit" -
173 "--cc" - "-z" - "--header" - "--parents" - "--boundary" -
174 "--no-color" - "-g" - "--walk-reflogs" - "--no-walk" -
175 "--timestamp" - "relative-date" - "--date=*" - "--stdin" -
176 "--objects" - "--objects-edge" - "--reverse" {
178 # These are harmless, and some are even useful
179 "--stat=*" - "--numstat" - "--shortstat" - "--summary" -
180 "--check" - "--exit-code" - "--quiet" - "--topo-order" -
181 "--full-history" - "--dense" - "--sparse" -
182 "--follow" - "--left-right" - "--encoding=*" {
185 # These mean that we get a subset of the commits
186 "--diff-filter=*" - "--no-merges" - "--unpacked" -
187 "--max-count=*" - "--skip=*" - "--since=*" - "--after=*" -
188 "--until=*" - "--before=*" - "--max-age=*" - "--min-age=*" -
189 "--author=*" - "--committer=*" - "--grep=*" - "-[iE]" -
190 "--remove-empty" - "--first-parent" - "--cherry-pick" -
191 "-S*" - "--pickaxe-all" - "--pickaxe-regex" - {
195 # This appears to be the only one that has a value as a
196 # separate word following it
203 set notflag
[expr {!$notflag}]
211 # git rev-parse doesn't understand --merge
212 lappend revargs
--gitk-symmetric-diff-marker MERGE_HEAD...HEAD
214 # Other flag arguments including -<n>
216 if {[string is digit
-strict [string range
$arg 1 end
]]} {
219 # a flag argument that we don't recognize;
220 # that means we can't optimize
225 # Non-flag arguments specify commits or ranges of commits
227 if {[string match
"*...*" $arg]} {
228 lappend revargs
--gitk-symmetric-diff-marker
234 set vdflags
($n) $diffargs
235 set vflags
($n) $glflags
236 set vrevs
($n) $revargs
237 set vfiltered
($n) $filtered
238 set vorigargs
($n) $origargs
242 proc parseviewrevs
{view revs
} {
243 global vposids vnegids
248 if {[catch
{set ids
[eval exec git rev-parse
$revs]} err
]} {
249 # we get stdout followed by stderr in $err
250 # for an unknown rev, git rev-parse echoes it and then errors out
251 set errlines
[split $err "\n"]
253 for {set l
0} {$l < [llength
$errlines]} {incr l
} {
254 set line
[lindex
$errlines $l]
255 if {!([string length
$line] == 40 && [string is xdigit
$line])} {
256 if {[string match
"fatal:*" $line]} {
257 if {[string match
"fatal: ambiguous argument*" $line]
259 if {[llength
$badrev] == 1} {
260 set err
"unknown revision $badrev"
262 set err
"unknown revisions: [join $badrev ", "]"
265 set err
[join [lrange
$errlines $l end
] "\n"]
272 error_popup
"[mc "Error parsing revisions
:"] $err"
279 foreach id
[split $ids "\n"] {
280 if {$id eq
"--gitk-symmetric-diff-marker"} {
282 } elseif
{[string match
"^*" $id]} {
289 lappend neg
[string range
$id 1 end
]
294 lset ret end
[lindex
$ret end
]...
$id
300 set vposids
($view) $pos
301 set vnegids
($view) $neg
305 # Start off a git log process and arrange to read its output
306 proc start_rev_list
{view
} {
307 global startmsecs commitidx viewcomplete curview
309 global viewargs viewargscmd viewfiles vfilelimit
310 global showlocalchanges commitinterest
311 global viewactive viewinstances vmergeonly
313 global vcanopt vflags vrevs vorigargs
315 set startmsecs
[clock clicks
-milliseconds]
316 set commitidx
($view) 0
317 # these are set this way for the error exits
318 set viewcomplete
($view) 1
319 set viewactive
($view) 0
322 set args
$viewargs($view)
323 if {$viewargscmd($view) ne
{}} {
325 set str
[exec sh
-c $viewargscmd($view)]
327 error_popup
"[mc "Error executing
--argscmd command:"] $err"
330 set args
[concat
$args [split $str "\n"]]
332 set vcanopt
($view) [parseviewargs
$view $args]
334 set files
$viewfiles($view)
335 if {$vmergeonly($view)} {
336 set files
[unmerged_files
$files]
339 if {$nr_unmerged == 0} {
340 error_popup
[mc
"No files selected: --merge specified but\
341 no files are unmerged."]
343 error_popup
[mc
"No files selected: --merge specified but\
344 no unmerged files are within file limit."]
349 set vfilelimit
($view) $files
351 if {$vcanopt($view)} {
352 set revs
[parseviewrevs
$view $vrevs($view)]
356 set args
[concat
$vflags($view) $revs]
358 set args
$vorigargs($view)
362 set fd
[open
[concat | git log
--no-color -z --pretty=raw
--parents \
363 --boundary $args "--" $files] r
]
365 error_popup
"[mc "Error executing git log
:"] $err"
368 set i
[reg_instance
$fd]
369 set viewinstances
($view) [list
$i]
370 if {$showlocalchanges && $mainheadid ne
{}} {
371 lappend commitinterest
($mainheadid) {dodiffindex
}
373 fconfigure
$fd -blocking 0 -translation lf
-eofchar {}
374 if {$tclencoding != {}} {
375 fconfigure
$fd -encoding $tclencoding
377 filerun
$fd [list getcommitlines
$fd $i $view 0]
378 nowbusy
$view [mc
"Reading"]
379 set viewcomplete
($view) 0
380 set viewactive
($view) 1
384 proc stop_instance
{inst
} {
385 global commfd leftover
387 set fd
$commfd($inst)
391 if {$
::tcl_platform
(platform
) eq
{windows
}} {
400 unset leftover
($inst)
403 proc stop_backends
{} {
406 foreach inst
[array names commfd
] {
411 proc stop_rev_list
{view
} {
414 foreach inst
$viewinstances($view) {
417 set viewinstances
($view) {}
420 proc reset_pending_select
{selid
} {
421 global pending_select mainheadid selectheadid
424 set pending_select
$selid
425 } elseif
{$selectheadid ne
{}} {
426 set pending_select
$selectheadid
428 set pending_select
$mainheadid
432 proc getcommits
{selid
} {
433 global canv curview need_redisplay viewactive
436 if {[start_rev_list
$curview]} {
437 reset_pending_select
$selid
438 show_status
[mc
"Reading commits..."]
441 show_status
[mc
"No commits selected"]
445 proc updatecommits
{} {
446 global curview vcanopt vorigargs vfilelimit viewinstances
447 global viewactive viewcomplete tclencoding
448 global startmsecs showneartags showlocalchanges
449 global mainheadid pending_select
451 global varcid vposids vnegids vflags vrevs
453 set isworktree
[expr {[exec git rev-parse
--is-inside-work-tree] == "true"}]
454 set oldmainid
$mainheadid
456 if {$showlocalchanges} {
457 if {$mainheadid ne
$oldmainid} {
460 if {[commitinview
$mainheadid $curview]} {
465 if {$vcanopt($view)} {
466 set oldpos
$vposids($view)
467 set oldneg
$vnegids($view)
468 set revs
[parseviewrevs
$view $vrevs($view)]
472 # note: getting the delta when negative refs change is hard,
473 # and could require multiple git log invocations, so in that
474 # case we ask git log for all the commits (not just the delta)
475 if {$oldneg eq
$vnegids($view)} {
478 # take out positive refs that we asked for before or
479 # that we have already seen
481 if {[string length
$rev] == 40} {
482 if {[lsearch
-exact $oldpos $rev] < 0
483 && ![info exists varcid
($view,$rev)]} {
488 lappend
$newrevs $rev
491 if {$npos == 0} return
493 set vposids
($view) [lsort
-unique [concat
$oldpos $vposids($view)]]
495 set args
[concat
$vflags($view) $revs --not $oldpos]
497 set args
$vorigargs($view)
500 set fd
[open
[concat | git log
--no-color -z --pretty=raw
--parents \
501 --boundary $args "--" $vfilelimit($view)] r
]
503 error_popup
"[mc "Error executing git log
:"] $err"
506 if {$viewactive($view) == 0} {
507 set startmsecs
[clock clicks
-milliseconds]
509 set i
[reg_instance
$fd]
510 lappend viewinstances
($view) $i
511 fconfigure
$fd -blocking 0 -translation lf
-eofchar {}
512 if {$tclencoding != {}} {
513 fconfigure
$fd -encoding $tclencoding
515 filerun
$fd [list getcommitlines
$fd $i $view 1]
516 incr viewactive
($view)
517 set viewcomplete
($view) 0
518 reset_pending_select
{}
519 nowbusy
$view "Reading"
525 proc reloadcommits
{} {
526 global curview viewcomplete selectedline currentid thickerline
527 global showneartags treediffs commitinterest cached_commitrow
531 if {$selectedline ne
{}} {
535 if {!$viewcomplete($curview)} {
536 stop_rev_list
$curview
540 catch
{unset currentid
}
541 catch
{unset thickerline
}
542 catch
{unset treediffs
}
549 catch
{unset commitinterest
}
550 catch
{unset cached_commitrow
}
551 catch
{unset targetid
}
557 # This makes a string representation of a positive integer which
558 # sorts as a string in numerical order
561 return [format
"%x" $n]
562 } elseif
{$n < 256} {
563 return [format
"x%.2x" $n]
564 } elseif
{$n < 65536} {
565 return [format
"y%.4x" $n]
567 return [format
"z%.8x" $n]
570 # Procedures used in reordering commits from git log (without
571 # --topo-order) into the order for display.
573 proc varcinit
{view
} {
574 global varcstart vupptr vdownptr vleftptr vbackptr varctok varcrow
575 global vtokmod varcmod vrowmod varcix vlastins
577 set varcstart
($view) {{}}
578 set vupptr
($view) {0}
579 set vdownptr
($view) {0}
580 set vleftptr
($view) {0}
581 set vbackptr
($view) {0}
582 set varctok
($view) {{}}
583 set varcrow
($view) {{}}
584 set vtokmod
($view) {}
587 set varcix
($view) {{}}
588 set vlastins
($view) {0}
591 proc resetvarcs
{view
} {
592 global varcid varccommits parents children vseedcount ordertok
594 foreach vid
[array names varcid
$view,*] {
599 # some commits might have children but haven't been seen yet
600 foreach vid
[array names children
$view,*] {
603 foreach va
[array names varccommits
$view,*] {
604 unset varccommits
($va)
606 foreach vd
[array names vseedcount
$view,*] {
607 unset vseedcount
($vd)
609 catch
{unset ordertok
}
612 # returns a list of the commits with no children
614 global vdownptr vleftptr varcstart
617 set a
[lindex
$vdownptr($v) 0]
619 lappend ret
[lindex
$varcstart($v) $a]
620 set a
[lindex
$vleftptr($v) $a]
625 proc newvarc
{view id
} {
626 global varcid varctok parents children vdatemode
627 global vupptr vdownptr vleftptr vbackptr varcrow varcix varcstart
628 global commitdata commitinfo vseedcount varccommits vlastins
630 set a
[llength
$varctok($view)]
632 if {[llength
$children($vid)] == 0 ||
$vdatemode($view)} {
633 if {![info exists commitinfo
($id)]} {
634 parsecommit
$id $commitdata($id) 1
636 set cdate
[lindex
$commitinfo($id) 4]
637 if {![string is integer
-strict $cdate]} {
640 if {![info exists vseedcount
($view,$cdate)]} {
641 set vseedcount
($view,$cdate) -1
643 set c
[incr vseedcount
($view,$cdate)]
644 set cdate
[expr {$cdate ^
0xffffffff}]
645 set tok
"s[strrep $cdate][strrep $c]"
650 if {[llength
$children($vid)] > 0} {
651 set kid
[lindex
$children($vid) end
]
652 set k
$varcid($view,$kid)
653 if {[string compare
[lindex
$varctok($view) $k] $tok] > 0} {
656 set tok
[lindex
$varctok($view) $k]
660 set i
[lsearch
-exact $parents($view,$ki) $id]
661 set j
[expr {[llength
$parents($view,$ki)] - 1 - $i}]
662 append tok
[strrep
$j]
664 set c
[lindex
$vlastins($view) $ka]
665 if {$c == 0 ||
[string compare
$tok [lindex
$varctok($view) $c]] < 0} {
667 set b
[lindex
$vdownptr($view) $ka]
669 set b
[lindex
$vleftptr($view) $c]
671 while {$b != 0 && [string compare
$tok [lindex
$varctok($view) $b]] >= 0} {
673 set b
[lindex
$vleftptr($view) $c]
676 lset vdownptr
($view) $ka $a
677 lappend vbackptr
($view) 0
679 lset vleftptr
($view) $c $a
680 lappend vbackptr
($view) $c
682 lset vlastins
($view) $ka $a
683 lappend vupptr
($view) $ka
684 lappend vleftptr
($view) $b
686 lset vbackptr
($view) $b $a
688 lappend varctok
($view) $tok
689 lappend varcstart
($view) $id
690 lappend vdownptr
($view) 0
691 lappend varcrow
($view) {}
692 lappend varcix
($view) {}
693 set varccommits
($view,$a) {}
694 lappend vlastins
($view) 0
698 proc splitvarc
{p v
} {
699 global varcid varcstart varccommits varctok
700 global vupptr vdownptr vleftptr vbackptr varcix varcrow vlastins
702 set oa
$varcid($v,$p)
703 set ac
$varccommits($v,$oa)
704 set i
[lsearch
-exact $varccommits($v,$oa) $p]
706 set na
[llength
$varctok($v)]
707 # "%" sorts before "0"...
708 set tok
"[lindex $varctok($v) $oa]%[strrep $i]"
709 lappend varctok
($v) $tok
710 lappend varcrow
($v) {}
711 lappend varcix
($v) {}
712 set varccommits
($v,$oa) [lrange
$ac 0 [expr {$i - 1}]]
713 set varccommits
($v,$na) [lrange
$ac $i end
]
714 lappend varcstart
($v) $p
715 foreach id
$varccommits($v,$na) {
716 set varcid
($v,$id) $na
718 lappend vdownptr
($v) [lindex
$vdownptr($v) $oa]
719 lappend vlastins
($v) [lindex
$vlastins($v) $oa]
720 lset vdownptr
($v) $oa $na
721 lset vlastins
($v) $oa 0
722 lappend vupptr
($v) $oa
723 lappend vleftptr
($v) 0
724 lappend vbackptr
($v) 0
725 for {set b
[lindex
$vdownptr($v) $na]} {$b != 0} {set b
[lindex
$vleftptr($v) $b]} {
726 lset vupptr
($v) $b $na
730 proc renumbervarc
{a v
} {
731 global parents children varctok varcstart varccommits
732 global vupptr vdownptr vleftptr vbackptr vlastins varcid vtokmod vdatemode
734 set t1
[clock clicks
-milliseconds]
740 if {[info exists isrelated
($a)]} {
742 set id
[lindex
$varccommits($v,$a) end
]
743 foreach p
$parents($v,$id) {
744 if {[info exists varcid
($v,$p)]} {
745 set isrelated
($varcid($v,$p)) 1
750 set b
[lindex
$vdownptr($v) $a]
753 set b
[lindex
$vleftptr($v) $a]
755 set a
[lindex
$vupptr($v) $a]
761 if {![info exists kidchanged
($a)]} continue
762 set id
[lindex
$varcstart($v) $a]
763 if {[llength
$children($v,$id)] > 1} {
764 set children
($v,$id) [lsort
-command [list vtokcmp
$v] \
767 set oldtok
[lindex
$varctok($v) $a]
768 if {!$vdatemode($v)} {
774 set kid
[last_real_child
$v,$id]
776 set k
$varcid($v,$kid)
777 if {[string compare
[lindex
$varctok($v) $k] $tok] > 0} {
780 set tok
[lindex
$varctok($v) $k]
784 set i
[lsearch
-exact $parents($v,$ki) $id]
785 set j
[expr {[llength
$parents($v,$ki)] - 1 - $i}]
786 append tok
[strrep
$j]
788 if {$tok eq
$oldtok} {
791 set id
[lindex
$varccommits($v,$a) end
]
792 foreach p
$parents($v,$id) {
793 if {[info exists varcid
($v,$p)]} {
794 set kidchanged
($varcid($v,$p)) 1
799 lset varctok
($v) $a $tok
800 set b
[lindex
$vupptr($v) $a]
802 if {[string compare
[lindex
$varctok($v) $ka] $vtokmod($v)] < 0} {
805 if {[string compare
[lindex
$varctok($v) $b] $vtokmod($v)] < 0} {
808 set c
[lindex
$vbackptr($v) $a]
809 set d
[lindex
$vleftptr($v) $a]
811 lset vdownptr
($v) $b $d
813 lset vleftptr
($v) $c $d
816 lset vbackptr
($v) $d $c
818 if {[lindex
$vlastins($v) $b] == $a} {
819 lset vlastins
($v) $b $c
821 lset vupptr
($v) $a $ka
822 set c
[lindex
$vlastins($v) $ka]
824 [string compare
$tok [lindex
$varctok($v) $c]] < 0} {
826 set b
[lindex
$vdownptr($v) $ka]
828 set b
[lindex
$vleftptr($v) $c]
831 [string compare
$tok [lindex
$varctok($v) $b]] >= 0} {
833 set b
[lindex
$vleftptr($v) $c]
836 lset vdownptr
($v) $ka $a
837 lset vbackptr
($v) $a 0
839 lset vleftptr
($v) $c $a
840 lset vbackptr
($v) $a $c
842 lset vleftptr
($v) $a $b
844 lset vbackptr
($v) $b $a
846 lset vlastins
($v) $ka $a
849 foreach id
[array names sortkids
] {
850 if {[llength
$children($v,$id)] > 1} {
851 set children
($v,$id) [lsort
-command [list vtokcmp
$v] \
855 set t2
[clock clicks
-milliseconds]
856 #puts "renumbervarc did [llength $todo] of $ntot arcs in [expr {$t2-$t1}]ms"
859 # Fix up the graph after we have found out that in view $v,
860 # $p (a commit that we have already seen) is actually the parent
861 # of the last commit in arc $a.
862 proc fix_reversal
{p a v
} {
863 global varcid varcstart varctok vupptr
865 set pa
$varcid($v,$p)
866 if {$p ne
[lindex
$varcstart($v) $pa]} {
868 set pa
$varcid($v,$p)
870 # seeds always need to be renumbered
871 if {[lindex
$vupptr($v) $pa] == 0 ||
872 [string compare
[lindex
$varctok($v) $a] \
873 [lindex
$varctok($v) $pa]] > 0} {
878 proc insertrow
{id p v
} {
879 global cmitlisted children parents varcid varctok vtokmod
880 global varccommits ordertok commitidx numcommits curview
881 global targetid targetrow
885 set cmitlisted
($vid) 1
886 set children
($vid) {}
887 set parents
($vid) [list
$p]
888 set a
[newvarc
$v $id]
890 if {[string compare
[lindex
$varctok($v) $a] $vtokmod($v)] < 0} {
893 lappend varccommits
($v,$a) $id
895 if {[llength
[lappend children
($vp) $id]] > 1} {
896 set children
($vp) [lsort
-command [list vtokcmp
$v] $children($vp)]
897 catch
{unset ordertok
}
899 fix_reversal
$p $a $v
901 if {$v == $curview} {
902 set numcommits
$commitidx($v)
904 if {[info exists targetid
]} {
905 if {![comes_before
$targetid $p]} {
912 proc insertfakerow
{id p
} {
913 global varcid varccommits parents children cmitlisted
914 global commitidx varctok vtokmod targetid targetrow curview numcommits
918 set i
[lsearch
-exact $varccommits($v,$a) $p]
920 puts
"oops: insertfakerow can't find [shortids $p] on arc $a"
923 set children
($v,$id) {}
924 set parents
($v,$id) [list
$p]
925 set varcid
($v,$id) $a
926 lappend children
($v,$p) $id
927 set cmitlisted
($v,$id) 1
928 set numcommits
[incr commitidx
($v)]
929 # note we deliberately don't update varcstart($v) even if $i == 0
930 set varccommits
($v,$a) [linsert
$varccommits($v,$a) $i $id]
932 if {[info exists targetid
]} {
933 if {![comes_before
$targetid $p]} {
941 proc removefakerow
{id
} {
942 global varcid varccommits parents children commitidx
943 global varctok vtokmod cmitlisted currentid selectedline
944 global targetid curview numcommits
947 if {[llength
$parents($v,$id)] != 1} {
948 puts
"oops: removefakerow [shortids $id] has [llength $parents($v,$id)] parents"
951 set p
[lindex
$parents($v,$id) 0]
952 set a
$varcid($v,$id)
953 set i
[lsearch
-exact $varccommits($v,$a) $id]
955 puts
"oops: removefakerow can't find [shortids $id] on arc $a"
959 set varccommits
($v,$a) [lreplace
$varccommits($v,$a) $i $i]
960 unset parents
($v,$id)
961 unset children
($v,$id)
962 unset cmitlisted
($v,$id)
963 set numcommits
[incr commitidx
($v) -1]
964 set j
[lsearch
-exact $children($v,$p) $id]
966 set children
($v,$p) [lreplace
$children($v,$p) $j $j]
969 if {[info exist currentid
] && $id eq
$currentid} {
973 if {[info exists targetid
] && $targetid eq
$id} {
980 proc first_real_child
{vp
} {
981 global children nullid nullid2
983 foreach id
$children($vp) {
984 if {$id ne
$nullid && $id ne
$nullid2} {
991 proc last_real_child
{vp
} {
992 global children nullid nullid2
994 set kids
$children($vp)
995 for {set i
[llength
$kids]} {[incr i
-1] >= 0} {} {
996 set id
[lindex
$kids $i]
997 if {$id ne
$nullid && $id ne
$nullid2} {
1004 proc vtokcmp
{v a b
} {
1005 global varctok varcid
1007 return [string compare
[lindex
$varctok($v) $varcid($v,$a)] \
1008 [lindex
$varctok($v) $varcid($v,$b)]]
1011 # This assumes that if lim is not given, the caller has checked that
1012 # arc a's token is less than $vtokmod($v)
1013 proc modify_arc
{v a
{lim
{}}} {
1014 global varctok vtokmod varcmod varcrow vupptr curview vrowmod varccommits
1017 set c
[string compare
[lindex
$varctok($v) $a] $vtokmod($v)]
1020 set r
[lindex
$varcrow($v) $a]
1021 if {$r ne
{} && $vrowmod($v) <= $r + $lim} return
1024 set vtokmod
($v) [lindex
$varctok($v) $a]
1026 if {$v == $curview} {
1027 while {$a != 0 && [lindex
$varcrow($v) $a] eq
{}} {
1028 set a
[lindex
$vupptr($v) $a]
1034 set lim
[llength
$varccommits($v,$a)]
1036 set r
[expr {[lindex
$varcrow($v) $a] + $lim}]
1043 proc update_arcrows
{v
} {
1044 global vtokmod varcmod vrowmod varcrow commitidx currentid selectedline
1045 global varcid vrownum varcorder varcix varccommits
1046 global vupptr vdownptr vleftptr varctok
1047 global displayorder parentlist curview cached_commitrow
1049 if {$vrowmod($v) == $commitidx($v)} return
1050 if {$v == $curview} {
1051 if {[llength
$displayorder] > $vrowmod($v)} {
1052 set displayorder
[lrange
$displayorder 0 [expr {$vrowmod($v) - 1}]]
1053 set parentlist
[lrange
$parentlist 0 [expr {$vrowmod($v) - 1}]]
1055 catch
{unset cached_commitrow
}
1057 set narctot
[expr {[llength
$varctok($v)] - 1}]
1059 while {$a != 0 && [lindex
$varcix($v) $a] eq
{}} {
1060 # go up the tree until we find something that has a row number,
1061 # or we get to a seed
1062 set a
[lindex
$vupptr($v) $a]
1065 set a
[lindex
$vdownptr($v) 0]
1068 set varcorder
($v) [list
$a]
1069 lset varcix
($v) $a 0
1070 lset varcrow
($v) $a 0
1074 set arcn
[lindex
$varcix($v) $a]
1075 if {[llength
$vrownum($v)] > $arcn + 1} {
1076 set vrownum
($v) [lrange
$vrownum($v) 0 $arcn]
1077 set varcorder
($v) [lrange
$varcorder($v) 0 $arcn]
1079 set row
[lindex
$varcrow($v) $a]
1083 incr row
[llength
$varccommits($v,$a)]
1084 # go down if possible
1085 set b
[lindex
$vdownptr($v) $a]
1087 # if not, go left, or go up until we can go left
1089 set b
[lindex
$vleftptr($v) $a]
1091 set a
[lindex
$vupptr($v) $a]
1097 lappend vrownum
($v) $row
1098 lappend varcorder
($v) $a
1099 lset varcix
($v) $a $arcn
1100 lset varcrow
($v) $a $row
1102 set vtokmod
($v) [lindex
$varctok($v) $p]
1104 set vrowmod
($v) $row
1105 if {[info exists currentid
]} {
1106 set selectedline
[rowofcommit
$currentid]
1110 # Test whether view $v contains commit $id
1111 proc commitinview
{id v
} {
1114 return [info exists varcid
($v,$id)]
1117 # Return the row number for commit $id in the current view
1118 proc rowofcommit
{id
} {
1119 global varcid varccommits varcrow curview cached_commitrow
1120 global varctok vtokmod
1123 if {![info exists varcid
($v,$id)]} {
1124 puts
"oops rowofcommit no arc for [shortids $id]"
1127 set a
$varcid($v,$id)
1128 if {[string compare
[lindex
$varctok($v) $a] $vtokmod($v)] >= 0} {
1131 if {[info exists cached_commitrow
($id)]} {
1132 return $cached_commitrow($id)
1134 set i
[lsearch
-exact $varccommits($v,$a) $id]
1136 puts
"oops didn't find commit [shortids $id] in arc $a"
1139 incr i
[lindex
$varcrow($v) $a]
1140 set cached_commitrow
($id) $i
1144 # Returns 1 if a is on an earlier row than b, otherwise 0
1145 proc comes_before
{a b
} {
1146 global varcid varctok curview
1149 if {$a eq
$b ||
![info exists varcid
($v,$a)] || \
1150 ![info exists varcid
($v,$b)]} {
1153 if {$varcid($v,$a) != $varcid($v,$b)} {
1154 return [expr {[string compare
[lindex
$varctok($v) $varcid($v,$a)] \
1155 [lindex
$varctok($v) $varcid($v,$b)]] < 0}]
1157 return [expr {[rowofcommit
$a] < [rowofcommit
$b]}]
1160 proc bsearch
{l elt
} {
1161 if {[llength
$l] == 0 ||
$elt <= [lindex
$l 0]} {
1166 while {$hi - $lo > 1} {
1167 set mid
[expr {int
(($lo + $hi) / 2)}]
1168 set t
[lindex
$l $mid]
1171 } elseif
{$elt > $t} {
1180 # Make sure rows $start..$end-1 are valid in displayorder and parentlist
1181 proc make_disporder
{start end
} {
1182 global vrownum curview commitidx displayorder parentlist
1183 global varccommits varcorder parents vrowmod varcrow
1184 global d_valid_start d_valid_end
1186 if {$end > $vrowmod($curview)} {
1187 update_arcrows
$curview
1189 set ai
[bsearch
$vrownum($curview) $start]
1190 set start
[lindex
$vrownum($curview) $ai]
1191 set narc
[llength
$vrownum($curview)]
1192 for {set r
$start} {$ai < $narc && $r < $end} {incr ai
} {
1193 set a
[lindex
$varcorder($curview) $ai]
1194 set l
[llength
$displayorder]
1195 set al
[llength
$varccommits($curview,$a)]
1196 if {$l < $r + $al} {
1198 set pad
[ntimes
[expr {$r - $l}] {}]
1199 set displayorder
[concat
$displayorder $pad]
1200 set parentlist
[concat
$parentlist $pad]
1201 } elseif
{$l > $r} {
1202 set displayorder
[lrange
$displayorder 0 [expr {$r - 1}]]
1203 set parentlist
[lrange
$parentlist 0 [expr {$r - 1}]]
1205 foreach id
$varccommits($curview,$a) {
1206 lappend displayorder
$id
1207 lappend parentlist
$parents($curview,$id)
1209 } elseif
{[lindex
$displayorder [expr {$r + $al - 1}]] eq
{}} {
1211 foreach id
$varccommits($curview,$a) {
1212 lset displayorder
$i $id
1213 lset parentlist
$i $parents($curview,$id)
1221 proc commitonrow
{row
} {
1224 set id
[lindex
$displayorder $row]
1226 make_disporder
$row [expr {$row + 1}]
1227 set id
[lindex
$displayorder $row]
1232 proc closevarcs
{v
} {
1233 global varctok varccommits varcid parents children
1234 global cmitlisted commitidx commitinterest vtokmod
1236 set missing_parents
0
1238 set narcs
[llength
$varctok($v)]
1239 for {set a
1} {$a < $narcs} {incr a
} {
1240 set id
[lindex
$varccommits($v,$a) end
]
1241 foreach p
$parents($v,$id) {
1242 if {[info exists varcid
($v,$p)]} continue
1243 # add p as a new commit
1244 incr missing_parents
1245 set cmitlisted
($v,$p) 0
1246 set parents
($v,$p) {}
1247 if {[llength
$children($v,$p)] == 1 &&
1248 [llength
$parents($v,$id)] == 1} {
1251 set b
[newvarc
$v $p]
1253 set varcid
($v,$p) $b
1254 if {[string compare
[lindex
$varctok($v) $b] $vtokmod($v)] < 0} {
1257 lappend varccommits
($v,$b) $p
1259 if {[info exists commitinterest
($p)]} {
1260 foreach
script $commitinterest($p) {
1261 lappend scripts
[string map
[list
"%I" $p] $script]
1263 unset commitinterest
($id)
1267 if {$missing_parents > 0} {
1268 foreach s
$scripts {
1274 # Use $rwid as a substitute for $id, i.e. reparent $id's children to $rwid
1275 # Assumes we already have an arc for $rwid.
1276 proc rewrite_commit
{v id rwid
} {
1277 global children parents varcid varctok vtokmod varccommits
1279 foreach ch
$children($v,$id) {
1280 # make $rwid be $ch's parent in place of $id
1281 set i
[lsearch
-exact $parents($v,$ch) $id]
1283 puts
"oops rewrite_commit didn't find $id in parent list for $ch"
1285 set parents
($v,$ch) [lreplace
$parents($v,$ch) $i $i $rwid]
1286 # add $ch to $rwid's children and sort the list if necessary
1287 if {[llength
[lappend children
($v,$rwid) $ch]] > 1} {
1288 set children
($v,$rwid) [lsort
-command [list vtokcmp
$v] \
1289 $children($v,$rwid)]
1291 # fix the graph after joining $id to $rwid
1292 set a
$varcid($v,$ch)
1293 fix_reversal
$rwid $a $v
1294 # parentlist is wrong for the last element of arc $a
1295 # even if displayorder is right, hence the 3rd arg here
1296 modify_arc
$v $a [expr {[llength
$varccommits($v,$a)] - 1}]
1300 proc getcommitlines
{fd inst view updating
} {
1301 global cmitlisted commitinterest leftover
1302 global commitidx commitdata vdatemode
1303 global parents children curview hlview
1304 global idpending ordertok
1305 global varccommits varcid varctok vtokmod vfilelimit
1307 set stuff
[read $fd 500000]
1308 # git log doesn't terminate the last commit with a null...
1309 if {$stuff == {} && $leftover($inst) ne
{} && [eof
$fd]} {
1316 global commfd viewcomplete viewactive viewname
1317 global viewinstances
1319 set i
[lsearch
-exact $viewinstances($view) $inst]
1321 set viewinstances
($view) [lreplace
$viewinstances($view) $i $i]
1323 # set it blocking so we wait for the process to terminate
1324 fconfigure
$fd -blocking 1
1325 if {[catch
{close
$fd} err
]} {
1327 if {$view != $curview} {
1328 set fv
" for the \"$viewname($view)\" view"
1330 if {[string range
$err 0 4] == "usage"} {
1331 set err
"Gitk: error reading commits$fv:\
1332 bad arguments to git log."
1333 if {$viewname($view) eq
"Command line"} {
1335 " (Note: arguments to gitk are passed to git log\
1336 to allow selection of commits to be displayed.)"
1339 set err
"Error reading commits$fv: $err"
1343 if {[incr viewactive
($view) -1] <= 0} {
1344 set viewcomplete
($view) 1
1345 # Check if we have seen any ids listed as parents that haven't
1346 # appeared in the list
1350 if {$view == $curview} {
1359 set i
[string first
"\0" $stuff $start]
1361 append leftover
($inst) [string range
$stuff $start end
]
1365 set cmit
$leftover($inst)
1366 append cmit
[string range
$stuff 0 [expr {$i - 1}]]
1367 set leftover
($inst) {}
1369 set cmit
[string range
$stuff $start [expr {$i - 1}]]
1371 set start
[expr {$i + 1}]
1372 set j
[string first
"\n" $cmit]
1375 if {$j >= 0 && [string match
"commit *" $cmit]} {
1376 set ids
[string range
$cmit 7 [expr {$j - 1}]]
1377 if {[string match
{[-^
<>]*} $ids]} {
1378 switch
-- [string index
$ids 0] {
1384 set ids
[string range
$ids 1 end
]
1388 if {[string length
$id] != 40} {
1396 if {[string length
$shortcmit] > 80} {
1397 set shortcmit
"[string range $shortcmit 0 80]..."
1399 error_popup
"[mc "Can
't parse git log output:"] {$shortcmit}"
1402 set id [lindex $ids 0]
1405 if {!$listed && $updating && ![info exists varcid($vid)] &&
1406 $vfilelimit($view) ne {}} {
1407 # git log doesn't rewrite parents
for unlisted commits
1408 # when doing path limiting, so work around that here
1409 # by working out the rewritten parent with git rev-list
1410 # and if we already know about it, using the rewritten
1411 # parent as a substitute parent for $id's children.
1413 set rwid
[exec git rev-list
--first-parent --max-count=1 \
1414 $id -- $vfilelimit($view)]
1416 if {$rwid ne
{} && [info exists varcid
($view,$rwid)]} {
1417 # use $rwid in place of $id
1418 rewrite_commit
$view $id $rwid
1425 if {[info exists varcid
($vid)]} {
1426 if {$cmitlisted($vid) ||
!$listed} continue
1430 set olds
[lrange
$ids 1 end
]
1434 set commitdata
($id) [string range
$cmit [expr {$j + 1}] end
]
1435 set cmitlisted
($vid) $listed
1436 set parents
($vid) $olds
1437 if {![info exists children
($vid)]} {
1438 set children
($vid) {}
1439 } elseif
{$a == 0 && [llength
$children($vid)] == 1} {
1440 set k
[lindex
$children($vid) 0]
1441 if {[llength
$parents($view,$k)] == 1 &&
1442 (!$vdatemode($view) ||
1443 $varcid($view,$k) == [llength
$varctok($view)] - 1)} {
1444 set a
$varcid($view,$k)
1449 set a
[newvarc
$view $id]
1451 if {[string compare
[lindex
$varctok($view) $a] $vtokmod($view)] < 0} {
1454 if {![info exists varcid
($vid)]} {
1456 lappend varccommits
($view,$a) $id
1457 incr commitidx
($view)
1462 if {$i == 0 ||
[lsearch
-exact $olds $p] >= $i} {
1464 if {[llength
[lappend children
($vp) $id]] > 1 &&
1465 [vtokcmp
$view [lindex
$children($vp) end-1
] $id] > 0} {
1466 set children
($vp) [lsort
-command [list vtokcmp
$view] \
1468 catch
{unset ordertok
}
1470 if {[info exists varcid
($view,$p)]} {
1471 fix_reversal
$p $a $view
1477 if {[info exists commitinterest
($id)]} {
1478 foreach
script $commitinterest($id) {
1479 lappend scripts
[string map
[list
"%I" $id] $script]
1481 unset commitinterest
($id)
1486 global numcommits hlview
1488 if {$view == $curview} {
1489 set numcommits
$commitidx($view)
1492 if {[info exists hlview
] && $view == $hlview} {
1493 # we never actually get here...
1496 foreach s
$scripts {
1503 proc chewcommits
{} {
1504 global curview hlview viewcomplete
1505 global pending_select
1508 if {$viewcomplete($curview)} {
1509 global commitidx varctok
1510 global numcommits startmsecs
1512 if {[info exists pending_select
]} {
1514 reset_pending_select
{}
1516 if {[commitinview
$pending_select $curview]} {
1517 selectline
[rowofcommit
$pending_select] 1
1519 set row
[first_real_row
]
1523 if {$commitidx($curview) > 0} {
1524 #set ms [expr {[clock clicks -milliseconds] - $startmsecs}]
1525 #puts "overall $ms ms for $numcommits commits"
1526 #puts "[llength $varctok($view)] arcs, $commitidx($view) commits"
1528 show_status
[mc
"No commits selected"]
1535 proc readcommit
{id
} {
1536 if {[catch
{set contents
[exec git cat-file commit
$id]}]} return
1537 parsecommit
$id $contents 0
1540 proc parsecommit
{id contents listed
} {
1541 global commitinfo cdate
1550 set hdrend
[string first
"\n\n" $contents]
1552 # should never happen...
1553 set hdrend
[string length
$contents]
1555 set header
[string range
$contents 0 [expr {$hdrend - 1}]]
1556 set comment
[string range
$contents [expr {$hdrend + 2}] end
]
1557 foreach line
[split $header "\n"] {
1558 set tag
[lindex
$line 0]
1559 if {$tag == "author"} {
1560 set audate
[lindex
$line end-1
]
1561 set auname
[lrange
$line 1 end-2
]
1562 } elseif
{$tag == "committer"} {
1563 set comdate
[lindex
$line end-1
]
1564 set comname
[lrange
$line 1 end-2
]
1568 # take the first non-blank line of the comment as the headline
1569 set headline
[string trimleft
$comment]
1570 set i
[string first
"\n" $headline]
1572 set headline
[string range
$headline 0 $i]
1574 set headline
[string trimright
$headline]
1575 set i
[string first
"\r" $headline]
1577 set headline
[string trimright
[string range
$headline 0 $i]]
1580 # git log indents the comment by 4 spaces;
1581 # if we got this via git cat-file, add the indentation
1583 foreach line
[split $comment "\n"] {
1584 append newcomment
" "
1585 append newcomment
$line
1586 append newcomment
"\n"
1588 set comment
$newcomment
1590 if {$comdate != {}} {
1591 set cdate
($id) $comdate
1593 set commitinfo
($id) [list
$headline $auname $audate \
1594 $comname $comdate $comment]
1597 proc getcommit
{id
} {
1598 global commitdata commitinfo
1600 if {[info exists commitdata
($id)]} {
1601 parsecommit
$id $commitdata($id) 1
1604 if {![info exists commitinfo
($id)]} {
1605 set commitinfo
($id) [list
[mc
"No commit information available"]]
1612 global tagids idtags headids idheads tagobjid
1613 global otherrefids idotherrefs mainhead mainheadid
1614 global selecthead selectheadid
1616 foreach v
{tagids idtags headids idheads otherrefids idotherrefs
} {
1619 set refd
[open
[list | git show-ref
-d] r
]
1620 while {[gets
$refd line
] >= 0} {
1621 if {[string index
$line 40] ne
" "} continue
1622 set id
[string range
$line 0 39]
1623 set ref
[string range
$line 41 end
]
1624 if {![string match
"refs/*" $ref]} continue
1625 set name
[string range
$ref 5 end
]
1626 if {[string match
"remotes/*" $name]} {
1627 if {![string match
"*/HEAD" $name]} {
1628 set headids
($name) $id
1629 lappend idheads
($id) $name
1631 } elseif
{[string match
"heads/*" $name]} {
1632 set name
[string range
$name 6 end
]
1633 set headids
($name) $id
1634 lappend idheads
($id) $name
1635 } elseif
{[string match
"tags/*" $name]} {
1636 # this lets refs/tags/foo^{} overwrite refs/tags/foo,
1637 # which is what we want since the former is the commit ID
1638 set name
[string range
$name 5 end
]
1639 if {[string match
"*^{}" $name]} {
1640 set name
[string range
$name 0 end-3
]
1642 set tagobjid
($name) $id
1644 set tagids
($name) $id
1645 lappend idtags
($id) $name
1647 set otherrefids
($name) $id
1648 lappend idotherrefs
($id) $name
1655 set mainheadid
[exec git rev-parse HEAD
]
1656 set thehead
[exec git symbolic-ref HEAD
]
1657 if {[string match
"refs/heads/*" $thehead]} {
1658 set mainhead
[string range
$thehead 11 end
]
1662 if {$selecthead ne
{}} {
1664 set selectheadid
[exec git rev-parse
--verify $selecthead]
1669 # skip over fake commits
1670 proc first_real_row
{} {
1671 global nullid nullid2 numcommits
1673 for {set row
0} {$row < $numcommits} {incr row
} {
1674 set id
[commitonrow
$row]
1675 if {$id ne
$nullid && $id ne
$nullid2} {
1682 # update things for a head moved to a child of its previous location
1683 proc movehead
{id name
} {
1684 global headids idheads
1686 removehead
$headids($name) $name
1687 set headids
($name) $id
1688 lappend idheads
($id) $name
1691 # update things when a head has been removed
1692 proc removehead
{id name
} {
1693 global headids idheads
1695 if {$idheads($id) eq
$name} {
1698 set i
[lsearch
-exact $idheads($id) $name]
1700 set idheads
($id) [lreplace
$idheads($id) $i $i]
1703 unset headids
($name)
1706 proc show_error
{w top msg
} {
1707 message
$w.m
-text $msg -justify center
-aspect 400
1708 pack
$w.m
-side top
-fill x
-padx 20 -pady 20
1709 button
$w.ok
-text [mc OK
] -command "destroy $top"
1710 pack
$w.ok
-side bottom
-fill x
1711 bind $top <Visibility
> "grab $top; focus $top"
1712 bind $top <Key-Return
> "destroy $top"
1716 proc error_popup msg
{
1720 show_error
$w $w $msg
1723 proc confirm_popup msg
{
1729 message
$w.m
-text $msg -justify center
-aspect 400
1730 pack
$w.m
-side top
-fill x
-padx 20 -pady 20
1731 button
$w.ok
-text [mc OK
] -command "set confirm_ok 1; destroy $w"
1732 pack
$w.ok
-side left
-fill x
1733 button
$w.cancel
-text [mc Cancel
] -command "destroy $w"
1734 pack
$w.cancel
-side right
-fill x
1735 bind $w <Visibility
> "grab $w; focus $w"
1740 proc setoptions
{} {
1741 option add
*Panedwindow.showHandle
1 startupFile
1742 option add
*Panedwindow.sashRelief raised startupFile
1743 option add
*Button.font uifont startupFile
1744 option add
*Checkbutton.font uifont startupFile
1745 option add
*Radiobutton.font uifont startupFile
1746 option add
*Menu.font uifont startupFile
1747 option add
*Menubutton.font uifont startupFile
1748 option add
*Label.font uifont startupFile
1749 option add
*Message.font uifont startupFile
1750 option add
*Entry.font uifont startupFile
1753 proc makewindow
{} {
1754 global canv canv2 canv3 linespc charspc ctext cflist cscroll
1756 global findtype findtypemenu findloc findstring fstring geometry
1757 global entries sha1entry sha1string sha1but
1758 global diffcontextstring diffcontext
1760 global maincursor textcursor curtextcursor
1761 global rowctxmenu fakerowmenu mergemax wrapcomment
1762 global highlight_files gdttype
1763 global searchstring sstring
1764 global bgcolor fgcolor bglist fglist diffcolors selectbgcolor
1765 global headctxmenu progresscanv progressitem progresscoords statusw
1766 global fprogitem fprogcoord lastprogupdate progupdatepending
1767 global rprogitem rprogcoord rownumsel numcommits
1771 .bar add cascade
-label [mc
"File"] -menu .bar.
file
1773 .bar.
file add
command -label [mc
"Update"] -command updatecommits
1774 .bar.
file add
command -label [mc
"Reload"] -command reloadcommits
1775 .bar.
file add
command -label [mc
"Reread references"] -command rereadrefs
1776 .bar.
file add
command -label [mc
"List references"] -command showrefs
1777 .bar.
file add
command -label [mc
"Quit"] -command doquit
1779 .bar add cascade
-label [mc
"Edit"] -menu .bar.edit
1780 .bar.edit add
command -label [mc
"Preferences"] -command doprefs
1783 .bar add cascade
-label [mc
"View"] -menu .bar.view
1784 .bar.view add
command -label [mc
"New view..."] -command {newview
0}
1785 .bar.view add
command -label [mc
"Edit view..."] -command editview \
1787 .bar.view add
command -label [mc
"Delete view"] -command delview
-state disabled
1788 .bar.view add separator
1789 .bar.view add radiobutton
-label [mc
"All files"] -command {showview
0} \
1790 -variable selectedview
-value 0
1793 .bar add cascade
-label [mc
"Help"] -menu .bar.
help
1794 .bar.
help add
command -label [mc
"About gitk"] -command about
1795 .bar.
help add
command -label [mc
"Key bindings"] -command keys
1797 . configure
-menu .bar
1799 # the gui has upper and lower half, parts of a paned window.
1800 panedwindow .ctop
-orient vertical
1802 # possibly use assumed geometry
1803 if {![info exists geometry
(pwsash0
)]} {
1804 set geometry
(topheight
) [expr {15 * $linespc}]
1805 set geometry
(topwidth
) [expr {80 * $charspc}]
1806 set geometry
(botheight
) [expr {15 * $linespc}]
1807 set geometry
(botwidth
) [expr {50 * $charspc}]
1808 set geometry
(pwsash0
) "[expr {40 * $charspc}] 2"
1809 set geometry
(pwsash1
) "[expr {60 * $charspc}] 2"
1812 # the upper half will have a paned window, a scroll bar to the right, and some stuff below
1813 frame .tf
-height $geometry(topheight
) -width $geometry(topwidth
)
1815 panedwindow .tf.histframe.pwclist
-orient horizontal
-sashpad 0 -handlesize 4
1817 # create three canvases
1818 set cscroll .tf.histframe.csb
1819 set canv .tf.histframe.pwclist.canv
1821 -selectbackground $selectbgcolor \
1822 -background $bgcolor -bd 0 \
1823 -yscrollincr $linespc -yscrollcommand "scrollcanv $cscroll"
1824 .tf.histframe.pwclist add
$canv
1825 set canv2 .tf.histframe.pwclist.canv2
1827 -selectbackground $selectbgcolor \
1828 -background $bgcolor -bd 0 -yscrollincr $linespc
1829 .tf.histframe.pwclist add
$canv2
1830 set canv3 .tf.histframe.pwclist.canv3
1832 -selectbackground $selectbgcolor \
1833 -background $bgcolor -bd 0 -yscrollincr $linespc
1834 .tf.histframe.pwclist add
$canv3
1835 eval .tf.histframe.pwclist sash place
0 $geometry(pwsash0
)
1836 eval .tf.histframe.pwclist sash place
1 $geometry(pwsash1
)
1838 # a scroll bar to rule them
1839 scrollbar
$cscroll -command {allcanvs yview
} -highlightthickness 0
1840 pack
$cscroll -side right
-fill y
1841 bind .tf.histframe.pwclist
<Configure
> {resizeclistpanes
%W
%w
}
1842 lappend bglist
$canv $canv2 $canv3
1843 pack .tf.histframe.pwclist
-fill both
-expand 1 -side left
1845 # we have two button bars at bottom of top frame. Bar 1
1847 frame .tf.lbar
-height 15
1849 set sha1entry .tf.bar.sha1
1850 set entries
$sha1entry
1851 set sha1but .tf.bar.sha1label
1852 button
$sha1but -text [mc
"SHA1 ID: "] -state disabled
-relief flat \
1853 -command gotocommit
-width 8
1854 $sha1but conf
-disabledforeground [$sha1but cget
-foreground]
1855 pack .tf.bar.sha1label
-side left
1856 entry
$sha1entry -width 40 -font textfont
-textvariable sha1string
1857 trace add variable sha1string
write sha1change
1858 pack
$sha1entry -side left
-pady 2
1860 image create bitmap bm-left
-data {
1861 #define left_width 16
1862 #define left_height 16
1863 static unsigned char left_bits
[] = {
1864 0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
1865 0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
1866 0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
1868 image create bitmap bm-right
-data {
1869 #define right_width 16
1870 #define right_height 16
1871 static unsigned char right_bits
[] = {
1872 0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
1873 0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
1874 0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
1876 button .tf.bar.leftbut
-image bm-left
-command goback \
1877 -state disabled
-width 26
1878 pack .tf.bar.leftbut
-side left
-fill y
1879 button .tf.bar.rightbut
-image bm-right
-command goforw \
1880 -state disabled
-width 26
1881 pack .tf.bar.rightbut
-side left
-fill y
1883 label .tf.bar.rowlabel
-text [mc
"Row"]
1885 label .tf.bar.rownum
-width 7 -font textfont
-textvariable rownumsel \
1886 -relief sunken
-anchor e
1887 label .tf.bar.rowlabel2
-text "/"
1888 label .tf.bar.numcommits
-width 7 -font textfont
-textvariable numcommits \
1889 -relief sunken
-anchor e
1890 pack .tf.bar.rowlabel .tf.bar.rownum .tf.bar.rowlabel2 .tf.bar.numcommits \
1893 trace add variable selectedline
write selectedline_change
1895 # Status label and progress bar
1896 set statusw .tf.bar.status
1897 label
$statusw -width 15 -relief sunken
1898 pack
$statusw -side left
-padx 5
1899 set h
[expr {[font metrics uifont
-linespace] + 2}]
1900 set progresscanv .tf.bar.progress
1901 canvas
$progresscanv -relief sunken
-height $h -borderwidth 2
1902 set progressitem
[$progresscanv create rect
-1 0 0 $h -fill green
]
1903 set fprogitem
[$progresscanv create rect
-1 0 0 $h -fill yellow
]
1904 set rprogitem
[$progresscanv create rect
-1 0 0 $h -fill red
]
1905 pack
$progresscanv -side right
-expand 1 -fill x
1906 set progresscoords
{0 0}
1909 bind $progresscanv <Configure
> adjustprogress
1910 set lastprogupdate
[clock clicks
-milliseconds]
1911 set progupdatepending
0
1913 # build up the bottom bar of upper window
1914 label .tf.lbar.flabel
-text "[mc "Find
"] "
1915 button .tf.lbar.fnext
-text [mc
"next"] -command {dofind
1 1}
1916 button .tf.lbar.fprev
-text [mc
"prev"] -command {dofind
-1 1}
1917 label .tf.lbar.flab2
-text " [mc "commit
"] "
1918 pack .tf.lbar.flabel .tf.lbar.fnext .tf.lbar.fprev .tf.lbar.flab2 \
1920 set gdttype
[mc
"containing:"]
1921 set gm
[tk_optionMenu .tf.lbar.gdttype gdttype \
1922 [mc
"containing:"] \
1923 [mc
"touching paths:"] \
1924 [mc
"adding/removing string:"]]
1925 trace add variable gdttype
write gdttype_change
1926 pack .tf.lbar.gdttype
-side left
-fill y
1929 set fstring .tf.lbar.findstring
1930 lappend entries
$fstring
1931 entry
$fstring -width 30 -font textfont
-textvariable findstring
1932 trace add variable findstring
write find_change
1933 set findtype
[mc
"Exact"]
1934 set findtypemenu
[tk_optionMenu .tf.lbar.findtype \
1935 findtype
[mc
"Exact"] [mc
"IgnCase"] [mc
"Regexp"]]
1936 trace add variable findtype
write findcom_change
1937 set findloc
[mc
"All fields"]
1938 tk_optionMenu .tf.lbar.findloc findloc
[mc
"All fields"] [mc
"Headline"] \
1939 [mc
"Comments"] [mc
"Author"] [mc
"Committer"]
1940 trace add variable findloc
write find_change
1941 pack .tf.lbar.findloc
-side right
1942 pack .tf.lbar.findtype
-side right
1943 pack
$fstring -side left
-expand 1 -fill x
1945 # Finish putting the upper half of the viewer together
1946 pack .tf.lbar
-in .tf
-side bottom
-fill x
1947 pack .tf.bar
-in .tf
-side bottom
-fill x
1948 pack .tf.histframe
-fill both
-side top
-expand 1
1950 .ctop paneconfigure .tf
-height $geometry(topheight
)
1951 .ctop paneconfigure .tf
-width $geometry(topwidth
)
1953 # now build up the bottom
1954 panedwindow .pwbottom
-orient horizontal
1956 # lower left, a text box over search bar, scroll bar to the right
1957 # if we know window height, then that will set the lower text height, otherwise
1958 # we set lower text height which will drive window height
1959 if {[info exists geometry
(main
)]} {
1960 frame .bleft
-width $geometry(botwidth
)
1962 frame .bleft
-width $geometry(botwidth
) -height $geometry(botheight
)
1968 button .bleft.top.search
-text [mc
"Search"] -command dosearch
1969 pack .bleft.top.search
-side left
-padx 5
1970 set sstring .bleft.top.sstring
1971 entry
$sstring -width 20 -font textfont
-textvariable searchstring
1972 lappend entries
$sstring
1973 trace add variable searchstring
write incrsearch
1974 pack
$sstring -side left
-expand 1 -fill x
1975 radiobutton .bleft.mid.
diff -text [mc
"Diff"] \
1976 -command changediffdisp
-variable diffelide
-value {0 0}
1977 radiobutton .bleft.mid.old
-text [mc
"Old version"] \
1978 -command changediffdisp
-variable diffelide
-value {0 1}
1979 radiobutton .bleft.mid.new
-text [mc
"New version"] \
1980 -command changediffdisp
-variable diffelide
-value {1 0}
1981 label .bleft.mid.labeldiffcontext
-text " [mc "Lines of context
"]: "
1982 pack .bleft.mid.
diff .bleft.mid.old .bleft.mid.new
-side left
1983 spinbox .bleft.mid.diffcontext
-width 5 -font textfont \
1984 -from 1 -increment 1 -to 10000000 \
1985 -validate all
-validatecommand "diffcontextvalidate %P" \
1986 -textvariable diffcontextstring
1987 .bleft.mid.diffcontext
set $diffcontext
1988 trace add variable diffcontextstring
write diffcontextchange
1989 lappend entries .bleft.mid.diffcontext
1990 pack .bleft.mid.labeldiffcontext .bleft.mid.diffcontext
-side left
1991 checkbutton .bleft.mid.ignspace
-text [mc
"Ignore space change"] \
1992 -command changeignorespace
-variable ignorespace
1993 pack .bleft.mid.ignspace
-side left
-padx 5
1994 set ctext .bleft.bottom.ctext
1995 text
$ctext -background $bgcolor -foreground $fgcolor \
1996 -state disabled
-font textfont \
1997 -yscrollcommand scrolltext
-wrap none \
1998 -xscrollcommand ".bleft.bottom.sbhorizontal set"
2000 $ctext conf
-tabstyle wordprocessor
2002 scrollbar .bleft.bottom.sb
-command "$ctext yview"
2003 scrollbar .bleft.bottom.sbhorizontal
-command "$ctext xview" -orient h \
2005 pack .bleft.top
-side top
-fill x
2006 pack .bleft.mid
-side top
-fill x
2007 grid
$ctext .bleft.bottom.sb
-sticky nsew
2008 grid .bleft.bottom.sbhorizontal
-sticky ew
2009 grid columnconfigure .bleft.bottom
0 -weight 1
2010 grid rowconfigure .bleft.bottom
0 -weight 1
2011 grid rowconfigure .bleft.bottom
1 -weight 0
2012 pack .bleft.bottom
-side top
-fill both
-expand 1
2013 lappend bglist
$ctext
2014 lappend fglist
$ctext
2016 $ctext tag conf comment
-wrap $wrapcomment
2017 $ctext tag conf filesep
-font textfontbold
-back "#aaaaaa"
2018 $ctext tag conf hunksep
-fore [lindex
$diffcolors 2]
2019 $ctext tag conf d0
-fore [lindex
$diffcolors 0]
2020 $ctext tag conf d1
-fore [lindex
$diffcolors 1]
2021 $ctext tag conf m0
-fore red
2022 $ctext tag conf m1
-fore blue
2023 $ctext tag conf m2
-fore green
2024 $ctext tag conf m3
-fore purple
2025 $ctext tag conf
m4 -fore brown
2026 $ctext tag conf m5
-fore "#009090"
2027 $ctext tag conf m6
-fore magenta
2028 $ctext tag conf m7
-fore "#808000"
2029 $ctext tag conf m8
-fore "#009000"
2030 $ctext tag conf m9
-fore "#ff0080"
2031 $ctext tag conf m10
-fore cyan
2032 $ctext tag conf m11
-fore "#b07070"
2033 $ctext tag conf m12
-fore "#70b0f0"
2034 $ctext tag conf m13
-fore "#70f0b0"
2035 $ctext tag conf m14
-fore "#f0b070"
2036 $ctext tag conf m15
-fore "#ff70b0"
2037 $ctext tag conf mmax
-fore darkgrey
2039 $ctext tag conf mresult
-font textfontbold
2040 $ctext tag conf msep
-font textfontbold
2041 $ctext tag conf found
-back yellow
2043 .pwbottom add .bleft
2044 .pwbottom paneconfigure .bleft
-width $geometry(botwidth
)
2049 radiobutton .bright.mode.
patch -text [mc
"Patch"] \
2050 -command reselectline
-variable cmitmode
-value "patch"
2051 radiobutton .bright.mode.tree
-text [mc
"Tree"] \
2052 -command reselectline
-variable cmitmode
-value "tree"
2053 grid .bright.mode.
patch .bright.mode.tree
-sticky ew
2054 pack .bright.mode
-side top
-fill x
2055 set cflist .bright.cfiles
2056 set indent
[font measure mainfont
"nn"]
2058 -selectbackground $selectbgcolor \
2059 -background $bgcolor -foreground $fgcolor \
2061 -tabs [list
$indent [expr {2 * $indent}]] \
2062 -yscrollcommand ".bright.sb set" \
2063 -cursor [. cget
-cursor] \
2064 -spacing1 1 -spacing3 1
2065 lappend bglist
$cflist
2066 lappend fglist
$cflist
2067 scrollbar .bright.sb
-command "$cflist yview"
2068 pack .bright.sb
-side right
-fill y
2069 pack
$cflist -side left
-fill both
-expand 1
2070 $cflist tag configure highlight \
2071 -background [$cflist cget
-selectbackground]
2072 $cflist tag configure bold
-font mainfontbold
2074 .pwbottom add .bright
2077 # restore window width & height if known
2078 if {[info exists geometry
(main
)]} {
2079 if {[scan
$geometry(main
) "%dx%d" w h
] >= 2} {
2080 if {$w > [winfo screenwidth .
]} {
2081 set w
[winfo screenwidth .
]
2083 if {$h > [winfo screenheight .
]} {
2084 set h
[winfo screenheight .
]
2086 wm geometry .
"${w}x$h"
2090 if {[tk windowingsystem
] eq
{aqua
}} {
2096 bind .pwbottom
<Configure
> {resizecdetpanes
%W
%w
}
2097 pack .ctop
-fill both
-expand 1
2098 bindall
<1> {selcanvline
%W
%x
%y
}
2099 #bindall <B1-Motion> {selcanvline %W %x %y}
2100 if {[tk windowingsystem
] == "win32"} {
2101 bind .
<MouseWheel
> { windows_mousewheel_redirector
%W
%X
%Y
%D
}
2102 bind $ctext <MouseWheel
> { windows_mousewheel_redirector
%W
%X
%Y
%D
; break }
2104 bindall
<ButtonRelease-4
> "allcanvs yview scroll -5 units"
2105 bindall
<ButtonRelease-5
> "allcanvs yview scroll 5 units"
2106 if {[tk windowingsystem
] eq
"aqua"} {
2107 bindall
<MouseWheel
> {
2108 set delta
[expr {- (%D
)}]
2109 allcanvs yview scroll
$delta units
2113 bindall
<2> "canvscan mark %W %x %y"
2114 bindall
<B2-Motion
> "canvscan dragto %W %x %y"
2115 bindkey
<Home
> selfirstline
2116 bindkey
<End
> sellastline
2117 bind .
<Key-Up
> "selnextline -1"
2118 bind .
<Key-Down
> "selnextline 1"
2119 bind .
<Shift-Key-Up
> "dofind -1 0"
2120 bind .
<Shift-Key-Down
> "dofind 1 0"
2121 bindkey
<Key-Right
> "goforw"
2122 bindkey
<Key-Left
> "goback"
2123 bind .
<Key-Prior
> "selnextpage -1"
2124 bind .
<Key-Next
> "selnextpage 1"
2125 bind .
<$M1B-Home> "allcanvs yview moveto 0.0"
2126 bind .
<$M1B-End> "allcanvs yview moveto 1.0"
2127 bind .
<$M1B-Key-Up> "allcanvs yview scroll -1 units"
2128 bind .
<$M1B-Key-Down> "allcanvs yview scroll 1 units"
2129 bind .
<$M1B-Key-Prior> "allcanvs yview scroll -1 pages"
2130 bind .
<$M1B-Key-Next> "allcanvs yview scroll 1 pages"
2131 bindkey
<Key-Delete
> "$ctext yview scroll -1 pages"
2132 bindkey
<Key-BackSpace
> "$ctext yview scroll -1 pages"
2133 bindkey
<Key-space
> "$ctext yview scroll 1 pages"
2134 bindkey p
"selnextline -1"
2135 bindkey n
"selnextline 1"
2138 bindkey i
"selnextline -1"
2139 bindkey k
"selnextline 1"
2143 bindkey d
"$ctext yview scroll 18 units"
2144 bindkey u
"$ctext yview scroll -18 units"
2145 bindkey
/ {dofind
1 1}
2146 bindkey
<Key-Return
> {dofind
1 1}
2147 bindkey ?
{dofind
-1 1}
2149 bindkey
<F5
> updatecommits
2150 bind .
<$M1B-q> doquit
2151 bind .
<$M1B-f> {dofind
1 1}
2152 bind .
<$M1B-g> {dofind
1 0}
2153 bind .
<$M1B-r> dosearchback
2154 bind .
<$M1B-s> dosearch
2155 bind .
<$M1B-equal> {incrfont
1}
2156 bind .
<$M1B-plus> {incrfont
1}
2157 bind .
<$M1B-KP_Add> {incrfont
1}
2158 bind .
<$M1B-minus> {incrfont
-1}
2159 bind .
<$M1B-KP_Subtract> {incrfont
-1}
2160 wm protocol . WM_DELETE_WINDOW doquit
2161 bind .
<Destroy
> {stop_backends
}
2162 bind .
<Button-1
> "click %W"
2163 bind $fstring <Key-Return
> {dofind
1 1}
2164 bind $sha1entry <Key-Return
> {gotocommit
; break}
2165 bind $sha1entry <<PasteSelection>> clearsha1
2166 bind $cflist <1> {sel_flist %W %x %y; break}
2167 bind $cflist <B1-Motion> {sel_flist %W %x %y; break}
2168 bind $cflist <ButtonRelease-1> {treeclick %W %x %y}
2170 bind $cflist $ctxbut {pop_flist_menu %W %X %Y %x %y}
2172 set maincursor [. cget -cursor]
2173 set textcursor [$ctext cget -cursor]
2174 set curtextcursor $textcursor
2176 set rowctxmenu .rowctxmenu
2177 menu $rowctxmenu -tearoff 0
2178 $rowctxmenu add command -label [mc "Diff this -> selected"] \
2179 -command {diffvssel 0}
2180 $rowctxmenu add command -label [mc "Diff selected -> this"] \
2181 -command {diffvssel 1}
2182 $rowctxmenu add command -label [mc "Make patch"] -command mkpatch
2183 $rowctxmenu add command -label [mc "Create tag"] -command mktag
2184 $rowctxmenu add command -label [mc "Write commit to file"] -command writecommit
2185 $rowctxmenu add command -label [mc "Create new branch"] -command mkbranch
2186 $rowctxmenu add command -label [mc "Cherry-pick this commit"] \
2188 $rowctxmenu add command -label [mc "Reset HEAD branch to here"] \
2191 set fakerowmenu .fakerowmenu
2192 menu $fakerowmenu -tearoff 0
2193 $fakerowmenu add command -label [mc "Diff this -> selected"] \
2194 -command {diffvssel 0}
2195 $fakerowmenu add command -label [mc "Diff selected -> this"] \
2196 -command {diffvssel 1}
2197 $fakerowmenu add command -label [mc "Make patch"] -command mkpatch
2198 # $fakerowmenu add command -label [mc "Commit"] -command {mkcommit 0}
2199 # $fakerowmenu add command -label [mc "Commit all"] -command {mkcommit 1}
2200 # $fakerowmenu add command -label [mc "Revert local changes"] -command revertlocal
2202 set headctxmenu .headctxmenu
2203 menu $headctxmenu -tearoff 0
2204 $headctxmenu add command -label [mc "Check out this branch"] \
2206 $headctxmenu add command -label [mc "Remove this branch"] \
2210 set flist_menu .flistctxmenu
2211 menu $flist_menu -tearoff 0
2212 $flist_menu add command -label [mc "Highlight this too"] \
2213 -command {flist_hl 0}
2214 $flist_menu add command -label [mc "Highlight this only"] \
2215 -command {flist_hl 1}
2216 $flist_menu add command -label [mc "External diff"] \
2217 -command {external_diff}
2218 $flist_menu add command -label [mc "Blame parent commit"] \
2219 -command {external_blame 1}
2222 # Windows sends all mouse wheel events to the current focused window, not
2223 # the one where the mouse hovers, so bind those events here and redirect
2224 # to the correct window
2225 proc windows_mousewheel_redirector {W X Y D} {
2226 global canv canv2 canv3
2227 set w [winfo containing -displayof $W $X $Y]
2229 set u [expr {$D < 0 ? 5 : -5}]
2230 if {$w == $canv || $w == $canv2 || $w == $canv3} {
2231 allcanvs yview scroll $u units
2234 $w yview scroll $u units
2240 # Update row number label when selectedline changes
2241 proc selectedline_change {n1 n2 op} {
2242 global selectedline rownumsel
2244 if {$selectedline eq {}} {
2247 set rownumsel [expr {$selectedline + 1}]
2251 # mouse-2 makes all windows scan vertically, but only the one
2252 # the cursor is in scans horizontally
2253 proc canvscan {op w x y} {
2254 global canv canv2 canv3
2255 foreach c [list $canv $canv2 $canv3] {
2264 proc scrollcanv {cscroll f0 f1} {
2265 $cscroll set $f0 $f1
2270 # when we make a key binding for the toplevel, make sure
2271 # it doesn't get triggered when that key is pressed in the
2272 # find string entry widget.
2273 proc bindkey {ev script} {
2276 set escript [bind Entry $ev]
2277 if {$escript == {}} {
2278 set escript [bind Entry <Key>]
2280 foreach e $entries {
2281 bind $e $ev "$escript; break"
2285 # set the focus back to the toplevel for any click outside
2288 global ctext entries
2289 foreach e [concat $entries $ctext] {
2290 if {$w == $e} return
2295 # Adjust the progress bar for a change in requested extent or canvas size
2296 proc adjustprogress {} {
2297 global progresscanv progressitem progresscoords
2298 global fprogitem fprogcoord lastprogupdate progupdatepending
2299 global rprogitem rprogcoord
2301 set w [expr {[winfo width $progresscanv] - 4}]
2302 set x0 [expr {$w * [lindex $progresscoords 0]}]
2303 set x1 [expr {$w * [lindex $progresscoords 1]}]
2304 set h [winfo height $progresscanv]
2305 $progresscanv coords $progressitem $x0 0 $x1 $h
2306 $progresscanv coords $fprogitem 0 0 [expr {$w * $fprogcoord}] $h
2307 $progresscanv coords $rprogitem 0 0 [expr {$w * $rprogcoord}] $h
2308 set now [clock clicks -milliseconds]
2309 if {$now >= $lastprogupdate + 100} {
2310 set progupdatepending 0
2312 } elseif {!$progupdatepending} {
2313 set progupdatepending 1
2314 after [expr {$lastprogupdate + 100 - $now}] doprogupdate
2318 proc doprogupdate {} {
2319 global lastprogupdate progupdatepending
2321 if {$progupdatepending} {
2322 set progupdatepending 0
2323 set lastprogupdate [clock clicks -milliseconds]
2328 proc savestuff {w} {
2329 global canv canv2 canv3 mainfont textfont uifont tabstop
2330 global stuffsaved findmergefiles maxgraphpct
2331 global maxwidth showneartags showlocalchanges
2332 global viewname viewfiles viewargs viewargscmd viewperm nextviewnum
2333 global cmitmode wrapcomment datetimeformat limitdiffs
2334 global colors bgcolor fgcolor diffcolors diffcontext selectbgcolor
2335 global autoselect extdifftool perfile_attrs
2337 if {$stuffsaved} return
2338 if {![winfo viewable .]} return
2340 set f [open "~/.gitk-new" w]
2341 puts $f [list set mainfont $mainfont]
2342 puts $f [list set textfont $textfont]
2343 puts $f [list set uifont $uifont]
2344 puts $f [list set tabstop $tabstop]
2345 puts $f [list set findmergefiles $findmergefiles]
2346 puts $f [list set maxgraphpct $maxgraphpct]
2347 puts $f [list set maxwidth $maxwidth]
2348 puts $f [list set cmitmode $cmitmode]
2349 puts $f [list set wrapcomment $wrapcomment]
2350 puts $f [list set autoselect $autoselect]
2351 puts $f [list set showneartags $showneartags]
2352 puts $f [list set showlocalchanges $showlocalchanges]
2353 puts $f [list set datetimeformat $datetimeformat]
2354 puts $f [list set limitdiffs $limitdiffs]
2355 puts $f [list set bgcolor $bgcolor]
2356 puts $f [list set fgcolor $fgcolor]
2357 puts $f [list set colors $colors]
2358 puts $f [list set diffcolors $diffcolors]
2359 puts $f [list set diffcontext $diffcontext]
2360 puts $f [list set selectbgcolor $selectbgcolor]
2361 puts $f [list set extdifftool $extdifftool]
2362 puts $f [list set perfile_attrs $perfile_attrs]
2364 puts $f "set geometry(main) [wm geometry .]"
2365 puts $f "set geometry(topwidth) [winfo width .tf]"
2366 puts $f "set geometry(topheight) [winfo height .tf]"
2367 puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sash coord 0]\""
2368 puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sash coord 1]\""
2369 puts $f "set geometry(botwidth) [winfo width .bleft]"
2370 puts $f "set geometry(botheight) [winfo height .bleft]"
2372 puts -nonewline $f "set permviews {"
2373 for {set v 0} {$v < $nextviewnum} {incr v} {
2374 if {$viewperm($v)} {
2375 puts $f "{[list $viewname($v) $viewfiles($v) $viewargs($v) $viewargscmd($v)]}"
2380 file rename -force "~/.gitk-new" "~/.gitk"
2385 proc resizeclistpanes {win w} {
2387 if {[info exists oldwidth($win)]} {
2388 set s0 [$win sash coord 0]
2389 set s1 [$win sash coord 1]
2391 set sash0 [expr {int($w/2 - 2)}]
2392 set sash1 [expr {int($w*5/6 - 2)}]
2394 set factor [expr {1.0 * $w / $oldwidth($win)}]
2395 set sash0 [expr {int($factor * [lindex $s0 0])}]
2396 set sash1 [expr {int($factor * [lindex $s1 0])}]
2400 if {$sash1 < $sash0 + 20} {
2401 set sash1 [expr {$sash0 + 20}]
2403 if {$sash1 > $w - 10} {
2404 set sash1 [expr {$w - 10}]
2405 if {$sash0 > $sash1 - 20} {
2406 set sash0 [expr {$sash1 - 20}]
2410 $win sash place 0 $sash0 [lindex $s0 1]
2411 $win sash place 1 $sash1 [lindex $s1 1]
2413 set oldwidth($win) $w
2416 proc resizecdetpanes {win w} {
2418 if {[info exists oldwidth($win)]} {
2419 set s0 [$win sash coord 0]
2421 set sash0 [expr {int($w*3/4 - 2)}]
2423 set factor [expr {1.0 * $w / $oldwidth($win)}]
2424 set sash0 [expr {int($factor * [lindex $s0 0])}]
2428 if {$sash0 > $w - 15} {
2429 set sash0 [expr {$w - 15}]
2432 $win sash place 0 $sash0 [lindex $s0 1]
2434 set oldwidth($win) $w
2437 proc allcanvs args {
2438 global canv canv2 canv3
2444 proc bindall {event action} {
2445 global canv canv2 canv3
2446 bind $canv $event $action
2447 bind $canv2 $event $action
2448 bind $canv3 $event $action
2454 if {[winfo exists $w]} {
2459 wm title $w [mc "About gitk"]
2460 message $w.m -text [mc "
2461 Gitk - a commit viewer for git
2463 Copyright © 2005-2008 Paul Mackerras
2465 Use and redistribute under the terms of the GNU General Public License"] \
2466 -justify center -aspect 400 -border 2 -bg white -relief groove
2467 pack $w.m -side top -fill x -padx 2 -pady 2
2468 button $w.ok -text [mc "Close"] -command "destroy $w" -default active
2469 pack $w.ok -side bottom
2470 bind $w <Visibility> "focus $w.ok"
2471 bind $w <Key-Escape> "destroy $w"
2472 bind $w <Key-Return> "destroy $w"
2477 if {[winfo exists $w]} {
2481 if {[tk windowingsystem] eq {aqua}} {
2487 wm title $w [mc "Gitk key bindings"]
2488 message $w.m -text "
2489 [mc "Gitk key bindings:"]
2491 [mc "<%s-Q> Quit" $M1T]
2492 [mc "<Home> Move to first commit"]
2493 [mc "<End> Move to last commit"]
2494 [mc "<Up>, p, i Move up one commit"]
2495 [mc "<Down>, n, k Move down one commit"]
2496 [mc "<Left>, z, j Go back in history list"]
2497 [mc "<Right>, x, l Go forward in history list"]
2498 [mc "<PageUp> Move up one page in commit list"]
2499 [mc "<PageDown> Move down one page in commit list"]
2500 [mc "<%s-Home> Scroll to top of commit list" $M1T]
2501 [mc "<%s-End> Scroll to bottom of commit list" $M1T]
2502 [mc "<%s-Up> Scroll commit list up one line" $M1T]
2503 [mc "<%s-Down> Scroll commit list down one line" $M1T]
2504 [mc "<%s-PageUp> Scroll commit list up one page" $M1T]
2505 [mc "<%s-PageDown> Scroll commit list down one page" $M1T]
2506 [mc "<Shift-Up> Find backwards (upwards, later commits)"]
2507 [mc "<Shift-Down> Find forwards (downwards, earlier commits)"]
2508 [mc "<Delete>, b Scroll diff view up one page"]
2509 [mc "<Backspace> Scroll diff view up one page"]
2510 [mc "<Space> Scroll diff view down one page"]
2511 [mc "u Scroll diff view up 18 lines"]
2512 [mc "d Scroll diff view down 18 lines"]
2513 [mc "<%s-F> Find" $M1T]
2514 [mc "<%s-G> Move to next find hit" $M1T]
2515 [mc "<Return> Move to next find hit"]
2516 [mc "/ Move to next find hit, or redo find"]
2517 [mc "? Move to previous find hit"]
2518 [mc "f Scroll diff view to next file"]
2519 [mc "<%s-S> Search for next hit in diff view" $M1T]
2520 [mc "<%s-R> Search for previous hit in diff view" $M1T]
2521 [mc "<%s-KP+> Increase font size" $M1T]
2522 [mc "<%s-plus> Increase font size" $M1T]
2523 [mc "<%s-KP-> Decrease font size" $M1T]
2524 [mc "<%s-minus> Decrease font size" $M1T]
2527 -justify left -bg white -border 2 -relief groove
2528 pack $w.m -side top -fill both -padx 2 -pady 2
2529 button $w.ok -text [mc "Close"] -command "destroy $w" -default active
2530 pack $w.ok -side bottom
2531 bind $w <Visibility> "focus $w.ok"
2532 bind $w <Key-Escape> "destroy $w"
2533 bind $w <Key-Return> "destroy $w"
2536 # Procedures for manipulating the file list window at the
2537 # bottom right of the overall window.
2539 proc treeview {w l openlevs} {
2540 global treecontents treediropen treeheight treeparent treeindex
2550 set treecontents() {}
2551 $w conf -state normal
2553 while {[string range $f 0 $prefixend] ne $prefix} {
2554 if {$lev <= $openlevs} {
2555 $w mark set e:$treeindex($prefix) "end -1c"
2556 $w mark gravity e:$treeindex($prefix) left
2558 set treeheight($prefix) $ht
2559 incr ht [lindex $htstack end]
2560 set htstack [lreplace $htstack end end]
2561 set prefixend [lindex $prefendstack end]
2562 set prefendstack [lreplace $prefendstack end end]
2563 set prefix [string range $prefix 0 $prefixend]
2566 set tail [string range $f [expr {$prefixend+1}] end]
2567 while {[set slash [string first "/" $tail]] >= 0} {
2570 lappend prefendstack $prefixend
2571 incr prefixend [expr {$slash + 1}]
2572 set d [string range $tail 0 $slash]
2573 lappend treecontents($prefix) $d
2574 set oldprefix $prefix
2576 set treecontents($prefix) {}
2577 set treeindex($prefix) [incr ix]
2578 set treeparent($prefix) $oldprefix
2579 set tail [string range $tail [expr {$slash+1}] end]
2580 if {$lev <= $openlevs} {
2582 set treediropen($prefix) [expr {$lev < $openlevs}]
2583 set bm [expr {$lev == $openlevs? "tri-rt": "tri-dn"}]
2584 $w mark set d:$ix "end -1c"
2585 $w mark gravity d:$ix left
2587 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
2589 $w image create end -align center -image $bm -padx 1 \
2591 $w insert end $d [highlight_tag $prefix]
2592 $w mark set s:$ix "end -1c"
2593 $w mark gravity s:$ix left
2598 if {$lev <= $openlevs} {
2601 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
2603 $w insert end $tail [highlight_tag $f]
2605 lappend treecontents($prefix) $tail
2608 while {$htstack ne {}} {
2609 set treeheight($prefix) $ht
2610 incr ht [lindex $htstack end]
2611 set htstack [lreplace $htstack end end]
2612 set prefixend [lindex $prefendstack end]
2613 set prefendstack [lreplace $prefendstack end end]
2614 set prefix [string range $prefix 0 $prefixend]
2616 $w conf -state disabled
2619 proc linetoelt {l} {
2620 global treeheight treecontents
2625 foreach e $treecontents($prefix) {
2630 if {[string index $e end] eq "/"} {
2631 set n $treeheight($prefix$e)
2643 proc highlight_tree {y prefix} {
2644 global treeheight treecontents cflist
2646 foreach e $treecontents($prefix) {
2648 if {[highlight_tag $path] ne {}} {
2649 $cflist tag add bold $y.0 "$y.0 lineend"
2652 if {[string index $e end] eq "/" && $treeheight($path) > 1} {
2653 set y [highlight_tree $y $path]
2659 proc treeclosedir {w dir} {
2660 global treediropen treeheight treeparent treeindex
2662 set ix $treeindex($dir)
2663 $w conf -state normal
2664 $w delete s:$ix e:$ix
2665 set treediropen($dir) 0
2666 $w image configure a:$ix -image tri-rt
2667 $w conf -state disabled
2668 set n [expr {1 - $treeheight($dir)}]
2669 while {$dir ne {}} {
2670 incr treeheight($dir) $n
2671 set dir $treeparent($dir)
2675 proc treeopendir {w dir} {
2676 global treediropen treeheight treeparent treecontents treeindex
2678 set ix $treeindex($dir)
2679 $w conf -state normal
2680 $w image configure a:$ix -image tri-dn
2681 $w mark set e:$ix s:$ix
2682 $w mark gravity e:$ix right
2685 set n [llength $treecontents($dir)]
2686 for {set x $dir} {$x ne {}} {set x $treeparent($x)} {
2689 incr treeheight($x) $n
2691 foreach e $treecontents($dir) {
2693 if {[string index $e end] eq "/"} {
2694 set iy $treeindex($de)
2695 $w mark set d:$iy e:$ix
2696 $w mark gravity d:$iy left
2697 $w insert e:$ix $str
2698 set treediropen($de) 0
2699 $w image create e:$ix -align center -image tri-rt -padx 1 \
2701 $w insert e:$ix $e [highlight_tag $de]
2702 $w mark set s:$iy e:$ix
2703 $w mark gravity s:$iy left
2704 set treeheight($de) 1
2706 $w insert e:$ix $str
2707 $w insert e:$ix $e [highlight_tag $de]
2710 $w mark gravity e:$ix right
2711 $w conf -state disabled
2712 set treediropen($dir) 1
2713 set top [lindex [split [$w index @0,0] .] 0]
2714 set ht [$w cget -height]
2715 set l [lindex [split [$w index s:$ix] .] 0]
2718 } elseif {$l + $n + 1 > $top + $ht} {
2719 set top [expr {$l + $n + 2 - $ht}]
2727 proc treeclick {w x y} {
2728 global treediropen cmitmode ctext cflist cflist_top
2730 if {$cmitmode ne "tree"} return
2731 if {![info exists cflist_top]} return
2732 set l [lindex [split [$w index "@$x,$y"] "."] 0]
2733 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
2734 $cflist tag add highlight $l.0 "$l.0 lineend"
2740 set e [linetoelt $l]
2741 if {[string index $e end] ne "/"} {
2743 } elseif {$treediropen($e)} {
2750 proc setfilelist {id} {
2751 global treefilelist cflist
2753 treeview $cflist $treefilelist($id) 0
2756 image create bitmap tri-rt -background black -foreground blue -data {
2757 #define tri-rt_width 13
2758 #define tri-rt_height 13
2759 static unsigned char tri-rt_bits[] = {
2760 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00,
2761 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x30, 0x00, 0x10, 0x00, 0x00, 0x00,
2764 #define tri-rt-mask_width 13
2765 #define tri-rt-mask_height 13
2766 static unsigned char tri-rt-mask_bits[] = {
2767 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01,
2768 0xf8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0x38, 0x00, 0x18, 0x00,
2771 image create bitmap tri-dn -background black -foreground blue -data {
2772 #define tri-dn_width 13
2773 #define tri-dn_height 13
2774 static unsigned char tri-dn_bits[] = {
2775 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xf8, 0x03,
2776 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2779 #define tri-dn-mask_width 13
2780 #define tri-dn-mask_height 13
2781 static unsigned char tri-dn-mask_bits[] = {
2782 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07,
2783 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
2787 image create bitmap reficon-T -background black -foreground yellow -data {
2788 #define tagicon_width 13
2789 #define tagicon_height 9
2790 static unsigned char tagicon_bits[] = {
2791 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x07,
2792 0xfc, 0x07, 0xf8, 0x07, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00};
2794 #define tagicon-mask_width 13
2795 #define tagicon-mask_height 9
2796 static unsigned char tagicon-mask_bits[] = {
2797 0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x0f, 0xfc, 0x0f,
2798 0xfe, 0x0f, 0xfc, 0x0f, 0xf8, 0x0f, 0xf0, 0x0f, 0x00, 0x00};
2801 #define headicon_width 13
2802 #define headicon_height 9
2803 static unsigned char headicon_bits[] = {
2804 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0xf8, 0x07,
2805 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00};
2808 #define headicon-mask_width 13
2809 #define headicon-mask_height 9
2810 static unsigned char headicon-mask_bits[] = {
2811 0x00, 0x00, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f,
2812 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0x00, 0x00};
2814 image create bitmap reficon-H -background black -foreground green \
2815 -data $rectdata -maskdata $rectmask
2816 image create bitmap reficon-o -background black -foreground "#ddddff" \
2817 -data $rectdata -maskdata $rectmask
2819 proc init_flist {first} {
2820 global cflist cflist_top difffilestart
2822 $cflist conf -state normal
2823 $cflist delete 0.0 end
2825 $cflist insert end $first
2827 $cflist tag add highlight 1.0 "1.0 lineend"
2829 catch {unset cflist_top}
2831 $cflist conf -state disabled
2832 set difffilestart {}
2835 proc highlight_tag {f} {
2836 global highlight_paths
2838 foreach p $highlight_paths {
2839 if {[string match $p $f]} {
2846 proc highlight_filelist {} {
2847 global cmitmode cflist
2849 $cflist conf -state normal
2850 if {$cmitmode ne "tree"} {
2851 set end [lindex [split [$cflist index end] .] 0]
2852 for {set l 2} {$l < $end} {incr l} {
2853 set line [$cflist get $l.0 "$l.0 lineend"]
2854 if {[highlight_tag $line] ne {}} {
2855 $cflist tag add bold $l.0 "$l.0 lineend"
2861 $cflist conf -state disabled
2864 proc unhighlight_filelist {} {
2867 $cflist conf -state normal
2868 $cflist tag remove bold 1.0 end
2869 $cflist conf -state disabled
2872 proc add_flist {fl} {
2875 $cflist conf -state normal
2877 $cflist insert end "\n"
2878 $cflist insert end $f [highlight_tag $f]
2880 $cflist conf -state disabled
2883 proc sel_flist {w x y} {
2884 global ctext difffilestart cflist cflist_top cmitmode
2886 if {$cmitmode eq "tree"} return
2887 if {![info exists cflist_top]} return
2888 set l [lindex [split [$w index "@$x,$y"] "."] 0]
2889 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
2890 $cflist tag add highlight $l.0 "$l.0 lineend"
2895 catch {$ctext yview [lindex $difffilestart [expr {$l - 2}]]}
2899 proc pop_flist_menu {w X Y x y} {
2900 global ctext cflist cmitmode flist_menu flist_menu_file
2901 global treediffs diffids
2904 set l [lindex [split [$w index "@$x,$y"] "."] 0]
2906 if {$cmitmode eq "tree"} {
2907 set e [linetoelt $l]
2908 if {[string index $e end] eq "/"} return
2910 set e [lindex $treediffs($diffids) [expr {$l-2}]]
2912 set flist_menu_file $e
2913 set xdiffstate "normal"
2914 if {$cmitmode eq "tree"} {
2915 set xdiffstate "disabled"
2917 # Disable "External diff" item in tree mode
2918 $flist_menu entryconf 2 -state $xdiffstate
2919 tk_popup $flist_menu $X $Y
2922 proc flist_hl {only} {
2923 global flist_menu_file findstring gdttype
2925 set x [shellquote $flist_menu_file]
2926 if {$only || $findstring eq {} || $gdttype ne [mc "touching paths:"]} {
2929 append findstring " " $x
2931 set gdttype [mc "touching paths:"]
2934 proc save_file_from_commit {filename output what} {
2937 if {[catch {exec git show $filename -- > $output} err]} {
2938 if {[string match "fatal: bad revision *" $err]} {
2941 error_popup "[mc "Error getting \"%s\" from %s:" $filename $what] $err"
2947 proc external_diff_get_one_file {diffid filename diffdir} {
2948 global nullid nullid2 nullfile
2951 if {$diffid == $nullid} {
2952 set difffile [file join [file dirname $gitdir] $filename]
2953 if {[file exists $difffile]} {
2958 if {$diffid == $nullid2} {
2959 set difffile [file join $diffdir "\[index\] [file tail $filename]"]
2960 return [save_file_from_commit :$filename $difffile index]
2962 set difffile [file join $diffdir "\[$diffid\] [file tail $filename]"]
2963 return [save_file_from_commit $diffid:$filename $difffile \
2967 proc external_diff {} {
2968 global gitktmpdir nullid nullid2
2969 global flist_menu_file
2972 global gitdir extdifftool
2974 if {[llength $diffids] == 1} {
2975 # no reference commit given
2976 set diffidto [lindex $diffids 0]
2977 if {$diffidto eq $nullid} {
2978 # diffing working copy with index
2979 set diffidfrom $nullid2
2980 } elseif {$diffidto eq $nullid2} {
2981 # diffing index with HEAD
2982 set diffidfrom "HEAD"
2984 # use first parent commit
2985 global parentlist selectedline
2986 set diffidfrom [lindex $parentlist $selectedline 0]
2989 set diffidfrom [lindex $diffids 0]
2990 set diffidto [lindex $diffids 1]
2993 # make sure that several diffs wont collide
2994 if {![info exists gitktmpdir]} {
2995 set gitktmpdir [file join [file dirname $gitdir] \
2996 [format ".gitk-tmp.%s" [pid]]]
2997 if {[catch {file mkdir $gitktmpdir} err]} {
2998 error_popup "[mc "Error creating temporary directory %s:" $gitktmpdir] $err"
3005 set diffdir [file join $gitktmpdir $diffnum]
3006 if {[catch {file mkdir $diffdir} err]} {
3007 error_popup "[mc "Error creating temporary directory %s:" $diffdir] $err"
3011 # gather files to diff
3012 set difffromfile [external_diff_get_one_file $diffidfrom $flist_menu_file $diffdir]
3013 set difftofile [external_diff_get_one_file $diffidto $flist_menu_file $diffdir]
3015 if {$difffromfile ne {} && $difftofile ne {}} {
3016 set cmd [concat | [shellsplit $extdifftool] \
3017 [list $difffromfile $difftofile]]
3018 if {[catch {set fl [open $cmd r]} err]} {
3019 file delete -force $diffdir
3020 error_popup "$extdifftool: [mc "command failed:"] $err"
3022 fconfigure $fl -blocking 0
3023 filerun $fl [list delete_at_eof $fl $diffdir]
3028 proc external_blame {parent_idx} {
3029 global flist_menu_file
3030 global nullid nullid2
3031 global parentlist selectedline currentid
3033 if {$parent_idx > 0} {
3034 set base_commit [lindex $parentlist $selectedline [expr {$parent_idx-1}]]
3036 set base_commit $currentid
3039 if {$base_commit eq {} || $base_commit eq $nullid || $base_commit eq $nullid2} {
3040 error_popup [mc "No such commit"]
3044 if {[catch {exec git gui blame $base_commit $flist_menu_file &} err]} {
3045 error_popup "[mc "git gui blame: command failed:"] $err"
3049 # delete $dir when we see eof on $f (presumably because the child has exited)
3050 proc delete_at_eof {f dir} {
3051 while {[gets $f line] >= 0} {}
3053 if {[catch {close $f} err]} {
3054 error_popup "[mc "External diff viewer failed:"] $err"
3056 file delete -force $dir
3062 # Functions for adding and removing shell-type quoting
3064 proc shellquote {str} {
3065 if {![string match "*\['\"\\ \t]*" $str]} {
3068 if {![string match "*\['\"\\]*" $str]} {
3071 if {![string match "*'*" $str]} {
3074 return "\"[string map {\" \\\" \\ \\\\} $str]\""
3077 proc shellarglist {l} {
3083 append str [shellquote $a]
3088 proc shelldequote {str} {
3093 if {![regexp -start $used -indices "\['\"\\\\ \t]" $str first]} {
3094 append ret [string range $str $used end]
3095 set used [string length $str]
3098 set first [lindex $first 0]
3099 set ch [string index $str $first]
3100 if {$first > $used} {
3101 append ret [string range $str $used [expr {$first - 1}]]
3104 if {$ch eq " " || $ch eq "\t"} break
3107 set first [string first "'" $str $used]
3109 error "unmatched single-quote"
3111 append ret [string range $str $used [expr {$first - 1}]]
3116 if {$used >= [string length $str]} {
3117 error "trailing backslash"
3119 append ret [string index $str $used]
3124 if {![regexp -start $used -indices "\[\"\\\\]" $str first]} {
3125 error "unmatched double-quote"
3127 set first [lindex $first 0]
3128 set ch [string index $str $first]
3129 if {$first > $used} {
3130 append ret [string range $str $used [expr {$first - 1}]]
3133 if {$ch eq "\""} break
3135 append ret [string index $str $used]
3139 return [list $used $ret]
3142 proc shellsplit {str} {
3145 set str [string trimleft $str]
3146 if {$str eq {}} break
3147 set dq [shelldequote $str]
3148 set n [lindex $dq 0]
3149 set word [lindex $dq 1]
3150 set str [string range $str $n end]
3156 # Code to implement multiple views
3158 proc newview {ishighlight} {
3159 global nextviewnum newviewname newviewperm newishighlight
3160 global newviewargs revtreeargs viewargscmd newviewargscmd curview
3162 set newishighlight $ishighlight
3164 if {[winfo exists $top]} {
3168 set newviewname($nextviewnum) "[mc "View"] $nextviewnum"
3169 set newviewperm($nextviewnum) 0
3170 set newviewargs($nextviewnum) [shellarglist $revtreeargs]
3171 set newviewargscmd($nextviewnum) $viewargscmd($curview)
3172 vieweditor $top $nextviewnum [mc "Gitk view definition"]
3177 global viewname viewperm newviewname newviewperm
3178 global viewargs newviewargs viewargscmd newviewargscmd
3180 set top .gitkvedit-$curview
3181 if {[winfo exists $top]} {
3185 set newviewname($curview) $viewname($curview)
3186 set newviewperm($curview) $viewperm($curview)
3187 set newviewargs($curview) [shellarglist $viewargs($curview)]
3188 set newviewargscmd($curview) $viewargscmd($curview)
3189 vieweditor $top $curview "Gitk: edit view $viewname($curview)"
3192 proc vieweditor {top n title} {
3193 global newviewname newviewperm viewfiles bgcolor
3196 wm title $top $title
3197 label $top.nl -text [mc "Name"]
3198 entry $top.name -width 20 -textvariable newviewname($n)
3199 grid $top.nl $top.name -sticky w -pady 5
3200 checkbutton $top.perm -text [mc "Remember this view"] \
3201 -variable newviewperm($n)
3202 grid $top.perm - -pady 5 -sticky w
3203 message $top.al -aspect 1000 \
3204 -text [mc "Commits to include (arguments to git log):"]
3205 grid $top.al - -sticky w -pady 5
3206 entry $top.args -width 50 -textvariable newviewargs($n) \
3207 -background $bgcolor
3208 grid $top.args - -sticky ew -padx 5
3210 message $top.ac -aspect 1000 \
3211 -text [mc "Command to generate more commits to include:"]
3212 grid $top.ac - -sticky w -pady 5
3213 entry $top.argscmd -width 50 -textvariable newviewargscmd($n) \
3215 grid $top.argscmd - -sticky ew -padx 5
3217 message $top.l -aspect 1000 \
3218 -text [mc "Enter files and directories to include, one per line:"]
3219 grid $top.l - -sticky w
3220 text $top.t -width 40 -height 10 -background $bgcolor -font uifont
3221 if {[info exists viewfiles($n)]} {
3222 foreach f $viewfiles($n) {
3223 $top.t insert end $f
3224 $top.t insert end "\n"
3226 $top.t delete {end - 1c} end
3227 $top.t mark set insert 0.0
3229 grid $top.t - -sticky ew -padx 5
3231 button $top.buts.ok -text [mc "OK"] -command [list newviewok $top $n]
3232 button $top.buts.can -text [mc "Cancel"] -command [list destroy $top]
3233 grid $top.buts.ok $top.buts.can
3234 grid columnconfigure $top.buts 0 -weight 1 -uniform a
3235 grid columnconfigure $top.buts 1 -weight 1 -uniform a
3236 grid $top.buts - -pady 10 -sticky ew
3240 proc doviewmenu {m first cmd op argv} {
3241 set nmenu [$m index end]
3242 for {set i $first} {$i <= $nmenu} {incr i} {
3243 if {[$m entrycget $i -command] eq $cmd} {
3244 eval $m $op $i $argv
3250 proc allviewmenus {n op args} {
3253 doviewmenu .bar.view 5 [list showview $n] $op $args
3254 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] $op $args
3257 proc newviewok {top n} {
3258 global nextviewnum newviewperm newviewname newishighlight
3259 global viewname viewfiles viewperm selectedview curview
3260 global viewargs newviewargs viewargscmd newviewargscmd viewhlmenu
3263 set newargs [shellsplit $newviewargs($n)]
3265 error_popup "[mc "Error in commit selection arguments:"] $err"
3271 foreach f [split [$top.t get 0.0 end] "\n"] {
3272 set ft [string trim $f]
3277 if {![info exists viewfiles($n)]} {
3278 # creating a new view
3280 set viewname($n) $newviewname($n)
3281 set viewperm($n) $newviewperm($n)
3282 set viewfiles($n) $files
3283 set viewargs($n) $newargs
3284 set viewargscmd($n) $newviewargscmd($n)
3286 if {!$newishighlight} {
3289 run addvhighlight $n
3292 # editing an existing view
3293 set viewperm($n) $newviewperm($n)
3294 if {$newviewname($n) ne $viewname($n)} {
3295 set viewname($n) $newviewname($n)
3296 doviewmenu .bar.view 5 [list showview $n] \
3297 entryconf [list -label $viewname($n)]
3298 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] \
3299 # entryconf [list -label $viewname($n) -value $viewname($n)]
3301 if {$files ne $viewfiles($n) || $newargs ne $viewargs($n) || \
3302 $newviewargscmd($n) ne $viewargscmd($n)} {
3303 set viewfiles($n) $files
3304 set viewargs($n) $newargs
3305 set viewargscmd($n) $newviewargscmd($n)
3306 if {$curview == $n} {
3311 catch {destroy $top}
3315 global curview viewperm hlview selectedhlview
3317 if {$curview == 0} return
3318 if {[info exists hlview] && $hlview == $curview} {
3319 set selectedhlview [mc "None"]
3322 allviewmenus $curview delete
3323 set viewperm($curview) 0
3327 proc addviewmenu {n} {
3328 global viewname viewhlmenu
3330 .bar.view add radiobutton -label $viewname($n) \
3331 -command [list showview $n] -variable selectedview -value $n
3332 #$viewhlmenu add radiobutton -label $viewname($n) \
3333 # -command [list addvhighlight $n] -variable selectedhlview
3337 global curview cached_commitrow ordertok
3338 global displayorder parentlist rowidlist rowisopt rowfinal
3339 global colormap rowtextx nextcolor canvxmax
3340 global numcommits viewcomplete
3341 global selectedline currentid canv canvy0
3343 global pending_select mainheadid
3346 global hlview selectedhlview commitinterest
3348 if {$n == $curview} return
3350 set ymax [lindex [$canv cget -scrollregion] 3]
3351 set span [$canv yview]
3352 set ytop [expr {[lindex $span 0] * $ymax}]
3353 set ybot [expr {[lindex $span 1] * $ymax}]
3354 set yscreen [expr {($ybot - $ytop) / 2}]
3355 if {$selectedline ne {}} {
3356 set selid $currentid
3357 set y [yc $selectedline]
3358 if {$ytop < $y && $y < $ybot} {
3359 set yscreen [expr {$y - $ytop}]
3361 } elseif {[info exists pending_select]} {
3362 set selid $pending_select
3363 unset pending_select
3367 catch {unset treediffs}
3369 if {[info exists hlview] && $hlview == $n} {
3371 set selectedhlview [mc "None"]
3373 catch {unset commitinterest}
3374 catch {unset cached_commitrow}
3375 catch {unset ordertok}
3379 .bar.view entryconf [mc "Edit view..."] -state [expr {$n == 0? "disabled": "normal"}]
3380 .bar.view entryconf [mc "Delete view"] -state [expr {$n == 0? "disabled": "normal"}]
3383 if {![info exists viewcomplete($n)]} {
3393 set numcommits $commitidx($n)
3395 catch {unset colormap}
3396 catch {unset rowtextx}
3398 set canvxmax [$canv cget -width]
3404 if {$selid ne {} && [commitinview $selid $n]} {
3405 set row [rowofcommit $selid]
3406 # try to get the selected row in the same position on the screen
3407 set ymax [lindex [$canv cget -scrollregion] 3]
3408 set ytop [expr {[yc $row] - $yscreen}]
3412 set yf [expr {$ytop * 1.0 / $ymax}]
3414 allcanvs yview moveto $yf
3418 } elseif {!$viewcomplete($n)} {
3419 reset_pending_select $selid
3421 reset_pending_select {}
3423 if {[commitinview $pending_select $curview]} {
3424 selectline [rowofcommit $pending_select] 1
3426 set row [first_real_row]
3427 if {$row < $numcommits} {
3432 if {!$viewcomplete($n)} {
3433 if {$numcommits == 0} {
3434 show_status [mc "Reading commits..."]
3436 } elseif {$numcommits == 0} {
3437 show_status [mc "No commits selected"]
3441 # Stuff relating to the highlighting facility
3443 proc ishighlighted {id} {
3444 global vhighlights fhighlights nhighlights rhighlights
3446 if {[info exists nhighlights($id)] && $nhighlights($id) > 0} {
3447 return $nhighlights($id)
3449 if {[info exists vhighlights($id)] && $vhighlights($id) > 0} {
3450 return $vhighlights($id)
3452 if {[info exists fhighlights($id)] && $fhighlights($id) > 0} {
3453 return $fhighlights($id)
3455 if {[info exists rhighlights($id)] && $rhighlights($id) > 0} {
3456 return $rhighlights($id)
3461 proc bolden {row font} {
3462 global canv linehtag selectedline boldrows
3464 lappend boldrows $row
3465 $canv itemconf $linehtag($row) -font $font
3466 if {$row == $selectedline} {
3468 set t [eval $canv create rect [$canv bbox $linehtag($row)] \
3469 -outline {{}} -tags secsel \
3470 -fill [$canv cget -selectbackground]]
3475 proc bolden_name {row font} {
3476 global canv2 linentag selectedline boldnamerows
3478 lappend boldnamerows $row
3479 $canv2 itemconf $linentag($row) -font $font
3480 if {$row == $selectedline} {
3481 $canv2 delete secsel
3482 set t [eval $canv2 create rect [$canv2 bbox $linentag($row)] \
3483 -outline {{}} -tags secsel \
3484 -fill [$canv2 cget -selectbackground]]
3493 foreach row $boldrows {
3494 if {![ishighlighted [commitonrow $row]]} {
3495 bolden $row mainfont
3497 lappend stillbold $row
3500 set boldrows $stillbold
3503 proc addvhighlight {n} {
3504 global hlview viewcomplete curview vhl_done commitidx
3506 if {[info exists hlview]} {
3510 if {$n != $curview && ![info exists viewcomplete($n)]} {
3513 set vhl_done $commitidx($hlview)
3514 if {$vhl_done > 0} {
3519 proc delvhighlight {} {
3520 global hlview vhighlights
3522 if {![info exists hlview]} return
3524 catch {unset vhighlights}
3528 proc vhighlightmore {} {
3529 global hlview vhl_done commitidx vhighlights curview
3531 set max $commitidx($hlview)
3532 set vr [visiblerows]
3533 set r0 [lindex $vr 0]
3534 set r1 [lindex $vr 1]
3535 for {set i $vhl_done} {$i < $max} {incr i} {
3536 set id [commitonrow $i $hlview]
3537 if {[commitinview $id $curview]} {
3538 set row [rowofcommit $id]
3539 if {$r0 <= $row && $row <= $r1} {
3540 if {![highlighted $row]} {
3541 bolden $row mainfontbold
3543 set vhighlights($id) 1
3551 proc askvhighlight {row id} {
3552 global hlview vhighlights iddrawn
3554 if {[commitinview $id $hlview]} {
3555 if {[info exists iddrawn($id)] && ![ishighlighted $id]} {
3556 bolden $row mainfontbold
3558 set vhighlights($id) 1
3560 set vhighlights($id) 0
3564 proc hfiles_change {} {
3565 global highlight_files filehighlight fhighlights fh_serial
3566 global highlight_paths gdttype
3568 if {[info exists filehighlight]} {
3569 # delete previous highlights
3570 catch {close $filehighlight}
3572 catch {unset fhighlights}
3574 unhighlight_filelist
3576 set highlight_paths {}
3577 after cancel do_file_hl $fh_serial
3579 if {$highlight_files ne {}} {
3580 after 300 do_file_hl $fh_serial
3584 proc gdttype_change {name ix op} {
3585 global gdttype highlight_files findstring findpattern
3588 if {$findstring ne {}} {
3589 if {$gdttype eq [mc "containing:"]} {
3590 if {$highlight_files ne {}} {
3591 set highlight_files {}
3596 if {$findpattern ne {}} {
3600 set highlight_files $findstring
3605 # enable/disable findtype/findloc menus too
3608 proc find_change {name ix op} {
3609 global gdttype findstring highlight_files
3612 if {$gdttype eq [mc "containing:"]} {
3615 if {$highlight_files ne $findstring} {
3616 set highlight_files $findstring
3623 proc findcom_change args {
3624 global nhighlights boldnamerows
3625 global findpattern findtype findstring gdttype
3628 # delete previous highlights, if any
3629 foreach row $boldnamerows {
3630 bolden_name $row mainfont
3633 catch {unset nhighlights}
3636 if {$gdttype ne [mc "containing:"] || $findstring eq {}} {
3638 } elseif {$findtype eq [mc "Regexp"]} {
3639 set findpattern $findstring
3641 set e [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} \
3643 set findpattern "*$e*"
3647 proc makepatterns {l} {
3650 set ee [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} $e]
3651 if {[string index $ee end] eq "/"} {
3661 proc do_file_hl {serial} {
3662 global highlight_files filehighlight highlight_paths gdttype fhl_list
3664 if {$gdttype eq [mc "touching paths:"]} {
3665 if {[catch {set paths [shellsplit $highlight_files]}]} return
3666 set highlight_paths [makepatterns $paths]
3668 set gdtargs [concat -- $paths]
3669 } elseif {$gdttype eq [mc "adding/removing string:"]} {
3670 set gdtargs [list "-S$highlight_files"]
3672 # must be "containing:", i.e. we're searching commit info
3675 set cmd [concat | git diff-tree -r -s --stdin $gdtargs]
3676 set filehighlight [open $cmd r+]
3677 fconfigure $filehighlight -blocking 0
3678 filerun $filehighlight readfhighlight
3684 proc flushhighlights {} {
3685 global filehighlight fhl_list
3687 if {[info exists filehighlight]} {
3689 puts $filehighlight ""
3690 flush $filehighlight
3694 proc askfilehighlight {row id} {
3695 global filehighlight fhighlights fhl_list
3697 lappend fhl_list $id
3698 set fhighlights($id) -1
3699 puts $filehighlight $id
3702 proc readfhighlight {} {
3703 global filehighlight fhighlights curview iddrawn
3704 global fhl_list find_dirn
3706 if {![info exists filehighlight]} {
3710 while {[incr nr] <= 100 && [gets $filehighlight line] >= 0} {
3711 set line [string trim $line]
3712 set i [lsearch -exact $fhl_list $line]
3713 if {$i < 0} continue
3714 for {set j 0} {$j < $i} {incr j} {
3715 set id [lindex $fhl_list $j]
3716 set fhighlights($id) 0
3718 set fhl_list [lrange $fhl_list [expr {$i+1}] end]
3719 if {$line eq {}} continue
3720 if {![commitinview $line $curview]} continue
3721 set row [rowofcommit $line]
3722 if {[info exists iddrawn($line)] && ![ishighlighted $line]} {
3723 bolden $row mainfontbold
3725 set fhighlights($line) 1
3727 if {[eof $filehighlight]} {
3729 puts "oops, git diff-tree died"
3730 catch {close $filehighlight}
3734 if {[info exists find_dirn]} {
3740 proc doesmatch {f} {
3741 global findtype findpattern
3743 if {$findtype eq [mc "Regexp"]} {
3744 return [regexp $findpattern $f]
3745 } elseif {$findtype eq [mc "IgnCase"]} {
3746 return [string match -nocase $findpattern $f]
3748 return [string match $findpattern $f]
3752 proc askfindhighlight {row id} {
3753 global nhighlights commitinfo iddrawn
3755 global markingmatches
3757 if {![info exists commitinfo($id)]} {
3760 set info $commitinfo($id)
3762 set fldtypes [list [mc Headline] [mc Author] [mc Date] [mc Committer] [mc CDate] [mc Comments]]
3763 foreach f $info ty $fldtypes {
3764 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
3766 if {$ty eq [mc "Author"]} {
3773 if {$isbold && [info exists iddrawn($id)]} {
3774 if {![ishighlighted $id]} {
3775 bolden $row mainfontbold
3777 bolden_name $row mainfontbold
3780 if {$markingmatches} {
3781 markrowmatches $row $id
3784 set nhighlights($id) $isbold
3787 proc markrowmatches {row id} {
3788 global canv canv2 linehtag linentag commitinfo findloc
3790 set headline [lindex $commitinfo($id) 0]
3791 set author [lindex $commitinfo($id) 1]
3792 $canv delete match$row
3793 $canv2 delete match$row
3794 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Headline"]} {
3795 set m [findmatches $headline]
3797 markmatches $canv $row $headline $linehtag($row) $m \
3798 [$canv itemcget $linehtag($row) -font] $row
3801 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Author"]} {
3802 set m [findmatches $author]
3804 markmatches $canv2 $row $author $linentag($row) $m \
3805 [$canv2 itemcget $linentag($row) -font] $row
3810 proc vrel_change {name ix op} {
3811 global highlight_related
3814 if {$highlight_related ne [mc "None"]} {
3819 # prepare for testing whether commits are descendents or ancestors of a
3820 proc rhighlight_sel {a} {
3821 global descendent desc_todo ancestor anc_todo
3822 global highlight_related
3824 catch {unset descendent}
3825 set desc_todo [list $a]
3826 catch {unset ancestor}
3827 set anc_todo [list $a]
3828 if {$highlight_related ne [mc "None"]} {
3834 proc rhighlight_none {} {
3837 catch {unset rhighlights}
3841 proc is_descendent {a} {
3842 global curview children descendent desc_todo
3845 set la [rowofcommit $a]
3849 for {set i 0} {$i < [llength $todo]} {incr i} {
3850 set do [lindex $todo $i]
3851 if {[rowofcommit $do] < $la} {
3852 lappend leftover $do
3855 foreach nk $children($v,$do) {
3856 if {![info exists descendent($nk)]} {
3857 set descendent($nk) 1
3865 set desc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
3869 set descendent($a) 0
3870 set desc_todo $leftover
3873 proc is_ancestor {a} {
3874 global curview parents ancestor anc_todo
3877 set la [rowofcommit $a]
3881 for {set i 0} {$i < [llength $todo]} {incr i} {
3882 set do [lindex $todo $i]
3883 if {![commitinview $do $v] || [rowofcommit $do] > $la} {
3884 lappend leftover $do
3887 foreach np $parents($v,$do) {
3888 if {![info exists ancestor($np)]} {
3897 set anc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
3902 set anc_todo $leftover
3905 proc askrelhighlight {row id} {
3906 global descendent highlight_related iddrawn rhighlights
3907 global selectedline ancestor
3909 if {$selectedline eq {}} return
3911 if {$highlight_related eq [mc "Descendant"] ||
3912 $highlight_related eq [mc "Not descendant"]} {
3913 if {![info exists descendent($id)]} {
3916 if {$descendent($id) == ($highlight_related eq [mc "Descendant"])} {
3919 } elseif {$highlight_related eq [mc "Ancestor"] ||
3920 $highlight_related eq [mc "Not ancestor"]} {
3921 if {![info exists ancestor($id)]} {
3924 if {$ancestor($id) == ($highlight_related eq [mc "Ancestor"])} {
3928 if {[info exists iddrawn($id)]} {
3929 if {$isbold && ![ishighlighted $id]} {
3930 bolden $row mainfontbold
3933 set rhighlights($id) $isbold
3936 # Graph layout functions
3938 proc shortids {ids} {
3941 if {[llength $id] > 1} {
3942 lappend res [shortids $id]
3943 } elseif {[regexp {^[0-9a-f]{40}$} $id]} {
3944 lappend res [string range $id 0 7]
3955 for {set mask 1} {$mask <= $n} {incr mask $mask} {
3956 if {($n & $mask) != 0} {
3957 set ret [concat $ret $o]
3959 set o [concat $o $o]
3964 proc ordertoken {id} {
3965 global ordertok curview varcid varcstart varctok curview parents children
3966 global nullid nullid2
3968 if {[info exists ordertok($id)]} {
3969 return $ordertok($id)
3974 if {[info exists varcid($curview,$id)]} {
3975 set a $varcid($curview,$id)
3976 set p [lindex $varcstart($curview) $a]
3978 set p [lindex $children($curview,$id) 0]
3980 if {[info exists ordertok($p)]} {
3981 set tok $ordertok($p)
3984 set id [first_real_child $curview,$p]
3987 set tok [lindex $varctok($curview) $varcid($curview,$p)]
3990 if {[llength $parents($curview,$id)] == 1} {
3991 lappend todo [list $p {}]
3993 set j [lsearch -exact $parents($curview,$id) $p]
3995 puts "oops didn't find [shortids $p] in parents of [shortids $id]"
3997 lappend todo [list $p [strrep $j]]
4000 for {set i [llength $todo]} {[incr i -1] >= 0} {} {
4001 set p [lindex $todo $i 0]
4002 append tok [lindex $todo $i 1]
4003 set ordertok($p) $tok
4005 set ordertok($origid) $tok
4009 # Work out where id should go in idlist so that order-token
4010 # values increase from left to right
4011 proc idcol {idlist id {i 0}} {
4012 set t [ordertoken $id]
4016 if {$i >= [llength $idlist] || $t < [ordertoken [lindex $idlist $i]]} {
4017 if {$i > [llength $idlist]} {
4018 set i [llength $idlist]
4020 while {[incr i -1] >= 0 && $t < [ordertoken [lindex $idlist $i]]} {}
4023 if {$t > [ordertoken [lindex $idlist $i]]} {
4024 while {[incr i] < [llength $idlist] &&
4025 $t >= [ordertoken [lindex $idlist $i]]} {}
4031 proc initlayout {} {
4032 global rowidlist rowisopt rowfinal displayorder parentlist
4033 global numcommits canvxmax canv
4035 global colormap rowtextx
4044 set canvxmax [$canv cget -width]
4045 catch {unset colormap}
4046 catch {unset rowtextx}
4050 proc setcanvscroll {} {
4051 global canv canv2 canv3 numcommits linespc canvxmax canvy0
4052 global lastscrollset lastscrollrows
4054 set ymax [expr {$canvy0 + ($numcommits - 0.5) * $linespc + 2}]
4055 $canv conf -scrollregion [list 0 0 $canvxmax $ymax]
4056 $canv2 conf -scrollregion [list 0 0 0 $ymax]
4057 $canv3 conf -scrollregion [list 0 0 0 $ymax]
4058 set lastscrollset [clock clicks -milliseconds]
4059 set lastscrollrows $numcommits
4062 proc visiblerows {} {
4063 global canv numcommits linespc
4065 set ymax [lindex [$canv cget -scrollregion] 3]
4066 if {$ymax eq {} || $ymax == 0} return
4068 set y0 [expr {int([lindex $f 0] * $ymax)}]
4069 set r0 [expr {int(($y0 - 3) / $linespc) - 1}]
4073 set y1 [expr {int([lindex $f 1] * $ymax)}]
4074 set r1 [expr {int(($y1 - 3) / $linespc) + 1}]
4075 if {$r1 >= $numcommits} {
4076 set r1 [expr {$numcommits - 1}]
4078 return [list $r0 $r1]
4081 proc layoutmore {} {
4082 global commitidx viewcomplete curview
4083 global numcommits pending_select curview
4084 global lastscrollset lastscrollrows commitinterest
4086 if {$lastscrollrows < 100 || $viewcomplete($curview) ||
4087 [clock clicks -milliseconds] - $lastscrollset > 500} {
4090 if {[info exists pending_select] &&
4091 [commitinview $pending_select $curview]} {
4093 selectline [rowofcommit $pending_select] 1
4098 proc doshowlocalchanges {} {
4099 global curview mainheadid
4101 if {$mainheadid eq {}} return
4102 if {[commitinview $mainheadid $curview]} {
4105 lappend commitinterest($mainheadid) {dodiffindex}
4109 proc dohidelocalchanges {} {
4110 global nullid nullid2 lserial curview
4112 if {[commitinview $nullid $curview]} {
4113 removefakerow $nullid
4115 if {[commitinview $nullid2 $curview]} {
4116 removefakerow $nullid2
4121 # spawn off a process to do git diff-index --cached HEAD
4122 proc dodiffindex {} {
4123 global lserial showlocalchanges
4126 if {!$showlocalchanges || !$isworktree} return
4128 set fd [open "|git diff-index --cached HEAD" r]
4129 fconfigure $fd -blocking 0
4130 set i [reg_instance $fd]
4131 filerun $fd [list readdiffindex $fd $lserial $i]
4134 proc readdiffindex {fd serial inst} {
4135 global mainheadid nullid nullid2 curview commitinfo commitdata lserial
4138 if {[gets $fd line] < 0} {
4144 # we only need to see one line and we don't really care what it says...
4147 if {$serial != $lserial} {
4151 # now see if there are any local changes not checked in to the index
4152 set fd [open "|git diff-files" r]
4153 fconfigure $fd -blocking 0
4154 set i [reg_instance $fd]
4155 filerun $fd [list readdifffiles $fd $serial $i]
4157 if {$isdiff && ![commitinview $nullid2 $curview]} {
4158 # add the line for the changes in the index to the graph
4159 set hl [mc "Local changes checked in to index but not committed"]
4160 set commitinfo($nullid2) [list $hl {} {} {} {} " $hl\n"]
4161 set commitdata($nullid2) "\n $hl\n"
4162 if {[commitinview $nullid $curview]} {
4163 removefakerow $nullid
4165 insertfakerow $nullid2 $mainheadid
4166 } elseif {!$isdiff && [commitinview $nullid2 $curview]} {
4167 removefakerow $nullid2
4172 proc readdifffiles {fd serial inst} {
4173 global mainheadid nullid nullid2 curview
4174 global commitinfo commitdata lserial
4177 if {[gets $fd line] < 0} {
4183 # we only need to see one line and we don't really care what it says...
4186 if {$serial != $lserial} {
4190 if {$isdiff && ![commitinview $nullid $curview]} {
4191 # add the line for the local diff to the graph
4192 set hl [mc "Local uncommitted changes, not checked in to index"]
4193 set commitinfo($nullid) [list $hl {} {} {} {} " $hl\n"]
4194 set commitdata($nullid) "\n $hl\n"
4195 if {[commitinview $nullid2 $curview]} {
4200 insertfakerow $nullid $p
4201 } elseif {!$isdiff && [commitinview $nullid $curview]} {
4202 removefakerow $nullid
4207 proc nextuse {id row} {
4208 global curview children
4210 if {[info exists children($curview,$id)]} {
4211 foreach kid $children($curview,$id) {
4212 if {![commitinview $kid $curview]} {
4215 if {[rowofcommit $kid] > $row} {
4216 return [rowofcommit $kid]
4220 if {[commitinview $id $curview]} {
4221 return [rowofcommit $id]
4226 proc prevuse {id row} {
4227 global curview children
4230 if {[info exists children($curview,$id)]} {
4231 foreach kid $children($curview,$id) {
4232 if {![commitinview $kid $curview]} break
4233 if {[rowofcommit $kid] < $row} {
4234 set ret [rowofcommit $kid]
4241 proc make_idlist {row} {
4242 global displayorder parentlist uparrowlen downarrowlen mingaplen
4243 global commitidx curview children
4245 set r [expr {$row - $mingaplen - $downarrowlen - 1}]
4249 set ra [expr {$row - $downarrowlen}]
4253 set rb [expr {$row + $uparrowlen}]
4254 if {$rb > $commitidx($curview)} {
4255 set rb $commitidx($curview)
4257 make_disporder $r [expr {$rb + 1}]
4259 for {} {$r < $ra} {incr r} {
4260 set nextid [lindex $displayorder [expr {$r + 1}]]
4261 foreach p [lindex $parentlist $r] {
4262 if {$p eq $nextid} continue
4263 set rn [nextuse $p $r]
4265 $rn <= $r + $downarrowlen + $mingaplen + $uparrowlen} {
4266 lappend ids [list [ordertoken $p] $p]
4270 for {} {$r < $row} {incr r} {
4271 set nextid [lindex $displayorder [expr {$r + 1}]]
4272 foreach p [lindex $parentlist $r] {
4273 if {$p eq $nextid} continue
4274 set rn [nextuse $p $r]
4275 if {$rn < 0 || $rn >= $row} {
4276 lappend ids [list [ordertoken $p] $p]
4280 set id [lindex $displayorder $row]
4281 lappend ids [list [ordertoken $id] $id]
4283 foreach p [lindex $parentlist $r] {
4284 set firstkid [lindex $children($curview,$p) 0]
4285 if {[rowofcommit $firstkid] < $row} {
4286 lappend ids [list [ordertoken $p] $p]
4290 set id [lindex $displayorder $r]
4292 set firstkid [lindex $children($curview,$id) 0]
4293 if {$firstkid ne {} && [rowofcommit $firstkid] < $row} {
4294 lappend ids [list [ordertoken $id] $id]
4299 foreach idx [lsort -unique $ids] {
4300 lappend idlist [lindex $idx 1]
4305 proc rowsequal {a b} {
4306 while {[set i [lsearch -exact $a {}]] >= 0} {
4307 set a [lreplace $a $i $i]
4309 while {[set i [lsearch -exact $b {}]] >= 0} {
4310 set b [lreplace $b $i $i]
4312 return [expr {$a eq $b}]
4315 proc makeupline {id row rend col} {
4316 global rowidlist uparrowlen downarrowlen mingaplen
4318 for {set r $rend} {1} {set r $rstart} {
4319 set rstart [prevuse $id $r]
4320 if {$rstart < 0} return
4321 if {$rstart < $row} break
4323 if {$rstart + $uparrowlen + $mingaplen + $downarrowlen < $rend} {
4324 set rstart [expr {$rend - $uparrowlen - 1}]
4326 for {set r $rstart} {[incr r] <= $row} {} {
4327 set idlist [lindex $rowidlist $r]
4328 if {$idlist ne {} && [lsearch -exact $idlist $id] < 0} {
4329 set col [idcol $idlist $id $col]
4330 lset rowidlist $r [linsert $idlist $col $id]
4336 proc layoutrows {row endrow} {
4337 global rowidlist rowisopt rowfinal displayorder
4338 global uparrowlen downarrowlen maxwidth mingaplen
4339 global children parentlist
4340 global commitidx viewcomplete curview
4342 make_disporder [expr {$row - 1}] [expr {$endrow + $uparrowlen}]
4345 set rm1 [expr {$row - 1}]
4346 foreach id [lindex $rowidlist $rm1] {
4351 set final [lindex $rowfinal $rm1]
4353 for {} {$row < $endrow} {incr row} {
4354 set rm1 [expr {$row - 1}]
4355 if {$rm1 < 0 || $idlist eq {}} {
4356 set idlist [make_idlist $row]
4359 set id [lindex $displayorder $rm1]
4360 set col [lsearch -exact $idlist $id]
4361 set idlist [lreplace $idlist $col $col]
4362 foreach p [lindex $parentlist $rm1] {
4363 if {[lsearch -exact $idlist $p] < 0} {
4364 set col [idcol $idlist $p $col]
4365 set idlist [linsert $idlist $col $p]
4366 # if not the first child, we have to insert a line going up
4367 if {$id ne [lindex $children($curview,$p) 0]} {
4368 makeupline $p $rm1 $row $col
4372 set id [lindex $displayorder $row]
4373 if {$row > $downarrowlen} {
4374 set termrow [expr {$row - $downarrowlen - 1}]
4375 foreach p [lindex $parentlist $termrow] {
4376 set i [lsearch -exact $idlist $p]
4377 if {$i < 0} continue
4378 set nr [nextuse $p $termrow]
4379 if {$nr < 0 || $nr >= $row + $mingaplen + $uparrowlen} {
4380 set idlist [lreplace $idlist $i $i]
4384 set col [lsearch -exact $idlist $id]
4386 set col [idcol $idlist $id]
4387 set idlist [linsert $idlist $col $id]
4388 if {$children($curview,$id) ne {}} {
4389 makeupline $id $rm1 $row $col
4392 set r [expr {$row + $uparrowlen - 1}]
4393 if {$r < $commitidx($curview)} {
4395 foreach p [lindex $parentlist $r] {
4396 if {[lsearch -exact $idlist $p] >= 0} continue
4397 set fk [lindex $children($curview,$p) 0]
4398 if {[rowofcommit $fk] < $row} {
4399 set x [idcol $idlist $p $x]
4400 set idlist [linsert $idlist $x $p]
4403 if {[incr r] < $commitidx($curview)} {
4404 set p [lindex $displayorder $r]
4405 if {[lsearch -exact $idlist $p] < 0} {
4406 set fk [lindex $children($curview,$p) 0]
4407 if {$fk ne {} && [rowofcommit $fk] < $row} {
4408 set x [idcol $idlist $p $x]
4409 set idlist [linsert $idlist $x $p]
4415 if {$final && !$viewcomplete($curview) &&
4416 $row + $uparrowlen + $mingaplen + $downarrowlen
4417 >= $commitidx($curview)} {
4420 set l [llength $rowidlist]
4422 lappend rowidlist $idlist
4424 lappend rowfinal $final
4425 } elseif {$row < $l} {
4426 if {![rowsequal $idlist [lindex $rowidlist $row]]} {
4427 lset rowidlist $row $idlist
4430 lset rowfinal $row $final
4432 set pad [ntimes [expr {$row - $l}] {}]
4433 set rowidlist [concat $rowidlist $pad]
4434 lappend rowidlist $idlist
4435 set rowfinal [concat $rowfinal $pad]
4436 lappend rowfinal $final
4437 set rowisopt [concat $rowisopt [ntimes [expr {$row - $l + 1}] 0]]
4443 proc changedrow {row} {
4444 global displayorder iddrawn rowisopt need_redisplay
4446 set l [llength $rowisopt]
4448 lset rowisopt $row 0
4449 if {$row + 1 < $l} {
4450 lset rowisopt [expr {$row + 1}] 0
4451 if {$row + 2 < $l} {
4452 lset rowisopt [expr {$row + 2}] 0
4456 set id [lindex $displayorder $row]
4457 if {[info exists iddrawn($id)]} {
4458 set need_redisplay 1
4462 proc insert_pad {row col npad} {
4465 set pad [ntimes $npad {}]
4466 set idlist [lindex $rowidlist $row]
4467 set bef [lrange $idlist 0 [expr {$col - 1}]]
4468 set aft [lrange $idlist $col end]
4469 set i [lsearch -exact $aft {}]
4471 set aft [lreplace $aft $i $i]
4473 lset rowidlist $row [concat $bef $pad $aft]
4477 proc optimize_rows {row col endrow} {
4478 global rowidlist rowisopt displayorder curview children
4483 for {} {$row < $endrow} {incr row; set col 0} {
4484 if {[lindex $rowisopt $row]} continue
4486 set y0 [expr {$row - 1}]
4487 set ym [expr {$row - 2}]
4488 set idlist [lindex $rowidlist $row]
4489 set previdlist [lindex $rowidlist $y0]
4490 if {$idlist eq {} || $previdlist eq {}} continue
4492 set pprevidlist [lindex $rowidlist $ym]
4493 if {$pprevidlist eq {}} continue
4499 for {} {$col < [llength $idlist]} {incr col} {
4500 set id [lindex $idlist $col]
4501 if {[lindex $previdlist $col] eq $id} continue
4506 set x0 [lsearch -exact $previdlist $id]
4507 if {$x0 < 0} continue
4508 set z [expr {$x0 - $col}]
4512 set xm [lsearch -exact $pprevidlist $id]
4514 set z0 [expr {$xm - $x0}]
4518 # if row y0 is the first child of $id then it's not an arrow
4519 if {[lindex $children($curview,$id) 0] ne
4520 [lindex $displayorder $y0]} {
4524 if {!$isarrow && $id ne [lindex $displayorder $row] &&
4525 [lsearch -exact [lindex $rowidlist [expr {$row+1}]] $id] < 0} {
4528 # Looking at lines from this row to the previous row,
4529 # make them go straight up if they end in an arrow on
4530 # the previous row; otherwise make them go straight up
4532 if {$z < -1 || ($z < 0 && $isarrow)} {
4533 # Line currently goes left too much;
4534 # insert pads in the previous row, then optimize it
4535 set npad [expr {-1 - $z + $isarrow}]
4536 insert_pad $y0 $x0 $npad
4538 optimize_rows $y0 $x0 $row
4540 set previdlist [lindex $rowidlist $y0]
4541 set x0 [lsearch -exact $previdlist $id]
4542 set z [expr {$x0 - $col}]
4544 set pprevidlist [lindex $rowidlist $ym]
4545 set xm [lsearch -exact $pprevidlist $id]
4546 set z0 [expr {$xm - $x0}]
4548 } elseif {$z > 1 || ($z > 0 && $isarrow)} {
4549 # Line currently goes right too much;
4550 # insert pads in this line
4551 set npad [expr {$z - 1 + $isarrow}]
4552 insert_pad $row $col $npad
4553 set idlist [lindex $rowidlist $row]
4555 set z [expr {$x0 - $col}]
4558 if {$z0 eq {} && !$isarrow && $ym >= 0} {
4559 # this line links to its first child on row $row-2
4560 set id [lindex $displayorder $ym]
4561 set xc [lsearch -exact $pprevidlist $id]
4563 set z0 [expr {$xc - $x0}]
4566 # avoid lines jigging left then immediately right
4567 if {$z0 ne {} && $z < 0 && $z0 > 0} {
4568 insert_pad $y0 $x0 1
4570 optimize_rows $y0 $x0 $row
4571 set previdlist [lindex $rowidlist $y0]
4575 # Find the first column that doesn't have a line going right
4576 for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
4577 set id [lindex $idlist $col]
4578 if {$id eq {}} break
4579 set x0 [lsearch -exact $previdlist $id]
4581 # check if this is the link to the first child
4582 set kid [lindex $displayorder $y0]
4583 if {[lindex $children($curview,$id) 0] eq $kid} {
4584 # it is, work out offset to child
4585 set x0 [lsearch -exact $previdlist $kid]
4588 if {$x0 <= $col} break
4590 # Insert a pad at that column as long as it has a line and
4591 # isn't the last column
4592 if {$x0 >= 0 && [incr col] < [llength $idlist]} {
4593 set idlist [linsert $idlist $col {}]
4594 lset rowidlist $row $idlist
4602 global canvx0 linespc
4603 return [expr {$canvx0 + $col * $linespc}]
4607 global canvy0 linespc
4608 return [expr {$canvy0 + $row * $linespc}]
4611 proc linewidth {id} {
4612 global thickerline lthickness
4615 if {[info exists thickerline] && $id eq $thickerline} {
4616 set wid [expr {2 * $lthickness}]
4621 proc rowranges {id} {
4622 global curview children uparrowlen downarrowlen
4625 set kids $children($curview,$id)
4631 foreach child $kids {
4632 if {![commitinview $child $curview]} break
4633 set row [rowofcommit $child]
4634 if {![info exists prev]} {
4635 lappend ret [expr {$row + 1}]
4637 if {$row <= $prevrow} {
4638 puts "oops children of [shortids $id] out of order [shortids $child] $row <= [shortids $prev] $prevrow"
4640 # see if the line extends the whole way from prevrow to row
4641 if {$row > $prevrow + $uparrowlen + $downarrowlen &&
4642 [lsearch -exact [lindex $rowidlist \
4643 [expr {int(($row + $prevrow) / 2)}]] $id] < 0} {
4644 # it doesn't, see where it ends
4645 set r [expr {$prevrow + $downarrowlen}]
4646 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
4647 while {[incr r -1] > $prevrow &&
4648 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
4650 while {[incr r] <= $row &&
4651 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
4655 # see where it starts up again
4656 set r [expr {$row - $uparrowlen}]
4657 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
4658 while {[incr r] < $row &&
4659 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
4661 while {[incr r -1] >= $prevrow &&
4662 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
4668 if {$child eq $id} {
4677 proc drawlineseg {id row endrow arrowlow} {
4678 global rowidlist displayorder iddrawn linesegs
4679 global canv colormap linespc curview maxlinelen parentlist
4681 set cols [list [lsearch -exact [lindex $rowidlist $row] $id]]
4682 set le [expr {$row + 1}]
4685 set c [lsearch -exact [lindex $rowidlist $le] $id]
4691 set x [lindex $displayorder $le]
4696 if {[info exists iddrawn($x)] || $le == $endrow} {
4697 set c [lsearch -exact [lindex $rowidlist [expr {$le+1}]] $id]
4713 if {[info exists linesegs($id)]} {
4714 set lines $linesegs($id)
4716 set r0 [lindex $li 0]
4718 if {$r0 == $le && [lindex $li 1] - $row <= $maxlinelen} {
4728 set li [lindex $lines [expr {$i-1}]]
4729 set r1 [lindex $li 1]
4730 if {$r1 == $row && $le - [lindex $li 0] <= $maxlinelen} {
4735 set x [lindex $cols [expr {$le - $row}]]
4736 set xp [lindex $cols [expr {$le - 1 - $row}]]
4737 set dir [expr {$xp - $x}]
4739 set ith [lindex $lines $i 2]
4740 set coords [$canv coords $ith]
4741 set ah [$canv itemcget $ith -arrow]
4742 set arrowhigh [expr {$ah eq "first" || $ah eq "both"}]
4743 set x2 [lindex $cols [expr {$le + 1 - $row}]]
4744 if {$x2 ne {} && $x - $x2 == $dir} {
4745 set coords [lrange $coords 0 end-2]
4748 set coords [list [xc $le $x] [yc $le]]
4751 set itl [lindex $lines [expr {$i-1}] 2]
4752 set al [$canv itemcget $itl -arrow]
4753 set arrowlow [expr {$al eq "last" || $al eq "both"}]
4754 } elseif {$arrowlow} {
4755 if {[lsearch -exact [lindex $rowidlist [expr {$row-1}]] $id] >= 0 ||
4756 [lsearch -exact [lindex $parentlist [expr {$row-1}]] $id] >= 0} {
4760 set arrow [lindex {none first last both} [expr {$arrowhigh + 2*$arrowlow}]]
4761 for {set y $le} {[incr y -1] > $row} {} {
4763 set xp [lindex $cols [expr {$y - 1 - $row}]]
4764 set ndir [expr {$xp - $x}]
4765 if {$dir != $ndir || $xp < 0} {
4766 lappend coords [xc $y $x] [yc $y]
4772 # join parent line to first child
4773 set ch [lindex $displayorder $row]
4774 set xc [lsearch -exact [lindex $rowidlist $row] $ch]
4776 puts "oops: drawlineseg: child $ch not on row $row"
4777 } elseif {$xc != $x} {
4778 if {($arrowhigh && $le == $row + 1) || $dir == 0} {
4779 set d [expr {int(0.5 * $linespc)}]
4782 set x2 [expr {$x1 - $d}]
4784 set x2 [expr {$x1 + $d}]
4787 set y1 [expr {$y2 + $d}]
4788 lappend coords $x1 $y1 $x2 $y2
4789 } elseif {$xc < $x - 1} {
4790 lappend coords [xc $row [expr {$x-1}]] [yc $row]
4791 } elseif {$xc > $x + 1} {
4792 lappend coords [xc $row [expr {$x+1}]] [yc $row]
4796 lappend coords [xc $row $x] [yc $row]
4798 set xn [xc $row $xp]
4800 lappend coords $xn $yn
4804 set t [$canv create line $coords -width [linewidth $id] \
4805 -fill $colormap($id) -tags lines.$id -arrow $arrow]
4808 set lines [linsert $lines $i [list $row $le $t]]
4810 $canv coords $ith $coords
4811 if {$arrow ne $ah} {
4812 $canv itemconf $ith -arrow $arrow
4814 lset lines $i 0 $row
4817 set xo [lsearch -exact [lindex $rowidlist [expr {$row - 1}]] $id]
4818 set ndir [expr {$xo - $xp}]
4819 set clow [$canv coords $itl]
4820 if {$dir == $ndir} {
4821 set clow [lrange $clow 2 end]
4823 set coords [concat $coords $clow]
4825 lset lines [expr {$i-1}] 1 $le
4827 # coalesce two pieces
4829 set b [lindex $lines [expr {$i-1}] 0]
4830 set e [lindex $lines $i 1]
4831 set lines [lreplace $lines [expr {$i-1}] $i [list $b $e $itl]]
4833 $canv coords $itl $coords
4834 if {$arrow ne $al} {
4835 $canv itemconf $itl -arrow $arrow
4839 set linesegs($id) $lines
4843 proc drawparentlinks {id row} {
4844 global rowidlist canv colormap curview parentlist
4845 global idpos linespc
4847 set rowids [lindex $rowidlist $row]
4848 set col [lsearch -exact $rowids $id]
4849 if {$col < 0} return
4850 set olds [lindex $parentlist $row]
4851 set row2 [expr {$row + 1}]
4852 set x [xc $row $col]
4855 set d [expr {int(0.5 * $linespc)}]
4856 set ymid [expr {$y + $d}]
4857 set ids [lindex $rowidlist $row2]
4858 # rmx = right-most X coord used
4861 set i [lsearch -exact $ids $p]
4863 puts "oops, parent $p of $id not in list"
4866 set x2 [xc $row2 $i]
4870 set j [lsearch -exact $rowids $p]
4872 # drawlineseg will do this one for us
4876 # should handle duplicated parents here...
4877 set coords [list $x $y]
4879 # if attaching to a vertical segment, draw a smaller
4880 # slant for visual distinctness
4883 lappend coords [expr {$x2 + $d}] $y $x2 $ymid
4885 lappend coords [expr {$x2 - $d}] $y $x2 $ymid
4887 } elseif {$i < $col && $i < $j} {
4888 # segment slants towards us already
4889 lappend coords [xc $row $j] $y
4891 if {$i < $col - 1} {
4892 lappend coords [expr {$x2 + $linespc}] $y
4893 } elseif {$i > $col + 1} {
4894 lappend coords [expr {$x2 - $linespc}] $y
4896 lappend coords $x2 $y2
4899 lappend coords $x2 $y2
4901 set t [$canv create line $coords -width [linewidth $p] \
4902 -fill $colormap($p) -tags lines.$p]
4906 if {$rmx > [lindex $idpos($id) 1]} {
4907 lset idpos($id) 1 $rmx
4912 proc drawlines {id} {
4915 $canv itemconf lines.$id -width [linewidth $id]
4918 proc drawcmittext {id row col} {
4919 global linespc canv canv2 canv3 fgcolor curview
4920 global cmitlisted commitinfo rowidlist parentlist
4921 global rowtextx idpos idtags idheads idotherrefs
4922 global linehtag linentag linedtag selectedline
4923 global canvxmax boldrows boldnamerows fgcolor
4924 global mainheadid nullid nullid2 circleitem circlecolors ctxbut
4926 # listed is 0 for boundary, 1 for normal, 2 for negative, 3 for left, 4 for right
4927 set listed $cmitlisted($curview,$id)
4928 if {$id eq $nullid} {
4930 } elseif {$id eq $nullid2} {
4932 } elseif {$id eq $mainheadid} {
4935 set ofill [lindex $circlecolors $listed]
4937 set x [xc $row $col]
4939 set orad [expr {$linespc / 3}]
4941 set t [$canv create oval [expr {$x - $orad}] [expr {$y - $orad}] \
4942 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
4943 -fill $ofill -outline $fgcolor -width 1 -tags circle]
4944 } elseif {$listed == 3} {
4945 # triangle pointing left for left-side commits
4946 set t [$canv create polygon \
4947 [expr {$x - $orad}] $y \
4948 [expr {$x + $orad - 1}] [expr {$y - $orad}] \
4949 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
4950 -fill $ofill -outline $fgcolor -width 1 -tags circle]
4952 # triangle pointing right for right-side commits
4953 set t [$canv create polygon \
4954 [expr {$x + $orad - 1}] $y \
4955 [expr {$x - $orad}] [expr {$y - $orad}] \
4956 [expr {$x - $orad}] [expr {$y + $orad - 1}] \
4957 -fill $ofill -outline $fgcolor -width 1 -tags circle]
4959 set circleitem($row) $t
4961 $canv bind $t <1> {selcanvline {} %x %y}
4962 set rmx [llength [lindex $rowidlist $row]]
4963 set olds [lindex $parentlist $row]
4965 set nextids [lindex $rowidlist [expr {$row + 1}]]
4967 set i [lsearch -exact $nextids $p]
4973 set xt [xc $row $rmx]
4974 set rowtextx($row) $xt
4975 set idpos($id) [list $x $xt $y]
4976 if {[info exists idtags($id)] || [info exists idheads($id)]
4977 || [info exists idotherrefs($id)]} {
4978 set xt [drawtags $id $x $xt $y]
4980 set headline [lindex $commitinfo($id) 0]
4981 set name [lindex $commitinfo($id) 1]
4982 set date [lindex $commitinfo($id) 2]
4983 set date [formatdate $date]
4986 set isbold [ishighlighted $id]
4988 lappend boldrows $row
4989 set font mainfontbold
4991 lappend boldnamerows $row
4992 set nfont mainfontbold
4995 set linehtag($row) [$canv create text $xt $y -anchor w -fill $fgcolor \
4996 -text $headline -font $font -tags text]
4997 $canv bind $linehtag($row) $ctxbut "rowmenu %X %Y $id"
4998 set linentag($row) [$canv2 create text 3 $y -anchor w -fill $fgcolor \
4999 -text $name -font $nfont -tags text]
5000 set linedtag($row) [$canv3 create text 3 $y -anchor w -fill $fgcolor \
5001 -text $date -font mainfont -tags text]
5002 if {$selectedline == $row} {
5005 set xr [expr {$xt + [font measure $font $headline]}]
5006 if {$xr > $canvxmax} {
5012 proc drawcmitrow {row} {
5013 global displayorder rowidlist nrows_drawn
5014 global iddrawn markingmatches
5015 global commitinfo numcommits
5016 global filehighlight fhighlights findpattern nhighlights
5017 global hlview vhighlights
5018 global highlight_related rhighlights
5020 if {$row >= $numcommits} return
5022 set id [lindex $displayorder $row]
5023 if {[info exists hlview] && ![info exists vhighlights($id)]} {
5024 askvhighlight $row $id
5026 if {[info exists filehighlight] && ![info exists fhighlights($id)]} {
5027 askfilehighlight $row $id
5029 if {$findpattern ne {} && ![info exists nhighlights($id)]} {
5030 askfindhighlight $row $id
5032 if {$highlight_related ne [mc "None"] && ![info exists rhighlights($id)]} {
5033 askrelhighlight $row $id
5035 if {![info exists iddrawn($id)]} {
5036 set col [lsearch -exact [lindex $rowidlist $row] $id]
5038 puts "oops, row $row id $id not in list"
5041 if {![info exists commitinfo($id)]} {
5045 drawcmittext $id $row $col
5049 if {$markingmatches} {
5050 markrowmatches $row $id
5054 proc drawcommits {row {endrow {}}} {
5055 global numcommits iddrawn displayorder curview need_redisplay
5056 global parentlist rowidlist rowfinal uparrowlen downarrowlen nrows_drawn
5061 if {$endrow eq {}} {
5064 if {$endrow >= $numcommits} {
5065 set endrow [expr {$numcommits - 1}]
5068 set rl1 [expr {$row - $downarrowlen - 3}]
5072 set ro1 [expr {$row - 3}]
5076 set r2 [expr {$endrow + $uparrowlen + 3}]
5077 if {$r2 > $numcommits} {
5080 for {set r $rl1} {$r < $r2} {incr r} {
5081 if {[lindex $rowidlist $r] ne {} && [lindex $rowfinal $r]} {
5085 set rl1 [expr {$r + 1}]
5091 optimize_rows $ro1 0 $r2
5092 if {$need_redisplay || $nrows_drawn > 2000} {
5097 # make the lines join to already-drawn rows either side
5098 set r [expr {$row - 1}]
5099 if {$r < 0 || ![info exists iddrawn([lindex $displayorder $r])]} {
5102 set er [expr {$endrow + 1}]
5103 if {$er >= $numcommits ||
5104 ![info exists iddrawn([lindex $displayorder $er])]} {
5107 for {} {$r <= $er} {incr r} {
5108 set id [lindex $displayorder $r]
5109 set wasdrawn [info exists iddrawn($id)]
5111 if {$r == $er} break
5112 set nextid [lindex $displayorder [expr {$r + 1}]]
5113 if {$wasdrawn && [info exists iddrawn($nextid)]} continue
5114 drawparentlinks $id $r
5116 set rowids [lindex $rowidlist $r]
5117 foreach lid $rowids {
5118 if {$lid eq {}} continue
5119 if {[info exists lineend($lid)] && $lineend($lid) > $r} continue
5121 # see if this is the first child of any of its parents
5122 foreach p [lindex $parentlist $r] {
5123 if {[lsearch -exact $rowids $p] < 0} {
5124 # make this line extend up to the child
5125 set lineend($p) [drawlineseg $p $r $er 0]
5129 set lineend($lid) [drawlineseg $lid $r $er 1]
5135 proc undolayout {row} {
5136 global uparrowlen mingaplen downarrowlen
5137 global rowidlist rowisopt rowfinal need_redisplay
5139 set r [expr {$row - ($uparrowlen + $mingaplen + $downarrowlen)}]
5143 if {[llength $rowidlist] > $r} {
5145 set rowidlist [lrange $rowidlist 0 $r]
5146 set rowfinal [lrange $rowfinal 0 $r]
5147 set rowisopt [lrange $rowisopt 0 $r]
5148 set need_redisplay 1
5153 proc drawvisible {} {
5154 global canv linespc curview vrowmod selectedline targetrow targetid
5155 global need_redisplay cscroll numcommits
5157 set fs [$canv yview]
5158 set ymax [lindex [$canv cget -scrollregion] 3]
5159 if {$ymax eq {} || $ymax == 0 || $numcommits == 0} return
5160 set f0 [lindex $fs 0]
5161 set f1 [lindex $fs 1]
5162 set y0 [expr {int($f0 * $ymax)}]
5163 set y1 [expr {int($f1 * $ymax)}]
5165 if {[info exists targetid]} {
5166 if {[commitinview $targetid $curview]} {
5167 set r [rowofcommit $targetid]
5168 if {$r != $targetrow} {
5169 # Fix up the scrollregion and change the scrolling position
5170 # now that our target row has moved.
5171 set diff [expr {($r - $targetrow) * $linespc}]
5174 set ymax [lindex [$canv cget -scrollregion] 3]
5177 set f0 [expr {$y0 / $ymax}]
5178 set f1 [expr {$y1 / $ymax}]
5179 allcanvs yview moveto $f0
5180 $cscroll set $f0 $f1
5181 set need_redisplay 1
5188 set row [expr {int(($y0 - 3) / $linespc) - 1}]
5189 set endrow [expr {int(($y1 - 3) / $linespc) + 1}]
5190 if {$endrow >= $vrowmod($curview)} {
5191 update_arcrows $curview
5193 if {$selectedline ne {} &&
5194 $row <= $selectedline && $selectedline <= $endrow} {
5195 set targetrow $selectedline
5196 } elseif {[info exists targetid]} {
5197 set targetrow [expr {int(($row + $endrow) / 2)}]
5199 if {[info exists targetrow]} {
5200 if {$targetrow >= $numcommits} {
5201 set targetrow [expr {$numcommits - 1}]
5203 set targetid [commitonrow $targetrow]
5205 drawcommits $row $endrow
5208 proc clear_display {} {
5209 global iddrawn linesegs need_redisplay nrows_drawn
5210 global vhighlights fhighlights nhighlights rhighlights
5211 global linehtag linentag linedtag boldrows boldnamerows
5214 catch {unset iddrawn}
5215 catch {unset linesegs}
5216 catch {unset linehtag}
5217 catch {unset linentag}
5218 catch {unset linedtag}
5221 catch {unset vhighlights}
5222 catch {unset fhighlights}
5223 catch {unset nhighlights}
5224 catch {unset rhighlights}
5225 set need_redisplay 0
5229 proc findcrossings {id} {
5230 global rowidlist parentlist numcommits displayorder
5234 foreach {s e} [rowranges $id] {
5235 if {$e >= $numcommits} {
5236 set e [expr {$numcommits - 1}]
5238 if {$e <= $s} continue
5239 for {set row $e} {[incr row -1] >= $s} {} {
5240 set x [lsearch -exact [lindex $rowidlist $row] $id]
5242 set olds [lindex $parentlist $row]
5243 set kid [lindex $displayorder $row]
5244 set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
5245 if {$kidx < 0} continue
5246 set nextrow [lindex $rowidlist [expr {$row + 1}]]
5248 set px [lsearch -exact $nextrow $p]
5249 if {$px < 0} continue
5250 if {($kidx < $x && $x < $px) || ($px < $x && $x < $kidx)} {
5251 if {[lsearch -exact $ccross $p] >= 0} continue
5252 if {$x == $px + ($kidx < $px? -1: 1)} {
5254 } elseif {[lsearch -exact $cross $p] < 0} {
5261 return [concat $ccross {{}} $cross]
5264 proc assigncolor {id} {
5265 global colormap colors nextcolor
5266 global parents children children curview
5268 if {[info exists colormap($id)]} return
5269 set ncolors [llength $colors]
5270 if {[info exists children($curview,$id)]} {
5271 set kids $children($curview,$id)
5275 if {[llength $kids] == 1} {
5276 set child [lindex $kids 0]
5277 if {[info exists colormap($child)]
5278 && [llength $parents($curview,$child)] == 1} {
5279 set colormap($id) $colormap($child)
5285 foreach x [findcrossings $id] {
5287 # delimiter between corner crossings and other crossings
5288 if {[llength $badcolors] >= $ncolors - 1} break
5289 set origbad $badcolors
5291 if {[info exists colormap($x)]
5292 && [lsearch -exact $badcolors $colormap($x)] < 0} {
5293 lappend badcolors $colormap($x)
5296 if {[llength $badcolors] >= $ncolors} {
5297 set badcolors $origbad
5299 set origbad $badcolors
5300 if {[llength $badcolors] < $ncolors - 1} {
5301 foreach child $kids {
5302 if {[info exists colormap($child)]
5303 && [lsearch -exact $badcolors $colormap($child)] < 0} {
5304 lappend badcolors $colormap($child)
5306 foreach p $parents($curview,$child) {
5307 if {[info exists colormap($p)]
5308 && [lsearch -exact $badcolors $colormap($p)] < 0} {
5309 lappend badcolors $colormap($p)
5313 if {[llength $badcolors] >= $ncolors} {
5314 set badcolors $origbad
5317 for {set i 0} {$i <= $ncolors} {incr i} {
5318 set c [lindex $colors $nextcolor]
5319 if {[incr nextcolor] >= $ncolors} {
5322 if {[lsearch -exact $badcolors $c]} break
5324 set colormap($id) $c
5327 proc bindline {t id} {
5330 $canv bind $t <Enter> "lineenter %x %y $id"
5331 $canv bind $t <Motion> "linemotion %x %y $id"
5332 $canv bind $t <Leave> "lineleave $id"
5333 $canv bind $t <Button-1> "lineclick %x %y $id 1"
5336 proc drawtags {id x xt y1} {
5337 global idtags idheads idotherrefs mainhead
5338 global linespc lthickness
5339 global canv rowtextx curview fgcolor bgcolor ctxbut
5344 if {[info exists idtags($id)]} {
5345 set marks $idtags($id)
5346 set ntags [llength $marks]
5348 if {[info exists idheads($id)]} {
5349 set marks [concat $marks $idheads($id)]
5350 set nheads [llength $idheads($id)]
5352 if {[info exists idotherrefs($id)]} {
5353 set marks [concat $marks $idotherrefs($id)]
5359 set delta [expr {int(0.5 * ($linespc - $lthickness))}]
5360 set yt [expr {$y1 - 0.5 * $linespc}]
5361 set yb [expr {$yt + $linespc - 1}]
5365 foreach tag $marks {
5367 if {$i >= $ntags && $i < $ntags + $nheads && $tag eq $mainhead} {
5368 set wid [font measure mainfontbold $tag]
5370 set wid [font measure mainfont $tag]
5374 set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
5376 set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
5377 -width $lthickness -fill black -tags tag.$id]
5379 foreach tag $marks x $xvals wid $wvals {
5380 set xl [expr {$x + $delta}]
5381 set xr [expr {$x + $delta + $wid + $lthickness}]
5383 if {[incr ntags -1] >= 0} {
5385 set t [$canv create polygon $x [expr {$yt + $delta}] $xl $yt \
5386 $xr $yt $xr $yb $xl $yb $x [expr {$yb - $delta}] \
5387 -width 1 -outline black -fill yellow -tags tag.$id]
5388 $canv bind $t <1> [list showtag $tag 1]
5389 set rowtextx([rowofcommit $id]) [expr {$xr + $linespc}]
5391 # draw a head or other ref
5392 if {[incr nheads -1] >= 0} {
5394 if {$tag eq $mainhead} {
5395 set font mainfontbold
5400 set xl [expr {$xl - $delta/2}]
5401 $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
5402 -width 1 -outline black -fill $col -tags tag.$id
5403 if {[regexp {^(remotes/.*/|remotes/)} $tag match remoteprefix]} {
5404 set rwid [font measure mainfont $remoteprefix]
5405 set xi [expr {$x + 1}]
5406 set yti [expr {$yt + 1}]
5407 set xri [expr {$x + $rwid}]
5408 $canv create polygon $xi $yti $xri $yti $xri $yb $xi $yb \
5409 -width 0 -fill "#ffddaa" -tags tag.$id
5412 set t [$canv create text $xl $y1 -anchor w -text $tag -fill $fgcolor \
5413 -font $font -tags [list tag.$id text]]
5415 $canv bind $t <1> [list showtag $tag 1]
5416 } elseif {$nheads >= 0} {
5417 $canv bind $t $ctxbut [list headmenu %X %Y $id $tag]
5423 proc xcoord {i level ln} {
5424 global canvx0 xspc1 xspc2
5426 set x [expr {$canvx0 + $i * $xspc1($ln)}]
5427 if {$i > 0 && $i == $level} {
5428 set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
5429 } elseif {$i > $level} {
5430 set x [expr {$x + $xspc2 - $xspc1($ln)}]
5435 proc show_status {msg} {
5439 $canv create text 3 3 -anchor nw -text $msg -font mainfont \
5440 -tags text -fill $fgcolor
5443 # Don't change the text pane cursor if it is currently the hand cursor,
5444 # showing that we are over a sha1 ID link.
5445 proc settextcursor {c} {
5446 global ctext curtextcursor
5448 if {[$ctext cget -cursor] == $curtextcursor} {
5449 $ctext config -cursor $c
5451 set curtextcursor $c
5454 proc nowbusy {what {name {}}} {
5455 global isbusy busyname statusw
5457 if {[array names isbusy] eq {}} {
5458 . config -cursor watch
5462 set busyname($what) $name
5464 $statusw conf -text $name
5468 proc notbusy {what} {
5469 global isbusy maincursor textcursor busyname statusw
5473 if {$busyname($what) ne {} &&
5474 [$statusw cget -text] eq $busyname($what)} {
5475 $statusw conf -text {}
5478 if {[array names isbusy] eq {}} {
5479 . config -cursor $maincursor
5480 settextcursor $textcursor
5484 proc findmatches {f} {
5485 global findtype findstring
5486 if {$findtype == [mc "Regexp"]} {
5487 set matches [regexp -indices -all -inline $findstring $f]
5490 if {$findtype == [mc "IgnCase"]} {
5491 set f [string tolower $f]
5492 set fs [string tolower $fs]
5496 set l [string length $fs]
5497 while {[set j [string first $fs $f $i]] >= 0} {
5498 lappend matches [list $j [expr {$j+$l-1}]]
5499 set i [expr {$j + $l}]
5505 proc dofind {{dirn 1} {wrap 1}} {
5506 global findstring findstartline findcurline selectedline numcommits
5507 global gdttype filehighlight fh_serial find_dirn findallowwrap
5509 if {[info exists find_dirn]} {
5510 if {$find_dirn == $dirn} return
5514 if {$findstring eq {} || $numcommits == 0} return
5515 if {$selectedline eq {}} {
5516 set findstartline [lindex [visiblerows] [expr {$dirn < 0}]]
5518 set findstartline $selectedline
5520 set findcurline $findstartline
5521 nowbusy finding [mc "Searching"]
5522 if {$gdttype ne [mc "containing:"] && ![info exists filehighlight]} {
5523 after cancel do_file_hl $fh_serial
5524 do_file_hl $fh_serial
5527 set findallowwrap $wrap
5531 proc stopfinding {} {
5532 global find_dirn findcurline fprogcoord
5534 if {[info exists find_dirn]} {
5544 global commitdata commitinfo numcommits findpattern findloc
5545 global findstartline findcurline findallowwrap
5546 global find_dirn gdttype fhighlights fprogcoord
5547 global curview varcorder vrownum varccommits vrowmod
5549 if {![info exists find_dirn]} {
5552 set fldtypes [list [mc "Headline"] [mc "Author"] [mc "Date"] [mc "Committer"] [mc "CDate"] [mc "Comments"]]
5555 if {$find_dirn > 0} {
5557 if {$l >= $numcommits} {
5560 if {$l <= $findstartline} {
5561 set lim [expr {$findstartline + 1}]
5564 set moretodo $findallowwrap
5571 if {$l >= $findstartline} {
5572 set lim [expr {$findstartline - 1}]
5575 set moretodo $findallowwrap
5578 set n [expr {($lim - $l) * $find_dirn}]
5583 if {$l + ($find_dirn > 0? $n: 1) > $vrowmod($curview)} {
5584 update_arcrows $curview
5588 set ai [bsearch $vrownum($curview) $l]
5589 set a [lindex $varcorder($curview) $ai]
5590 set arow [lindex $vrownum($curview) $ai]
5591 set ids [lindex $varccommits($curview,$a)]
5592 set arowend [expr {$arow + [llength $ids]}]
5593 if {$gdttype eq [mc "containing:"]} {
5594 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
5595 if {$l < $arow || $l >= $arowend} {
5597 set a [lindex $varcorder($curview) $ai]
5598 set arow [lindex $vrownum($curview) $ai]
5599 set ids [lindex $varccommits($curview,$a)]
5600 set arowend [expr {$arow + [llength $ids]}]
5602 set id [lindex $ids [expr {$l - $arow}]]
5603 # shouldn't happen unless git log doesn't give all the commits...
5604 if {![info exists commitdata($id)] ||
5605 ![doesmatch $commitdata($id)]} {
5608 if {![info exists commitinfo($id)]} {
5611 set info $commitinfo($id)
5612 foreach f $info ty $fldtypes {
5613 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
5622 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
5623 if {$l < $arow || $l >= $arowend} {
5625 set a [lindex $varcorder($curview) $ai]
5626 set arow [lindex $vrownum($curview) $ai]
5627 set ids [lindex $varccommits($curview,$a)]
5628 set arowend [expr {$arow + [llength $ids]}]
5630 set id [lindex $ids [expr {$l - $arow}]]
5631 if {![info exists fhighlights($id)]} {
5632 # this sets fhighlights($id) to -1
5633 askfilehighlight $l $id
5635 if {$fhighlights($id) > 0} {
5639 if {$fhighlights($id) < 0} {
5642 set findcurline [expr {$l - $find_dirn}]
5647 if {$found || ($domore && !$moretodo)} {
5663 set findcurline [expr {$l - $find_dirn}]
5665 set n [expr {($findcurline - $findstartline) * $find_dirn - 1}]
5669 set fprogcoord [expr {$n * 1.0 / $numcommits}]
5674 proc findselectline {l} {
5675 global findloc commentend ctext findcurline markingmatches gdttype
5677 set markingmatches 1
5680 if {$findloc == [mc "All fields"] || $findloc == [mc "Comments"]} {
5681 # highlight the matches in the comments
5682 set f [$ctext get 1.0 $commentend]
5683 set matches [findmatches $f]
5684 foreach match $matches {
5685 set start [lindex $match 0]
5686 set end [expr {[lindex $match 1] + 1}]
5687 $ctext tag add found "1.0 + $start c" "1.0 + $end c"
5693 # mark the bits of a headline or author that match a find string
5694 proc markmatches {canv l str tag matches font row} {
5697 set bbox [$canv bbox $tag]
5698 set x0 [lindex $bbox 0]
5699 set y0 [lindex $bbox 1]
5700 set y1 [lindex $bbox 3]
5701 foreach match $matches {
5702 set start [lindex $match 0]
5703 set end [lindex $match 1]
5704 if {$start > $end} continue
5705 set xoff [font measure $font [string range $str 0 [expr {$start-1}]]]
5706 set xlen [font measure $font [string range $str 0 [expr {$end}]]]
5707 set t [$canv create rect [expr {$x0+$xoff}] $y0 \
5708 [expr {$x0+$xlen+2}] $y1 \
5709 -outline {} -tags [list match$l matches] -fill yellow]
5711 if {$row == $selectedline} {
5712 $canv raise $t secsel
5717 proc unmarkmatches {} {
5718 global markingmatches
5720 allcanvs delete matches
5721 set markingmatches 0
5725 proc selcanvline {w x y} {
5726 global canv canvy0 ctext linespc
5728 set ymax [lindex [$canv cget -scrollregion] 3]
5729 if {$ymax == {}} return
5730 set yfrac [lindex [$canv yview] 0]
5731 set y [expr {$y + $yfrac * $ymax}]
5732 set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
5737 set xmax [lindex [$canv cget -scrollregion] 2]
5738 set xleft [expr {[lindex [$canv xview] 0] * $xmax}]
5739 if {![info exists rowtextx($l)] || $xleft + $x < $rowtextx($l)} return
5745 proc commit_descriptor {p} {
5747 if {![info exists commitinfo($p)]} {
5751 if {[llength $commitinfo($p)] > 1} {
5752 set l [lindex $commitinfo($p) 0]
5757 # append some text to the ctext widget, and make any SHA1 ID
5758 # that we know about be a clickable link.
5759 proc appendwithlinks {text tags} {
5760 global ctext linknum curview pendinglinks
5762 set start [$ctext index "end - 1c"]
5763 $ctext insert end $text $tags
5764 set links [regexp -indices -all -inline {[0-9a-f]{40}} $text]
5768 set linkid [string range $text $s $e]
5770 $ctext tag delete link$linknum
5771 $ctext tag add link$linknum "$start + $s c" "$start + $e c"
5772 setlink $linkid link$linknum
5777 proc setlink {id lk} {
5778 global curview ctext pendinglinks commitinterest
5780 if {[commitinview $id $curview]} {
5781 $ctext tag conf $lk -foreground blue -underline 1
5782 $ctext tag bind $lk <1> [list selectline [rowofcommit $id] 1]
5783 $ctext tag bind $lk <Enter> {linkcursor %W 1}
5784 $ctext tag bind $lk <Leave> {linkcursor %W -1}
5786 lappend pendinglinks($id) $lk
5787 lappend commitinterest($id) {makelink %I}
5791 proc makelink {id} {
5794 if {![info exists pendinglinks($id)]} return
5795 foreach lk $pendinglinks($id) {
5798 unset pendinglinks($id)
5801 proc linkcursor {w inc} {
5802 global linkentercount curtextcursor
5804 if {[incr linkentercount $inc] > 0} {
5805 $w configure -cursor hand2
5807 $w configure -cursor $curtextcursor
5808 if {$linkentercount < 0} {
5809 set linkentercount 0
5814 proc viewnextline {dir} {
5818 set ymax [lindex [$canv cget -scrollregion] 3]
5819 set wnow [$canv yview]
5820 set wtop [expr {[lindex $wnow 0] * $ymax}]
5821 set newtop [expr {$wtop + $dir * $linespc}]
5824 } elseif {$newtop > $ymax} {
5827 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
5830 # add a list of tag or branch names at position pos
5831 # returns the number of names inserted
5832 proc appendrefs {pos ids var} {
5833 global ctext linknum curview $var maxrefs
5835 if {[catch {$ctext index $pos}]} {
5838 $ctext conf -state normal
5839 $ctext delete $pos "$pos lineend"
5842 foreach tag [set $var\($id\)] {
5843 lappend tags [list $tag $id]
5846 if {[llength $tags] > $maxrefs} {
5847 $ctext insert $pos "many ([llength $tags])"
5849 set tags [lsort -index 0 -decreasing $tags]
5852 set id [lindex $ti 1]
5855 $ctext tag delete $lk
5856 $ctext insert $pos $sep
5857 $ctext insert $pos [lindex $ti 0] $lk
5862 $ctext conf -state disabled
5863 return [llength $tags]
5866 # called when we have finished computing the nearby tags
5867 proc dispneartags {delay} {
5868 global selectedline currentid showneartags tagphase
5870 if {$selectedline eq {} || !$showneartags} return
5871 after cancel dispnexttag
5873 after 200 dispnexttag
5876 after idle dispnexttag
5881 proc dispnexttag {} {
5882 global selectedline currentid showneartags tagphase ctext
5884 if {$selectedline eq {} || !$showneartags} return
5885 switch -- $tagphase {
5887 set dtags [desctags $currentid]
5889 appendrefs precedes $dtags idtags
5893 set atags [anctags $currentid]
5895 appendrefs follows $atags idtags
5899 set dheads [descheads $currentid]
5900 if {$dheads ne {}} {
5901 if {[appendrefs branch $dheads idheads] > 1
5902 && [$ctext get "branch -3c"] eq "h"} {
5903 # turn "Branch" into "Branches"
5904 $ctext conf -state normal
5905 $ctext insert "branch -2c" "es"
5906 $ctext conf -state disabled
5911 if {[incr tagphase] <= 2} {
5912 after idle dispnexttag
5916 proc make_secsel {l} {
5917 global linehtag linentag linedtag canv canv2 canv3
5919 if {![info exists linehtag($l)]} return
5921 set t [eval $canv create rect [$canv bbox $linehtag($l)] -outline {{}} \
5922 -tags secsel -fill [$canv cget -selectbackground]]
5924 $canv2 delete secsel
5925 set t [eval $canv2 create rect [$canv2 bbox $linentag($l)] -outline {{}} \
5926 -tags secsel -fill [$canv2 cget -selectbackground]]
5928 $canv3 delete secsel
5929 set t [eval $canv3 create rect [$canv3 bbox $linedtag($l)] -outline {{}} \
5930 -tags secsel -fill [$canv3 cget -selectbackground]]
5934 proc selectline {l isnew} {
5935 global canv ctext commitinfo selectedline
5936 global canvy0 linespc parents children curview
5937 global currentid sha1entry
5938 global commentend idtags linknum
5939 global mergemax numcommits pending_select
5940 global cmitmode showneartags allcommits
5941 global targetrow targetid lastscrollrows
5944 catch {unset pending_select}
5949 if {$l < 0 || $l >= $numcommits} return
5950 set id [commitonrow $l]
5955 if {$lastscrollrows < $numcommits} {
5959 set y [expr {$canvy0 + $l * $linespc}]
5960 set ymax [lindex [$canv cget -scrollregion] 3]
5961 set ytop [expr {$y - $linespc - 1}]
5962 set ybot [expr {$y + $linespc + 1}]
5963 set wnow [$canv yview]
5964 set wtop [expr {[lindex $wnow 0] * $ymax}]
5965 set wbot [expr {[lindex $wnow 1] * $ymax}]
5966 set wh [expr {$wbot - $wtop}]
5968 if {$ytop < $wtop} {
5969 if {$ybot < $wtop} {
5970 set newtop [expr {$y - $wh / 2.0}]
5973 if {$newtop > $wtop - $linespc} {
5974 set newtop [expr {$wtop - $linespc}]
5977 } elseif {$ybot > $wbot} {
5978 if {$ytop > $wbot} {
5979 set newtop [expr {$y - $wh / 2.0}]
5981 set newtop [expr {$ybot - $wh}]
5982 if {$newtop < $wtop + $linespc} {
5983 set newtop [expr {$wtop + $linespc}]
5987 if {$newtop != $wtop} {
5991 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
5998 addtohistory [list selbyid $id]
6001 $sha1entry delete 0 end
6002 $sha1entry insert 0 $id
6004 $sha1entry selection from 0
6005 $sha1entry selection to end
6009 $ctext conf -state normal
6012 if {![info exists commitinfo($id)]} {
6015 set info $commitinfo($id)
6016 set date [formatdate [lindex $info 2]]
6017 $ctext insert end "[mc "Author"]: [lindex $info 1] $date\n"
6018 set date [formatdate [lindex $info 4]]
6019 $ctext insert end "[mc "Committer"]: [lindex $info 3] $date\n"
6020 if {[info exists idtags($id)]} {
6021 $ctext insert end [mc "Tags:"]
6022 foreach tag $idtags($id) {
6023 $ctext insert end " $tag"
6025 $ctext insert end "\n"
6029 set olds $parents($curview,$id)
6030 if {[llength $olds] > 1} {
6033 if {$np >= $mergemax} {
6038 $ctext insert end "[mc "Parent"]: " $tag
6039 appendwithlinks [commit_descriptor $p] {}
6044 append headers "[mc "Parent"]: [commit_descriptor $p]"
6048 foreach c $children($curview,$id) {
6049 append headers "[mc "Child"]: [commit_descriptor $c]"
6052 # make anything that looks like a SHA1 ID be a clickable link
6053 appendwithlinks $headers {}
6054 if {$showneartags} {
6055 if {![info exists allcommits]} {
6058 $ctext insert end "[mc "Branch"]: "
6059 $ctext mark set branch "end -1c"
6060 $ctext mark gravity branch left
6061 $ctext insert end "\n[mc "Follows"]: "
6062 $ctext mark set follows "end -1c"
6063 $ctext mark gravity follows left
6064 $ctext insert end "\n[mc "Precedes"]: "
6065 $ctext mark set precedes "end -1c"
6066 $ctext mark gravity precedes left
6067 $ctext insert end "\n"
6070 $ctext insert end "\n"
6071 set comment [lindex $info 5]
6072 if {[string first "\r" $comment] >= 0} {
6073 set comment [string map {"\r" "\n "} $comment]
6075 appendwithlinks $comment {comment}
6077 $ctext tag remove found 1.0 end
6078 $ctext conf -state disabled
6079 set commentend [$ctext index "end - 1c"]
6081 init_flist [mc "Comments"]
6082 if {$cmitmode eq "tree"} {
6084 } elseif {[llength $olds] <= 1} {
6091 proc selfirstline {} {
6096 proc sellastline {} {
6099 set l [expr {$numcommits - 1}]
6103 proc selnextline {dir} {
6106 if {$selectedline eq {}} return
6107 set l [expr {$selectedline + $dir}]
6112 proc selnextpage {dir} {
6113 global canv linespc selectedline numcommits
6115 set lpp [expr {([winfo height $canv] - 2) / $linespc}]
6119 allcanvs yview scroll [expr {$dir * $lpp}] units
6121 if {$selectedline eq {}} return
6122 set l [expr {$selectedline + $dir * $lpp}]
6125 } elseif {$l >= $numcommits} {
6126 set l [expr $numcommits - 1]
6132 proc unselectline {} {
6133 global selectedline currentid
6136 catch {unset currentid}
6137 allcanvs delete secsel
6141 proc reselectline {} {
6144 if {$selectedline ne {}} {
6145 selectline $selectedline 0
6149 proc addtohistory {cmd} {
6150 global history historyindex curview
6152 set elt [list $curview $cmd]
6153 if {$historyindex > 0
6154 && [lindex $history [expr {$historyindex - 1}]] == $elt} {
6158 if {$historyindex < [llength $history]} {
6159 set history [lreplace $history $historyindex end $elt]
6161 lappend history $elt
6164 if {$historyindex > 1} {
6165 .tf.bar.leftbut conf -state normal
6167 .tf.bar.leftbut conf -state disabled
6169 .tf.bar.rightbut conf -state disabled
6175 set view [lindex $elt 0]
6176 set cmd [lindex $elt 1]
6177 if {$curview != $view} {
6184 global history historyindex
6187 if {$historyindex > 1} {
6188 incr historyindex -1
6189 godo [lindex $history [expr {$historyindex - 1}]]
6190 .tf.bar.rightbut conf -state normal
6192 if {$historyindex <= 1} {
6193 .tf.bar.leftbut conf -state disabled
6198 global history historyindex
6201 if {$historyindex < [llength $history]} {
6202 set cmd [lindex $history $historyindex]
6205 .tf.bar.leftbut conf -state normal
6207 if {$historyindex >= [llength $history]} {
6208 .tf.bar.rightbut conf -state disabled
6213 global treefilelist treeidlist diffids diffmergeid treepending
6214 global nullid nullid2
6217 catch {unset diffmergeid}
6218 if {![info exists treefilelist($id)]} {
6219 if {![info exists treepending]} {
6220 if {$id eq $nullid} {
6221 set cmd [list | git ls-files]
6222 } elseif {$id eq $nullid2} {
6223 set cmd [list | git ls-files --stage -t]
6225 set cmd [list | git ls-tree -r $id]
6227 if {[catch {set gtf [open $cmd r]}]} {
6231 set treefilelist($id) {}
6232 set treeidlist($id) {}
6233 fconfigure $gtf -blocking 0 -encoding binary
6234 filerun $gtf [list gettreeline $gtf $id]
6241 proc gettreeline {gtf id} {
6242 global treefilelist treeidlist treepending cmitmode diffids nullid nullid2
6245 while {[incr nl] <= 1000 && [gets $gtf line] >= 0} {
6246 if {$diffids eq $nullid} {
6249 set i [string first "\t" $line]
6250 if {$i < 0} continue
6251 set fname [string range $line [expr {$i+1}] end]
6252 set line [string range $line 0 [expr {$i-1}]]
6253 if {$diffids ne $nullid2 && [lindex $line 1] ne "blob"} continue
6254 set sha1 [lindex $line 2]
6255 lappend treeidlist($id) $sha1
6257 if {[string index $fname 0] eq "\""} {
6258 set fname [lindex $fname 0]
6260 set fname [encoding convertfrom $fname]
6261 lappend treefilelist($id) $fname
6264 return [expr {$nl >= 1000? 2: 1}]
6268 if {$cmitmode ne "tree"} {
6269 if {![info exists diffmergeid]} {
6270 gettreediffs $diffids
6272 } elseif {$id ne $diffids} {
6281 global treefilelist treeidlist diffids nullid nullid2
6282 global ctext commentend
6284 set i [lsearch -exact $treefilelist($diffids) $f]
6286 puts "oops, $f not in list for id $diffids"
6289 if {$diffids eq $nullid} {
6290 if {[catch {set bf [open $f r]} err]} {
6291 puts "oops, can't read $f: $err"
6295 set blob [lindex $treeidlist($diffids) $i]
6296 if {[catch {set bf [open [concat | git cat-file blob $blob] r]} err]} {
6297 puts "oops, error reading blob $blob: $err"
6301 fconfigure $bf -blocking 0 -encoding [get_path_encoding $f]
6302 filerun $bf [list getblobline $bf $diffids]
6303 $ctext config -state normal
6304 clear_ctext $commentend
6305 $ctext insert end "\n"
6306 $ctext insert end "$f\n" filesep
6307 $ctext config -state disabled
6308 $ctext yview $commentend
6312 proc getblobline {bf id} {
6313 global diffids cmitmode ctext
6315 if {$id ne $diffids || $cmitmode ne "tree"} {
6319 $ctext config -state normal
6321 while {[incr nl] <= 1000 && [gets $bf line] >= 0} {
6322 $ctext insert end "$line\n"
6325 # delete last newline
6326 $ctext delete "end - 2c" "end - 1c"
6330 $ctext config -state disabled
6331 return [expr {$nl >= 1000? 2: 1}]
6334 proc mergediff {id} {
6335 global diffmergeid mdifffd
6340 global limitdiffs vfilelimit curview
6344 # this doesn't seem to actually affect anything...
6345 set cmd [concat | git diff-tree --no-commit-id --cc -U$diffcontext $id]
6346 if {$limitdiffs && $vfilelimit($curview) ne {}} {
6347 set cmd [concat $cmd -- $vfilelimit($curview)]
6349 if {[catch {set mdf [open $cmd r]} err]} {
6350 error_popup "[mc "Error getting merge diffs:"] $err"
6353 fconfigure $mdf -blocking 0 -encoding binary
6354 set mdifffd($id) $mdf
6355 set np [llength $parents($curview,$id)]
6356 set diffencoding [get_path_encoding {}]
6358 filerun $mdf [list getmergediffline $mdf $id $np]
6361 proc getmergediffline {mdf id np} {
6362 global diffmergeid ctext cflist mergemax
6363 global difffilestart mdifffd
6366 $ctext conf -state normal
6368 while {[incr nr] <= 1000 && [gets $mdf line] >= 0} {
6369 if {![info exists diffmergeid] || $id != $diffmergeid
6370 || $mdf != $mdifffd($id)} {
6374 if {[regexp {^diff --cc (.*)} $line match fname]} {
6375 # start of a new file
6376 set fname [encoding convertfrom $fname]
6377 $ctext insert end "\n"
6378 set here [$ctext index "end - 1c"]
6379 lappend difffilestart $here
6380 add_flist [list $fname]
6381 set diffencoding [get_path_encoding $fname]
6382 set l [expr {(78 - [string length $fname]) / 2}]
6383 set pad [string range "----------------------------------------" 1 $l]
6384 $ctext insert end "$pad $fname $pad\n" filesep
6385 } elseif {[regexp {^@@} $line]} {
6386 set line [encoding convertfrom $diffencoding $line]
6387 $ctext insert end "$line\n" hunksep
6388 } elseif {[regexp {^[0-9a-f]{40}$} $line] || [regexp {^index} $line]} {
6391 set line [encoding convertfrom $diffencoding $line]
6392 # parse the prefix - one ' ', '-' or '+' for each parent
6397 for {set j 0} {$j < $np} {incr j} {
6398 set c [string range $line $j $j]
6401 } elseif {$c == "-"} {
6403 } elseif {$c == "+"} {
6412 if {!$isbad && $minuses ne {} && $pluses eq {}} {
6413 # line doesn't appear in result, parents in $minuses have the line
6414 set num [lindex $minuses 0]
6415 } elseif {!$isbad && $pluses ne {} && $minuses eq {}} {
6416 # line appears in result, parents in $pluses don't have the line
6417 lappend tags mresult
6418 set num [lindex $spaces 0]
6421 if {$num >= $mergemax} {
6426 $ctext insert end "$line\n" $tags
6429 $ctext conf -state disabled
6434 return [expr {$nr >= 1000? 2: 1}]
6437 proc startdiff {ids} {
6438 global treediffs diffids treepending diffmergeid nullid nullid2
6442 catch {unset diffmergeid}
6443 if {![info exists treediffs($ids)] ||
6444 [lsearch -exact $ids $nullid] >= 0 ||
6445 [lsearch -exact $ids $nullid2] >= 0} {
6446 if {![info exists treepending]} {
6454 proc path_filter {filter name} {
6456 set l [string length $p]
6457 if {[string index $p end] eq "/"} {
6458 if {[string compare -length $l $p $name] == 0} {
6462 if {[string compare -length $l $p $name] == 0 &&
6463 ([string length $name] == $l ||
6464 [string index $name $l] eq "/")} {
6472 proc addtocflist {ids} {
6475 add_flist $treediffs($ids)
6479 proc diffcmd {ids flags} {
6480 global nullid nullid2
6482 set i [lsearch -exact $ids $nullid]
6483 set j [lsearch -exact $ids $nullid2]
6485 if {[llength $ids] > 1 && $j < 0} {
6486 # comparing working directory with some specific revision
6487 set cmd [concat | git diff-index $flags]
6489 lappend cmd -R [lindex $ids 1]
6491 lappend cmd [lindex $ids 0]
6494 # comparing working directory with index
6495 set cmd [concat | git diff-files $flags]
6500 } elseif {$j >= 0} {
6501 set cmd [concat | git diff-index --cached $flags]
6502 if {[llength $ids] > 1} {
6503 # comparing index with specific revision
6505 lappend cmd -R [lindex $ids 1]
6507 lappend cmd [lindex $ids 0]
6510 # comparing index with HEAD
6514 set cmd [concat | git diff-tree -r $flags $ids]
6519 proc gettreediffs {ids} {
6520 global treediff treepending
6522 if {[catch {set gdtf [open [diffcmd $ids {--no-commit-id}] r]}]} return
6524 set treepending $ids
6526 fconfigure $gdtf -blocking 0 -encoding binary
6527 filerun $gdtf [list gettreediffline $gdtf $ids]
6530 proc gettreediffline {gdtf ids} {
6531 global treediff treediffs treepending diffids diffmergeid
6532 global cmitmode vfilelimit curview limitdiffs perfile_attrs
6537 if {$perfile_attrs} {
6538 # cache_gitattr is slow, and even slower on win32 where we
6539 # have to invoke it for only about 30 paths at a time
6541 if {[tk windowingsystem] == "win32"} {
6545 while {[incr nr] <= $max && [gets $gdtf line] >= 0} {
6546 set i [string first "\t" $line]
6548 set file [string range $line [expr {$i+1}] end]
6549 if {[string index $file 0] eq "\""} {
6550 set file [lindex $file 0]
6552 set file [encoding convertfrom $file]
6553 lappend treediff $file
6554 lappend sublist $file
6557 if {$perfile_attrs} {
6558 cache_gitattr encoding $sublist
6561 return [expr {$nr >= $max? 2: 1}]
6564 if {$limitdiffs && $vfilelimit($curview) ne {}} {
6566 foreach f $treediff {
6567 if {[path_filter $vfilelimit($curview) $f]} {
6571 set treediffs($ids) $flist
6573 set treediffs($ids) $treediff
6576 if {$cmitmode eq "tree"} {
6578 } elseif {$ids != $diffids} {
6579 if {![info exists diffmergeid]} {
6580 gettreediffs $diffids
6588 # empty string or positive integer
6589 proc diffcontextvalidate {v} {
6590 return [regexp {^(|[1-9][0-9]*)$} $v]
6593 proc diffcontextchange {n1 n2 op} {
6594 global diffcontextstring diffcontext
6596 if {[string is integer -strict $diffcontextstring]} {
6597 if {$diffcontextstring > 0} {
6598 set diffcontext $diffcontextstring
6604 proc changeignorespace {} {
6608 proc getblobdiffs {ids} {
6609 global blobdifffd diffids env
6610 global diffinhdr treediffs
6613 global limitdiffs vfilelimit curview
6616 set cmd [diffcmd $ids "-p -C --no-commit-id -U$diffcontext"]
6620 if {$limitdiffs && $vfilelimit($curview) ne {}} {
6621 set cmd [concat $cmd -- $vfilelimit($curview)]
6623 if {[catch {set bdf [open $cmd r]} err]} {
6624 puts "error getting diffs: $err"
6628 set diffencoding [get_path_encoding {}]
6629 fconfigure $bdf -blocking 0 -encoding binary
6630 set blobdifffd($ids) $bdf
6631 filerun $bdf [list getblobdiffline $bdf $diffids]
6634 proc setinlist {var i val} {
6637 while {[llength [set $var]] < $i} {
6640 if {[llength [set $var]] == $i} {
6647 proc makediffhdr {fname ids} {
6648 global ctext curdiffstart treediffs
6650 set i [lsearch -exact $treediffs($ids) $fname]
6652 setinlist difffilestart $i $curdiffstart
6654 set l [expr {(78 - [string length $fname]) / 2}]
6655 set pad [string range "----------------------------------------" 1 $l]
6656 $ctext insert $curdiffstart "$pad $fname $pad" filesep
6659 proc getblobdiffline {bdf ids} {
6660 global diffids blobdifffd ctext curdiffstart
6661 global diffnexthead diffnextnote difffilestart
6662 global diffinhdr treediffs
6666 $ctext conf -state normal
6667 while {[incr nr] <= 1000 && [gets $bdf line] >= 0} {
6668 if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
6672 if {![string compare -length 11 "diff --git " $line]} {
6673 # trim off "diff --git "
6674 set line [string range $line 11 end]
6676 # start of a new file
6677 $ctext insert end "\n"
6678 set curdiffstart [$ctext index "end - 1c"]
6679 $ctext insert end "\n" filesep
6680 # If the name hasn't changed the length will be odd,
6681 # the middle char will be a space, and the two bits either
6682 # side will be a/name and b/name, or "a/name" and "b/name".
6683 # If the name has changed we'll get "rename from" and
6684 # "rename to" or "copy from" and "copy to" lines following this,
6685 # and we'll use them to get the filenames.
6686 # This complexity is necessary because spaces in the filename(s)
6687 # don't get escaped.
6688 set l [string length $line]
6689 set i [expr {$l / 2}]
6690 if {!(($l & 1) && [string index $line $i] eq " " &&
6691 [string range $line 2 [expr {$i - 1}]] eq \
6692 [string range $line [expr {$i + 3}] end])} {
6695 # unescape if quoted and chop off the a/ from the front
6696 if {[string index $line 0] eq "\""} {
6697 set fname [string range [lindex $line 0] 2 end]
6699 set fname [string range $line 2 [expr {$i - 1}]]
6701 set fname [encoding convertfrom $fname]
6702 set diffencoding [get_path_encoding $fname]
6703 makediffhdr $fname $ids
6705 } elseif {[regexp {^@@ -([0-9]+)(,[0-9]+)? \+([0-9]+)(,[0-9]+)? @@(.*)} \
6706 $line match f1l f1c f2l f2c rest]} {
6707 set line [encoding convertfrom $diffencoding $line]
6708 $ctext insert end "$line\n" hunksep
6711 } elseif {$diffinhdr} {
6712 if {![string compare -length 12 "rename from " $line]} {
6713 set fname [string range $line [expr 6 + [string first " from " $line] ] end]
6714 if {[string index $fname 0] eq "\""} {
6715 set fname [lindex $fname 0]
6717 set fname [encoding convertfrom $fname]
6718 set i [lsearch -exact $treediffs($ids) $fname]
6720 setinlist difffilestart $i $curdiffstart
6722 } elseif {![string compare -length 10 $line "rename to "] ||
6723 ![string compare -length 8 $line "copy to "]} {
6724 set fname [string range $line [expr 4 + [string first " to " $line] ] end]
6725 if {[string index $fname 0] eq "\""} {
6726 set fname [lindex $fname 0]
6728 set fname [encoding convertfrom $fname]
6729 set diffencoding [get_path_encoding $fname]
6730 makediffhdr $fname $ids
6731 } elseif {[string compare -length 3 $line "---"] == 0} {
6734 } elseif {[string compare -length 3 $line "+++"] == 0} {
6738 $ctext insert end "$line\n" filesep
6741 set line [encoding convertfrom $diffencoding $line]
6742 set x [string range $line 0 0]
6743 if {$x == "-" || $x == "+"} {
6744 set tag [expr {$x == "+"}]
6745 $ctext insert end "$line\n" d$tag
6746 } elseif {$x == " "} {
6747 $ctext insert end "$line\n"
6749 # "\ No newline at end of file",
6750 # or something else we don't recognize
6751 $ctext insert end "$line\n" hunksep
6755 $ctext conf -state disabled
6760 return [expr {$nr >= 1000? 2: 1}]
6763 proc changediffdisp {} {
6764 global ctext diffelide
6766 $ctext tag conf d0 -elide [lindex $diffelide 0]
6767 $ctext tag conf d1 -elide [lindex $diffelide 1]
6770 proc highlightfile {loc cline} {
6771 global ctext cflist cflist_top
6774 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
6775 $cflist tag add highlight $cline.0 "$cline.0 lineend"
6776 $cflist see $cline.0
6777 set cflist_top $cline
6781 global difffilestart ctext cmitmode
6783 if {$cmitmode eq "tree"} return
6786 set here [$ctext index @0,0]
6787 foreach loc $difffilestart {
6788 if {[$ctext compare $loc >= $here]} {
6789 highlightfile $prev $prevline
6795 highlightfile $prev $prevline
6799 global difffilestart ctext cmitmode
6801 if {$cmitmode eq "tree"} return
6802 set here [$ctext index @0,0]
6804 foreach loc $difffilestart {
6806 if {[$ctext compare $loc > $here]} {
6807 highlightfile $loc $line
6813 proc clear_ctext {{first 1.0}} {
6814 global ctext smarktop smarkbot
6817 set l [lindex [split $first .] 0]
6818 if {![info exists smarktop] || [$ctext compare $first < $smarktop.0]} {
6821 if {![info exists smarkbot] || [$ctext compare $first < $smarkbot.0]} {
6824 $ctext delete $first end
6825 if {$first eq "1.0"} {
6826 catch {unset pendinglinks}
6830 proc settabs {{firstab {}}} {
6831 global firsttabstop tabstop ctext have_tk85
6833 if {$firstab ne {} && $have_tk85} {
6834 set firsttabstop $firstab
6836 set w [font measure textfont "0"]
6837 if {$firsttabstop != 0} {
6838 $ctext conf -tabs [list [expr {($firsttabstop + $tabstop) * $w}] \
6839 [expr {($firsttabstop + 2 * $tabstop) * $w}]]
6840 } elseif {$have_tk85 || $tabstop != 8} {
6841 $ctext conf -tabs [expr {$tabstop * $w}]
6843 $ctext conf -tabs {}
6847 proc incrsearch {name ix op} {
6848 global ctext searchstring searchdirn
6850 $ctext tag remove found 1.0 end
6851 if {[catch {$ctext index anchor}]} {
6852 # no anchor set, use start of selection, or of visible area
6853 set sel [$ctext tag ranges sel]
6855 $ctext mark set anchor [lindex $sel 0]
6856 } elseif {$searchdirn eq "-forwards"} {
6857 $ctext mark set anchor @0,0
6859 $ctext mark set anchor @0,[winfo height $ctext]
6862 if {$searchstring ne {}} {
6863 set here [$ctext search $searchdirn -- $searchstring anchor]
6872 global sstring ctext searchstring searchdirn
6875 $sstring icursor end
6876 set searchdirn -forwards
6877 if {$searchstring ne {}} {
6878 set sel [$ctext tag ranges sel]
6880 set start "[lindex $sel 0] + 1c"
6881 } elseif {[catch {set start [$ctext index anchor]}]} {
6884 set match [$ctext search -count mlen -- $searchstring $start]
6885 $ctext tag remove sel 1.0 end
6891 set mend "$match + $mlen c"
6892 $ctext tag add sel $match $mend
6893 $ctext mark unset anchor
6897 proc dosearchback {} {
6898 global sstring ctext searchstring searchdirn
6901 $sstring icursor end
6902 set searchdirn -backwards
6903 if {$searchstring ne {}} {
6904 set sel [$ctext tag ranges sel]
6906 set start [lindex $sel 0]
6907 } elseif {[catch {set start [$ctext index anchor]}]} {
6908 set start @0,[winfo height $ctext]
6910 set match [$ctext search -backwards -count ml -- $searchstring $start]
6911 $ctext tag remove sel 1.0 end
6917 set mend "$match + $ml c"
6918 $ctext tag add sel $match $mend
6919 $ctext mark unset anchor
6923 proc searchmark {first last} {
6924 global ctext searchstring
6928 set match [$ctext search -count mlen -- $searchstring $mend $last.end]
6929 if {$match eq {}} break
6930 set mend "$match + $mlen c"
6931 $ctext tag add found $match $mend
6935 proc searchmarkvisible {doall} {
6936 global ctext smarktop smarkbot
6938 set topline [lindex [split [$ctext index @0,0] .] 0]
6939 set botline [lindex [split [$ctext index @0,[winfo height $ctext]] .] 0]
6940 if {$doall || $botline < $smarktop || $topline > $smarkbot} {
6941 # no overlap with previous
6942 searchmark $topline $botline
6943 set smarktop $topline
6944 set smarkbot $botline
6946 if {$topline < $smarktop} {
6947 searchmark $topline [expr {$smarktop-1}]
6948 set smarktop $topline
6950 if {$botline > $smarkbot} {
6951 searchmark [expr {$smarkbot+1}] $botline
6952 set smarkbot $botline
6957 proc scrolltext {f0 f1} {
6960 .bleft.bottom.sb set $f0 $f1
6961 if {$searchstring ne {}} {
6967 global linespc charspc canvx0 canvy0
6968 global xspc1 xspc2 lthickness
6970 set linespc [font metrics mainfont -linespace]
6971 set charspc [font measure mainfont "m"]
6972 set canvy0 [expr {int(3 + 0.5 * $linespc)}]
6973 set canvx0 [expr {int(3 + 0.5 * $linespc)}]
6974 set lthickness [expr {int($linespc / 9) + 1}]
6975 set xspc1(0) $linespc
6983 set ymax [lindex [$canv cget -scrollregion] 3]
6984 if {$ymax eq {} || $ymax == 0} return
6985 set span [$canv yview]
6988 allcanvs yview moveto [lindex $span 0]
6990 if {$selectedline ne {}} {
6991 selectline $selectedline 0
6992 allcanvs yview moveto [lindex $span 0]
6996 proc parsefont {f n} {
6999 set fontattr($f,family) [lindex $n 0]
7001 if {$s eq {} || $s == 0} {
7004 set s [expr {int(-$s / [winfo fpixels . 1p] + 0.5)}]
7006 set fontattr($f,size) $s
7007 set fontattr($f,weight) normal
7008 set fontattr($f,slant) roman
7009 foreach style [lrange $n 2 end] {
7012 "bold" {set fontattr($f,weight) $style}
7014 "italic" {set fontattr($f,slant) $style}
7019 proc fontflags {f {isbold 0}} {
7022 return [list -family $fontattr($f,family) -size $fontattr($f,size) \
7023 -weight [expr {$isbold? "bold": $fontattr($f,weight)}] \
7024 -slant $fontattr($f,slant)]
7030 set n [list $fontattr($f,family) $fontattr($f,size)]
7031 if {$fontattr($f,weight) eq "bold"} {
7034 if {$fontattr($f,slant) eq "italic"} {
7040 proc incrfont {inc} {
7041 global mainfont textfont ctext canv cflist showrefstop
7042 global stopped entries fontattr
7045 set s $fontattr(mainfont,size)
7050 set fontattr(mainfont,size) $s
7051 font config mainfont -size $s
7052 font config mainfontbold -size $s
7053 set mainfont [fontname mainfont]
7054 set s $fontattr(textfont,size)
7059 set fontattr(textfont,size) $s
7060 font config textfont -size $s
7061 font config textfontbold -size $s
7062 set textfont [fontname textfont]
7069 global sha1entry sha1string
7070 if {[string length $sha1string] == 40} {
7071 $sha1entry delete 0 end
7075 proc sha1change {n1 n2 op} {
7076 global sha1string currentid sha1but
7077 if {$sha1string == {}
7078 || ([info exists currentid] && $sha1string == $currentid)} {
7083 if {[$sha1but cget -state] == $state} return
7084 if {$state == "normal"} {
7085 $sha1but conf -state normal -relief raised -text "[mc "Goto:"] "
7087 $sha1but conf -state disabled -relief flat -text "[mc "SHA1 ID:"] "
7091 proc gotocommit {} {
7092 global sha1string tagids headids curview varcid
7094 if {$sha1string == {}
7095 || ([info exists currentid] && $sha1string == $currentid)} return
7096 if {[info exists tagids($sha1string)]} {
7097 set id $tagids($sha1string)
7098 } elseif {[info exists headids($sha1string)]} {
7099 set id $headids($sha1string)
7101 set id [string tolower $sha1string]
7102 if {[regexp {^[0-9a-f]{4,39}$} $id]} {
7103 set matches [array names varcid "$curview,$id*"]
7104 if {$matches ne {}} {
7105 if {[llength $matches] > 1} {
7106 error_popup [mc "Short SHA1 id %s is ambiguous" $id]
7109 set id [lindex [split [lindex $matches 0] ","] 1]
7113 if {[commitinview $id $curview]} {
7114 selectline [rowofcommit $id] 1
7117 if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
7118 set msg [mc "SHA1 id %s is not known" $sha1string]
7120 set msg [mc "Tag/Head %s is not known" $sha1string]
7125 proc lineenter {x y id} {
7126 global hoverx hovery hoverid hovertimer
7127 global commitinfo canv
7129 if {![info exists commitinfo($id)] && ![getcommit $id]} return
7133 if {[info exists hovertimer]} {
7134 after cancel $hovertimer
7136 set hovertimer [after 500 linehover]
7140 proc linemotion {x y id} {
7141 global hoverx hovery hoverid hovertimer
7143 if {[info exists hoverid] && $id == $hoverid} {
7146 if {[info exists hovertimer]} {
7147 after cancel $hovertimer
7149 set hovertimer [after 500 linehover]
7153 proc lineleave {id} {
7154 global hoverid hovertimer canv
7156 if {[info exists hoverid] && $id == $hoverid} {
7158 if {[info exists hovertimer]} {
7159 after cancel $hovertimer
7167 global hoverx hovery hoverid hovertimer
7168 global canv linespc lthickness
7171 set text [lindex $commitinfo($hoverid) 0]
7172 set ymax [lindex [$canv cget -scrollregion] 3]
7173 if {$ymax == {}} return
7174 set yfrac [lindex [$canv yview] 0]
7175 set x [expr {$hoverx + 2 * $linespc}]
7176 set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
7177 set x0 [expr {$x - 2 * $lthickness}]
7178 set y0 [expr {$y - 2 * $lthickness}]
7179 set x1 [expr {$x + [font measure mainfont $text] + 2 * $lthickness}]
7180 set y1 [expr {$y + $linespc + 2 * $lthickness}]
7181 set t [$canv create rectangle $x0 $y0 $x1 $y1 \
7182 -fill \#ffff80 -outline black -width 1 -tags hover]
7184 set t [$canv create text $x $y -anchor nw -text $text -tags hover \
7189 proc clickisonarrow {id y} {
7192 set ranges [rowranges $id]
7193 set thresh [expr {2 * $lthickness + 6}]
7194 set n [expr {[llength $ranges] - 1}]
7195 for {set i 1} {$i < $n} {incr i} {
7196 set row [lindex $ranges $i]
7197 if {abs([yc $row] - $y) < $thresh} {
7204 proc arrowjump {id n y} {
7207 # 1 <-> 2, 3 <-> 4, etc...
7208 set n [expr {(($n - 1) ^ 1) + 1}]
7209 set row [lindex [rowranges $id] $n]
7211 set ymax [lindex [$canv cget -scrollregion] 3]
7212 if {$ymax eq {} || $ymax <= 0} return
7213 set view [$canv yview]
7214 set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
7215 set yfrac [expr {$yt / $ymax - $yspan / 2}]
7219 allcanvs yview moveto $yfrac
7222 proc lineclick {x y id isnew} {
7223 global ctext commitinfo children canv thickerline curview
7225 if {![info exists commitinfo($id)] && ![getcommit $id]} return
7230 # draw this line thicker than normal
7234 set ymax [lindex [$canv cget -scrollregion] 3]
7235 if {$ymax eq {}} return
7236 set yfrac [lindex [$canv yview] 0]
7237 set y [expr {$y + $yfrac * $ymax}]
7239 set dirn [clickisonarrow $id $y]
7241 arrowjump $id $dirn $y
7246 addtohistory [list lineclick $x $y $id 0]
7248 # fill the details pane with info about this line
7249 $ctext conf -state normal
7252 $ctext insert end "[mc "Parent"]:\t"
7253 $ctext insert end $id link0
7255 set info $commitinfo($id)
7256 $ctext insert end "\n\t[lindex $info 0]\n"
7257 $ctext insert end "\t[mc "Author"]:\t[lindex $info 1]\n"
7258 set date [formatdate [lindex $info 2]]
7259 $ctext insert end "\t[mc "Date"]:\t$date\n"
7260 set kids $children($curview,$id)
7262 $ctext insert end "\n[mc "Children"]:"
7264 foreach child $kids {
7266 if {![info exists commitinfo($child)] && ![getcommit $child]} continue
7267 set info $commitinfo($child)
7268 $ctext insert end "\n\t"
7269 $ctext insert end $child link$i
7270 setlink $child link$i
7271 $ctext insert end "\n\t[lindex $info 0]"
7272 $ctext insert end "\n\t[mc "Author"]:\t[lindex $info 1]"
7273 set date [formatdate [lindex $info 2]]
7274 $ctext insert end "\n\t[mc "Date"]:\t$date\n"
7277 $ctext conf -state disabled
7281 proc normalline {} {
7283 if {[info exists thickerline]} {
7292 if {[commitinview $id $curview]} {
7293 selectline [rowofcommit $id] 1
7299 if {![info exists startmstime]} {
7300 set startmstime [clock clicks -milliseconds]
7302 return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
7305 proc rowmenu {x y id} {
7306 global rowctxmenu selectedline rowmenuid curview
7307 global nullid nullid2 fakerowmenu mainhead
7311 if {$selectedline eq {} || [rowofcommit $id] eq $selectedline} {
7316 if {$id ne $nullid && $id ne $nullid2} {
7317 set menu $rowctxmenu
7318 if {$mainhead ne {}} {
7319 $menu entryconfigure 7 -label [mc "Reset %s branch to here" $mainhead]
7321 $menu entryconfigure 7 -label [mc "Detached head: can't reset" $mainhead] -state disabled
7324 set menu $fakerowmenu
7326 $menu entryconfigure [mc "Diff this -> selected"] -state $state
7327 $menu entryconfigure [mc "Diff selected -> this"] -state $state
7328 $menu entryconfigure [mc "Make patch"] -state $state
7329 tk_popup $menu $x $y
7332 proc diffvssel {dirn} {
7333 global rowmenuid selectedline
7335 if {$selectedline eq {}} return
7337 set oldid [commitonrow $selectedline]
7338 set newid $rowmenuid
7340 set oldid $rowmenuid
7341 set newid [commitonrow $selectedline]
7343 addtohistory [list doseldiff $oldid $newid]
7344 doseldiff $oldid $newid
7347 proc doseldiff {oldid newid} {
7351 $ctext conf -state normal
7353 init_flist [mc "Top"]
7354 $ctext insert end "[mc "From"] "
7355 $ctext insert end $oldid link0
7356 setlink $oldid link0
7357 $ctext insert end "\n "
7358 $ctext insert end [lindex $commitinfo($oldid) 0]
7359 $ctext insert end "\n\n[mc "To"] "
7360 $ctext insert end $newid link1
7361 setlink $newid link1
7362 $ctext insert end "\n "
7363 $ctext insert end [lindex $commitinfo($newid) 0]
7364 $ctext insert end "\n"
7365 $ctext conf -state disabled
7366 $ctext tag remove found 1.0 end
7367 startdiff [list $oldid $newid]
7371 global rowmenuid currentid commitinfo patchtop patchnum
7373 if {![info exists currentid]} return
7374 set oldid $currentid
7375 set oldhead [lindex $commitinfo($oldid) 0]
7376 set newid $rowmenuid
7377 set newhead [lindex $commitinfo($newid) 0]
7380 catch {destroy $top}
7382 label $top.title -text [mc "Generate patch"]
7383 grid $top.title - -pady 10
7384 label $top.from -text [mc "From:"]
7385 entry $top.fromsha1 -width 40 -relief flat
7386 $top.fromsha1 insert 0 $oldid
7387 $top.fromsha1 conf -state readonly
7388 grid $top.from $top.fromsha1 -sticky w
7389 entry $top.fromhead -width 60 -relief flat
7390 $top.fromhead insert 0 $oldhead
7391 $top.fromhead conf -state readonly
7392 grid x $top.fromhead -sticky w
7393 label $top.to -text [mc "To:"]
7394 entry $top.tosha1 -width 40 -relief flat
7395 $top.tosha1 insert 0 $newid
7396 $top.tosha1 conf -state readonly
7397 grid $top.to $top.tosha1 -sticky w
7398 entry $top.tohead -width 60 -relief flat
7399 $top.tohead insert 0 $newhead
7400 $top.tohead conf -state readonly
7401 grid x $top.tohead -sticky w
7402 button $top.rev -text [mc "Reverse"] -command mkpatchrev -padx 5
7403 grid $top.rev x -pady 10
7404 label $top.flab -text [mc "Output file:"]
7405 entry $top.fname -width 60
7406 $top.fname insert 0 [file normalize "patch$patchnum.patch"]
7408 grid $top.flab $top.fname -sticky w
7410 button $top.buts.gen -text [mc "Generate"] -command mkpatchgo
7411 button $top.buts.can -text [mc "Cancel"] -command mkpatchcan
7412 grid $top.buts.gen $top.buts.can
7413 grid columnconfigure $top.buts 0 -weight 1 -uniform a
7414 grid columnconfigure $top.buts 1 -weight 1 -uniform a
7415 grid $top.buts - -pady 10 -sticky ew
7419 proc mkpatchrev {} {
7422 set oldid [$patchtop.fromsha1 get]
7423 set oldhead [$patchtop.fromhead get]
7424 set newid [$patchtop.tosha1 get]
7425 set newhead [$patchtop.tohead get]
7426 foreach e [list fromsha1 fromhead tosha1 tohead] \
7427 v [list $newid $newhead $oldid $oldhead] {
7428 $patchtop.$e conf -state normal
7429 $patchtop.$e delete 0 end
7430 $patchtop.$e insert 0 $v
7431 $patchtop.$e conf -state readonly
7436 global patchtop nullid nullid2
7438 set oldid [$patchtop.fromsha1 get]
7439 set newid [$patchtop.tosha1 get]
7440 set fname [$patchtop.fname get]
7441 set cmd [diffcmd [list $oldid $newid] -p]
7442 # trim off the initial "|"
7443 set cmd [lrange $cmd 1 end]
7444 lappend cmd >$fname &
7445 if {[catch {eval exec $cmd} err]} {
7446 error_popup "[mc "Error creating patch:"] $err"
7448 catch {destroy $patchtop}
7452 proc mkpatchcan {} {
7455 catch {destroy $patchtop}
7460 global rowmenuid mktagtop commitinfo
7464 catch {destroy $top}
7466 label $top.title -text [mc "Create tag"]
7467 grid $top.title - -pady 10
7468 label $top.id -text [mc "ID:"]
7469 entry $top.sha1 -width 40 -relief flat
7470 $top.sha1 insert 0 $rowmenuid
7471 $top.sha1 conf -state readonly
7472 grid $top.id $top.sha1 -sticky w
7473 entry $top.head -width 60 -relief flat
7474 $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
7475 $top.head conf -state readonly
7476 grid x $top.head -sticky w
7477 label $top.tlab -text [mc "Tag name:"]
7478 entry $top.tag -width 60
7479 grid $top.tlab $top.tag -sticky w
7481 button $top.buts.gen -text [mc "Create"] -command mktaggo
7482 button $top.buts.can -text [mc "Cancel"] -command mktagcan
7483 grid $top.buts.gen $top.buts.can
7484 grid columnconfigure $top.buts 0 -weight 1 -uniform a
7485 grid columnconfigure $top.buts 1 -weight 1 -uniform a
7486 grid $top.buts - -pady 10 -sticky ew
7491 global mktagtop env tagids idtags
7493 set id [$mktagtop.sha1 get]
7494 set tag [$mktagtop.tag get]
7496 error_popup [mc "No tag name specified"]
7499 if {[info exists tagids($tag)]} {
7500 error_popup [mc "Tag \"%s\" already exists" $tag]
7504 exec git tag $tag $id
7506 error_popup "[mc "Error creating tag:"] $err"
7510 set tagids($tag) $id
7511 lappend idtags($id) $tag
7518 proc redrawtags {id} {
7519 global canv linehtag idpos currentid curview cmitlisted
7520 global canvxmax iddrawn circleitem mainheadid circlecolors
7522 if {![commitinview $id $curview]} return
7523 if {![info exists iddrawn($id)]} return
7524 set row [rowofcommit $id]
7525 if {$id eq $mainheadid} {
7528 set ofill [lindex $circlecolors $cmitlisted($curview,$id)]
7530 $canv itemconf $circleitem($row) -fill $ofill
7531 $canv delete tag.$id
7532 set xt [eval drawtags $id $idpos($id)]
7533 $canv coords $linehtag($row) $xt [lindex $idpos($id) 2]
7534 set text [$canv itemcget $linehtag($row) -text]
7535 set font [$canv itemcget $linehtag($row) -font]
7536 set xr [expr {$xt + [font measure $font $text]}]
7537 if {$xr > $canvxmax} {
7541 if {[info exists currentid] && $currentid == $id} {
7549 catch {destroy $mktagtop}
7558 proc writecommit {} {
7559 global rowmenuid wrcomtop commitinfo wrcomcmd
7561 set top .writecommit
7563 catch {destroy $top}
7565 label $top.title -text [mc "Write commit to file"]
7566 grid $top.title - -pady 10
7567 label $top.id -text [mc "ID:"]
7568 entry $top.sha1 -width 40 -relief flat
7569 $top.sha1 insert 0 $rowmenuid
7570 $top.sha1 conf -state readonly
7571 grid $top.id $top.sha1 -sticky w
7572 entry $top.head -width 60 -relief flat
7573 $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
7574 $top.head conf -state readonly
7575 grid x $top.head -sticky w
7576 label $top.clab -text [mc "Command:"]
7577 entry $top.cmd -width 60 -textvariable wrcomcmd
7578 grid $top.clab $top.cmd -sticky w -pady 10
7579 label $top.flab -text [mc "Output file:"]
7580 entry $top.fname -width 60
7581 $top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
7582 grid $top.flab $top.fname -sticky w
7584 button $top.buts.gen -text [mc "Write"] -command wrcomgo
7585 button $top.buts.can -text [mc "Cancel"] -command wrcomcan
7586 grid $top.buts.gen $top.buts.can
7587 grid columnconfigure $top.buts 0 -weight 1 -uniform a
7588 grid columnconfigure $top.buts 1 -weight 1 -uniform a
7589 grid $top.buts - -pady 10 -sticky ew
7596 set id [$wrcomtop.sha1 get]
7597 set cmd "echo $id | [$wrcomtop.cmd get]"
7598 set fname [$wrcomtop.fname get]
7599 if {[catch {exec sh -c $cmd >$fname &} err]} {
7600 error_popup "[mc "Error writing commit:"] $err"
7602 catch {destroy $wrcomtop}
7609 catch {destroy $wrcomtop}
7614 global rowmenuid mkbrtop
7617 catch {destroy $top}
7619 label $top.title -text [mc "Create new branch"]
7620 grid $top.title - -pady 10
7621 label $top.id -text [mc "ID:"]
7622 entry $top.sha1 -width 40 -relief flat
7623 $top.sha1 insert 0 $rowmenuid
7624 $top.sha1 conf -state readonly
7625 grid $top.id $top.sha1 -sticky w
7626 label $top.nlab -text [mc "Name:"]
7627 entry $top.name -width 40
7628 bind $top.name <Key-Return> "[list mkbrgo $top]"
7629 grid $top.nlab $top.name -sticky w
7631 button $top.buts.go -text [mc "Create"] -command [list mkbrgo $top]
7632 button $top.buts.can -text [mc "Cancel"] -command "catch {destroy $top}"
7633 grid $top.buts.go $top.buts.can
7634 grid columnconfigure $top.buts 0 -weight 1 -uniform a
7635 grid columnconfigure $top.buts 1 -weight 1 -uniform a
7636 grid $top.buts - -pady 10 -sticky ew
7641 global headids idheads
7643 set name [$top.name get]
7644 set id [$top.sha1 get]
7646 error_popup [mc "Please specify a name for the new branch"]
7649 catch {destroy $top}
7653 exec git branch $name $id
7658 set headids($name) $id
7659 lappend idheads($id) $name
7668 proc cherrypick {} {
7669 global rowmenuid curview
7670 global mainhead mainheadid
7672 set oldhead [exec git rev-parse HEAD]
7673 set dheads [descheads $rowmenuid]
7674 if {$dheads ne {} && [lsearch -exact $dheads $oldhead] >= 0} {
7675 set ok [confirm_popup [mc "Commit %s is already\
7676 included in branch %s -- really re-apply it?" \
7677 [string range $rowmenuid 0 7] $mainhead]]
7680 nowbusy cherrypick [mc "Cherry-picking"]
7682 # Unfortunately git-cherry-pick writes stuff to stderr even when
7683 # no error occurs, and exec takes that as an indication of error...
7684 if {[catch {exec sh -c "git cherry-pick -r $rowmenuid 2>&1"} err]} {
7689 set newhead [exec git rev-parse HEAD]
7690 if {$newhead eq $oldhead} {
7692 error_popup [mc "No changes committed"]
7695 addnewchild $newhead $oldhead
7696 if {[commitinview $oldhead $curview]} {
7697 insertrow $newhead $oldhead $curview
7698 if {$mainhead ne {}} {
7699 movehead $newhead $mainhead
7700 movedhead $newhead $mainhead
7702 set mainheadid $newhead
7711 global mainhead rowmenuid confirm_ok resettype
7714 set w ".confirmreset"
7717 wm title $w [mc "Confirm reset"]
7718 message $w.m -text \
7719 [mc "Reset branch %s to %s?" $mainhead [string range $rowmenuid 0 7]] \
7720 -justify center -aspect 1000
7721 pack $w.m -side top -fill x -padx 20 -pady 20
7722 frame $w.f -relief sunken -border 2
7723 message $w.f.rt -text [mc "Reset type:"] -aspect 1000
7724 grid $w.f.rt -sticky w
7726 radiobutton $w.f.soft -value soft -variable resettype -justify left \
7727 -text [mc "Soft: Leave working tree and index untouched"]
7728 grid $w.f.soft -sticky w
7729 radiobutton $w.f.mixed -value mixed -variable resettype -justify left \
7730 -text [mc "Mixed: Leave working tree untouched, reset index"]
7731 grid $w.f.mixed -sticky w
7732 radiobutton $w.f.hard -value hard -variable resettype -justify left \
7733 -text [mc "Hard: Reset working tree and index\n(discard ALL local changes)"]
7734 grid $w.f.hard -sticky w
7735 pack $w.f -side top -fill x
7736 button $w.ok -text [mc OK] -command "set confirm_ok 1; destroy $w"
7737 pack $w.ok -side left -fill x -padx 20 -pady 20
7738 button $w.cancel -text [mc Cancel] -command "destroy $w"
7739 pack $w.cancel -side right -fill x -padx 20 -pady 20
7740 bind $w <Visibility> "grab $w; focus $w"
7742 if {!$confirm_ok} return
7743 if {[catch {set fd [open \
7744 [list | git reset --$resettype $rowmenuid 2>@1] r]} err]} {
7748 filerun $fd [list readresetstat $fd]
7749 nowbusy reset [mc "Resetting"]
7754 proc readresetstat {fd} {
7755 global mainhead mainheadid showlocalchanges rprogcoord
7757 if {[gets $fd line] >= 0} {
7758 if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
7759 set rprogcoord [expr {1.0 * $m / $n}]
7767 if {[catch {close $fd} err]} {
7770 set oldhead $mainheadid
7771 set newhead [exec git rev-parse HEAD]
7772 if {$newhead ne $oldhead} {
7773 movehead $newhead $mainhead
7774 movedhead $newhead $mainhead
7775 set mainheadid $newhead
7779 if {$showlocalchanges} {
7785 # context menu for a head
7786 proc headmenu {x y id head} {
7787 global headmenuid headmenuhead headctxmenu mainhead
7791 set headmenuhead $head
7793 if {$head eq $mainhead} {
7796 $headctxmenu entryconfigure 0 -state $state
7797 $headctxmenu entryconfigure 1 -state $state
7798 tk_popup $headctxmenu $x $y
7802 global headmenuid headmenuhead headids
7803 global showlocalchanges mainheadid
7805 # check the tree is clean first??
7806 nowbusy checkout [mc "Checking out"]
7810 set fd [open [list | git checkout $headmenuhead 2>@1] r]
7814 if {$showlocalchanges} {
7818 filerun $fd [list readcheckoutstat $fd $headmenuhead $headmenuid]
7822 proc readcheckoutstat {fd newhead newheadid} {
7823 global mainhead mainheadid headids showlocalchanges progresscoords
7825 if {[gets $fd line] >= 0} {
7826 if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
7827 set progresscoords [list 0 [expr {1.0 * $m / $n}]]
7832 set progresscoords {0 0}
7835 if {[catch {close $fd} err]} {
7838 set oldmainid $mainheadid
7839 set mainhead $newhead
7840 set mainheadid $newheadid
7841 redrawtags $oldmainid
7842 redrawtags $newheadid
7844 if {$showlocalchanges} {
7850 global headmenuid headmenuhead mainhead
7853 set head $headmenuhead
7855 # this check shouldn't be needed any more...
7856 if {$head eq $mainhead} {
7857 error_popup [mc "Cannot delete the currently checked-out branch"]
7860 set dheads [descheads $id]
7861 if {[llength $dheads] == 1 && $idheads($dheads) eq $head} {
7862 # the stuff on this branch isn't on any other branch
7863 if {![confirm_popup [mc "The commits on branch %s aren't on any other\
7864 branch.\nReally delete branch %s?" $head $head]]} return
7868 if {[catch {exec git branch -D $head} err]} {
7873 removehead $id $head
7874 removedhead $id $head
7881 # Display a list of tags and heads
7883 global showrefstop bgcolor fgcolor selectbgcolor
7884 global bglist fglist reflistfilter reflist maincursor
7887 set showrefstop $top
7888 if {[winfo exists $top]} {
7894 wm title $top [mc "Tags and heads: %s" [file tail [pwd]]]
7895 text $top.list -background $bgcolor -foreground $fgcolor \
7896 -selectbackground $selectbgcolor -font mainfont \
7897 -xscrollcommand "$top.xsb set" -yscrollcommand "$top.ysb set" \
7898 -width 30 -height 20 -cursor $maincursor \
7899 -spacing1 1 -spacing3 1 -state disabled
7900 $top.list tag configure highlight -background $selectbgcolor
7901 lappend bglist $top.list
7902 lappend fglist $top.list
7903 scrollbar $top.ysb -command "$top.list yview" -orient vertical
7904 scrollbar $top.xsb -command "$top.list xview" -orient horizontal
7905 grid $top.list $top.ysb -sticky nsew
7906 grid $top.xsb x -sticky ew
7908 label $top.f.l -text "[mc "Filter"]: "
7909 entry $top.f.e -width 20 -textvariable reflistfilter
7910 set reflistfilter "*"
7911 trace add variable reflistfilter write reflistfilter_change
7912 pack $top.f.e -side right -fill x -expand 1
7913 pack $top.f.l -side left
7914 grid $top.f - -sticky ew -pady 2
7915 button $top.close -command [list destroy $top] -text [mc "Close"]
7917 grid columnconfigure $top 0 -weight 1
7918 grid rowconfigure $top 0 -weight 1
7919 bind $top.list <1> {break}
7920 bind $top.list <B1-Motion> {break}
7921 bind $top.list <ButtonRelease-1> {sel_reflist %W %x %y; break}
7926 proc sel_reflist {w x y} {
7927 global showrefstop reflist headids tagids otherrefids
7929 if {![winfo exists $showrefstop]} return
7930 set l [lindex [split [$w index "@$x,$y"] "."] 0]
7931 set ref [lindex $reflist [expr {$l-1}]]
7932 set n [lindex $ref 0]
7933 switch -- [lindex $ref 1] {
7934 "H" {selbyid $headids($n)}
7935 "T" {selbyid $tagids($n)}
7936 "o" {selbyid $otherrefids($n)}
7938 $showrefstop.list tag add highlight $l.0 "$l.0 lineend"
7941 proc unsel_reflist {} {
7944 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
7945 $showrefstop.list tag remove highlight 0.0 end
7948 proc reflistfilter_change {n1 n2 op} {
7949 global reflistfilter
7951 after cancel refill_reflist
7952 after 200 refill_reflist
7955 proc refill_reflist {} {
7956 global reflist reflistfilter showrefstop headids tagids otherrefids
7957 global curview commitinterest
7959 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
7961 foreach n [array names headids] {
7962 if {[string match $reflistfilter $n]} {
7963 if {[commitinview $headids($n) $curview]} {
7964 lappend refs [list $n H]
7966 set commitinterest($headids($n)) {run refill_reflist}
7970 foreach n [array names tagids] {
7971 if {[string match $reflistfilter $n]} {
7972 if {[commitinview $tagids($n) $curview]} {
7973 lappend refs [list $n T]
7975 set commitinterest($tagids($n)) {run refill_reflist}
7979 foreach n [array names otherrefids] {
7980 if {[string match $reflistfilter $n]} {
7981 if {[commitinview $otherrefids($n) $curview]} {
7982 lappend refs [list $n o]
7984 set commitinterest($otherrefids($n)) {run refill_reflist}
7988 set refs [lsort -index 0 $refs]
7989 if {$refs eq $reflist} return
7991 # Update the contents of $showrefstop.list according to the
7992 # differences between $reflist (old) and $refs (new)
7993 $showrefstop.list conf -state normal
7994 $showrefstop.list insert end "\n"
7997 while {$i < [llength $reflist] || $j < [llength $refs]} {
7998 if {$i < [llength $reflist]} {
7999 if {$j < [llength $refs]} {
8000 set cmp [string compare [lindex $reflist $i 0] \
8001 [lindex $refs $j 0]]
8003 set cmp [string compare [lindex $reflist $i 1] \
8004 [lindex $refs $j 1]]
8014 $showrefstop.list delete "[expr {$j+1}].0" "[expr {$j+2}].0"
8022 set l [expr {$j + 1}]
8023 $showrefstop.list image create $l.0 -align baseline \
8024 -image reficon-[lindex $refs $j 1] -padx 2
8025 $showrefstop.list insert $l.1 "[lindex $refs $j 0]\n"
8031 # delete last newline
8032 $showrefstop.list delete end-2c end-1c
8033 $showrefstop.list conf -state disabled
8036 # Stuff for finding nearby tags
8037 proc getallcommits {} {
8038 global allcommits nextarc seeds allccache allcwait cachedarcs allcupdate
8039 global idheads idtags idotherrefs allparents tagobjid
8041 if {![info exists allcommits]} {
8047 set allccache [file join [gitdir] "gitk.cache"]
8049 set f [open $allccache r]
8058 set cmd [list | git rev-list --parents]
8059 set allcupdate [expr {$seeds ne {}}]
8063 set refs [concat [array names idheads] [array names idtags] \
8064 [array names idotherrefs]]
8067 foreach name [array names tagobjid] {
8068 lappend tagobjs $tagobjid($name)
8070 foreach id [lsort -unique $refs] {
8071 if {![info exists allparents($id)] &&
8072 [lsearch -exact $tagobjs $id] < 0} {
8083 set fd [open [concat $cmd $ids] r]
8084 fconfigure $fd -blocking 0
8087 filerun $fd [list getallclines $fd]
8093 # Since most commits have 1 parent and 1 child, we group strings of
8094 # such commits into "arcs" joining branch/merge points (BMPs), which
8095 # are commits that either don't have 1 parent or don't have 1 child.
8097 # arcnos(id) - incoming arcs for BMP, arc we're on for other nodes
8098 # arcout(id) - outgoing arcs for BMP
8099 # arcids(a) - list of IDs on arc including end but not start
8100 # arcstart(a) - BMP ID at start of arc
8101 # arcend(a) - BMP ID at end of arc
8102 # growing(a) - arc a is still growing
8103 # arctags(a) - IDs out of arcids (excluding end) that have tags
8104 # archeads(a) - IDs out of arcids (excluding end) that have heads
8105 # The start of an arc is at the descendent end, so "incoming" means
8106 # coming from descendents, and "outgoing" means going towards ancestors.
8108 proc getallclines {fd} {
8109 global allparents allchildren idtags idheads nextarc
8110 global arcnos arcids arctags arcout arcend arcstart archeads growing
8111 global seeds allcommits cachedarcs allcupdate
8114 while {[incr nid] <= 1000 && [gets $fd line] >= 0} {
8115 set id [lindex $line 0]
8116 if {[info exists allparents($id)]} {
8121 set olds [lrange $line 1 end]
8122 set allparents($id) $olds
8123 if {![info exists allchildren($id)]} {
8124 set allchildren($id) {}
8129 if {[llength $olds] == 1 && [llength $a] == 1} {
8130 lappend arcids($a) $id
8131 if {[info exists idtags($id)]} {
8132 lappend arctags($a) $id
8134 if {[info exists idheads($id)]} {
8135 lappend archeads($a) $id
8137 if {[info exists allparents($olds)]} {
8138 # seen parent already
8139 if {![info exists arcout($olds)]} {
8142 lappend arcids($a) $olds
8143 set arcend($a) $olds
8146 lappend allchildren($olds) $id
8147 lappend arcnos($olds) $a
8151 foreach a $arcnos($id) {
8152 lappend arcids($a) $id
8159 lappend allchildren($p) $id
8160 set a [incr nextarc]
8161 set arcstart($a) $id
8168 if {[info exists allparents($p)]} {
8169 # seen it already, may need to make a new branch
8170 if {![info exists arcout($p)]} {
8173 lappend arcids($a) $p
8177 lappend arcnos($p) $a
8182 global cached_dheads cached_dtags cached_atags
8183 catch {unset cached_dheads}
8184 catch {unset cached_dtags}
8185 catch {unset cached_atags}
8188 return [expr {$nid >= 1000? 2: 1}]
8192 fconfigure $fd -blocking 1
8195 # got an error reading the list of commits
8196 # if we were updating, try rereading the whole thing again
8202 error_popup "[mc "Error reading commit topology information;\
8203 branch and preceding/following tag information\
8204 will be incomplete."]\n($err)"
8207 if {[incr allcommits -1] == 0} {
8217 proc recalcarc {a} {
8218 global arctags archeads arcids idtags idheads
8222 foreach id [lrange $arcids($a) 0 end-1] {
8223 if {[info exists idtags($id)]} {
8226 if {[info exists idheads($id)]} {
8231 set archeads($a) $ah
8235 global arcnos arcids nextarc arctags archeads idtags idheads
8236 global arcstart arcend arcout allparents growing
8239 if {[llength $a] != 1} {
8240 puts "oops splitarc called but [llength $a] arcs already"
8244 set i [lsearch -exact $arcids($a) $p]
8246 puts "oops splitarc $p not in arc $a"
8249 set na [incr nextarc]
8250 if {[info exists arcend($a)]} {
8251 set arcend($na) $arcend($a)
8253 set l [lindex $allparents([lindex $arcids($a) end]) 0]
8254 set j [lsearch -exact $arcnos($l) $a]
8255 set arcnos($l) [lreplace $arcnos($l) $j $j $na]
8257 set tail [lrange $arcids($a) [expr {$i+1}] end]
8258 set arcids($a) [lrange $arcids($a) 0 $i]
8260 set arcstart($na) $p
8262 set arcids($na) $tail
8263 if {[info exists growing($a)]} {
8269 if {[llength $arcnos($id)] == 1} {
8272 set j [lsearch -exact $arcnos($id) $a]
8273 set arcnos($id) [lreplace $arcnos($id) $j $j $na]
8277 # reconstruct tags and heads lists
8278 if {$arctags($a) ne {} || $archeads($a) ne {}} {
8283 set archeads($na) {}
8287 # Update things for a new commit added that is a child of one
8288 # existing commit. Used when cherry-picking.
8289 proc addnewchild {id p} {
8290 global allparents allchildren idtags nextarc
8291 global arcnos arcids arctags arcout arcend arcstart archeads growing
8292 global seeds allcommits
8294 if {![info exists allcommits] || ![info exists arcnos($p)]} return
8295 set allparents($id) [list $p]
8296 set allchildren($id) {}
8299 lappend allchildren($p) $id
8300 set a [incr nextarc]
8301 set arcstart($a) $id
8304 set arcids($a) [list $p]
8306 if {![info exists arcout($p)]} {
8309 lappend arcnos($p) $a
8310 set arcout($id) [list $a]
8313 # This implements a cache for the topology information.
8314 # The cache saves, for each arc, the start and end of the arc,
8315 # the ids on the arc, and the outgoing arcs from the end.
8316 proc readcache {f} {
8317 global arcnos arcids arcout arcstart arcend arctags archeads nextarc
8318 global idtags idheads allparents cachedarcs possible_seeds seeds growing
8323 if {$lim - $a > 500} {
8324 set lim [expr {$a + 500}]
8328 # finish reading the cache and setting up arctags, etc.
8330 if {$line ne "1"} {error "bad final version"}
8332 foreach id [array names idtags] {
8333 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
8334 [llength $allparents($id)] == 1} {
8335 set a [lindex $arcnos($id) 0]
8336 if {$arctags($a) eq {}} {
8341 foreach id [array names idheads] {
8342 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
8343 [llength $allparents($id)] == 1} {
8344 set a [lindex $arcnos($id) 0]
8345 if {$archeads($a) eq {}} {
8350 foreach id [lsort -unique $possible_seeds] {
8351 if {$arcnos($id) eq {}} {
8357 while {[incr a] <= $lim} {
8359 if {[llength $line] != 3} {error "bad line"}
8360 set s [lindex $line 0]
8362 lappend arcout($s) $a
8363 if {![info exists arcnos($s)]} {
8364 lappend possible_seeds $s
8367 set e [lindex $line 1]
8372 if {![info exists arcout($e)]} {
8376 set arcids($a) [lindex $line 2]
8377 foreach id $arcids($a) {
8378 lappend allparents($s) $id
8380 lappend arcnos($id) $a
8382 if {![info exists allparents($s)]} {
8383 set allparents($s) {}
8388 set nextarc [expr {$a - 1}]
8401 global nextarc cachedarcs possible_seeds
8405 if {[llength $line] != 2 || [lindex $line 0] ne "1"} {error "bad version"}
8406 # make sure it's an integer
8407 set cachedarcs [expr {int([lindex $line 1])}]
8408 if {$cachedarcs < 0} {error "bad number of arcs"}
8410 set possible_seeds {}
8418 proc dropcache {err} {
8419 global allcwait nextarc cachedarcs seeds
8421 #puts "dropping cache ($err)"
8422 foreach v {arcnos arcout arcids arcstart arcend growing \
8423 arctags archeads allparents allchildren} {
8434 proc writecache {f} {
8435 global cachearc cachedarcs allccache
8436 global arcstart arcend arcnos arcids arcout
8440 if {$lim - $a > 1000} {
8441 set lim [expr {$a + 1000}]
8444 while {[incr a] <= $lim} {
8445 if {[info exists arcend($a)]} {
8446 puts $f [list $arcstart($a) $arcend($a) $arcids($a)]
8448 puts $f [list $arcstart($a) {} $arcids($a)]
8453 catch {file delete $allccache}
8454 #puts "writing cache failed ($err)"
8457 set cachearc [expr {$a - 1}]
8458 if {$a > $cachedarcs} {
8467 global nextarc cachedarcs cachearc allccache
8469 if {$nextarc == $cachedarcs} return
8471 set cachedarcs $nextarc
8473 set f [open $allccache w]
8474 puts $f [list 1 $cachedarcs]
8479 # Returns 1 if a is an ancestor of b, -1 if b is an ancestor of a,
8480 # or 0 if neither is true.
8481 proc anc_or_desc {a b} {
8482 global arcout arcstart arcend arcnos cached_isanc
8484 if {$arcnos($a) eq $arcnos($b)} {
8485 # Both are on the same arc(s); either both are the same BMP,
8486 # or if one is not a BMP, the other is also not a BMP or is
8487 # the BMP at end of the arc (and it only has 1 incoming arc).
8488 # Or both can be BMPs with no incoming arcs.
8489 if {$a eq $b || $arcnos($a) eq {}} {
8492 # assert {[llength $arcnos($a)] == 1}
8493 set arc [lindex $arcnos($a) 0]
8494 set i [lsearch -exact $arcids($arc) $a]
8495 set j [lsearch -exact $arcids($arc) $b]
8496 if {$i < 0 || $i > $j} {
8503 if {![info exists arcout($a)]} {
8504 set arc [lindex $arcnos($a) 0]
8505 if {[info exists arcend($arc)]} {
8506 set aend $arcend($arc)
8510 set a $arcstart($arc)
8514 if {![info exists arcout($b)]} {
8515 set arc [lindex $arcnos($b) 0]
8516 if {[info exists arcend($arc)]} {
8517 set bend $arcend($arc)
8521 set b $arcstart($arc)
8531 if {[info exists cached_isanc($a,$bend)]} {
8532 if {$cached_isanc($a,$bend)} {
8536 if {[info exists cached_isanc($b,$aend)]} {
8537 if {$cached_isanc($b,$aend)} {
8540 if {[info exists cached_isanc($a,$bend)]} {
8545 set todo [list $a $b]
8548 for {set i 0} {$i < [llength $todo]} {incr i} {
8549 set x [lindex $todo $i]
8550 if {$anc($x) eq {}} {
8553 foreach arc $arcnos($x) {
8554 set xd $arcstart($arc)
8556 set cached_isanc($a,$bend) 1
8557 set cached_isanc($b,$aend) 0
8559 } elseif {$xd eq $aend} {
8560 set cached_isanc($b,$aend) 1
8561 set cached_isanc($a,$bend) 0
8564 if {![info exists anc($xd)]} {
8565 set anc($xd) $anc($x)
8567 } elseif {$anc($xd) ne $anc($x)} {
8572 set cached_isanc($a,$bend) 0
8573 set cached_isanc($b,$aend) 0
8577 # This identifies whether $desc has an ancestor that is
8578 # a growing tip of the graph and which is not an ancestor of $anc
8579 # and returns 0 if so and 1 if not.
8580 # If we subsequently discover a tag on such a growing tip, and that
8581 # turns out to be a descendent of $anc (which it could, since we
8582 # don't necessarily see children before parents), then $desc
8583 # isn't a good choice to display as a descendent tag of
8584 # $anc (since it is the descendent of another tag which is
8585 # a descendent of $anc). Similarly, $anc isn't a good choice to
8586 # display as a ancestor tag of $desc.
8588 proc is_certain {desc anc} {
8589 global arcnos arcout arcstart arcend growing problems
8592 if {[llength $arcnos($anc)] == 1} {
8593 # tags on the same arc are certain
8594 if {$arcnos($desc) eq $arcnos($anc)} {
8597 if {![info exists arcout($anc)]} {
8598 # if $anc is partway along an arc, use the start of the arc instead
8599 set a [lindex $arcnos($anc) 0]
8600 set anc $arcstart($a)
8603 if {[llength $arcnos($desc)] > 1 || [info exists arcout($desc)]} {
8606 set a [lindex $arcnos($desc) 0]
8612 set anclist [list $x]
8616 for {set i 0} {$i < [llength $anclist] && ($nnh > 0 || $ngrowanc > 0)} {incr i} {
8617 set x [lindex $anclist $i]
8622 foreach a $arcout($x) {
8623 if {[info exists growing($a)]} {
8624 if {![info exists growanc($x)] && $dl($x)} {
8630 if {[info exists dl($y)]} {
8634 if {![info exists done($y)]} {
8637 if {[info exists growanc($x)]} {
8641 for {set k 0} {$k < [llength $xl]} {incr k} {
8642 set z [lindex $xl $k]
8643 foreach c $arcout($z) {
8644 if {[info exists arcend($c)]} {
8646 if {[info exists dl($v)] && $dl($v)} {
8648 if {![info exists done($v)]} {
8651 if {[info exists growanc($v)]} {
8661 } elseif {$y eq $anc || !$dl($x)} {
8672 foreach x [array names growanc] {
8681 proc validate_arctags {a} {
8682 global arctags idtags
8686 foreach id $arctags($a) {
8688 if {![info exists idtags($id)]} {
8689 set na [lreplace $na $i $i]
8696 proc validate_archeads {a} {
8697 global archeads idheads
8700 set na $archeads($a)
8701 foreach id $archeads($a) {
8703 if {![info exists idheads($id)]} {
8704 set na [lreplace $na $i $i]
8708 set archeads($a) $na
8711 # Return the list of IDs that have tags that are descendents of id,
8712 # ignoring IDs that are descendents of IDs already reported.
8713 proc desctags {id} {
8714 global arcnos arcstart arcids arctags idtags allparents
8715 global growing cached_dtags
8717 if {![info exists allparents($id)]} {
8720 set t1 [clock clicks -milliseconds]
8722 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
8723 # part-way along an arc; check that arc first
8724 set a [lindex $arcnos($id) 0]
8725 if {$arctags($a) ne {}} {
8727 set i [lsearch -exact $arcids($a) $id]
8729 foreach t $arctags($a) {
8730 set j [lsearch -exact $arcids($a) $t]
8738 set id $arcstart($a)
8739 if {[info exists idtags($id)]} {
8743 if {[info exists cached_dtags($id)]} {
8744 return $cached_dtags($id)
8751 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
8752 set id [lindex $todo $i]
8754 set ta [info exists hastaggedancestor($id)]
8758 # ignore tags on starting node
8759 if {!$ta && $i > 0} {
8760 if {[info exists idtags($id)]} {
8763 } elseif {[info exists cached_dtags($id)]} {
8764 set tagloc($id) $cached_dtags($id)
8768 foreach a $arcnos($id) {
8770 if {!$ta && $arctags($a) ne {}} {
8772 if {$arctags($a) ne {}} {
8773 lappend tagloc($id) [lindex $arctags($a) end]
8776 if {$ta || $arctags($a) ne {}} {
8777 set tomark [list $d]
8778 for {set j 0} {$j < [llength $tomark]} {incr j} {
8779 set dd [lindex $tomark $j]
8780 if {![info exists hastaggedancestor($dd)]} {
8781 if {[info exists done($dd)]} {
8782 foreach b $arcnos($dd) {
8783 lappend tomark $arcstart($b)
8785 if {[info exists tagloc($dd)]} {
8788 } elseif {[info exists queued($dd)]} {
8791 set hastaggedancestor($dd) 1
8795 if {![info exists queued($d)]} {
8798 if {![info exists hastaggedancestor($d)]} {
8805 foreach id [array names tagloc] {
8806 if {![info exists hastaggedancestor($id)]} {
8807 foreach t $tagloc($id) {
8808 if {[lsearch -exact $tags $t] < 0} {
8814 set t2 [clock clicks -milliseconds]
8817 # remove tags that are descendents of other tags
8818 for {set i 0} {$i < [llength $tags]} {incr i} {
8819 set a [lindex $tags $i]
8820 for {set j 0} {$j < $i} {incr j} {
8821 set b [lindex $tags $j]
8822 set r [anc_or_desc $a $b]
8824 set tags [lreplace $tags $j $j]
8827 } elseif {$r == -1} {
8828 set tags [lreplace $tags $i $i]
8835 if {[array names growing] ne {}} {
8836 # graph isn't finished, need to check if any tag could get
8837 # eclipsed by another tag coming later. Simply ignore any
8838 # tags that could later get eclipsed.
8841 if {[is_certain $t $origid]} {
8845 if {$tags eq $ctags} {
8846 set cached_dtags($origid) $tags
8851 set cached_dtags($origid) $tags
8853 set t3 [clock clicks -milliseconds]
8854 if {0 && $t3 - $t1 >= 100} {
8855 puts "iterating descendents ($loopix/[llength $todo] nodes) took\
8856 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
8862 global arcnos arcids arcout arcend arctags idtags allparents
8863 global growing cached_atags
8865 if {![info exists allparents($id)]} {
8868 set t1 [clock clicks -milliseconds]
8870 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
8871 # part-way along an arc; check that arc first
8872 set a [lindex $arcnos($id) 0]
8873 if {$arctags($a) ne {}} {
8875 set i [lsearch -exact $arcids($a) $id]
8876 foreach t $arctags($a) {
8877 set j [lsearch -exact $arcids($a) $t]
8883 if {![info exists arcend($a)]} {
8887 if {[info exists idtags($id)]} {
8891 if {[info exists cached_atags($id)]} {
8892 return $cached_atags($id)
8900 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
8901 set id [lindex $todo $i]
8903 set td [info exists hastaggeddescendent($id)]
8907 # ignore tags on starting node
8908 if {!$td && $i > 0} {
8909 if {[info exists idtags($id)]} {
8912 } elseif {[info exists cached_atags($id)]} {
8913 set tagloc($id) $cached_atags($id)
8917 foreach a $arcout($id) {
8918 if {!$td && $arctags($a) ne {}} {
8920 if {$arctags($a) ne {}} {
8921 lappend tagloc($id) [lindex $arctags($a) 0]
8924 if {![info exists arcend($a)]} continue
8926 if {$td || $arctags($a) ne {}} {
8927 set tomark [list $d]
8928 for {set j 0} {$j < [llength $tomark]} {incr j} {
8929 set dd [lindex $tomark $j]
8930 if {![info exists hastaggeddescendent($dd)]} {
8931 if {[info exists done($dd)]} {
8932 foreach b $arcout($dd) {
8933 if {[info exists arcend($b)]} {
8934 lappend tomark $arcend($b)
8937 if {[info exists tagloc($dd)]} {
8940 } elseif {[info exists queued($dd)]} {
8943 set hastaggeddescendent($dd) 1
8947 if {![info exists queued($d)]} {
8950 if {![info exists hastaggeddescendent($d)]} {
8956 set t2 [clock clicks -milliseconds]
8959 foreach id [array names tagloc] {
8960 if {![info exists hastaggeddescendent($id)]} {
8961 foreach t $tagloc($id) {
8962 if {[lsearch -exact $tags $t] < 0} {
8969 # remove tags that are ancestors of other tags
8970 for {set i 0} {$i < [llength $tags]} {incr i} {
8971 set a [lindex $tags $i]
8972 for {set j 0} {$j < $i} {incr j} {
8973 set b [lindex $tags $j]
8974 set r [anc_or_desc $a $b]
8976 set tags [lreplace $tags $j $j]
8979 } elseif {$r == 1} {
8980 set tags [lreplace $tags $i $i]
8987 if {[array names growing] ne {}} {
8988 # graph isn't finished, need to check if any tag could get
8989 # eclipsed by another tag coming later. Simply ignore any
8990 # tags that could later get eclipsed.
8993 if {[is_certain $origid $t]} {
8997 if {$tags eq $ctags} {
8998 set cached_atags($origid) $tags
9003 set cached_atags($origid) $tags
9005 set t3 [clock clicks -milliseconds]
9006 if {0 && $t3 - $t1 >= 100} {
9007 puts "iterating ancestors ($loopix/[llength $todo] nodes) took\
9008 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
9013 # Return the list of IDs that have heads that are descendents of id,
9014 # including id itself if it has a head.
9015 proc descheads {id} {
9016 global arcnos arcstart arcids archeads idheads cached_dheads
9019 if {![info exists allparents($id)]} {
9023 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
9024 # part-way along an arc; check it first
9025 set a [lindex $arcnos($id) 0]
9026 if {$archeads($a) ne {}} {
9027 validate_archeads $a
9028 set i [lsearch -exact $arcids($a) $id]
9029 foreach t $archeads($a) {
9030 set j [lsearch -exact $arcids($a) $t]
9035 set id $arcstart($a)
9041 for {set i 0} {$i < [llength $todo]} {incr i} {
9042 set id [lindex $todo $i]
9043 if {[info exists cached_dheads($id)]} {
9044 set ret [concat $ret $cached_dheads($id)]
9046 if {[info exists idheads($id)]} {
9049 foreach a $arcnos($id) {
9050 if {$archeads($a) ne {}} {
9051 validate_archeads $a
9052 if {$archeads($a) ne {}} {
9053 set ret [concat $ret $archeads($a)]
9057 if {![info exists seen($d)]} {
9064 set ret [lsort -unique $ret]
9065 set cached_dheads($origid) $ret
9066 return [concat $ret $aret]
9069 proc addedtag {id} {
9070 global arcnos arcout cached_dtags cached_atags
9072 if {![info exists arcnos($id)]} return
9073 if {![info exists arcout($id)]} {
9074 recalcarc [lindex $arcnos($id) 0]
9076 catch {unset cached_dtags}
9077 catch {unset cached_atags}
9080 proc addedhead {hid head} {
9081 global arcnos arcout cached_dheads
9083 if {![info exists arcnos($hid)]} return
9084 if {![info exists arcout($hid)]} {
9085 recalcarc [lindex $arcnos($hid) 0]
9087 catch {unset cached_dheads}
9090 proc removedhead {hid head} {
9091 global cached_dheads
9093 catch {unset cached_dheads}
9096 proc movedhead {hid head} {
9097 global arcnos arcout cached_dheads
9099 if {![info exists arcnos($hid)]} return
9100 if {![info exists arcout($hid)]} {
9101 recalcarc [lindex $arcnos($hid) 0]
9103 catch {unset cached_dheads}
9106 proc changedrefs {} {
9107 global cached_dheads cached_dtags cached_atags
9108 global arctags archeads arcnos arcout idheads idtags
9110 foreach id [concat [array names idheads] [array names idtags]] {
9111 if {[info exists arcnos($id)] && ![info exists arcout($id)]} {
9112 set a [lindex $arcnos($id) 0]
9113 if {![info exists donearc($a)]} {
9119 catch {unset cached_dtags}
9120 catch {unset cached_atags}
9121 catch {unset cached_dheads}
9124 proc rereadrefs {} {
9125 global idtags idheads idotherrefs mainheadid
9127 set refids [concat [array names idtags] \
9128 [array names idheads] [array names idotherrefs]]
9129 foreach id $refids {
9130 if {![info exists ref($id)]} {
9131 set ref($id) [listrefs $id]
9134 set oldmainhead $mainheadid
9137 set refids [lsort -unique [concat $refids [array names idtags] \
9138 [array names idheads] [array names idotherrefs]]]
9139 foreach id $refids {
9140 set v [listrefs $id]
9141 if {![info exists ref($id)] || $ref($id) != $v} {
9145 if {$oldmainhead ne $mainheadid} {
9146 redrawtags $oldmainhead
9147 redrawtags $mainheadid
9152 proc listrefs {id} {
9153 global idtags idheads idotherrefs
9156 if {[info exists idtags($id)]} {
9160 if {[info exists idheads($id)]} {
9164 if {[info exists idotherrefs($id)]} {
9165 set z $idotherrefs($id)
9167 return [list $x $y $z]
9170 proc showtag {tag isnew} {
9171 global ctext tagcontents tagids linknum tagobjid
9174 addtohistory [list showtag $tag 0]
9176 $ctext conf -state normal
9180 if {![info exists tagcontents($tag)]} {
9182 set tagcontents($tag) [exec git cat-file tag $tagobjid($tag)]
9185 if {[info exists tagcontents($tag)]} {
9186 set text $tagcontents($tag)
9188 set text "[mc "Tag"]: $tag\n[mc "Id"]: $tagids($tag)"
9190 appendwithlinks $text {}
9191 $ctext conf -state disabled
9203 if {[info exists gitktmpdir]} {
9204 catch {file delete -force $gitktmpdir}
9208 proc mkfontdisp {font top which} {
9209 global fontattr fontpref $font
9211 set fontpref($font) [set $font]
9212 button $top.${font}but -text $which -font optionfont \
9213 -command [list choosefont $font $which]
9214 label $top.$font -relief flat -font $font \
9215 -text $fontattr($font,family) -justify left
9216 grid x $top.${font}but $top.$font -sticky w
9219 proc choosefont {font which} {
9220 global fontparam fontlist fonttop fontattr
9222 set fontparam(which) $which
9223 set fontparam(font) $font
9224 set fontparam(family) [font actual $font -family]
9225 set fontparam(size) $fontattr($font,size)
9226 set fontparam(weight) $fontattr($font,weight)
9227 set fontparam(slant) $fontattr($font,slant)
9230 if {![winfo exists $top]} {
9232 eval font config sample [font actual $font]
9234 wm title $top [mc "Gitk font chooser"]
9235 label $top.l -textvariable fontparam(which)
9236 pack $top.l -side top
9237 set fontlist [lsort [font families]]
9239 listbox $top.f.fam -listvariable fontlist \
9240 -yscrollcommand [list $top.f.sb set]
9241 bind $top.f.fam <<ListboxSelect>> selfontfam
9242 scrollbar $top.f.sb -command [list $top.f.fam yview]
9243 pack $top.f.sb -side right -fill y
9244 pack $top.f.fam -side left -fill both -expand 1
9245 pack $top.f -side top -fill both -expand 1
9247 spinbox $top.g.size -from 4 -to 40 -width 4 \
9248 -textvariable fontparam(size) \
9249 -validatecommand {string is integer -strict %s}
9250 checkbutton $top.g.bold -padx 5 \
9251 -font {{Times New Roman} 12 bold} -text [mc "B"] -indicatoron 0 \
9252 -variable fontparam(weight) -onvalue bold -offvalue normal
9253 checkbutton $top.g.ital -padx 5 \
9254 -font {{Times New Roman} 12 italic} -text [mc "I"] -indicatoron 0 \
9255 -variable fontparam(slant) -onvalue italic -offvalue roman
9256 pack $top.g.size $top.g.bold $top.g.ital -side left
9257 pack $top.g -side top
9258 canvas $top.c -width 150 -height 50 -border 2 -relief sunk \
9260 $top.c create text 100 25 -anchor center -text $which -font sample \
9261 -fill black -tags text
9262 bind $top.c <Configure> [list centertext $top.c]
9263 pack $top.c -side top -fill x
9265 button $top.buts.ok -text [mc "OK"] -command fontok -default active
9266 button $top.buts.can -text [mc "Cancel"] -command fontcan -default normal
9267 grid $top.buts.ok $top.buts.can
9268 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9269 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9270 pack $top.buts -side bottom -fill x
9271 trace add variable fontparam write chg_fontparam
9274 $top.c itemconf text -text $which
9276 set i [lsearch -exact $fontlist $fontparam(family)]
9278 $top.f.fam selection set $i
9283 proc centertext {w} {
9284 $w coords text [expr {[winfo width $w] / 2}] [expr {[winfo height $w] / 2}]
9288 global fontparam fontpref prefstop
9290 set f $fontparam(font)
9291 set fontpref($f) [list $fontparam(family) $fontparam(size)]
9292 if {$fontparam(weight) eq "bold"} {
9293 lappend fontpref($f) "bold"
9295 if {$fontparam(slant) eq "italic"} {
9296 lappend fontpref($f) "italic"
9299 $w conf -text $fontparam(family) -font $fontpref($f)
9305 global fonttop fontparam
9307 if {[info exists fonttop]} {
9308 catch {destroy $fonttop}
9309 catch {font delete sample}
9315 proc selfontfam {} {
9316 global fonttop fontparam
9318 set i [$fonttop.f.fam curselection]
9320 set fontparam(family) [$fonttop.f.fam get $i]
9324 proc chg_fontparam {v sub op} {
9327 font config sample -$sub $fontparam($sub)
9331 global maxwidth maxgraphpct
9332 global oldprefs prefstop showneartags showlocalchanges
9333 global bgcolor fgcolor ctext diffcolors selectbgcolor
9334 global tabstop limitdiffs autoselect extdifftool perfile_attrs
9338 if {[winfo exists $top]} {
9342 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
9343 limitdiffs tabstop perfile_attrs} {
9344 set oldprefs($v) [set $v]
9347 wm title $top [mc "Gitk preferences"]
9348 label $top.ldisp -text [mc "Commit list display options"]
9349 grid $top.ldisp - -sticky w -pady 10
9350 label $top.spacer -text " "
9351 label $top.maxwidthl -text [mc "Maximum graph width (lines)"] \
9353 spinbox $top.maxwidth -from 0 -to 100 -width 4 -textvariable maxwidth
9354 grid $top.spacer $top.maxwidthl $top.maxwidth -sticky w
9355 label $top.maxpctl -text [mc "Maximum graph width (% of pane)"] \
9357 spinbox $top.maxpct -from 1 -to 100 -width 4 -textvariable maxgraphpct
9358 grid x $top.maxpctl $top.maxpct -sticky w
9359 frame $top.showlocal
9360 label $top.showlocal.l -text [mc "Show local changes"] -font optionfont
9361 checkbutton $top.showlocal.b -variable showlocalchanges
9362 pack $top.showlocal.b $top.showlocal.l -side left
9363 grid x $top.showlocal -sticky w
9364 frame $top.autoselect
9365 label $top.autoselect.l -text [mc "Auto-select SHA1"] -font optionfont
9366 checkbutton $top.autoselect.b -variable autoselect
9367 pack $top.autoselect.b $top.autoselect.l -side left
9368 grid x $top.autoselect -sticky w
9370 label $top.ddisp -text [mc "Diff display options"]
9371 grid $top.ddisp - -sticky w -pady 10
9372 label $top.tabstopl -text [mc "Tab spacing"] -font optionfont
9373 spinbox $top.tabstop -from 1 -to 20 -width 4 -textvariable tabstop
9374 grid x $top.tabstopl $top.tabstop -sticky w
9376 label $top.ntag.l -text [mc "Display nearby tags"] -font optionfont
9377 checkbutton $top.ntag.b -variable showneartags
9378 pack $top.ntag.b $top.ntag.l -side left
9379 grid x $top.ntag -sticky w
9381 label $top.ldiff.l -text [mc "Limit diffs to listed paths"] -font optionfont
9382 checkbutton $top.ldiff.b -variable limitdiffs
9383 pack $top.ldiff.b $top.ldiff.l -side left
9384 grid x $top.ldiff -sticky w
9386 label $top.lattr.l -text [mc "Support per-file encodings"] -font optionfont
9387 checkbutton $top.lattr.b -variable perfile_attrs
9388 pack $top.lattr.b $top.lattr.l -side left
9389 grid x $top.lattr -sticky w
9391 entry $top.extdifft -textvariable extdifftool
9393 label $top.extdifff.l -text [mc "External diff tool" ] -font optionfont \
9395 button $top.extdifff.b -text [mc "Choose..."] -font optionfont \
9396 -command choose_extdiff
9397 pack $top.extdifff.l $top.extdifff.b -side left
9398 grid x $top.extdifff $top.extdifft -sticky w
9400 label $top.cdisp -text [mc "Colors: press to choose"]
9401 grid $top.cdisp - -sticky w -pady 10
9402 label $top.bg -padx 40 -relief sunk -background $bgcolor
9403 button $top.bgbut -text [mc "Background"] -font optionfont \
9404 -command [list choosecolor bgcolor {} $top.bg background setbg]
9405 grid x $top.bgbut $top.bg -sticky w
9406 label $top.fg -padx 40 -relief sunk -background $fgcolor
9407 button $top.fgbut -text [mc "Foreground"] -font optionfont \
9408 -command [list choosecolor fgcolor {} $top.fg foreground setfg]
9409 grid x $top.fgbut $top.fg -sticky w
9410 label $top.diffold -padx 40 -relief sunk -background [lindex $diffcolors 0]
9411 button $top.diffoldbut -text [mc "Diff: old lines"] -font optionfont \
9412 -command [list choosecolor diffcolors 0 $top.diffold "diff old lines" \
9413 [list $ctext tag conf d0 -foreground]]
9414 grid x $top.diffoldbut $top.diffold -sticky w
9415 label $top.diffnew -padx 40 -relief sunk -background [lindex $diffcolors 1]
9416 button $top.diffnewbut -text [mc "Diff: new lines"] -font optionfont \
9417 -command [list choosecolor diffcolors 1 $top.diffnew "diff new lines" \
9418 [list $ctext tag conf d1 -foreground]]
9419 grid x $top.diffnewbut $top.diffnew -sticky w
9420 label $top.hunksep -padx 40 -relief sunk -background [lindex $diffcolors 2]
9421 button $top.hunksepbut -text [mc "Diff: hunk header"] -font optionfont \
9422 -command [list choosecolor diffcolors 2 $top.hunksep \
9423 "diff hunk header" \
9424 [list $ctext tag conf hunksep -foreground]]
9425 grid x $top.hunksepbut $top.hunksep -sticky w
9426 label $top.selbgsep -padx 40 -relief sunk -background $selectbgcolor
9427 button $top.selbgbut -text [mc "Select bg"] -font optionfont \
9428 -command [list choosecolor selectbgcolor {} $top.selbgsep background setselbg]
9429 grid x $top.selbgbut $top.selbgsep -sticky w
9431 label $top.cfont -text [mc "Fonts: press to choose"]
9432 grid $top.cfont - -sticky w -pady 10
9433 mkfontdisp mainfont $top [mc "Main font"]
9434 mkfontdisp textfont $top [mc "Diff display font"]
9435 mkfontdisp uifont $top [mc "User interface font"]
9438 button $top.buts.ok -text [mc "OK"] -command prefsok -default active
9439 button $top.buts.can -text [mc "Cancel"] -command prefscan -default normal
9440 grid $top.buts.ok $top.buts.can
9441 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9442 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9443 grid $top.buts - - -pady 10 -sticky ew
9444 bind $top <Visibility> "focus $top.buts.ok"
9447 proc choose_extdiff {} {
9450 set prog [tk_getOpenFile -title "External diff tool" -multiple false]
9452 set extdifftool $prog
9456 proc choosecolor {v vi w x cmd} {
9459 set c [tk_chooseColor -initialcolor [lindex [set $v] $vi] \
9460 -title [mc "Gitk: choose color for %s" $x]]
9461 if {$c eq {}} return
9462 $w conf -background $c
9468 global bglist cflist
9470 $w configure -selectbackground $c
9472 $cflist tag configure highlight \
9473 -background [$cflist cget -selectbackground]
9474 allcanvs itemconf secsel -fill $c
9481 $w conf -background $c
9489 $w conf -foreground $c
9491 allcanvs itemconf text -fill $c
9492 $canv itemconf circle -outline $c
9496 global oldprefs prefstop
9498 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
9499 limitdiffs tabstop perfile_attrs} {
9501 set $v $oldprefs($v)
9503 catch {destroy $prefstop}
9509 global maxwidth maxgraphpct
9510 global oldprefs prefstop showneartags showlocalchanges
9511 global fontpref mainfont textfont uifont
9512 global limitdiffs treediffs perfile_attrs
9514 catch {destroy $prefstop}
9518 if {$mainfont ne $fontpref(mainfont)} {
9519 set mainfont $fontpref(mainfont)
9520 parsefont mainfont $mainfont
9521 eval font configure mainfont [fontflags mainfont]
9522 eval font configure mainfontbold [fontflags mainfont 1]
9526 if {$textfont ne $fontpref(textfont)} {
9527 set textfont $fontpref(textfont)
9528 parsefont textfont $textfont
9529 eval font configure textfont [fontflags textfont]
9530 eval font configure textfontbold [fontflags textfont 1]
9532 if {$uifont ne $fontpref(uifont)} {
9533 set uifont $fontpref(uifont)
9534 parsefont uifont $uifont
9535 eval font configure uifont [fontflags uifont]
9538 if {$showlocalchanges != $oldprefs(showlocalchanges)} {
9539 if {$showlocalchanges} {
9545 if {$limitdiffs != $oldprefs(limitdiffs) ||
9546 ($perfile_attrs && !$oldprefs(perfile_attrs))} {
9547 # treediffs elements are limited by path;
9548 # won't have encodings cached if perfile_attrs was just turned on
9549 catch {unset treediffs}
9551 if {$fontchanged || $maxwidth != $oldprefs(maxwidth)
9552 || $maxgraphpct != $oldprefs(maxgraphpct)} {
9554 } elseif {$showneartags != $oldprefs(showneartags) ||
9555 $limitdiffs != $oldprefs(limitdiffs)} {
9560 proc formatdate {d} {
9561 global datetimeformat
9563 set d [clock format $d -format $datetimeformat]
9568 # This list of encoding names and aliases is distilled from
9569 # http://www.iana.org/assignments/character-sets.
9570 # Not all of them are supported by Tcl.
9571 set encoding_aliases {
9572 { ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991 ASCII
9573 ISO646-US US-ASCII us IBM367 cp367 csASCII }
9574 { ISO-10646-UTF-1 csISO10646UTF1 }
9575 { ISO_646.basic:1983 ref csISO646basic1983 }
9576 { INVARIANT csINVARIANT }
9577 { ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion }
9578 { BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom }
9579 { NATS-SEFI iso-ir-8-1 csNATSSEFI }
9580 { NATS-SEFI-ADD iso-ir-8-2 csNATSSEFIADD }
9581 { NATS-DANO iso-ir-9-1 csNATSDANO }
9582 { NATS-DANO-ADD iso-ir-9-2 csNATSDANOADD }
9583 { SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE se csISO10Swedish }
9584 { SEN_850200_C iso-ir-11 ISO646-SE2 se2 csISO11SwedishForNames }
9585 { KS_C_5601-1987 iso-ir-149 KS_C_5601-1989 KSC_5601 korean csKSC56011987 }
9586 { ISO-2022-KR csISO2022KR }
9588 { ISO-2022-JP csISO2022JP }
9589 { ISO-2022-JP-2 csISO2022JP2 }
9590 { JIS_C6220-1969-jp JIS_C6220-1969 iso-ir-13 katakana x0201-7
9592 { JIS_C6220-1969-ro iso-ir-14 jp ISO646-JP csISO14JISC6220ro }
9593 { IT iso-ir-15 ISO646-IT csISO15Italian }
9594 { PT iso-ir-16 ISO646-PT csISO16Portuguese }
9595 { ES iso-ir-17 ISO646-ES csISO17Spanish }
9596 { greek7-old iso-ir-18 csISO18Greek7Old }
9597 { latin-greek iso-ir-19 csISO19LatinGreek }
9598 { DIN_66003 iso-ir-21 de ISO646-DE csISO21German }
9599 { NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French }
9600 { Latin-greek-1 iso-ir-27 csISO27LatinGreek1 }
9601 { ISO_5427 iso-ir-37 csISO5427Cyrillic }
9602 { JIS_C6226-1978 iso-ir-42 csISO42JISC62261978 }
9603 { BS_viewdata iso-ir-47 csISO47BSViewdata }
9604 { INIS iso-ir-49 csISO49INIS }
9605 { INIS-8 iso-ir-50 csISO50INIS8 }
9606 { INIS-cyrillic iso-ir-51 csISO51INISCyrillic }
9607 { ISO_5427:1981 iso-ir-54 ISO5427Cyrillic1981 }
9608 { ISO_5428:1980 iso-ir-55 csISO5428Greek }
9609 { GB_1988-80 iso-ir-57 cn ISO646-CN csISO57GB1988 }
9610 { GB_2312-80 iso-ir-58 chinese csISO58GB231280 }
9611 { NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
9613 { NS_4551-2 ISO646-NO2 iso-ir-61 no2 csISO61Norwegian2 }
9614 { NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French }
9615 { videotex-suppl iso-ir-70 csISO70VideotexSupp1 }
9616 { PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2 }
9617 { ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2 }
9618 { MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian }
9619 { JIS_C6226-1983 iso-ir-87 x0208 JIS_X0208-1983 csISO87JISX0208 }
9620 { greek7 iso-ir-88 csISO88Greek7 }
9621 { ASMO_449 ISO_9036 arabic7 iso-ir-89 csISO89ASMO449 }
9622 { iso-ir-90 csISO90 }
9623 { JIS_C6229-1984-a iso-ir-91 jp-ocr-a csISO91JISC62291984a }
9624 { JIS_C6229-1984-b iso-ir-92 ISO646-JP-OCR-B jp-ocr-b
9625 csISO92JISC62991984b }
9626 { JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add csISO93JIS62291984badd }
9627 { JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand csISO94JIS62291984hand }
9628 { JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
9629 csISO95JIS62291984handadd }
9630 { JIS_C6229-1984-kana iso-ir-96 csISO96JISC62291984kana }
9631 { ISO_2033-1983 iso-ir-98 e13b csISO2033 }
9632 { ANSI_X3.110-1983 iso-ir-99 CSA_T500-1983 NAPLPS csISO99NAPLPS }
9633 { ISO_8859-1:1987 iso-ir-100 ISO_8859-1 ISO-8859-1 latin1 l1 IBM819
9635 { ISO_8859-2:1987 iso-ir-101 ISO_8859-2 ISO-8859-2 latin2 l2 csISOLatin2 }
9636 { T.61-7bit iso-ir-102 csISO102T617bit }
9637 { T.61-8bit T.61 iso-ir-103 csISO103T618bit }
9638 { ISO_8859-3:1988 iso-ir-109 ISO_8859-3 ISO-8859-3 latin3 l3 csISOLatin3 }
9639 { ISO_8859-4:1988 iso-ir-110 ISO_8859-4 ISO-8859-4 latin4 l4 csISOLatin4 }
9640 { ECMA-cyrillic iso-ir-111 KOI8-E csISO111ECMACyrillic }
9641 { CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca csISO121Canadian1 }
9642 { CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2 csISO122Canadian2 }
9643 { CSA_Z243.4-1985-gr iso-ir-123 csISO123CSAZ24341985gr }
9644 { ISO_8859-6:1987 iso-ir-127 ISO_8859-6 ISO-8859-6 ECMA-114 ASMO-708
9645 arabic csISOLatinArabic }
9646 { ISO_8859-6-E csISO88596E ISO-8859-6-E }
9647 { ISO_8859-6-I csISO88596I ISO-8859-6-I }
9648 { ISO_8859-7:1987 iso-ir-126 ISO_8859-7 ISO-8859-7 ELOT_928 ECMA-118
9649 greek greek8 csISOLatinGreek }
9650 { T.101-G2 iso-ir-128 csISO128T101G2 }
9651 { ISO_8859-8:1988 iso-ir-138 ISO_8859-8 ISO-8859-8 hebrew
9653 { ISO_8859-8-E csISO88598E ISO-8859-8-E }
9654 { ISO_8859-8-I csISO88598I ISO-8859-8-I }
9655 { CSN_369103 iso-ir-139 csISO139CSN369103 }
9656 { JUS_I.B1.002 iso-ir-141 ISO646-YU js yu csISO141JUSIB1002 }
9657 { ISO_6937-2-add iso-ir-142 csISOTextComm }
9658 { IEC_P27-1 iso-ir-143 csISO143IECP271 }
9659 { ISO_8859-5:1988 iso-ir-144 ISO_8859-5 ISO-8859-5 cyrillic
9660 csISOLatinCyrillic }
9661 { JUS_I.B1.003-serb iso-ir-146 serbian csISO146Serbian }
9662 { JUS_I.B1.003-mac macedonian iso-ir-147 csISO147Macedonian }
9663 { ISO_8859-9:1989 iso-ir-148 ISO_8859-9 ISO-8859-9 latin5 l5 csISOLatin5 }
9664 { greek-ccitt iso-ir-150 csISO150 csISO150GreekCCITT }
9665 { NC_NC00-10:81 cuba iso-ir-151 ISO646-CU csISO151Cuba }
9666 { ISO_6937-2-25 iso-ir-152 csISO6937Add }
9667 { GOST_19768-74 ST_SEV_358-88 iso-ir-153 csISO153GOST1976874 }
9668 { ISO_8859-supp iso-ir-154 latin1-2-5 csISO8859Supp }
9669 { ISO_10367-box iso-ir-155 csISO10367Box }
9670 { ISO-8859-10 iso-ir-157 l6 ISO_8859-10:1992 csISOLatin6 latin6 }
9671 { latin-lap lap iso-ir-158 csISO158Lap }
9672 { JIS_X0212-1990 x0212 iso-ir-159 csISO159JISX02121990 }
9673 { DS_2089 DS2089 ISO646-DK dk csISO646Danish }
9676 { JIS_X0201 X0201 csHalfWidthKatakana }
9677 { KSC5636 ISO646-KR csKSC5636 }
9678 { ISO-10646-UCS-2 csUnicode }
9679 { ISO-10646-UCS-4 csUCS4 }
9680 { DEC-MCS dec csDECMCS }
9681 { hp-roman8 roman8 r8 csHPRoman8 }
9682 { macintosh mac csMacintosh }
9683 { IBM037 cp037 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl
9685 { IBM038 EBCDIC-INT cp038 csIBM038 }
9686 { IBM273 CP273 csIBM273 }
9687 { IBM274 EBCDIC-BE CP274 csIBM274 }
9688 { IBM275 EBCDIC-BR cp275 csIBM275 }
9689 { IBM277 EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 }
9690 { IBM278 CP278 ebcdic-cp-fi ebcdic-cp-se csIBM278 }
9691 { IBM280 CP280 ebcdic-cp-it csIBM280 }
9692 { IBM281 EBCDIC-JP-E cp281 csIBM281 }
9693 { IBM284 CP284 ebcdic-cp-es csIBM284 }
9694 { IBM285 CP285 ebcdic-cp-gb csIBM285 }
9695 { IBM290 cp290 EBCDIC-JP-kana csIBM290 }
9696 { IBM297 cp297 ebcdic-cp-fr csIBM297 }
9697 { IBM420 cp420 ebcdic-cp-ar1 csIBM420 }
9698 { IBM423 cp423 ebcdic-cp-gr csIBM423 }
9699 { IBM424 cp424 ebcdic-cp-he csIBM424 }
9700 { IBM437 cp437 437 csPC8CodePage437 }
9701 { IBM500 CP500 ebcdic-cp-be ebcdic-cp-ch csIBM500 }
9702 { IBM775 cp775 csPC775Baltic }
9703 { IBM850 cp850 850 csPC850Multilingual }
9704 { IBM851 cp851 851 csIBM851 }
9705 { IBM852 cp852 852 csPCp852 }
9706 { IBM855 cp855 855 csIBM855 }
9707 { IBM857 cp857 857 csIBM857 }
9708 { IBM860 cp860 860 csIBM860 }
9709 { IBM861 cp861 861 cp-is csIBM861 }
9710 { IBM862 cp862 862 csPC862LatinHebrew }
9711 { IBM863 cp863 863 csIBM863 }
9712 { IBM864 cp864 csIBM864 }
9713 { IBM865 cp865 865 csIBM865 }
9714 { IBM866 cp866 866 csIBM866 }
9715 { IBM868 CP868 cp-ar csIBM868 }
9716 { IBM869 cp869 869 cp-gr csIBM869 }
9717 { IBM870 CP870 ebcdic-cp-roece ebcdic-cp-yu csIBM870 }
9718 { IBM871 CP871 ebcdic-cp-is csIBM871 }
9719 { IBM880 cp880 EBCDIC-Cyrillic csIBM880 }
9720 { IBM891 cp891 csIBM891 }
9721 { IBM903 cp903 csIBM903 }
9722 { IBM904 cp904 904 csIBBM904 }
9723 { IBM905 CP905 ebcdic-cp-tr csIBM905 }
9724 { IBM918 CP918 ebcdic-cp-ar2 csIBM918 }
9725 { IBM1026 CP1026 csIBM1026 }
9726 { EBCDIC-AT-DE csIBMEBCDICATDE }
9727 { EBCDIC-AT-DE-A csEBCDICATDEA }
9728 { EBCDIC-CA-FR csEBCDICCAFR }
9729 { EBCDIC-DK-NO csEBCDICDKNO }
9730 { EBCDIC-DK-NO-A csEBCDICDKNOA }
9731 { EBCDIC-FI-SE csEBCDICFISE }
9732 { EBCDIC-FI-SE-A csEBCDICFISEA }
9733 { EBCDIC-FR csEBCDICFR }
9734 { EBCDIC-IT csEBCDICIT }
9735 { EBCDIC-PT csEBCDICPT }
9736 { EBCDIC-ES csEBCDICES }
9737 { EBCDIC-ES-A csEBCDICESA }
9738 { EBCDIC-ES-S csEBCDICESS }
9739 { EBCDIC-UK csEBCDICUK }
9740 { EBCDIC-US csEBCDICUS }
9741 { UNKNOWN-8BIT csUnknown8BiT }
9742 { MNEMONIC csMnemonic }
9747 { IBM00858 CCSID00858 CP00858 PC-Multilingual-850+euro }
9748 { IBM00924 CCSID00924 CP00924 ebcdic-Latin9--euro }
9749 { IBM01140 CCSID01140 CP01140 ebcdic-us-37+euro }
9750 { IBM01141 CCSID01141 CP01141 ebcdic-de-273+euro }
9751 { IBM01142 CCSID01142 CP01142 ebcdic-dk-277+euro ebcdic-no-277+euro }
9752 { IBM01143 CCSID01143 CP01143 ebcdic-fi-278+euro ebcdic-se-278+euro }
9753 { IBM01144 CCSID01144 CP01144 ebcdic-it-280+euro }
9754 { IBM01145 CCSID01145 CP01145 ebcdic-es-284+euro }
9755 { IBM01146 CCSID01146 CP01146 ebcdic-gb-285+euro }
9756 { IBM01147 CCSID01147 CP01147 ebcdic-fr-297+euro }
9757 { IBM01148 CCSID01148 CP01148 ebcdic-international-500+euro }
9758 { IBM01149 CCSID01149 CP01149 ebcdic-is-871+euro }
9759 { IBM1047 IBM-1047 }
9760 { PTCP154 csPTCP154 PT154 CP154 Cyrillic-Asian }
9761 { Amiga-1251 Ami1251 Amiga1251 Ami-1251 }
9762 { UNICODE-1-1 csUnicode11 }
9765 { UNICODE-1-1-UTF-7 csUnicode11UTF7 }
9766 { ISO-8859-14 iso-ir-199 ISO_8859-14:1998 ISO_8859-14 latin8 iso-celtic
9768 { ISO-8859-15 ISO_8859-15 Latin-9 }
9769 { ISO-8859-16 iso-ir-226 ISO_8859-16:2001 ISO_8859-16 latin10 l10 }
9770 { GBK CP936 MS936 windows-936 }
9771 { JIS_Encoding csJISEncoding }
9772 { Shift_JIS MS_Kanji csShiftJIS ShiftJIS Shift-JIS }
9773 { Extended_UNIX_Code_Packed_Format_for_Japanese csEUCPkdFmtJapanese
9775 { Extended_UNIX_Code_Fixed_Width_for_Japanese csEUCFixWidJapanese }
9776 { ISO-10646-UCS-Basic csUnicodeASCII }
9777 { ISO-10646-Unicode-Latin1 csUnicodeLatin1 ISO-10646 }
9778 { ISO-Unicode-IBM-1261 csUnicodeIBM1261 }
9779 { ISO-Unicode-IBM-1268 csUnicodeIBM1268 }
9780 { ISO-Unicode-IBM-1276 csUnicodeIBM1276 }
9781 { ISO-Unicode-IBM-1264 csUnicodeIBM1264 }
9782 { ISO-Unicode-IBM-1265 csUnicodeIBM1265 }
9783 { ISO-8859-1-Windows-3.0-Latin-1 csWindows30Latin1 }
9784 { ISO-8859-1-Windows-3.1-Latin-1 csWindows31Latin1 }
9785 { ISO-8859-2-Windows-Latin-2 csWindows31Latin2 }
9786 { ISO-8859-9-Windows-Latin-5 csWindows31Latin5 }
9787 { Adobe-Standard-Encoding csAdobeStandardEncoding }
9788 { Ventura-US csVenturaUS }
9789 { Ventura-International csVenturaInternational }
9790 { PC8-Danish-Norwegian csPC8DanishNorwegian }
9791 { PC8-Turkish csPC8Turkish }
9792 { IBM-Symbols csIBMSymbols }
9793 { IBM-Thai csIBMThai }
9794 { HP-Legal csHPLegal }
9795 { HP-Pi-font csHPPiFont }
9796 { HP-Math8 csHPMath8 }
9797 { Adobe-Symbol-Encoding csHPPSMath }
9798 { HP-DeskTop csHPDesktop }
9799 { Ventura-Math csVenturaMath }
9800 { Microsoft-Publishing csMicrosoftPublishing }
9801 { Windows-31J csWindows31J }
9806 proc tcl_encoding {enc} {
9807 global encoding_aliases tcl_encoding_cache
9808 if {[info exists tcl_encoding_cache($enc)]} {
9809 return $tcl_encoding_cache($enc)
9811 set names [encoding names]
9812 set lcnames [string tolower $names]
9813 set enc [string tolower $enc]
9814 set i [lsearch -exact $lcnames $enc]
9816 # look for "isonnn" instead of "iso-nnn" or "iso_nnn"
9817 if {[regsub {^(iso|cp|ibm|jis)[-_]} $enc {\1} encx]} {
9818 set i [lsearch -exact $lcnames $encx]
9822 foreach l $encoding_aliases {
9823 set ll [string tolower $l]
9824 if {[lsearch -exact $ll $enc] < 0} continue
9825 # look through the aliases for one that tcl knows about
9827 set i [lsearch -exact $lcnames $e]
9829 if {[regsub {^(iso|cp|ibm|jis)[-_]} $e {\1} ex]} {
9830 set i [lsearch -exact $lcnames $ex]
9840 set tclenc [lindex $names $i]
9842 set tcl_encoding_cache($enc) $tclenc
9846 proc gitattr {path attr default} {
9847 global path_attr_cache
9848 if {[info exists path_attr_cache($attr,$path)]} {
9849 set r $path_attr_cache($attr,$path)
9852 if {![catch {set line [exec git check-attr $attr -- $path]}]} {
9853 regexp "(.*): encoding: (.*)" $line m f r
9855 set path_attr_cache($attr,$path) $r
9857 if {$r eq "unspecified"} {
9863 proc cache_gitattr {attr pathlist} {
9864 global path_attr_cache
9866 foreach path $pathlist {
9867 if {![info exists path_attr_cache($attr,$path)]} {
9868 lappend newlist $path
9872 if {[tk windowingsystem] == "win32"} {
9873 # windows has a 32k limit on the arguments to a command...
9876 while {$newlist ne {}} {
9877 set head [lrange $newlist 0 [expr {$lim - 1}]]
9878 set newlist [lrange $newlist $lim end]
9879 if {![catch {set rlist [eval exec git check-attr $attr -- $head]}]} {
9880 foreach row [split $rlist "\n"] {
9881 if {[regexp "(.*): encoding: (.*)" $row m path value]} {
9882 if {[string index $path 0] eq "\""} {
9883 set path [encoding convertfrom [lindex $path 0]]
9885 set path_attr_cache($attr,$path) $value
9892 proc get_path_encoding {path} {
9893 global gui_encoding perfile_attrs
9894 set tcl_enc $gui_encoding
9895 if {$path ne {} && $perfile_attrs} {
9896 set enc2 [tcl_encoding [gitattr $path encoding $tcl_enc]]
9904 # First check that Tcl/Tk is recent enough
9905 if {[catch {package require Tk 8.4} err]} {
9906 show_error {} . [mc "Sorry, gitk cannot run with this version of Tcl/Tk.\n\
9907 Gitk requires at least Tcl/Tk 8.4."]
9912 set wrcomcmd "git diff-tree --stdin -p --pretty"
9916 set gitencoding [exec git config --get i18n.commitencoding]
9918 if {$gitencoding == ""} {
9919 set gitencoding "utf-8"
9921 set tclencoding [tcl_encoding $gitencoding]
9922 if {$tclencoding == {}} {
9923 puts stderr "Warning: encoding $gitencoding is not supported by Tcl/Tk"
9926 set gui_encoding [encoding system]
9928 set enc [exec git config --get gui.encoding]
9930 set tclenc [tcl_encoding $enc]
9931 if {$tclenc ne {}} {
9932 set gui_encoding $tclenc
9934 puts stderr "Warning: encoding $enc is not supported by Tcl/Tk"
9939 set mainfont {Helvetica 9}
9940 set textfont {Courier 9}
9941 set uifont {Helvetica 9 bold}
9943 set findmergefiles 0
9951 set cmitmode "patch"
9952 set wrapcomment "none"
9956 set showlocalchanges 1
9958 set datetimeformat "%Y-%m-%d %H:%M:%S"
9962 set extdifftool "meld"
9964 set colors {green red blue magenta darkgrey brown orange}
9967 set diffcolors {red "#00a000" blue}
9970 set selectbgcolor gray85
9972 set circlecolors {white blue gray blue blue}
9974 # button for popping up context menus
9975 if {[tk windowingsystem] eq "aqua"} {
9976 set ctxbut <Button-2>
9978 set ctxbut <Button-3>
9981 ## For msgcat loading, first locate the installation location.
9982 if { [info exists ::env(GITK_MSGSDIR)] } {
9983 ## Msgsdir was manually set in the environment.
9984 set gitk_msgsdir $::env(GITK_MSGSDIR)
9986 ## Let's guess the prefix from argv0.
9987 set gitk_prefix [file dirname [file dirname [file normalize $argv0]]]
9988 set gitk_libdir [file join $gitk_prefix share gitk lib]
9989 set gitk_msgsdir [file join $gitk_libdir msgs]
9993 ## Internationalization (i18n) through msgcat and gettext. See
9994 ## http://www.gnu.org/software/gettext/manual/html_node/Tcl.html
9995 package require msgcat
9996 namespace import ::msgcat::mc
9997 ## And eventually load the actual message catalog
9998 ::msgcat::mcload $gitk_msgsdir
10000 catch {source ~/.gitk}
10002 font create optionfont -family sans-serif -size -12
10004 parsefont mainfont $mainfont
10005 eval font create mainfont [fontflags mainfont]
10006 eval font create mainfontbold [fontflags mainfont 1]
10008 parsefont textfont $textfont
10009 eval font create textfont [fontflags textfont]
10010 eval font create textfontbold [fontflags textfont 1]
10012 parsefont uifont $uifont
10013 eval font create uifont [fontflags uifont]
10017 # check that we can find a .git directory somewhere...
10018 if {[catch {set gitdir [gitdir]}]} {
10019 show_error {} . [mc "Cannot find a git repository here."]
10022 if {![file isdirectory $gitdir]} {
10023 show_error {} . [mc "Cannot find the git directory \"%s\"." $gitdir]
10028 set selectheadid {}
10031 set cmdline_files {}
10033 set revtreeargscmd {}
10034 foreach arg $argv {
10035 switch -glob -- $arg {
10038 set cmdline_files [lrange $argv [expr {$i + 1}] end]
10041 "--select-commit=*" {
10042 set selecthead [string range $arg 16 end]
10045 set revtreeargscmd [string range $arg 10 end]
10048 lappend revtreeargs $arg
10054 if {$selecthead eq "HEAD"} {
10058 if {$i >= [llength $argv] && $revtreeargs ne {}} {
10059 # no -- on command line, but some arguments (other than --argscmd)
10061 set f [eval exec git rev-parse --no-revs --no-flags $revtreeargs]
10062 set cmdline_files [split $f "\n"]
10063 set n [llength $cmdline_files]
10064 set revtreeargs [lrange $revtreeargs 0 end-$n]
10065 # Unfortunately git rev-parse doesn't produce an error when
10066 # something is both a revision and a filename. To be consistent
10067 # with git log and git rev-list, check revtreeargs for filenames.
10068 foreach arg $revtreeargs {
10069 if {[file exists $arg]} {
10070 show_error {} . [mc "Ambiguous argument '%s': both revision\
10071 and filename" $arg]
10076 # unfortunately we get both stdout and stderr in $err,
10077 # so look for "fatal:".
10078 set i [string first "fatal:" $err]
10080 set err [string range $err [expr {$i + 6}] end]
10082 show_error {} . "[mc "Bad arguments to gitk:"]\n$err"
10087 set nullid "0000000000000000000000000000000000000000"
10088 set nullid2 "0000000000000000000000000000000000000001"
10089 set nullfile "/dev/null"
10091 set have_tk85 [expr {[package vcompare $tk_version "8.5"] >= 0}]
10098 set highlight_paths {}
10100 set searchdirn -forwards
10102 set boldnamerows {}
10103 set diffelide {0 0}
10104 set markingmatches 0
10105 set linkentercount 0
10106 set need_redisplay 0
10113 set selectedhlview [mc "None"]
10114 set highlight_related [mc "None"]
10115 set highlight_files {}
10116 set viewfiles(0) {}
10119 set viewargscmd(0) {}
10121 set selectedline {}
10129 set isworktree [expr {[exec git rev-parse --is-inside-work-tree] == "true"}]
10132 # wait for the window to become visible
10133 tkwait visibility .
10134 wm title . "[file tail $argv0]: [file tail [pwd]]"
10137 if {$cmdline_files ne {} || $revtreeargs ne {} || $revtreeargscmd ne {}} {
10138 # create a view for the files/dirs specified on the command line
10142 set viewname(1) [mc "Command line"]
10143 set viewfiles(1) $cmdline_files
10144 set viewargs(1) $revtreeargs
10145 set viewargscmd(1) $revtreeargscmd
10149 .bar.view entryconf [mc "Edit view..."] -state normal
10150 .bar.view entryconf [mc "Delete view"] -state normal
10153 if {[info exists permviews]} {
10154 foreach v $permviews {
10157 set viewname($n) [lindex $v 0]
10158 set viewfiles($n) [lindex $v 1]
10159 set viewargs($n) [lindex $v 2]
10160 set viewargscmd($n) [lindex $v 3]