2 # Tcl ignores the next line -*- tcl -*- \
5 # Copyright © 2005-2014 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.
13 return [expr {[exec git rev-parse
--is-bare-repository] == "false" &&
14 [exec git rev-parse
--is-inside-git-dir] == "false"}]
19 set n
[file normalize
$gitdir]
20 if {[string match
"*/.git" $n]} {
21 set n
[string range
$n 0 end-5
]
28 if {[info exists _gitworktree
]} {
31 # v1.7.0 introduced --show-toplevel to return the canonical work-tree
32 if {[catch
{set _gitworktree
[exec git rev-parse
--show-toplevel]}]} {
33 # try to set work tree from environment, core.worktree or use
34 # cdup to obtain a relative path to the top of the worktree. If
35 # run from the top, the ./ prefix ensures normalize expands pwd.
36 if {[catch
{ set _gitworktree
$env(GIT_WORK_TREE
) }]} {
37 catch
{set _gitworktree
[exec git config
--get core.worktree
]}
38 if {$_gitworktree eq
""} {
39 set _gitworktree
[file normalize .
/[exec git rev-parse
--show-cdup]]
46 # A simple scheduler for compute-intensive stuff.
47 # The aim is to make sure that event handlers for GUI actions can
48 # run at least every 50-100 ms. Unfortunately fileevent handlers are
49 # run before X event handlers, so reading from a fast source can
50 # make the GUI completely unresponsive.
52 global isonrunq runq currunq
55 if {[info exists isonrunq
($script)]} return
56 if {$runq eq
{} && ![info exists currunq
]} {
59 lappend runq
[list
{} $script]
60 set isonrunq
($script) 1
63 proc filerun
{fd
script} {
64 fileevent
$fd readable
[list filereadable
$fd $script]
67 proc filereadable
{fd
script} {
70 fileevent
$fd readable
{}
71 if {$runq eq
{} && ![info exists currunq
]} {
74 lappend runq
[list
$fd $script]
80 for {set i
0} {$i < [llength
$runq]} {} {
81 if {[lindex
$runq $i 0] eq
$fd} {
82 set runq
[lreplace
$runq $i $i]
90 global isonrunq runq currunq
92 set tstart
[clock clicks
-milliseconds]
94 while {[llength
$runq] > 0} {
95 set fd
[lindex
$runq 0 0]
96 set script [lindex
$runq 0 1]
97 set currunq
[lindex
$runq 0]
98 set runq
[lrange
$runq 1 end
]
99 set repeat
[eval $script]
101 set t1
[clock clicks
-milliseconds]
102 set t
[expr {$t1 - $t0}]
103 if {$repeat ne
{} && $repeat} {
104 if {$fd eq
{} ||
$repeat == 2} {
105 # script returns 1 if it wants to be readded
106 # file readers return 2 if they could do more straight away
107 lappend runq
[list
$fd $script]
109 fileevent
$fd readable
[list filereadable
$fd $script]
111 } elseif
{$fd eq
{}} {
112 unset isonrunq
($script)
115 if {$t1 - $tstart >= 80} break
122 proc reg_instance
{fd
} {
123 global commfd leftover loginstance
125 set i
[incr loginstance
]
131 proc unmerged_files
{files
} {
134 # find the list of unmerged files
138 set fd
[open
"| git ls-files -u" r
]
140 show_error
{} .
"[mc "Couldn
't get list of unmerged files:"] $err"
143 while {[gets $fd line] >= 0} {
144 set i [string first "\t" $line]
146 set fname [string range $line [expr {$i+1}] end]
147 if {[lsearch -exact $mlist $fname] >= 0} continue
149 if {$files eq {} || [path_filter $files $fname]} {
157 proc parseviewargs {n arglist} {
158 global vdatemode vmergeonly vflags vdflags vrevs vfiltered vorigargs env
160 global worddiff git_version
164 set vinlinediff($n) 0
169 set origargs $arglist
173 foreach arg $arglist {
180 switch -glob -- $arg {
184 # remove from origargs in case we hit an unknown option
185 set origargs [lreplace $origargs $i $i]
189 "--no-renames" - "--full-index" - "--binary" - "--abbrev=*" -
190 "--find-copies-harder" - "-l*" - "--ext-diff" - "--no-ext-diff" -
191 "--src-prefix=*" - "--dst-prefix=*" - "--no-prefix" -
192 "-O*" - "--text" - "--full-diff" - "--ignore-space-at-eol" -
193 "--ignore-space-change" - "-U*" - "--unified=*" {
194 # These request or affect diff output, which we don't want.
195 # Some could be used to set our defaults for diff display.
196 lappend diffargs
$arg
198 "--raw" - "--patch-with-raw" - "--patch-with-stat" -
199 "--name-only" - "--name-status" - "--color" -
200 "--log-size" - "--pretty=*" - "--decorate" - "--abbrev-commit" -
201 "--cc" - "-z" - "--header" - "--parents" - "--boundary" -
202 "--no-color" - "-g" - "--walk-reflogs" - "--no-walk" -
203 "--timestamp" - "relative-date" - "--date=*" - "--stdin" -
204 "--objects" - "--objects-edge" - "--reverse" {
205 # These cause our parsing of git log's output to fail, or else
206 # they're options we want to set ourselves, so ignore them.
208 "--color-words*" - "--word-diff=color" {
209 # These trigger a word diff in the console interface,
210 # so help the user by enabling our own support
211 if {[package vcompare
$git_version "1.7.2"] >= 0} {
212 set worddiff
[mc
"Color words"]
216 if {[package vcompare
$git_version "1.7.2"] >= 0} {
217 set worddiff
[mc
"Markup words"]
220 "--stat=*" - "--numstat" - "--shortstat" - "--summary" -
221 "--check" - "--exit-code" - "--quiet" - "--topo-order" -
222 "--full-history" - "--dense" - "--sparse" -
223 "--follow" - "--left-right" - "--encoding=*" {
224 # These are harmless, and some are even useful
227 "--diff-filter=*" - "--no-merges" - "--unpacked" -
228 "--max-count=*" - "--skip=*" - "--since=*" - "--after=*" -
229 "--until=*" - "--before=*" - "--max-age=*" - "--min-age=*" -
230 "--author=*" - "--committer=*" - "--grep=*" - "-[iE]" -
231 "--remove-empty" - "--first-parent" - "--cherry-pick" -
232 "-S*" - "-G*" - "--pickaxe-all" - "--pickaxe-regex" -
233 "--simplify-by-decoration" {
234 # These mean that we get a subset of the commits
239 # Line-log with 'stuck' argument (unstuck form is
242 set vinlinediff
($n) 1
247 # This appears to be the only one that has a value as a
248 # separate word following it
258 # git rev-parse doesn't understand --merge
259 lappend revargs
--gitk-symmetric-diff-marker MERGE_HEAD...HEAD
261 "--no-replace-objects" {
262 set env
(GIT_NO_REPLACE_OBJECTS
) "1"
265 # Other flag arguments including -<n>
266 if {[string is digit
-strict [string range
$arg 1 end
]]} {
269 # a flag argument that we don't recognize;
270 # that means we can't optimize
276 # Non-flag arguments specify commits or ranges of commits
277 if {[string match
"*...*" $arg]} {
278 lappend revargs
--gitk-symmetric-diff-marker
284 set vdflags
($n) $diffargs
285 set vflags
($n) $glflags
286 set vrevs
($n) $revargs
287 set vfiltered
($n) $filtered
288 set vorigargs
($n) $origargs
292 proc parseviewrevs
{view revs
} {
293 global vposids vnegids
297 } elseif
{[lsearch
-exact $revs --all] >= 0} {
300 if {[catch
{set ids
[eval exec git rev-parse
$revs]} err
]} {
301 # we get stdout followed by stderr in $err
302 # for an unknown rev, git rev-parse echoes it and then errors out
303 set errlines
[split $err "\n"]
305 for {set l
0} {$l < [llength
$errlines]} {incr l
} {
306 set line
[lindex
$errlines $l]
307 if {!([string length
$line] == 40 && [string is xdigit
$line])} {
308 if {[string match
"fatal:*" $line]} {
309 if {[string match
"fatal: ambiguous argument*" $line]
311 if {[llength
$badrev] == 1} {
312 set err
"unknown revision $badrev"
314 set err
"unknown revisions: [join $badrev ", "]"
317 set err
[join [lrange
$errlines $l end
] "\n"]
324 error_popup
"[mc "Error parsing revisions
:"] $err"
331 foreach id
[split $ids "\n"] {
332 if {$id eq
"--gitk-symmetric-diff-marker"} {
334 } elseif
{[string match
"^*" $id]} {
341 lappend neg
[string range
$id 1 end
]
346 lset ret end
$id...
[lindex
$ret end
]
352 set vposids
($view) $pos
353 set vnegids
($view) $neg
357 # Start off a git log process and arrange to read its output
358 proc start_rev_list
{view
} {
359 global startmsecs commitidx viewcomplete curview
361 global viewargs viewargscmd viewfiles vfilelimit
362 global showlocalchanges
363 global viewactive viewinstances vmergeonly
364 global mainheadid viewmainheadid viewmainheadid_orig
365 global vcanopt vflags vrevs vorigargs
368 set startmsecs
[clock clicks
-milliseconds]
369 set commitidx
($view) 0
370 # these are set this way for the error exits
371 set viewcomplete
($view) 1
372 set viewactive
($view) 0
375 set args
$viewargs($view)
376 if {$viewargscmd($view) ne
{}} {
378 set str
[exec sh
-c $viewargscmd($view)]
380 error_popup
"[mc "Error executing
--argscmd command:"] $err"
383 set args
[concat
$args [split $str "\n"]]
385 set vcanopt
($view) [parseviewargs
$view $args]
387 set files
$viewfiles($view)
388 if {$vmergeonly($view)} {
389 set files
[unmerged_files
$files]
392 if {$nr_unmerged == 0} {
393 error_popup
[mc
"No files selected: --merge specified but\
394 no files are unmerged."]
396 error_popup
[mc
"No files selected: --merge specified but\
397 no unmerged files are within file limit."]
402 set vfilelimit
($view) $files
404 if {$vcanopt($view)} {
405 set revs
[parseviewrevs
$view $vrevs($view)]
409 set args
[concat
$vflags($view) $revs]
411 set args
$vorigargs($view)
415 set fd
[open
[concat | git log
--no-color -z --pretty=raw
$show_notes \
416 --parents --boundary $args "--" $files] r
]
418 error_popup
"[mc "Error executing git log
:"] $err"
421 set i
[reg_instance
$fd]
422 set viewinstances
($view) [list
$i]
423 set viewmainheadid
($view) $mainheadid
424 set viewmainheadid_orig
($view) $mainheadid
425 if {$files ne
{} && $mainheadid ne
{}} {
426 get_viewmainhead
$view
428 if {$showlocalchanges && $viewmainheadid($view) ne
{}} {
429 interestedin
$viewmainheadid($view) dodiffindex
431 fconfigure
$fd -blocking 0 -translation lf
-eofchar {}
432 if {$tclencoding != {}} {
433 fconfigure
$fd -encoding $tclencoding
435 filerun
$fd [list getcommitlines
$fd $i $view 0]
436 nowbusy
$view [mc
"Reading"]
437 set viewcomplete
($view) 0
438 set viewactive
($view) 1
442 proc stop_instance
{inst
} {
443 global commfd leftover
445 set fd
$commfd($inst)
449 if {$
::tcl_platform
(platform
) eq
{windows
}} {
450 exec taskkill
/pid
$pid
458 unset leftover
($inst)
461 proc stop_backends
{} {
464 foreach inst
[array names commfd
] {
469 proc stop_rev_list
{view
} {
472 foreach inst
$viewinstances($view) {
475 set viewinstances
($view) {}
478 proc reset_pending_select
{selid
} {
479 global pending_select mainheadid selectheadid
482 set pending_select
$selid
483 } elseif
{$selectheadid ne
{}} {
484 set pending_select
$selectheadid
486 set pending_select
$mainheadid
490 proc getcommits
{selid
} {
491 global canv curview need_redisplay viewactive
494 if {[start_rev_list
$curview]} {
495 reset_pending_select
$selid
496 show_status
[mc
"Reading commits..."]
499 show_status
[mc
"No commits selected"]
503 proc updatecommits
{} {
504 global curview vcanopt vorigargs vfilelimit viewinstances
505 global viewactive viewcomplete tclencoding
506 global startmsecs showneartags showlocalchanges
507 global mainheadid viewmainheadid viewmainheadid_orig pending_select
509 global varcid vposids vnegids vflags vrevs
512 set hasworktree
[hasworktree
]
515 if {$mainheadid ne
$viewmainheadid_orig($view)} {
516 if {$showlocalchanges} {
519 set viewmainheadid
($view) $mainheadid
520 set viewmainheadid_orig
($view) $mainheadid
521 if {$vfilelimit($view) ne
{}} {
522 get_viewmainhead
$view
525 if {$showlocalchanges} {
528 if {$vcanopt($view)} {
529 set oldpos
$vposids($view)
530 set oldneg
$vnegids($view)
531 set revs
[parseviewrevs
$view $vrevs($view)]
535 # note: getting the delta when negative refs change is hard,
536 # and could require multiple git log invocations, so in that
537 # case we ask git log for all the commits (not just the delta)
538 if {$oldneg eq
$vnegids($view)} {
541 # take out positive refs that we asked for before or
542 # that we have already seen
544 if {[string length
$rev] == 40} {
545 if {[lsearch
-exact $oldpos $rev] < 0
546 && ![info exists varcid
($view,$rev)]} {
551 lappend
$newrevs $rev
554 if {$npos == 0} return
556 set vposids
($view) [lsort
-unique [concat
$oldpos $vposids($view)]]
558 set args
[concat
$vflags($view) $revs --not $oldpos]
560 set args
$vorigargs($view)
563 set fd
[open
[concat | git log
--no-color -z --pretty=raw
$show_notes \
564 --parents --boundary $args "--" $vfilelimit($view)] r
]
566 error_popup
"[mc "Error executing git log
:"] $err"
569 if {$viewactive($view) == 0} {
570 set startmsecs
[clock clicks
-milliseconds]
572 set i
[reg_instance
$fd]
573 lappend viewinstances
($view) $i
574 fconfigure
$fd -blocking 0 -translation lf
-eofchar {}
575 if {$tclencoding != {}} {
576 fconfigure
$fd -encoding $tclencoding
578 filerun
$fd [list getcommitlines
$fd $i $view 1]
579 incr viewactive
($view)
580 set viewcomplete
($view) 0
581 reset_pending_select
{}
582 nowbusy
$view [mc
"Reading"]
588 proc reloadcommits
{} {
589 global curview viewcomplete selectedline currentid thickerline
590 global showneartags treediffs commitinterest cached_commitrow
594 if {$selectedline ne
{}} {
598 if {!$viewcomplete($curview)} {
599 stop_rev_list
$curview
603 unset -nocomplain currentid
604 unset -nocomplain thickerline
605 unset -nocomplain treediffs
612 unset -nocomplain commitinterest
613 unset -nocomplain cached_commitrow
614 unset -nocomplain targetid
620 # This makes a string representation of a positive integer which
621 # sorts as a string in numerical order
624 return [format
"%x" $n]
625 } elseif
{$n < 256} {
626 return [format
"x%.2x" $n]
627 } elseif
{$n < 65536} {
628 return [format
"y%.4x" $n]
630 return [format
"z%.8x" $n]
633 # Procedures used in reordering commits from git log (without
634 # --topo-order) into the order for display.
636 proc varcinit
{view
} {
637 global varcstart vupptr vdownptr vleftptr vbackptr varctok varcrow
638 global vtokmod varcmod vrowmod varcix vlastins
640 set varcstart
($view) {{}}
641 set vupptr
($view) {0}
642 set vdownptr
($view) {0}
643 set vleftptr
($view) {0}
644 set vbackptr
($view) {0}
645 set varctok
($view) {{}}
646 set varcrow
($view) {{}}
647 set vtokmod
($view) {}
650 set varcix
($view) {{}}
651 set vlastins
($view) {0}
654 proc resetvarcs
{view
} {
655 global varcid varccommits parents children vseedcount ordertok
658 foreach vid
[array names varcid
$view,*] {
663 foreach vid
[array names vshortids
$view,*] {
664 unset vshortids
($vid)
666 # some commits might have children but haven't been seen yet
667 foreach vid
[array names children
$view,*] {
670 foreach va
[array names varccommits
$view,*] {
671 unset varccommits
($va)
673 foreach vd
[array names vseedcount
$view,*] {
674 unset vseedcount
($vd)
676 unset -nocomplain ordertok
679 # returns a list of the commits with no children
681 global vdownptr vleftptr varcstart
684 set a
[lindex
$vdownptr($v) 0]
686 lappend ret
[lindex
$varcstart($v) $a]
687 set a
[lindex
$vleftptr($v) $a]
692 proc newvarc
{view id
} {
693 global varcid varctok parents children vdatemode
694 global vupptr vdownptr vleftptr vbackptr varcrow varcix varcstart
695 global commitdata commitinfo vseedcount varccommits vlastins
697 set a
[llength
$varctok($view)]
699 if {[llength
$children($vid)] == 0 ||
$vdatemode($view)} {
700 if {![info exists commitinfo
($id)]} {
701 parsecommit
$id $commitdata($id) 1
703 set cdate
[lindex
[lindex
$commitinfo($id) 4] 0]
704 if {![string is integer
-strict $cdate]} {
707 if {![info exists vseedcount
($view,$cdate)]} {
708 set vseedcount
($view,$cdate) -1
710 set c
[incr vseedcount
($view,$cdate)]
711 set cdate
[expr {$cdate ^
0xffffffff}]
712 set tok
"s[strrep $cdate][strrep $c]"
717 if {[llength
$children($vid)] > 0} {
718 set kid
[lindex
$children($vid) end
]
719 set k
$varcid($view,$kid)
720 if {[string compare
[lindex
$varctok($view) $k] $tok] > 0} {
723 set tok
[lindex
$varctok($view) $k]
727 set i
[lsearch
-exact $parents($view,$ki) $id]
728 set j
[expr {[llength
$parents($view,$ki)] - 1 - $i}]
729 append tok
[strrep
$j]
731 set c
[lindex
$vlastins($view) $ka]
732 if {$c == 0 ||
[string compare
$tok [lindex
$varctok($view) $c]] < 0} {
734 set b
[lindex
$vdownptr($view) $ka]
736 set b
[lindex
$vleftptr($view) $c]
738 while {$b != 0 && [string compare
$tok [lindex
$varctok($view) $b]] >= 0} {
740 set b
[lindex
$vleftptr($view) $c]
743 lset vdownptr
($view) $ka $a
744 lappend vbackptr
($view) 0
746 lset vleftptr
($view) $c $a
747 lappend vbackptr
($view) $c
749 lset vlastins
($view) $ka $a
750 lappend vupptr
($view) $ka
751 lappend vleftptr
($view) $b
753 lset vbackptr
($view) $b $a
755 lappend varctok
($view) $tok
756 lappend varcstart
($view) $id
757 lappend vdownptr
($view) 0
758 lappend varcrow
($view) {}
759 lappend varcix
($view) {}
760 set varccommits
($view,$a) {}
761 lappend vlastins
($view) 0
765 proc splitvarc
{p v
} {
766 global varcid varcstart varccommits varctok vtokmod
767 global vupptr vdownptr vleftptr vbackptr varcix varcrow vlastins
769 set oa
$varcid($v,$p)
770 set otok
[lindex
$varctok($v) $oa]
771 set ac
$varccommits($v,$oa)
772 set i
[lsearch
-exact $varccommits($v,$oa) $p]
774 set na
[llength
$varctok($v)]
775 # "%" sorts before "0"...
776 set tok
"$otok%[strrep $i]"
777 lappend varctok
($v) $tok
778 lappend varcrow
($v) {}
779 lappend varcix
($v) {}
780 set varccommits
($v,$oa) [lrange
$ac 0 [expr {$i - 1}]]
781 set varccommits
($v,$na) [lrange
$ac $i end
]
782 lappend varcstart
($v) $p
783 foreach id
$varccommits($v,$na) {
784 set varcid
($v,$id) $na
786 lappend vdownptr
($v) [lindex
$vdownptr($v) $oa]
787 lappend vlastins
($v) [lindex
$vlastins($v) $oa]
788 lset vdownptr
($v) $oa $na
789 lset vlastins
($v) $oa 0
790 lappend vupptr
($v) $oa
791 lappend vleftptr
($v) 0
792 lappend vbackptr
($v) 0
793 for {set b
[lindex
$vdownptr($v) $na]} {$b != 0} {set b
[lindex
$vleftptr($v) $b]} {
794 lset vupptr
($v) $b $na
796 if {[string compare
$otok $vtokmod($v)] <= 0} {
801 proc renumbervarc
{a v
} {
802 global parents children varctok varcstart varccommits
803 global vupptr vdownptr vleftptr vbackptr vlastins varcid vtokmod vdatemode
805 set t1
[clock clicks
-milliseconds]
811 if {[info exists isrelated
($a)]} {
813 set id
[lindex
$varccommits($v,$a) end
]
814 foreach p
$parents($v,$id) {
815 if {[info exists varcid
($v,$p)]} {
816 set isrelated
($varcid($v,$p)) 1
821 set b
[lindex
$vdownptr($v) $a]
824 set b
[lindex
$vleftptr($v) $a]
826 set a
[lindex
$vupptr($v) $a]
832 if {![info exists kidchanged
($a)]} continue
833 set id
[lindex
$varcstart($v) $a]
834 if {[llength
$children($v,$id)] > 1} {
835 set children
($v,$id) [lsort
-command [list vtokcmp
$v] \
838 set oldtok
[lindex
$varctok($v) $a]
839 if {!$vdatemode($v)} {
845 set kid
[last_real_child
$v,$id]
847 set k
$varcid($v,$kid)
848 if {[string compare
[lindex
$varctok($v) $k] $tok] > 0} {
851 set tok
[lindex
$varctok($v) $k]
855 set i
[lsearch
-exact $parents($v,$ki) $id]
856 set j
[expr {[llength
$parents($v,$ki)] - 1 - $i}]
857 append tok
[strrep
$j]
859 if {$tok eq
$oldtok} {
862 set id
[lindex
$varccommits($v,$a) end
]
863 foreach p
$parents($v,$id) {
864 if {[info exists varcid
($v,$p)]} {
865 set kidchanged
($varcid($v,$p)) 1
870 lset varctok
($v) $a $tok
871 set b
[lindex
$vupptr($v) $a]
873 if {[string compare
[lindex
$varctok($v) $ka] $vtokmod($v)] < 0} {
876 if {[string compare
[lindex
$varctok($v) $b] $vtokmod($v)] < 0} {
879 set c
[lindex
$vbackptr($v) $a]
880 set d
[lindex
$vleftptr($v) $a]
882 lset vdownptr
($v) $b $d
884 lset vleftptr
($v) $c $d
887 lset vbackptr
($v) $d $c
889 if {[lindex
$vlastins($v) $b] == $a} {
890 lset vlastins
($v) $b $c
892 lset vupptr
($v) $a $ka
893 set c
[lindex
$vlastins($v) $ka]
895 [string compare
$tok [lindex
$varctok($v) $c]] < 0} {
897 set b
[lindex
$vdownptr($v) $ka]
899 set b
[lindex
$vleftptr($v) $c]
902 [string compare
$tok [lindex
$varctok($v) $b]] >= 0} {
904 set b
[lindex
$vleftptr($v) $c]
907 lset vdownptr
($v) $ka $a
908 lset vbackptr
($v) $a 0
910 lset vleftptr
($v) $c $a
911 lset vbackptr
($v) $a $c
913 lset vleftptr
($v) $a $b
915 lset vbackptr
($v) $b $a
917 lset vlastins
($v) $ka $a
920 foreach id
[array names sortkids
] {
921 if {[llength
$children($v,$id)] > 1} {
922 set children
($v,$id) [lsort
-command [list vtokcmp
$v] \
926 set t2
[clock clicks
-milliseconds]
927 #puts "renumbervarc did [llength $todo] of $ntot arcs in [expr {$t2-$t1}]ms"
930 # Fix up the graph after we have found out that in view $v,
931 # $p (a commit that we have already seen) is actually the parent
932 # of the last commit in arc $a.
933 proc fix_reversal
{p a v
} {
934 global varcid varcstart varctok vupptr
936 set pa
$varcid($v,$p)
937 if {$p ne
[lindex
$varcstart($v) $pa]} {
939 set pa
$varcid($v,$p)
941 # seeds always need to be renumbered
942 if {[lindex
$vupptr($v) $pa] == 0 ||
943 [string compare
[lindex
$varctok($v) $a] \
944 [lindex
$varctok($v) $pa]] > 0} {
949 proc insertrow
{id p v
} {
950 global cmitlisted children parents varcid varctok vtokmod
951 global varccommits ordertok commitidx numcommits curview
952 global targetid targetrow vshortids
956 set cmitlisted
($vid) 1
957 set children
($vid) {}
958 set parents
($vid) [list
$p]
959 set a
[newvarc
$v $id]
961 lappend vshortids
($v,[string range
$id 0 3]) $id
962 if {[string compare
[lindex
$varctok($v) $a] $vtokmod($v)] < 0} {
965 lappend varccommits
($v,$a) $id
967 if {[llength
[lappend children
($vp) $id]] > 1} {
968 set children
($vp) [lsort
-command [list vtokcmp
$v] $children($vp)]
969 unset -nocomplain ordertok
971 fix_reversal
$p $a $v
973 if {$v == $curview} {
974 set numcommits
$commitidx($v)
976 if {[info exists targetid
]} {
977 if {![comes_before
$targetid $p]} {
984 proc insertfakerow
{id p
} {
985 global varcid varccommits parents children cmitlisted
986 global commitidx varctok vtokmod targetid targetrow curview numcommits
990 set i
[lsearch
-exact $varccommits($v,$a) $p]
992 puts
"oops: insertfakerow can't find [shortids $p] on arc $a"
995 set children
($v,$id) {}
996 set parents
($v,$id) [list
$p]
997 set varcid
($v,$id) $a
998 lappend children
($v,$p) $id
999 set cmitlisted
($v,$id) 1
1000 set numcommits
[incr commitidx
($v)]
1001 # note we deliberately don't update varcstart($v) even if $i == 0
1002 set varccommits
($v,$a) [linsert
$varccommits($v,$a) $i $id]
1004 if {[info exists targetid
]} {
1005 if {![comes_before
$targetid $p]} {
1013 proc removefakerow
{id
} {
1014 global varcid varccommits parents children commitidx
1015 global varctok vtokmod cmitlisted currentid selectedline
1016 global targetid curview numcommits
1019 if {[llength
$parents($v,$id)] != 1} {
1020 puts
"oops: removefakerow [shortids $id] has [llength $parents($v,$id)] parents"
1023 set p
[lindex
$parents($v,$id) 0]
1024 set a
$varcid($v,$id)
1025 set i
[lsearch
-exact $varccommits($v,$a) $id]
1027 puts
"oops: removefakerow can't find [shortids $id] on arc $a"
1030 unset varcid
($v,$id)
1031 set varccommits
($v,$a) [lreplace
$varccommits($v,$a) $i $i]
1032 unset parents
($v,$id)
1033 unset children
($v,$id)
1034 unset cmitlisted
($v,$id)
1035 set numcommits
[incr commitidx
($v) -1]
1036 set j
[lsearch
-exact $children($v,$p) $id]
1038 set children
($v,$p) [lreplace
$children($v,$p) $j $j]
1041 if {[info exist currentid
] && $id eq
$currentid} {
1045 if {[info exists targetid
] && $targetid eq
$id} {
1052 proc real_children
{vp
} {
1053 global children nullid nullid2
1056 foreach id
$children($vp) {
1057 if {$id ne
$nullid && $id ne
$nullid2} {
1064 proc first_real_child
{vp
} {
1065 global children nullid nullid2
1067 foreach id
$children($vp) {
1068 if {$id ne
$nullid && $id ne
$nullid2} {
1075 proc last_real_child
{vp
} {
1076 global children nullid nullid2
1078 set kids
$children($vp)
1079 for {set i
[llength
$kids]} {[incr i
-1] >= 0} {} {
1080 set id
[lindex
$kids $i]
1081 if {$id ne
$nullid && $id ne
$nullid2} {
1088 proc vtokcmp
{v a b
} {
1089 global varctok varcid
1091 return [string compare
[lindex
$varctok($v) $varcid($v,$a)] \
1092 [lindex
$varctok($v) $varcid($v,$b)]]
1095 # This assumes that if lim is not given, the caller has checked that
1096 # arc a's token is less than $vtokmod($v)
1097 proc modify_arc
{v a
{lim
{}}} {
1098 global varctok vtokmod varcmod varcrow vupptr curview vrowmod varccommits
1101 set c
[string compare
[lindex
$varctok($v) $a] $vtokmod($v)]
1104 set r
[lindex
$varcrow($v) $a]
1105 if {$r ne
{} && $vrowmod($v) <= $r + $lim} return
1108 set vtokmod
($v) [lindex
$varctok($v) $a]
1110 if {$v == $curview} {
1111 while {$a != 0 && [lindex
$varcrow($v) $a] eq
{}} {
1112 set a
[lindex
$vupptr($v) $a]
1118 set lim
[llength
$varccommits($v,$a)]
1120 set r
[expr {[lindex
$varcrow($v) $a] + $lim}]
1127 proc update_arcrows
{v
} {
1128 global vtokmod varcmod vrowmod varcrow commitidx currentid selectedline
1129 global varcid vrownum varcorder varcix varccommits
1130 global vupptr vdownptr vleftptr varctok
1131 global displayorder parentlist curview cached_commitrow
1133 if {$vrowmod($v) == $commitidx($v)} return
1134 if {$v == $curview} {
1135 if {[llength
$displayorder] > $vrowmod($v)} {
1136 set displayorder
[lrange
$displayorder 0 [expr {$vrowmod($v) - 1}]]
1137 set parentlist
[lrange
$parentlist 0 [expr {$vrowmod($v) - 1}]]
1139 unset -nocomplain cached_commitrow
1141 set narctot
[expr {[llength
$varctok($v)] - 1}]
1143 while {$a != 0 && [lindex
$varcix($v) $a] eq
{}} {
1144 # go up the tree until we find something that has a row number,
1145 # or we get to a seed
1146 set a
[lindex
$vupptr($v) $a]
1149 set a
[lindex
$vdownptr($v) 0]
1152 set varcorder
($v) [list
$a]
1153 lset varcix
($v) $a 0
1154 lset varcrow
($v) $a 0
1158 set arcn
[lindex
$varcix($v) $a]
1159 if {[llength
$vrownum($v)] > $arcn + 1} {
1160 set vrownum
($v) [lrange
$vrownum($v) 0 $arcn]
1161 set varcorder
($v) [lrange
$varcorder($v) 0 $arcn]
1163 set row
[lindex
$varcrow($v) $a]
1167 incr row
[llength
$varccommits($v,$a)]
1168 # go down if possible
1169 set b
[lindex
$vdownptr($v) $a]
1171 # if not, go left, or go up until we can go left
1173 set b
[lindex
$vleftptr($v) $a]
1175 set a
[lindex
$vupptr($v) $a]
1181 lappend vrownum
($v) $row
1182 lappend varcorder
($v) $a
1183 lset varcix
($v) $a $arcn
1184 lset varcrow
($v) $a $row
1186 set vtokmod
($v) [lindex
$varctok($v) $p]
1188 set vrowmod
($v) $row
1189 if {[info exists currentid
]} {
1190 set selectedline
[rowofcommit
$currentid]
1194 # Test whether view $v contains commit $id
1195 proc commitinview
{id v
} {
1198 return [info exists varcid
($v,$id)]
1201 # Return the row number for commit $id in the current view
1202 proc rowofcommit
{id
} {
1203 global varcid varccommits varcrow curview cached_commitrow
1204 global varctok vtokmod
1207 if {![info exists varcid
($v,$id)]} {
1208 puts
"oops rowofcommit no arc for [shortids $id]"
1211 set a
$varcid($v,$id)
1212 if {[string compare
[lindex
$varctok($v) $a] $vtokmod($v)] >= 0} {
1215 if {[info exists cached_commitrow
($id)]} {
1216 return $cached_commitrow($id)
1218 set i
[lsearch
-exact $varccommits($v,$a) $id]
1220 puts
"oops didn't find commit [shortids $id] in arc $a"
1223 incr i
[lindex
$varcrow($v) $a]
1224 set cached_commitrow
($id) $i
1228 # Returns 1 if a is on an earlier row than b, otherwise 0
1229 proc comes_before
{a b
} {
1230 global varcid varctok curview
1233 if {$a eq
$b ||
![info exists varcid
($v,$a)] || \
1234 ![info exists varcid
($v,$b)]} {
1237 if {$varcid($v,$a) != $varcid($v,$b)} {
1238 return [expr {[string compare
[lindex
$varctok($v) $varcid($v,$a)] \
1239 [lindex
$varctok($v) $varcid($v,$b)]] < 0}]
1241 return [expr {[rowofcommit
$a] < [rowofcommit
$b]}]
1244 proc bsearch
{l elt
} {
1245 if {[llength
$l] == 0 ||
$elt <= [lindex
$l 0]} {
1250 while {$hi - $lo > 1} {
1251 set mid
[expr {int
(($lo + $hi) / 2)}]
1252 set t
[lindex
$l $mid]
1255 } elseif
{$elt > $t} {
1264 # Make sure rows $start..$end-1 are valid in displayorder and parentlist
1265 proc make_disporder
{start end
} {
1266 global vrownum curview commitidx displayorder parentlist
1267 global varccommits varcorder parents vrowmod varcrow
1268 global d_valid_start d_valid_end
1270 if {$end > $vrowmod($curview)} {
1271 update_arcrows
$curview
1273 set ai
[bsearch
$vrownum($curview) $start]
1274 set start
[lindex
$vrownum($curview) $ai]
1275 set narc
[llength
$vrownum($curview)]
1276 for {set r
$start} {$ai < $narc && $r < $end} {incr ai
} {
1277 set a
[lindex
$varcorder($curview) $ai]
1278 set l
[llength
$displayorder]
1279 set al
[llength
$varccommits($curview,$a)]
1280 if {$l < $r + $al} {
1282 set pad
[ntimes
[expr {$r - $l}] {}]
1283 set displayorder
[concat
$displayorder $pad]
1284 set parentlist
[concat
$parentlist $pad]
1285 } elseif
{$l > $r} {
1286 set displayorder
[lrange
$displayorder 0 [expr {$r - 1}]]
1287 set parentlist
[lrange
$parentlist 0 [expr {$r - 1}]]
1289 foreach id
$varccommits($curview,$a) {
1290 lappend displayorder
$id
1291 lappend parentlist
$parents($curview,$id)
1293 } elseif
{[lindex
$displayorder [expr {$r + $al - 1}]] eq
{}} {
1295 foreach id
$varccommits($curview,$a) {
1296 lset displayorder
$i $id
1297 lset parentlist
$i $parents($curview,$id)
1305 proc commitonrow
{row
} {
1308 set id
[lindex
$displayorder $row]
1310 make_disporder
$row [expr {$row + 1}]
1311 set id
[lindex
$displayorder $row]
1316 proc closevarcs
{v
} {
1317 global varctok varccommits varcid parents children
1318 global cmitlisted commitidx vtokmod
1320 set missing_parents
0
1322 set narcs
[llength
$varctok($v)]
1323 for {set a
1} {$a < $narcs} {incr a
} {
1324 set id
[lindex
$varccommits($v,$a) end
]
1325 foreach p
$parents($v,$id) {
1326 if {[info exists varcid
($v,$p)]} continue
1327 # add p as a new commit
1328 incr missing_parents
1329 set cmitlisted
($v,$p) 0
1330 set parents
($v,$p) {}
1331 if {[llength
$children($v,$p)] == 1 &&
1332 [llength
$parents($v,$id)] == 1} {
1335 set b
[newvarc
$v $p]
1337 set varcid
($v,$p) $b
1338 if {[string compare
[lindex
$varctok($v) $b] $vtokmod($v)] < 0} {
1341 lappend varccommits
($v,$b) $p
1343 set scripts
[check_interest
$p $scripts]
1346 if {$missing_parents > 0} {
1347 foreach s
$scripts {
1353 # Use $rwid as a substitute for $id, i.e. reparent $id's children to $rwid
1354 # Assumes we already have an arc for $rwid.
1355 proc rewrite_commit
{v id rwid
} {
1356 global children parents varcid varctok vtokmod varccommits
1358 foreach ch
$children($v,$id) {
1359 # make $rwid be $ch's parent in place of $id
1360 set i
[lsearch
-exact $parents($v,$ch) $id]
1362 puts
"oops rewrite_commit didn't find $id in parent list for $ch"
1364 set parents
($v,$ch) [lreplace
$parents($v,$ch) $i $i $rwid]
1365 # add $ch to $rwid's children and sort the list if necessary
1366 if {[llength
[lappend children
($v,$rwid) $ch]] > 1} {
1367 set children
($v,$rwid) [lsort
-command [list vtokcmp
$v] \
1368 $children($v,$rwid)]
1370 # fix the graph after joining $id to $rwid
1371 set a
$varcid($v,$ch)
1372 fix_reversal
$rwid $a $v
1373 # parentlist is wrong for the last element of arc $a
1374 # even if displayorder is right, hence the 3rd arg here
1375 modify_arc
$v $a [expr {[llength
$varccommits($v,$a)] - 1}]
1379 # Mechanism for registering a command to be executed when we come
1380 # across a particular commit. To handle the case when only the
1381 # prefix of the commit is known, the commitinterest array is now
1382 # indexed by the first 4 characters of the ID. Each element is a
1383 # list of id, cmd pairs.
1384 proc interestedin
{id cmd
} {
1385 global commitinterest
1387 lappend commitinterest
([string range
$id 0 3]) $id $cmd
1390 proc check_interest
{id scripts
} {
1391 global commitinterest
1393 set prefix
[string range
$id 0 3]
1394 if {[info exists commitinterest
($prefix)]} {
1396 foreach
{i
script} $commitinterest($prefix) {
1397 if {[string match
"$i*" $id]} {
1398 lappend scripts
[string map
[list
"%I" $id "%P" $i] $script]
1400 lappend newlist
$i $script
1403 if {$newlist ne
{}} {
1404 set commitinterest
($prefix) $newlist
1406 unset commitinterest
($prefix)
1412 proc getcommitlines
{fd inst view updating
} {
1413 global cmitlisted leftover
1414 global commitidx commitdata vdatemode
1415 global parents children curview hlview
1416 global idpending ordertok
1417 global varccommits varcid varctok vtokmod vfilelimit vshortids
1419 set stuff
[read $fd 500000]
1420 # git log doesn't terminate the last commit with a null...
1421 if {$stuff == {} && $leftover($inst) ne
{} && [eof
$fd]} {
1428 global commfd viewcomplete viewactive viewname
1429 global viewinstances
1431 set i
[lsearch
-exact $viewinstances($view) $inst]
1433 set viewinstances
($view) [lreplace
$viewinstances($view) $i $i]
1435 # set it blocking so we wait for the process to terminate
1436 fconfigure
$fd -blocking 1
1437 if {[catch
{close
$fd} err
]} {
1439 if {$view != $curview} {
1440 set fv
" for the \"$viewname($view)\" view"
1442 if {[string range
$err 0 4] == "usage"} {
1443 set err
"Gitk: error reading commits$fv:\
1444 bad arguments to git log."
1445 if {$viewname($view) eq
[mc
"Command line"]} {
1447 " (Note: arguments to gitk are passed to git log\
1448 to allow selection of commits to be displayed.)"
1451 set err
"Error reading commits$fv: $err"
1455 if {[incr viewactive
($view) -1] <= 0} {
1456 set viewcomplete
($view) 1
1457 # Check if we have seen any ids listed as parents that haven't
1458 # appeared in the list
1462 if {$view == $curview} {
1471 set i
[string first
"\0" $stuff $start]
1473 append leftover
($inst) [string range
$stuff $start end
]
1477 set cmit
$leftover($inst)
1478 append cmit
[string range
$stuff 0 [expr {$i - 1}]]
1479 set leftover
($inst) {}
1481 set cmit
[string range
$stuff $start [expr {$i - 1}]]
1483 set start
[expr {$i + 1}]
1484 set j
[string first
"\n" $cmit]
1487 if {$j >= 0 && [string match
"commit *" $cmit]} {
1488 set ids
[string range
$cmit 7 [expr {$j - 1}]]
1489 if {[string match
{[-^
<>]*} $ids]} {
1490 switch
-- [string index
$ids 0] {
1496 set ids
[string range
$ids 1 end
]
1500 if {[string length
$id] != 40} {
1508 if {[string length
$shortcmit] > 80} {
1509 set shortcmit
"[string range $shortcmit 0 80]..."
1511 error_popup
"[mc "Can
't parse git log output:"] {$shortcmit}"
1514 set id [lindex $ids 0]
1517 lappend vshortids($view,[string range $id 0 3]) $id
1519 if {!$listed && $updating && ![info exists varcid($vid)] &&
1520 $vfilelimit($view) ne {}} {
1521 # git log doesn't rewrite parents
for unlisted commits
1522 # when doing path limiting, so work around that here
1523 # by working out the rewritten parent with git rev-list
1524 # and if we already know about it, using the rewritten
1525 # parent as a substitute parent for $id's children.
1527 set rwid
[exec git rev-list
--first-parent --max-count=1 \
1528 $id -- $vfilelimit($view)]
1530 if {$rwid ne
{} && [info exists varcid
($view,$rwid)]} {
1531 # use $rwid in place of $id
1532 rewrite_commit
$view $id $rwid
1539 if {[info exists varcid
($vid)]} {
1540 if {$cmitlisted($vid) ||
!$listed} continue
1544 set olds
[lrange
$ids 1 end
]
1548 set commitdata
($id) [string range
$cmit [expr {$j + 1}] end
]
1549 set cmitlisted
($vid) $listed
1550 set parents
($vid) $olds
1551 if {![info exists children
($vid)]} {
1552 set children
($vid) {}
1553 } elseif
{$a == 0 && [llength
$children($vid)] == 1} {
1554 set k
[lindex
$children($vid) 0]
1555 if {[llength
$parents($view,$k)] == 1 &&
1556 (!$vdatemode($view) ||
1557 $varcid($view,$k) == [llength
$varctok($view)] - 1)} {
1558 set a
$varcid($view,$k)
1563 set a
[newvarc
$view $id]
1565 if {[string compare
[lindex
$varctok($view) $a] $vtokmod($view)] < 0} {
1568 if {![info exists varcid
($vid)]} {
1570 lappend varccommits
($view,$a) $id
1571 incr commitidx
($view)
1576 if {$i == 0 ||
[lsearch
-exact $olds $p] >= $i} {
1578 if {[llength
[lappend children
($vp) $id]] > 1 &&
1579 [vtokcmp
$view [lindex
$children($vp) end-1
] $id] > 0} {
1580 set children
($vp) [lsort
-command [list vtokcmp
$view] \
1582 unset -nocomplain ordertok
1584 if {[info exists varcid
($view,$p)]} {
1585 fix_reversal
$p $a $view
1591 set scripts
[check_interest
$id $scripts]
1595 global numcommits hlview
1597 if {$view == $curview} {
1598 set numcommits
$commitidx($view)
1601 if {[info exists hlview
] && $view == $hlview} {
1602 # we never actually get here...
1605 foreach s
$scripts {
1612 proc chewcommits
{} {
1613 global curview hlview viewcomplete
1614 global pending_select
1617 if {$viewcomplete($curview)} {
1618 global commitidx varctok
1619 global numcommits startmsecs
1621 if {[info exists pending_select
]} {
1623 reset_pending_select
{}
1625 if {[commitinview
$pending_select $curview]} {
1626 selectline
[rowofcommit
$pending_select] 1
1628 set row
[first_real_row
]
1632 if {$commitidx($curview) > 0} {
1633 #set ms [expr {[clock clicks -milliseconds] - $startmsecs}]
1634 #puts "overall $ms ms for $numcommits commits"
1635 #puts "[llength $varctok($view)] arcs, $commitidx($view) commits"
1637 show_status
[mc
"No commits selected"]
1644 proc do_readcommit
{id
} {
1647 # Invoke git-log to handle automatic encoding conversion
1648 set fd
[open
[concat | git log
--no-color --pretty=raw
-1 $id] r
]
1649 # Read the results using i18n.logoutputencoding
1650 fconfigure
$fd -translation lf
-eofchar {}
1651 if {$tclencoding != {}} {
1652 fconfigure
$fd -encoding $tclencoding
1654 set contents
[read $fd]
1656 # Remove the heading line
1657 regsub
{^commit
[0-9a-f]+\n} $contents {} contents
1662 proc readcommit
{id
} {
1663 if {[catch
{set contents
[do_readcommit
$id]}]} return
1664 parsecommit
$id $contents 1
1667 proc parsecommit
{id contents listed
} {
1677 set hdrend
[string first
"\n\n" $contents]
1679 # should never happen...
1680 set hdrend
[string length
$contents]
1682 set header
[string range
$contents 0 [expr {$hdrend - 1}]]
1683 set comment
[string range
$contents [expr {$hdrend + 2}] end
]
1684 foreach line
[split $header "\n"] {
1685 set line
[split $line " "]
1686 set tag
[lindex
$line 0]
1687 if {$tag == "author"} {
1688 set audate
[lrange
$line end-1 end
]
1689 set auname
[join [lrange
$line 1 end-2
] " "]
1690 } elseif
{$tag == "committer"} {
1691 set comdate
[lrange
$line end-1 end
]
1692 set comname
[join [lrange
$line 1 end-2
] " "]
1696 # take the first non-blank line of the comment as the headline
1697 set headline
[string trimleft
$comment]
1698 set i
[string first
"\n" $headline]
1700 set headline
[string range
$headline 0 $i]
1702 set headline
[string trimright
$headline]
1703 set i
[string first
"\r" $headline]
1705 set headline
[string trimright
[string range
$headline 0 $i]]
1708 # git log indents the comment by 4 spaces;
1709 # if we got this via git cat-file, add the indentation
1711 foreach line
[split $comment "\n"] {
1712 append newcomment
" "
1713 append newcomment
$line
1714 append newcomment
"\n"
1716 set comment
$newcomment
1718 set hasnote
[string first
"\nNotes:\n" $contents]
1720 # If there is diff output shown in the git-log stream, split it
1721 # out. But get rid of the empty line that always precedes the
1723 set i
[string first
"\n\ndiff" $comment]
1725 set diff [string range
$comment $i+1 end
]
1726 set comment
[string range
$comment 0 $i-1]
1728 set commitinfo
($id) [list
$headline $auname $audate \
1729 $comname $comdate $comment $hasnote $diff]
1732 proc getcommit
{id
} {
1733 global commitdata commitinfo
1735 if {[info exists commitdata
($id)]} {
1736 parsecommit
$id $commitdata($id) 1
1739 if {![info exists commitinfo
($id)]} {
1740 set commitinfo
($id) [list
[mc
"No commit information available"]]
1746 # Expand an abbreviated commit ID to a list of full 40-char IDs that match
1747 # and are present in the current view.
1748 # This is fairly slow...
1749 proc longid
{prefix
} {
1750 global varcid curview vshortids
1753 if {[string length
$prefix] >= 4} {
1754 set vshortid
$curview,[string range
$prefix 0 3]
1755 if {[info exists vshortids
($vshortid)]} {
1756 foreach id
$vshortids($vshortid) {
1757 if {[string match
"$prefix*" $id]} {
1758 if {[lsearch
-exact $ids $id] < 0} {
1760 if {[llength
$ids] >= 2} break
1766 foreach match
[array names varcid
"$curview,$prefix*"] {
1767 lappend ids
[lindex
[split $match ","] 1]
1768 if {[llength
$ids] >= 2} break
1775 global tagids idtags headids idheads tagobjid
1776 global otherrefids idotherrefs mainhead mainheadid
1777 global selecthead selectheadid
1780 foreach v
{tagids idtags headids idheads otherrefids idotherrefs
} {
1781 unset -nocomplain $v
1783 set refd
[open
[list | git show-ref
-d] r
]
1784 while {[gets
$refd line
] >= 0} {
1785 if {[string index
$line 40] ne
" "} continue
1786 set id
[string range
$line 0 39]
1787 set ref
[string range
$line 41 end
]
1788 if {![string match
"refs/*" $ref]} continue
1789 set name
[string range
$ref 5 end
]
1790 if {[string match
"remotes/*" $name]} {
1791 if {![string match
"*/HEAD" $name] && !$hideremotes} {
1792 set headids
($name) $id
1793 lappend idheads
($id) $name
1795 } elseif
{[string match
"heads/*" $name]} {
1796 set name
[string range
$name 6 end
]
1797 set headids
($name) $id
1798 lappend idheads
($id) $name
1799 } elseif
{[string match
"tags/*" $name]} {
1800 # this lets refs/tags/foo^{} overwrite refs/tags/foo,
1801 # which is what we want since the former is the commit ID
1802 set name
[string range
$name 5 end
]
1803 if {[string match
"*^{}" $name]} {
1804 set name
[string range
$name 0 end-3
]
1806 set tagobjid
($name) $id
1808 set tagids
($name) $id
1809 lappend idtags
($id) $name
1811 set otherrefids
($name) $id
1812 lappend idotherrefs
($id) $name
1819 set mainheadid
[exec git rev-parse HEAD
]
1820 set thehead
[exec git symbolic-ref HEAD
]
1821 if {[string match
"refs/heads/*" $thehead]} {
1822 set mainhead
[string range
$thehead 11 end
]
1826 if {$selecthead ne
{}} {
1828 set selectheadid
[exec git rev-parse
--verify $selecthead]
1833 # skip over fake commits
1834 proc first_real_row
{} {
1835 global nullid nullid2 numcommits
1837 for {set row
0} {$row < $numcommits} {incr row
} {
1838 set id
[commitonrow
$row]
1839 if {$id ne
$nullid && $id ne
$nullid2} {
1846 # update things for a head moved to a child of its previous location
1847 proc movehead
{id name
} {
1848 global headids idheads
1850 removehead
$headids($name) $name
1851 set headids
($name) $id
1852 lappend idheads
($id) $name
1855 # update things when a head has been removed
1856 proc removehead
{id name
} {
1857 global headids idheads
1859 if {$idheads($id) eq
$name} {
1862 set i
[lsearch
-exact $idheads($id) $name]
1864 set idheads
($id) [lreplace
$idheads($id) $i $i]
1867 unset headids
($name)
1870 proc ttk_toplevel
{w args
} {
1872 eval [linsert
$args 0 ::toplevel
$w]
1874 place
[ttk
::frame
$w._toplevel_background
] -x 0 -y 0 -relwidth 1 -relheight 1
1879 proc make_transient
{window origin
} {
1882 # In MacOS Tk 8.4 transient appears to work by setting
1883 # overrideredirect, which is utterly useless, since the
1884 # windows get no border, and are not even kept above
1886 if {!$have_tk85 && [tk windowingsystem
] eq
{aqua
}} return
1888 wm transient
$window $origin
1890 # Windows fails to place transient windows normally, so
1891 # schedule a callback to center them on the parent.
1892 if {[tk windowingsystem
] eq
{win32
}} {
1893 after idle
[list tk
::PlaceWindow
$window widget
$origin]
1897 proc show_error
{w top msg
} {
1899 if {![info exists NS
]} {set NS
""}
1900 if {[wm state
$top] eq
"withdrawn"} { wm deiconify
$top }
1901 message
$w.m
-text $msg -justify center
-aspect 400
1902 pack
$w.m
-side top
-fill x
-padx 20 -pady 20
1903 ${NS}::button
$w.ok
-default active
-text [mc OK
] -command "destroy $top"
1904 pack
$w.ok
-side bottom
-fill x
1905 bind $top <Visibility
> "grab $top; focus $top"
1906 bind $top <Key-Return
> "destroy $top"
1907 bind $top <Key-space
> "destroy $top"
1908 bind $top <Key-Escape
> "destroy $top"
1912 proc error_popup
{msg
{owner .
}} {
1913 if {[tk windowingsystem
] eq
"win32"} {
1914 tk_messageBox
-icon error
-type ok
-title [wm title .
] \
1915 -parent $owner -message $msg
1919 make_transient
$w $owner
1920 show_error
$w $w $msg
1924 proc confirm_popup
{msg
{owner .
}} {
1925 global confirm_ok NS
1929 make_transient
$w $owner
1930 message
$w.m
-text $msg -justify center
-aspect 400
1931 pack
$w.m
-side top
-fill x
-padx 20 -pady 20
1932 ${NS}::button
$w.ok
-text [mc OK
] -command "set confirm_ok 1; destroy $w"
1933 pack
$w.ok
-side left
-fill x
1934 ${NS}::button
$w.cancel
-text [mc Cancel
] -command "destroy $w"
1935 pack
$w.cancel
-side right
-fill x
1936 bind $w <Visibility
> "grab $w; focus $w"
1937 bind $w <Key-Return
> "set confirm_ok 1; destroy $w"
1938 bind $w <Key-space
> "set confirm_ok 1; destroy $w"
1939 bind $w <Key-Escape
> "destroy $w"
1940 tk
::PlaceWindow
$w widget
$owner
1945 proc setoptions
{} {
1946 if {[tk windowingsystem
] ne
"win32"} {
1947 option add
*Panedwindow.showHandle
1 startupFile
1948 option add
*Panedwindow.sashRelief raised startupFile
1949 if {[tk windowingsystem
] ne
"aqua"} {
1950 option add
*Menu.font uifont startupFile
1953 option add
*Menu.TearOff
0 startupFile
1955 option add
*Button.font uifont startupFile
1956 option add
*Checkbutton.font uifont startupFile
1957 option add
*Radiobutton.font uifont startupFile
1958 option add
*Menubutton.font uifont startupFile
1959 option add
*Label.font uifont startupFile
1960 option add
*Message.font uifont startupFile
1961 option add
*Entry.font textfont startupFile
1962 option add
*Text.font textfont startupFile
1963 option add
*Labelframe.font uifont startupFile
1964 option add
*Spinbox.font textfont startupFile
1965 option add
*Listbox.font mainfont startupFile
1968 # Make a menu and submenus.
1969 # m is the window name for the menu, items is the list of menu items to add.
1970 # Each item is a list {mc label type description options...}
1971 # mc is ignored; it's so we can put mc there to alert xgettext
1972 # label is the string that appears in the menu
1973 # type is cascade, command or radiobutton (should add checkbutton)
1974 # description depends on type; it's the sublist for cascade, the
1975 # command to invoke for command, or {variable value} for radiobutton
1976 proc makemenu
{m items
} {
1978 if {[tk windowingsystem
] eq
{aqua
}} {
1984 set name
[mc
[lindex
$i 1]]
1985 set type [lindex
$i 2]
1986 set thing
[lindex
$i 3]
1987 set params
[list
$type]
1989 set u
[string first
"&" [string map
{&& x
} $name]]
1990 lappend params
-label [string map
{&& & & {}} $name]
1992 lappend params
-underline $u
1997 set submenu
[string tolower
[string map
{& ""} [lindex
$i 1]]]
1998 lappend params
-menu $m.
$submenu
2001 lappend params
-command $thing
2004 lappend params
-variable [lindex
$thing 0] \
2005 -value [lindex
$thing 1]
2008 set tail [lrange
$i 4 end
]
2009 regsub
-all {\yMeta1\y
} $tail $Meta1 tail
2010 eval $m add
$params $tail
2011 if {$type eq
"cascade"} {
2012 makemenu
$m.
$submenu $thing
2017 # translate string and remove ampersands
2019 return [string map
{&& & & {}} [mc
$str]]
2022 proc cleardropsel
{w
} {
2025 proc makedroplist
{w varname args
} {
2029 foreach label
$args {
2030 set cx
[string length
$label]
2031 if {$cx > $width} {set width
$cx}
2033 set gm
[ttk
::combobox
$w -width $width -state readonly\
2034 -textvariable $varname -values $args \
2035 -exportselection false
]
2036 bind $gm <<ComboboxSelected>> [list $gm selection clear]
2038 set gm [eval [linsert $args 0 tk_optionMenu $w $varname]]
2043 proc makewindow {} {
2044 global canv canv2 canv3 linespc charspc ctext cflist cscroll
2046 global findtype findtypemenu findloc findstring fstring geometry
2047 global entries sha1entry sha1string sha1but
2048 global diffcontextstring diffcontext
2050 global maincursor textcursor curtextcursor
2051 global rowctxmenu fakerowmenu mergemax wrapcomment
2052 global highlight_files gdttype
2053 global searchstring sstring
2054 global bgcolor fgcolor bglist fglist diffcolors selectbgcolor
2055 global uifgcolor uifgdisabledcolor
2056 global filesepbgcolor filesepfgcolor
2057 global mergecolors foundbgcolor currentsearchhitbgcolor
2058 global headctxmenu progresscanv progressitem progresscoords statusw
2059 global fprogitem fprogcoord lastprogupdate progupdatepending
2060 global rprogitem rprogcoord rownumsel numcommits
2061 global have_tk85 use_ttk NS
2065 # The "mc" arguments here are purely so that xgettext
2066 # sees the following string as needing to be translated
2069 {mc "Update" command updatecommits -accelerator F5}
2070 {mc "Reload" command reloadcommits -accelerator Shift-F5}
2071 {mc "Reread references" command rereadrefs}
2072 {mc "List references" command showrefs -accelerator F2}
2074 {mc "Start git gui" command {exec git gui &}}
2076 {mc "Quit" command doquit -accelerator Meta1-Q}
2080 {mc "Preferences" command doprefs}
2084 {mc "New view..." command {newview 0} -accelerator Shift-F4}
2085 {mc "Edit view..." command editview -state disabled -accelerator F4}
2086 {mc "Delete view" command delview -state disabled}
2088 {mc "All files" radiobutton {selectedview 0} -command {showview 0}}
2090 if {[tk windowingsystem] ne "aqua"} {
2093 {mc "About gitk" command about}
2094 {mc "Key bindings" command keys}
2096 set bar [list $file $edit $view $help]
2098 proc ::tk::mac::ShowPreferences {} {doprefs}
2099 proc ::tk::mac::Quit {} {doquit}
2100 lset file end [lreplace [lindex $file end] end-1 end]
2102 xx "Apple" cascade {
2103 {mc "About gitk" command about}
2108 {mc "Key bindings" command keys}
2110 set bar [list $apple $file $view $help]
2113 . configure -menu .bar
2116 # cover the non-themed toplevel with a themed frame.
2117 place [ttk::frame ._main_background] -x 0 -y 0 -relwidth 1 -relheight 1
2120 # the gui has upper and lower half, parts of a paned window.
2121 ${NS}::panedwindow .ctop -orient vertical
2123 # possibly use assumed geometry
2124 if {![info exists geometry(pwsash0)]} {
2125 set geometry(topheight) [expr {15 * $linespc}]
2126 set geometry(topwidth) [expr {80 * $charspc}]
2127 set geometry(botheight) [expr {15 * $linespc}]
2128 set geometry(botwidth) [expr {50 * $charspc}]
2129 set geometry(pwsash0) [list [expr {40 * $charspc}] 2]
2130 set geometry(pwsash1) [list [expr {60 * $charspc}] 2]
2133 # the upper half will have a paned window, a scroll bar to the right, and some stuff below
2134 ${NS}::frame .tf -height $geometry(topheight) -width $geometry(topwidth)
2135 ${NS}::frame .tf.histframe
2136 ${NS}::panedwindow .tf.histframe.pwclist -orient horizontal
2138 .tf.histframe.pwclist configure -sashpad 0 -handlesize 4
2141 # create three canvases
2142 set cscroll .tf.histframe.csb
2143 set canv .tf.histframe.pwclist.canv
2145 -selectbackground $selectbgcolor \
2146 -background $bgcolor -bd 0 \
2147 -yscrollincr $linespc -yscrollcommand "scrollcanv $cscroll"
2148 .tf.histframe.pwclist add $canv
2149 set canv2 .tf.histframe.pwclist.canv2
2151 -selectbackground $selectbgcolor \
2152 -background $bgcolor -bd 0 -yscrollincr $linespc
2153 .tf.histframe.pwclist add $canv2
2154 set canv3 .tf.histframe.pwclist.canv3
2156 -selectbackground $selectbgcolor \
2157 -background $bgcolor -bd 0 -yscrollincr $linespc
2158 .tf.histframe.pwclist add $canv3
2160 bind .tf.histframe.pwclist <Map> {
2162 .tf.histframe.pwclist sashpos 1 [lindex $::geometry(pwsash1) 0]
2163 .tf.histframe.pwclist sashpos 0 [lindex $::geometry(pwsash0) 0]
2166 eval .tf.histframe.pwclist sash place 0 $geometry(pwsash0)
2167 eval .tf.histframe.pwclist sash place 1 $geometry(pwsash1)
2170 # a scroll bar to rule them
2171 ${NS}::scrollbar $cscroll -command {allcanvs yview}
2172 if {!$use_ttk} {$cscroll configure -highlightthickness 0}
2173 pack $cscroll -side right -fill y
2174 bind .tf.histframe.pwclist <Configure> {resizeclistpanes %W %w}
2175 lappend bglist $canv $canv2 $canv3
2176 pack .tf.histframe.pwclist -fill both -expand 1 -side left
2178 # we have two button bars at bottom of top frame. Bar 1
2179 ${NS}::frame .tf.bar
2180 ${NS}::frame .tf.lbar -height 15
2182 set sha1entry .tf.bar.sha1
2183 set entries $sha1entry
2184 set sha1but .tf.bar.sha1label
2185 button $sha1but -text "[mc "SHA1 ID:"] " -state disabled -relief flat \
2186 -command gotocommit -width 8
2187 $sha1but conf -disabledforeground [$sha1but cget -foreground]
2188 pack .tf.bar.sha1label -side left
2189 ${NS}::entry $sha1entry -width 40 -font textfont -textvariable sha1string
2190 trace add variable sha1string write sha1change
2191 pack $sha1entry -side left -pady 2
2194 #define left_width 16
2195 #define left_height 16
2196 static unsigned char left_bits[] = {
2197 0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
2198 0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
2199 0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
2202 #define right_width 16
2203 #define right_height 16
2204 static unsigned char right_bits[] = {
2205 0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
2206 0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
2207 0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
2209 image create bitmap bm-left -data $bm_left_data -foreground $uifgcolor
2210 image create bitmap bm-left-gray -data $bm_left_data -foreground $uifgdisabledcolor
2211 image create bitmap bm-right -data $bm_right_data -foreground $uifgcolor
2212 image create bitmap bm-right-gray -data $bm_right_data -foreground $uifgdisabledcolor
2214 ${NS}::button .tf.bar.leftbut -command goback -state disabled -width 26
2216 .tf.bar.leftbut configure -image [list bm-left disabled bm-left-gray]
2218 .tf.bar.leftbut configure -image bm-left
2220 pack .tf.bar.leftbut -side left -fill y
2221 ${NS}::button .tf.bar.rightbut -command goforw -state disabled -width 26
2223 .tf.bar.rightbut configure -image [list bm-right disabled bm-right-gray]
2225 .tf.bar.rightbut configure -image bm-right
2227 pack .tf.bar.rightbut -side left -fill y
2229 ${NS}::label .tf.bar.rowlabel -text [mc "Row"]
2231 ${NS}::label .tf.bar.rownum -width 7 -textvariable rownumsel \
2232 -relief sunken -anchor e
2233 ${NS}::label .tf.bar.rowlabel2 -text "/"
2234 ${NS}::label .tf.bar.numcommits -width 7 -textvariable numcommits \
2235 -relief sunken -anchor e
2236 pack .tf.bar.rowlabel .tf.bar.rownum .tf.bar.rowlabel2 .tf.bar.numcommits \
2239 foreach w {rownum numcommits} {.tf.bar.$w configure -font textfont}
2242 trace add variable selectedline write selectedline_change
2244 # Status label and progress bar
2245 set statusw .tf.bar.status
2246 ${NS}::label $statusw -width 15 -relief sunken
2247 pack $statusw -side left -padx 5
2249 set progresscanv [ttk::progressbar .tf.bar.progress]
2251 set h [expr {[font metrics uifont -linespace] + 2}]
2252 set progresscanv .tf.bar.progress
2253 canvas $progresscanv -relief sunken -height $h -borderwidth 2
2254 set progressitem [$progresscanv create rect -1 0 0 $h -fill green]
2255 set fprogitem [$progresscanv create rect -1 0 0 $h -fill yellow]
2256 set rprogitem [$progresscanv create rect -1 0 0 $h -fill red]
2258 pack $progresscanv -side right -expand 1 -fill x -padx {0 2}
2259 set progresscoords {0 0}
2262 bind $progresscanv <Configure> adjustprogress
2263 set lastprogupdate [clock clicks -milliseconds]
2264 set progupdatepending 0
2266 # build up the bottom bar of upper window
2267 ${NS}::label .tf.lbar.flabel -text "[mc "Find"] "
2270 #define down_width 16
2271 #define down_height 16
2272 static unsigned char down_bits[] = {
2273 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
2274 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
2275 0x87, 0xe1, 0x8e, 0x71, 0x9c, 0x39, 0xb8, 0x1d,
2276 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01};
2278 image create bitmap bm-down -data $bm_down_data -foreground $uifgcolor
2279 ${NS}::button .tf.lbar.fnext -width 26 -command {dofind 1 1}
2280 .tf.lbar.fnext configure -image bm-down
2284 #define up_height 16
2285 static unsigned char up_bits[] = {
2286 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f,
2287 0xb8, 0x1d, 0x9c, 0x39, 0x8e, 0x71, 0x87, 0xe1,
2288 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
2289 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01};
2291 image create bitmap bm-up -data $bm_up_data -foreground $uifgcolor
2292 ${NS}::button .tf.lbar.fprev -width 26 -command {dofind -1 1}
2293 .tf.lbar.fprev configure -image bm-up
2295 ${NS}::label .tf.lbar.flab2 -text " [mc "commit"] "
2297 pack .tf.lbar.flabel .tf.lbar.fnext .tf.lbar.fprev .tf.lbar.flab2 \
2299 set gdttype [mc "containing:"]
2300 set gm [makedroplist .tf.lbar.gdttype gdttype \
2301 [mc "containing:"] \
2302 [mc "touching paths:"] \
2303 [mc "adding/removing string:"] \
2304 [mc "changing lines matching:"]]
2305 trace add variable gdttype write gdttype_change
2306 pack .tf.lbar.gdttype -side left -fill y
2309 set fstring .tf.lbar.findstring
2310 lappend entries $fstring
2311 ${NS}::entry $fstring -width 30 -textvariable findstring
2312 trace add variable findstring write find_change
2313 set findtype [mc "Exact"]
2314 set findtypemenu [makedroplist .tf.lbar.findtype \
2315 findtype [mc "Exact"] [mc "IgnCase"] [mc "Regexp"]]
2316 trace add variable findtype write findcom_change
2317 set findloc [mc "All fields"]
2318 makedroplist .tf.lbar.findloc findloc [mc "All fields"] [mc "Headline"] \
2319 [mc "Comments"] [mc "Author"] [mc "Committer"]
2320 trace add variable findloc write find_change
2321 pack .tf.lbar.findloc -side right
2322 pack .tf.lbar.findtype -side right
2323 pack $fstring -side left -expand 1 -fill x
2325 # Finish putting the upper half of the viewer together
2326 pack .tf.lbar -in .tf -side bottom -fill x
2327 pack .tf.bar -in .tf -side bottom -fill x
2328 pack .tf.histframe -fill both -side top -expand 1
2331 .ctop paneconfigure .tf -height $geometry(topheight)
2332 .ctop paneconfigure .tf -width $geometry(topwidth)
2335 # now build up the bottom
2336 ${NS}::panedwindow .pwbottom -orient horizontal
2338 # lower left, a text box over search bar, scroll bar to the right
2339 # if we know window height, then that will set the lower text height, otherwise
2340 # we set lower text height which will drive window height
2341 if {[info exists geometry(main)]} {
2342 ${NS}::frame .bleft -width $geometry(botwidth)
2344 ${NS}::frame .bleft -width $geometry(botwidth) -height $geometry(botheight)
2346 ${NS}::frame .bleft.top
2347 ${NS}::frame .bleft.mid
2348 ${NS}::frame .bleft.bottom
2350 ${NS}::button .bleft.top.search -text [mc "Search"] -command dosearch
2351 pack .bleft.top.search -side left -padx 5
2352 set sstring .bleft.top.sstring
2354 ${NS}::entry $sstring -width 20 -textvariable searchstring
2355 lappend entries $sstring
2356 trace add variable searchstring write incrsearch
2357 pack $sstring -side left -expand 1 -fill x
2358 ${NS}::radiobutton .bleft.mid.diff -text [mc "Diff"] \
2359 -command changediffdisp -variable diffelide -value {0 0}
2360 ${NS}::radiobutton .bleft.mid.old -text [mc "Old version"] \
2361 -command changediffdisp -variable diffelide -value {0 1}
2362 ${NS}::radiobutton .bleft.mid.new -text [mc "New version"] \
2363 -command changediffdisp -variable diffelide -value {1 0}
2364 ${NS}::label .bleft.mid.labeldiffcontext -text " [mc "Lines of context"]: "
2365 pack .bleft.mid.diff .bleft.mid.old .bleft.mid.new -side left
2366 spinbox .bleft.mid.diffcontext -width 5 \
2367 -from 0 -increment 1 -to 10000000 \
2368 -validate all -validatecommand "diffcontextvalidate %P" \
2369 -textvariable diffcontextstring
2370 .bleft.mid.diffcontext set $diffcontext
2371 trace add variable diffcontextstring write diffcontextchange
2372 lappend entries .bleft.mid.diffcontext
2373 pack .bleft.mid.labeldiffcontext .bleft.mid.diffcontext -side left
2374 ${NS}::checkbutton .bleft.mid.ignspace -text [mc "Ignore space change"] \
2375 -command changeignorespace -variable ignorespace
2376 pack .bleft.mid.ignspace -side left -padx 5
2378 set worddiff [mc "Line diff"]
2379 if {[package vcompare $git_version "1.7.2"] >= 0} {
2380 makedroplist .bleft.mid.worddiff worddiff [mc "Line diff"] \
2381 [mc "Markup words"] [mc "Color words"]
2382 trace add variable worddiff write changeworddiff
2383 pack .bleft.mid.worddiff -side left -padx 5
2386 set ctext .bleft.bottom.ctext
2387 text $ctext -background $bgcolor -foreground $fgcolor \
2388 -state disabled -font textfont \
2389 -yscrollcommand scrolltext -wrap none \
2390 -xscrollcommand ".bleft.bottom.sbhorizontal set"
2392 $ctext conf -tabstyle wordprocessor
2394 ${NS}::scrollbar .bleft.bottom.sb -command "$ctext yview"
2395 ${NS}::scrollbar .bleft.bottom.sbhorizontal -command "$ctext xview" -orient h
2396 pack .bleft.top -side top -fill x
2397 pack .bleft.mid -side top -fill x
2398 grid $ctext .bleft.bottom.sb -sticky nsew
2399 grid .bleft.bottom.sbhorizontal -sticky ew
2400 grid columnconfigure .bleft.bottom 0 -weight 1
2401 grid rowconfigure .bleft.bottom 0 -weight 1
2402 grid rowconfigure .bleft.bottom 1 -weight 0
2403 pack .bleft.bottom -side top -fill both -expand 1
2404 lappend bglist $ctext
2405 lappend fglist $ctext
2407 $ctext tag conf comment -wrap $wrapcomment
2408 $ctext tag conf filesep -font textfontbold -fore $filesepfgcolor -back $filesepbgcolor
2409 $ctext tag conf hunksep -fore [lindex $diffcolors 2]
2410 $ctext tag conf d0 -fore [lindex $diffcolors 0]
2411 $ctext tag conf dresult -fore [lindex $diffcolors 1]
2412 $ctext tag conf m0 -fore [lindex $mergecolors 0]
2413 $ctext tag conf m1 -fore [lindex $mergecolors 1]
2414 $ctext tag conf m2 -fore [lindex $mergecolors 2]
2415 $ctext tag conf m3 -fore [lindex $mergecolors 3]
2416 $ctext tag conf m4 -fore [lindex $mergecolors 4]
2417 $ctext tag conf m5 -fore [lindex $mergecolors 5]
2418 $ctext tag conf m6 -fore [lindex $mergecolors 6]
2419 $ctext tag conf m7 -fore [lindex $mergecolors 7]
2420 $ctext tag conf m8 -fore [lindex $mergecolors 8]
2421 $ctext tag conf m9 -fore [lindex $mergecolors 9]
2422 $ctext tag conf m10 -fore [lindex $mergecolors 10]
2423 $ctext tag conf m11 -fore [lindex $mergecolors 11]
2424 $ctext tag conf m12 -fore [lindex $mergecolors 12]
2425 $ctext tag conf m13 -fore [lindex $mergecolors 13]
2426 $ctext tag conf m14 -fore [lindex $mergecolors 14]
2427 $ctext tag conf m15 -fore [lindex $mergecolors 15]
2428 $ctext tag conf mmax -fore darkgrey
2430 $ctext tag conf mresult -font textfontbold
2431 $ctext tag conf msep -font textfontbold
2432 $ctext tag conf found -back $foundbgcolor
2433 $ctext tag conf currentsearchhit -back $currentsearchhitbgcolor
2434 $ctext tag conf wwrap -wrap word -lmargin2 1c
2435 $ctext tag conf bold -font textfontbold
2437 .pwbottom add .bleft
2439 .pwbottom paneconfigure .bleft -width $geometry(botwidth)
2443 ${NS}::frame .bright
2444 ${NS}::frame .bright.mode
2445 ${NS}::radiobutton .bright.mode.patch -text [mc "Patch"] \
2446 -command reselectline -variable cmitmode -value "patch"
2447 ${NS}::radiobutton .bright.mode.tree -text [mc "Tree"] \
2448 -command reselectline -variable cmitmode -value "tree"
2449 grid .bright.mode.patch .bright.mode.tree -sticky ew
2450 pack .bright.mode -side top -fill x
2451 set cflist .bright.cfiles
2452 set indent [font measure mainfont "nn"]
2454 -selectbackground $selectbgcolor \
2455 -background $bgcolor -foreground $fgcolor \
2457 -tabs [list $indent [expr {2 * $indent}]] \
2458 -yscrollcommand ".bright.sb set" \
2459 -cursor [. cget -cursor] \
2460 -spacing1 1 -spacing3 1
2461 lappend bglist $cflist
2462 lappend fglist $cflist
2463 ${NS}::scrollbar .bright.sb -command "$cflist yview"
2464 pack .bright.sb -side right -fill y
2465 pack $cflist -side left -fill both -expand 1
2466 $cflist tag configure highlight \
2467 -background [$cflist cget -selectbackground]
2468 $cflist tag configure bold -font mainfontbold
2470 .pwbottom add .bright
2473 # restore window width & height if known
2474 if {[info exists geometry(main)]} {
2475 if {[scan $geometry(main) "%dx%d" w h] >= 2} {
2476 if {$w > [winfo screenwidth .]} {
2477 set w [winfo screenwidth .]
2479 if {$h > [winfo screenheight .]} {
2480 set h [winfo screenheight .]
2482 wm geometry . "${w}x$h"
2486 if {[info exists geometry(state)] && $geometry(state) eq "zoomed"} {
2487 wm state . $geometry(state)
2490 if {[tk windowingsystem] eq {aqua}} {
2501 %W sashpos 0 $::geometry(topheight)
2503 bind .pwbottom <Map> {
2505 %W sashpos 0 $::geometry(botwidth)
2509 bind .pwbottom <Configure> {resizecdetpanes %W %w}
2510 pack .ctop -fill both -expand 1
2511 bindall <1> {selcanvline %W %x %y}
2512 #bindall <B1-Motion> {selcanvline %W %x %y}
2513 if {[tk windowingsystem] == "win32"} {
2514 bind . <MouseWheel> { windows_mousewheel_redirector %W %X %Y %D }
2515 bind $ctext <MouseWheel> { windows_mousewheel_redirector %W %X %Y %D ; break }
2517 bindall <ButtonRelease-4> "allcanvs yview scroll -5 units"
2518 bindall <ButtonRelease-5> "allcanvs yview scroll 5 units"
2519 bind $ctext <Button> {
2521 $ctext xview scroll -5 units
2522 } elseif {"%b" eq 7} {
2523 $ctext xview scroll 5 units
2526 if {[tk windowingsystem] eq "aqua"} {
2527 bindall <MouseWheel> {
2528 set delta [expr {- (%D)}]
2529 allcanvs yview scroll $delta units
2531 bindall <Shift-MouseWheel> {
2532 set delta [expr {- (%D)}]
2533 $canv xview scroll $delta units
2537 bindall <$::BM> "canvscan mark %W %x %y"
2538 bindall <B$::BM-Motion> "canvscan dragto %W %x %y"
2539 bind all <$M1B-Key-w> {destroy [winfo toplevel %W]}
2540 bind . <$M1B-Key-w> doquit
2541 bindkey <Home> selfirstline
2542 bindkey <End> sellastline
2543 bind . <Key-Up> "selnextline -1"
2544 bind . <Key-Down> "selnextline 1"
2545 bind . <Shift-Key-Up> "dofind -1 0"
2546 bind . <Shift-Key-Down> "dofind 1 0"
2547 bindkey <Key-Right> "goforw"
2548 bindkey <Key-Left> "goback"
2549 bind . <Key-Prior> "selnextpage -1"
2550 bind . <Key-Next> "selnextpage 1"
2551 bind . <$M1B-Home> "allcanvs yview moveto 0.0"
2552 bind . <$M1B-End> "allcanvs yview moveto 1.0"
2553 bind . <$M1B-Key-Up> "allcanvs yview scroll -1 units"
2554 bind . <$M1B-Key-Down> "allcanvs yview scroll 1 units"
2555 bind . <$M1B-Key-Prior> "allcanvs yview scroll -1 pages"
2556 bind . <$M1B-Key-Next> "allcanvs yview scroll 1 pages"
2557 bindkey <Key-Delete> "$ctext yview scroll -1 pages"
2558 bindkey <Key-BackSpace> "$ctext yview scroll -1 pages"
2559 bindkey <Key-space> "$ctext yview scroll 1 pages"
2560 bindkey p "selnextline -1"
2561 bindkey n "selnextline 1"
2564 bindkey k "selnextline -1"
2565 bindkey j "selnextline 1"
2569 bindkey d "$ctext yview scroll 18 units"
2570 bindkey u "$ctext yview scroll -18 units"
2571 bindkey g {$sha1entry delete 0 end; focus $sha1entry}
2572 bindkey / {focus $fstring}
2573 bindkey <Key-KP_Divide> {focus $fstring}
2574 bindkey <Key-Return> {dofind 1 1}
2575 bindkey ? {dofind -1 1}
2577 bind . <F5> updatecommits
2578 bindmodfunctionkey Shift 5 reloadcommits
2579 bind . <F2> showrefs
2580 bindmodfunctionkey Shift 4 {newview 0}
2581 bind . <F4> edit_or_newview
2582 bind . <$M1B-q> doquit
2583 bind . <$M1B-f> {dofind 1 1}
2584 bind . <$M1B-g> {dofind 1 0}
2585 bind . <$M1B-r> dosearchback
2586 bind . <$M1B-s> dosearch
2587 bind . <$M1B-equal> {incrfont 1}
2588 bind . <$M1B-plus> {incrfont 1}
2589 bind . <$M1B-KP_Add> {incrfont 1}
2590 bind . <$M1B-minus> {incrfont -1}
2591 bind . <$M1B-KP_Subtract> {incrfont -1}
2592 wm protocol . WM_DELETE_WINDOW doquit
2593 bind . <Destroy> {stop_backends}
2594 bind . <Button-1> "click %W"
2595 bind $fstring <Key-Return> {dofind 1 1}
2596 bind $sha1entry <Key-Return> {gotocommit; break}
2597 bind $sha1entry <<PasteSelection>> clearsha1
2598 bind $sha1entry <<Paste>> clearsha1
2599 bind $cflist <1> {sel_flist %W %x %y; break}
2600 bind $cflist <B1-Motion> {sel_flist %W %x %y; break}
2601 bind $cflist <ButtonRelease-1> {treeclick %W %x %y}
2603 bind $cflist $ctxbut {pop_flist_menu %W %X %Y %x %y}
2604 bind $ctext $ctxbut {pop_diff_menu %W %X %Y %x %y}
2605 bind $ctext <Button-1> {focus %W}
2606 bind $ctext <<Selection>> rehighlight_search_results
2607 for {set i 1} {$i < 10} {incr i} {
2608 bind . <$M1B-Key-$i> [list go_to_parent $i]
2611 set maincursor [. cget -cursor]
2612 set textcursor [$ctext cget -cursor]
2613 set curtextcursor $textcursor
2615 set rowctxmenu .rowctxmenu
2616 makemenu $rowctxmenu {
2617 {mc "Diff this -> selected" command {diffvssel 0}}
2618 {mc "Diff selected -> this" command {diffvssel 1}}
2619 {mc "Make patch" command mkpatch}
2620 {mc "Create tag" command mktag}
2621 {mc "Write commit to file" command writecommit}
2622 {mc "Create new branch" command mkbranch}
2623 {mc "Cherry-pick this commit" command cherrypick}
2624 {mc "Reset HEAD branch to here" command resethead}
2625 {mc "Mark this commit" command markhere}
2626 {mc "Return to mark" command gotomark}
2627 {mc "Find descendant of this and mark" command find_common_desc}
2628 {mc "Compare with marked commit" command compare_commits}
2629 {mc "Diff this -> marked commit" command {diffvsmark 0}}
2630 {mc "Diff marked commit -> this" command {diffvsmark 1}}
2631 {mc "Revert this commit" command revert}
2633 $rowctxmenu configure -tearoff 0
2635 set fakerowmenu .fakerowmenu
2636 makemenu $fakerowmenu {
2637 {mc "Diff this -> selected" command {diffvssel 0}}
2638 {mc "Diff selected -> this" command {diffvssel 1}}
2639 {mc "Make patch" command mkpatch}
2640 {mc "Diff this -> marked commit" command {diffvsmark 0}}
2641 {mc "Diff marked commit -> this" command {diffvsmark 1}}
2643 $fakerowmenu configure -tearoff 0
2645 set headctxmenu .headctxmenu
2646 makemenu $headctxmenu {
2647 {mc "Check out this branch" command cobranch}
2648 {mc "Remove this branch" command rmbranch}
2649 {mc "Copy branch name" command {clipboard clear; clipboard append $headmenuhead}}
2651 $headctxmenu configure -tearoff 0
2654 set flist_menu .flistctxmenu
2655 makemenu $flist_menu {
2656 {mc "Highlight this too" command {flist_hl 0}}
2657 {mc "Highlight this only" command {flist_hl 1}}
2658 {mc "External diff" command {external_diff}}
2659 {mc "Blame parent commit" command {external_blame 1}}
2660 {mc "Copy path" command {clipboard clear; clipboard append $flist_menu_file}}
2662 $flist_menu configure -tearoff 0
2665 set diff_menu .diffctxmenu
2666 makemenu $diff_menu {
2667 {mc "Show origin of this line" command show_line_source}
2668 {mc "Run git gui blame on this line" command {external_blame_diff}}
2670 $diff_menu configure -tearoff 0
2673 # Windows sends all mouse wheel events to the current focused window, not
2674 # the one where the mouse hovers, so bind those events here and redirect
2675 # to the correct window
2676 proc windows_mousewheel_redirector {W X Y D} {
2677 global canv canv2 canv3
2678 set w [winfo containing -displayof $W $X $Y]
2680 set u [expr {$D < 0 ? 5 : -5}]
2681 if {$w == $canv || $w == $canv2 || $w == $canv3} {
2682 allcanvs yview scroll $u units
2685 $w yview scroll $u units
2691 # Update row number label when selectedline changes
2692 proc selectedline_change {n1 n2 op} {
2693 global selectedline rownumsel
2695 if {$selectedline eq {}} {
2698 set rownumsel [expr {$selectedline + 1}]
2702 # mouse-2 makes all windows scan vertically, but only the one
2703 # the cursor is in scans horizontally
2704 proc canvscan {op w x y} {
2705 global canv canv2 canv3
2706 foreach c [list $canv $canv2 $canv3] {
2715 proc scrollcanv {cscroll f0 f1} {
2716 $cscroll set $f0 $f1
2721 # when we make a key binding for the toplevel, make sure
2722 # it doesn't get triggered when that key is pressed in the
2723 # find string entry widget.
2724 proc bindkey {ev script} {
2727 set escript [bind Entry $ev]
2728 if {$escript == {}} {
2729 set escript [bind Entry <Key>]
2731 foreach e $entries {
2732 bind $e $ev "$escript; break"
2736 proc bindmodfunctionkey {mod n script} {
2737 bind . <$mod-F$n> $script
2738 catch { bind . <$mod-XF86_Switch_VT_$n> $script }
2741 # set the focus back to the toplevel for any click outside
2744 global ctext entries
2745 foreach e [concat $entries $ctext] {
2746 if {$w == $e} return
2751 # Adjust the progress bar for a change in requested extent or canvas size
2752 proc adjustprogress {} {
2753 global progresscanv progressitem progresscoords
2754 global fprogitem fprogcoord lastprogupdate progupdatepending
2755 global rprogitem rprogcoord use_ttk
2758 $progresscanv configure -value [expr {int($fprogcoord * 100)}]
2762 set w [expr {[winfo width $progresscanv] - 4}]
2763 set x0 [expr {$w * [lindex $progresscoords 0]}]
2764 set x1 [expr {$w * [lindex $progresscoords 1]}]
2765 set h [winfo height $progresscanv]
2766 $progresscanv coords $progressitem $x0 0 $x1 $h
2767 $progresscanv coords $fprogitem 0 0 [expr {$w * $fprogcoord}] $h
2768 $progresscanv coords $rprogitem 0 0 [expr {$w * $rprogcoord}] $h
2769 set now [clock clicks -milliseconds]
2770 if {$now >= $lastprogupdate + 100} {
2771 set progupdatepending 0
2773 } elseif {!$progupdatepending} {
2774 set progupdatepending 1
2775 after [expr {$lastprogupdate + 100 - $now}] doprogupdate
2779 proc doprogupdate {} {
2780 global lastprogupdate progupdatepending
2782 if {$progupdatepending} {
2783 set progupdatepending 0
2784 set lastprogupdate [clock clicks -milliseconds]
2789 proc config_check_tmp_exists {tries_left} {
2790 global config_file_tmp
2792 if {[file exists $config_file_tmp]} {
2794 if {$tries_left > 0} {
2795 after 100 [list config_check_tmp_exists $tries_left]
2797 error_popup "There appears to be a stale $config_file_tmp\
2798 file, which will prevent gitk from saving its configuration on exit.\
2799 Please remove it if it is not being used by any existing gitk process."
2804 proc config_init_trace {name} {
2805 global config_variable_changed config_variable_original
2808 set config_variable_changed($name) 0
2809 set config_variable_original($name) $var
2812 proc config_variable_change_cb {name name2 op} {
2813 global config_variable_changed config_variable_original
2816 if {$op eq "write" &&
2817 (![info exists config_variable_original($name)] ||
2818 $config_variable_original($name) ne $var)} {
2819 set config_variable_changed($name) 1
2823 proc savestuff {w} {
2825 global config_file config_file_tmp
2826 global config_variables config_variable_changed
2829 upvar #0 viewname current_viewname
2830 upvar #0 viewfiles current_viewfiles
2831 upvar #0 viewargs current_viewargs
2832 upvar #0 viewargscmd current_viewargscmd
2833 upvar #0 viewperm current_viewperm
2834 upvar #0 nextviewnum current_nextviewnum
2835 upvar #0 use_ttk current_use_ttk
2837 if {$stuffsaved} return
2838 if {![winfo viewable .]} return
2842 while {[catch {set f [open $config_file_tmp {WRONLY CREAT EXCL}]}]} {
2843 if {[incr try_count] > 50} {
2844 error "Unable to write config file: $config_file_tmp exists"
2849 if {$::tcl_platform(platform) eq {windows}} {
2850 file attributes $config_file_tmp -hidden true
2852 if {[file exists $config_file]} {
2855 foreach var_name $config_variables {
2856 upvar #0 $var_name var
2857 upvar 0 $var_name old_var
2858 if {!$config_variable_changed($var_name) && [info exists old_var]} {
2859 puts $f [list set $var_name $old_var]
2861 puts $f [list set $var_name $var]
2865 puts $f "set geometry(main) [wm geometry .]"
2866 puts $f "set geometry(state) [wm state .]"
2867 puts $f "set geometry(topwidth) [winfo width .tf]"
2868 puts $f "set geometry(topheight) [winfo height .tf]"
2869 if {$current_use_ttk} {
2870 puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sashpos 0] 1\""
2871 puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sashpos 1] 1\""
2873 puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sash coord 0]\""
2874 puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sash coord 1]\""
2876 puts $f "set geometry(botwidth) [winfo width .bleft]"
2877 puts $f "set geometry(botheight) [winfo height .bleft]"
2879 array set view_save {}
2881 if {![info exists permviews]} { set permviews {} }
2882 foreach view $permviews {
2883 set view_save([lindex $view 0]) 1
2884 set views([lindex $view 0]) $view
2886 puts -nonewline $f "set permviews {"
2887 for {set v 1} {$v < $current_nextviewnum} {incr v} {
2888 if {$viewchanged($v)} {
2889 if {$current_viewperm($v)} {
2890 set views($current_viewname($v)) [list $current_viewname($v) $current_viewfiles($v) $current_viewargs($v) $current_viewargscmd($v)]
2892 set view_save($current_viewname($v)) 0
2896 # write old and updated view to their places and append remaining to the end
2897 foreach view $permviews {
2898 set view_name [lindex $view 0]
2899 if {$view_save($view_name)} {
2900 puts $f "{$views($view_name)}"
2902 unset views($view_name)
2904 foreach view_name [array names views] {
2905 puts $f "{$views($view_name)}"
2909 file rename -force $config_file_tmp $config_file
2912 puts "Error saving config: $err"
2915 file delete -force $config_file_tmp
2920 proc resizeclistpanes {win w} {
2921 global oldwidth use_ttk
2922 if {[info exists oldwidth($win)]} {
2924 set s0 [$win sashpos 0]
2925 set s1 [$win sashpos 1]
2927 set s0 [$win sash coord 0]
2928 set s1 [$win sash coord 1]
2931 set sash0 [expr {int($w/2 - 2)}]
2932 set sash1 [expr {int($w*5/6 - 2)}]
2934 set factor [expr {1.0 * $w / $oldwidth($win)}]
2935 set sash0 [expr {int($factor * [lindex $s0 0])}]
2936 set sash1 [expr {int($factor * [lindex $s1 0])}]
2940 if {$sash1 < $sash0 + 20} {
2941 set sash1 [expr {$sash0 + 20}]
2943 if {$sash1 > $w - 10} {
2944 set sash1 [expr {$w - 10}]
2945 if {$sash0 > $sash1 - 20} {
2946 set sash0 [expr {$sash1 - 20}]
2951 $win sashpos 0 $sash0
2952 $win sashpos 1 $sash1
2954 $win sash place 0 $sash0 [lindex $s0 1]
2955 $win sash place 1 $sash1 [lindex $s1 1]
2958 set oldwidth($win) $w
2961 proc resizecdetpanes {win w} {
2962 global oldwidth use_ttk
2963 if {[info exists oldwidth($win)]} {
2965 set s0 [$win sashpos 0]
2967 set s0 [$win sash coord 0]
2970 set sash0 [expr {int($w*3/4 - 2)}]
2972 set factor [expr {1.0 * $w / $oldwidth($win)}]
2973 set sash0 [expr {int($factor * [lindex $s0 0])}]
2977 if {$sash0 > $w - 15} {
2978 set sash0 [expr {$w - 15}]
2982 $win sashpos 0 $sash0
2984 $win sash place 0 $sash0 [lindex $s0 1]
2987 set oldwidth($win) $w
2990 proc allcanvs args {
2991 global canv canv2 canv3
2997 proc bindall {event action} {
2998 global canv canv2 canv3
2999 bind $canv $event $action
3000 bind $canv2 $event $action
3001 bind $canv3 $event $action
3007 if {[winfo exists $w]} {
3012 wm title $w [mc "About gitk"]
3014 message $w.m -text [mc "
3015 Gitk - a commit viewer for git
3017 Copyright \u00a9 2005-2014 Paul Mackerras
3019 Use and redistribute under the terms of the GNU General Public License"] \
3020 -justify center -aspect 400 -border 2 -bg white -relief groove
3021 pack $w.m -side top -fill x -padx 2 -pady 2
3022 ${NS}::button $w.ok -text [mc "Close"] -command "destroy $w" -default active
3023 pack $w.ok -side bottom
3024 bind $w <Visibility> "focus $w.ok"
3025 bind $w <Key-Escape> "destroy $w"
3026 bind $w <Key-Return> "destroy $w"
3027 tk::PlaceWindow $w widget .
3033 if {[winfo exists $w]} {
3037 if {[tk windowingsystem] eq {aqua}} {
3043 wm title $w [mc "Gitk key bindings"]
3045 message $w.m -text "
3046 [mc "Gitk key bindings:"]
3048 [mc "<%s-Q> Quit" $M1T]
3049 [mc "<%s-W> Close window" $M1T]
3050 [mc "<Home> Move to first commit"]
3051 [mc "<End> Move to last commit"]
3052 [mc "<Up>, p, k Move up one commit"]
3053 [mc "<Down>, n, j Move down one commit"]
3054 [mc "<Left>, z, h Go back in history list"]
3055 [mc "<Right>, x, l Go forward in history list"]
3056 [mc "<%s-n> Go to n-th parent of current commit in history list" $M1T]
3057 [mc "<PageUp> Move up one page in commit list"]
3058 [mc "<PageDown> Move down one page in commit list"]
3059 [mc "<%s-Home> Scroll to top of commit list" $M1T]
3060 [mc "<%s-End> Scroll to bottom of commit list" $M1T]
3061 [mc "<%s-Up> Scroll commit list up one line" $M1T]
3062 [mc "<%s-Down> Scroll commit list down one line" $M1T]
3063 [mc "<%s-PageUp> Scroll commit list up one page" $M1T]
3064 [mc "<%s-PageDown> Scroll commit list down one page" $M1T]
3065 [mc "<Shift-Up> Find backwards (upwards, later commits)"]
3066 [mc "<Shift-Down> Find forwards (downwards, earlier commits)"]
3067 [mc "<Delete>, b Scroll diff view up one page"]
3068 [mc "<Backspace> Scroll diff view up one page"]
3069 [mc "<Space> Scroll diff view down one page"]
3070 [mc "u Scroll diff view up 18 lines"]
3071 [mc "d Scroll diff view down 18 lines"]
3072 [mc "<%s-F> Find" $M1T]
3073 [mc "<%s-G> Move to next find hit" $M1T]
3074 [mc "<Return> Move to next find hit"]
3075 [mc "g Go to commit"]
3076 [mc "/ Focus the search box"]
3077 [mc "? Move to previous find hit"]
3078 [mc "f Scroll diff view to next file"]
3079 [mc "<%s-S> Search for next hit in diff view" $M1T]
3080 [mc "<%s-R> Search for previous hit in diff view" $M1T]
3081 [mc "<%s-KP+> Increase font size" $M1T]
3082 [mc "<%s-plus> Increase font size" $M1T]
3083 [mc "<%s-KP-> Decrease font size" $M1T]
3084 [mc "<%s-minus> Decrease font size" $M1T]
3087 -justify left -bg white -border 2 -relief groove
3088 pack $w.m -side top -fill both -padx 2 -pady 2
3089 ${NS}::button $w.ok -text [mc "Close"] -command "destroy $w" -default active
3090 bind $w <Key-Escape> [list destroy $w]
3091 pack $w.ok -side bottom
3092 bind $w <Visibility> "focus $w.ok"
3093 bind $w <Key-Escape> "destroy $w"
3094 bind $w <Key-Return> "destroy $w"
3097 # Procedures for manipulating the file list window at the
3098 # bottom right of the overall window.
3100 proc treeview {w l openlevs} {
3101 global treecontents treediropen treeheight treeparent treeindex
3111 set treecontents() {}
3112 $w conf -state normal
3114 while {[string range $f 0 $prefixend] ne $prefix} {
3115 if {$lev <= $openlevs} {
3116 $w mark set e:$treeindex($prefix) "end -1c"
3117 $w mark gravity e:$treeindex($prefix) left
3119 set treeheight($prefix) $ht
3120 incr ht [lindex $htstack end]
3121 set htstack [lreplace $htstack end end]
3122 set prefixend [lindex $prefendstack end]
3123 set prefendstack [lreplace $prefendstack end end]
3124 set prefix [string range $prefix 0 $prefixend]
3127 set tail [string range $f [expr {$prefixend+1}] end]
3128 while {[set slash [string first "/" $tail]] >= 0} {
3131 lappend prefendstack $prefixend
3132 incr prefixend [expr {$slash + 1}]
3133 set d [string range $tail 0 $slash]
3134 lappend treecontents($prefix) $d
3135 set oldprefix $prefix
3137 set treecontents($prefix) {}
3138 set treeindex($prefix) [incr ix]
3139 set treeparent($prefix) $oldprefix
3140 set tail [string range $tail [expr {$slash+1}] end]
3141 if {$lev <= $openlevs} {
3143 set treediropen($prefix) [expr {$lev < $openlevs}]
3144 set bm [expr {$lev == $openlevs? "tri-rt": "tri-dn"}]
3145 $w mark set d:$ix "end -1c"
3146 $w mark gravity d:$ix left
3148 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
3150 $w image create end -align center -image $bm -padx 1 \
3152 $w insert end $d [highlight_tag $prefix]
3153 $w mark set s:$ix "end -1c"
3154 $w mark gravity s:$ix left
3159 if {$lev <= $openlevs} {
3162 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
3164 $w insert end $tail [highlight_tag $f]
3166 lappend treecontents($prefix) $tail
3169 while {$htstack ne {}} {
3170 set treeheight($prefix) $ht
3171 incr ht [lindex $htstack end]
3172 set htstack [lreplace $htstack end end]
3173 set prefixend [lindex $prefendstack end]
3174 set prefendstack [lreplace $prefendstack end end]
3175 set prefix [string range $prefix 0 $prefixend]
3177 $w conf -state disabled
3180 proc linetoelt {l} {
3181 global treeheight treecontents
3186 foreach e $treecontents($prefix) {
3191 if {[string index $e end] eq "/"} {
3192 set n $treeheight($prefix$e)
3204 proc highlight_tree {y prefix} {
3205 global treeheight treecontents cflist
3207 foreach e $treecontents($prefix) {
3209 if {[highlight_tag $path] ne {}} {
3210 $cflist tag add bold $y.0 "$y.0 lineend"
3213 if {[string index $e end] eq "/" && $treeheight($path) > 1} {
3214 set y [highlight_tree $y $path]
3220 proc treeclosedir {w dir} {
3221 global treediropen treeheight treeparent treeindex
3223 set ix $treeindex($dir)
3224 $w conf -state normal
3225 $w delete s:$ix e:$ix
3226 set treediropen($dir) 0
3227 $w image configure a:$ix -image tri-rt
3228 $w conf -state disabled
3229 set n [expr {1 - $treeheight($dir)}]
3230 while {$dir ne {}} {
3231 incr treeheight($dir) $n
3232 set dir $treeparent($dir)
3236 proc treeopendir {w dir} {
3237 global treediropen treeheight treeparent treecontents treeindex
3239 set ix $treeindex($dir)
3240 $w conf -state normal
3241 $w image configure a:$ix -image tri-dn
3242 $w mark set e:$ix s:$ix
3243 $w mark gravity e:$ix right
3246 set n [llength $treecontents($dir)]
3247 for {set x $dir} {$x ne {}} {set x $treeparent($x)} {
3250 incr treeheight($x) $n
3252 foreach e $treecontents($dir) {
3254 if {[string index $e end] eq "/"} {
3255 set iy $treeindex($de)
3256 $w mark set d:$iy e:$ix
3257 $w mark gravity d:$iy left
3258 $w insert e:$ix $str
3259 set treediropen($de) 0
3260 $w image create e:$ix -align center -image tri-rt -padx 1 \
3262 $w insert e:$ix $e [highlight_tag $de]
3263 $w mark set s:$iy e:$ix
3264 $w mark gravity s:$iy left
3265 set treeheight($de) 1
3267 $w insert e:$ix $str
3268 $w insert e:$ix $e [highlight_tag $de]
3271 $w mark gravity e:$ix right
3272 $w conf -state disabled
3273 set treediropen($dir) 1
3274 set top [lindex [split [$w index @0,0] .] 0]
3275 set ht [$w cget -height]
3276 set l [lindex [split [$w index s:$ix] .] 0]
3279 } elseif {$l + $n + 1 > $top + $ht} {
3280 set top [expr {$l + $n + 2 - $ht}]
3288 proc treeclick {w x y} {
3289 global treediropen cmitmode ctext cflist cflist_top
3291 if {$cmitmode ne "tree"} return
3292 if {![info exists cflist_top]} return
3293 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3294 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
3295 $cflist tag add highlight $l.0 "$l.0 lineend"
3301 set e [linetoelt $l]
3302 if {[string index $e end] ne "/"} {
3304 } elseif {$treediropen($e)} {
3311 proc setfilelist {id} {
3312 global treefilelist cflist jump_to_here
3314 treeview $cflist $treefilelist($id) 0
3315 if {$jump_to_here ne {}} {
3316 set f [lindex $jump_to_here 0]
3317 if {[lsearch -exact $treefilelist($id) $f] >= 0} {
3323 image create bitmap tri-rt -background black -foreground blue -data {
3324 #define tri-rt_width 13
3325 #define tri-rt_height 13
3326 static unsigned char tri-rt_bits[] = {
3327 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00,
3328 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x30, 0x00, 0x10, 0x00, 0x00, 0x00,
3331 #define tri-rt-mask_width 13
3332 #define tri-rt-mask_height 13
3333 static unsigned char tri-rt-mask_bits[] = {
3334 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01,
3335 0xf8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0x38, 0x00, 0x18, 0x00,
3338 image create bitmap tri-dn -background black -foreground blue -data {
3339 #define tri-dn_width 13
3340 #define tri-dn_height 13
3341 static unsigned char tri-dn_bits[] = {
3342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xf8, 0x03,
3343 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3346 #define tri-dn-mask_width 13
3347 #define tri-dn-mask_height 13
3348 static unsigned char tri-dn-mask_bits[] = {
3349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07,
3350 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
3354 image create bitmap reficon-T -background black -foreground yellow -data {
3355 #define tagicon_width 13
3356 #define tagicon_height 9
3357 static unsigned char tagicon_bits[] = {
3358 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x07,
3359 0xfc, 0x07, 0xf8, 0x07, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00};
3361 #define tagicon-mask_width 13
3362 #define tagicon-mask_height 9
3363 static unsigned char tagicon-mask_bits[] = {
3364 0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x0f, 0xfc, 0x0f,
3365 0xfe, 0x0f, 0xfc, 0x0f, 0xf8, 0x0f, 0xf0, 0x0f, 0x00, 0x00};
3368 #define headicon_width 13
3369 #define headicon_height 9
3370 static unsigned char headicon_bits[] = {
3371 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0xf8, 0x07,
3372 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00};
3375 #define headicon-mask_width 13
3376 #define headicon-mask_height 9
3377 static unsigned char headicon-mask_bits[] = {
3378 0x00, 0x00, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f,
3379 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0x00, 0x00};
3381 image create bitmap reficon-H -background black -foreground green \
3382 -data $rectdata -maskdata $rectmask
3383 image create bitmap reficon-o -background black -foreground "#ddddff" \
3384 -data $rectdata -maskdata $rectmask
3386 proc init_flist {first} {
3387 global cflist cflist_top difffilestart
3389 $cflist conf -state normal
3390 $cflist delete 0.0 end
3392 $cflist insert end $first
3394 $cflist tag add highlight 1.0 "1.0 lineend"
3396 unset -nocomplain cflist_top
3398 $cflist conf -state disabled
3399 set difffilestart {}
3402 proc highlight_tag {f} {
3403 global highlight_paths
3405 foreach p $highlight_paths {
3406 if {[string match $p $f]} {
3413 proc highlight_filelist {} {
3414 global cmitmode cflist
3416 $cflist conf -state normal
3417 if {$cmitmode ne "tree"} {
3418 set end [lindex [split [$cflist index end] .] 0]
3419 for {set l 2} {$l < $end} {incr l} {
3420 set line [$cflist get $l.0 "$l.0 lineend"]
3421 if {[highlight_tag $line] ne {}} {
3422 $cflist tag add bold $l.0 "$l.0 lineend"
3428 $cflist conf -state disabled
3431 proc unhighlight_filelist {} {
3434 $cflist conf -state normal
3435 $cflist tag remove bold 1.0 end
3436 $cflist conf -state disabled
3439 proc add_flist {fl} {
3442 $cflist conf -state normal
3444 $cflist insert end "\n"
3445 $cflist insert end $f [highlight_tag $f]
3447 $cflist conf -state disabled
3450 proc sel_flist {w x y} {
3451 global ctext difffilestart cflist cflist_top cmitmode
3453 if {$cmitmode eq "tree"} return
3454 if {![info exists cflist_top]} return
3455 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3456 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
3457 $cflist tag add highlight $l.0 "$l.0 lineend"
3462 catch {$ctext yview [lindex $difffilestart [expr {$l - 2}]]}
3464 suppress_highlighting_file_for_current_scrollpos
3467 proc pop_flist_menu {w X Y x y} {
3468 global ctext cflist cmitmode flist_menu flist_menu_file
3469 global treediffs diffids
3472 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3474 if {$cmitmode eq "tree"} {
3475 set e [linetoelt $l]
3476 if {[string index $e end] eq "/"} return
3478 set e [lindex $treediffs($diffids) [expr {$l-2}]]
3480 set flist_menu_file $e
3481 set xdiffstate "normal"
3482 if {$cmitmode eq "tree"} {
3483 set xdiffstate "disabled"
3485 # Disable "External diff" item in tree mode
3486 $flist_menu entryconf 2 -state $xdiffstate
3487 tk_popup $flist_menu $X $Y
3490 proc find_ctext_fileinfo {line} {
3491 global ctext_file_names ctext_file_lines
3493 set ok [bsearch $ctext_file_lines $line]
3494 set tline [lindex $ctext_file_lines $ok]
3496 if {$ok >= [llength $ctext_file_lines] || $line < $tline} {
3499 return [list [lindex $ctext_file_names $ok] $tline]
3503 proc pop_diff_menu {w X Y x y} {
3504 global ctext diff_menu flist_menu_file
3505 global diff_menu_txtpos diff_menu_line
3506 global diff_menu_filebase
3508 set diff_menu_txtpos [split [$w index "@$x,$y"] "."]
3509 set diff_menu_line [lindex $diff_menu_txtpos 0]
3510 # don't pop up the menu on hunk-separator or file-separator lines
3511 if {[lsearch -glob [$ctext tag names $diff_menu_line.0] "*sep"] >= 0} {
3515 set f [find_ctext_fileinfo $diff_menu_line]
3516 if {$f eq {}} return
3517 set flist_menu_file [lindex $f 0]
3518 set diff_menu_filebase [lindex $f 1]
3519 tk_popup $diff_menu $X $Y
3522 proc flist_hl {only} {
3523 global flist_menu_file findstring gdttype
3525 set x [shellquote $flist_menu_file]
3526 if {$only || $findstring eq {} || $gdttype ne [mc "touching paths:"]} {
3529 append findstring " " $x
3531 set gdttype [mc "touching paths:"]
3534 proc gitknewtmpdir {} {
3535 global diffnum gitktmpdir gitdir env
3537 if {![info exists gitktmpdir]} {
3538 if {[info exists env(GITK_TMPDIR)]} {
3539 set tmpdir $env(GITK_TMPDIR)
3540 } elseif {[info exists env(TMPDIR)]} {
3541 set tmpdir $env(TMPDIR)
3545 set gitktmpformat [file join $tmpdir ".gitk-tmp.XXXXXX"]
3546 if {[catch {set gitktmpdir [exec mktemp -d $gitktmpformat]}]} {
3547 set gitktmpdir [file join $gitdir [format ".gitk-tmp.%s" [pid]]]
3549 if {[catch {file mkdir $gitktmpdir} err]} {
3550 error_popup "[mc "Error creating temporary directory %s:" $gitktmpdir] $err"
3557 set diffdir [file join $gitktmpdir $diffnum]
3558 if {[catch {file mkdir $diffdir} err]} {
3559 error_popup "[mc "Error creating temporary directory %s:" $diffdir] $err"
3565 proc save_file_from_commit {filename output what} {
3568 if {[catch {exec git show $filename -- > $output} err]} {
3569 if {[string match "fatal: bad revision *" $err]} {
3572 error_popup "[mc "Error getting \"%s\" from %s:" $filename $what] $err"
3578 proc external_diff_get_one_file {diffid filename diffdir} {
3579 global nullid nullid2 nullfile
3582 if {$diffid == $nullid} {
3583 set difffile [file join $worktree $filename]
3584 if {[file exists $difffile]} {
3589 if {$diffid == $nullid2} {
3590 set difffile [file join $diffdir "\[index\] [file tail $filename]"]
3591 return [save_file_from_commit :$filename $difffile index]
3593 set difffile [file join $diffdir "\[$diffid\] [file tail $filename]"]
3594 return [save_file_from_commit $diffid:$filename $difffile \
3598 proc external_diff {} {
3599 global nullid nullid2
3600 global flist_menu_file
3604 if {[llength $diffids] == 1} {
3605 # no reference commit given
3606 set diffidto [lindex $diffids 0]
3607 if {$diffidto eq $nullid} {
3608 # diffing working copy with index
3609 set diffidfrom $nullid2
3610 } elseif {$diffidto eq $nullid2} {
3611 # diffing index with HEAD
3612 set diffidfrom "HEAD"
3614 # use first parent commit
3615 global parentlist selectedline
3616 set diffidfrom [lindex $parentlist $selectedline 0]
3619 set diffidfrom [lindex $diffids 0]
3620 set diffidto [lindex $diffids 1]
3623 # make sure that several diffs wont collide
3624 set diffdir [gitknewtmpdir]
3625 if {$diffdir eq {}} return
3627 # gather files to diff
3628 set difffromfile [external_diff_get_one_file $diffidfrom $flist_menu_file $diffdir]
3629 set difftofile [external_diff_get_one_file $diffidto $flist_menu_file $diffdir]
3631 if {$difffromfile ne {} && $difftofile ne {}} {
3632 set cmd [list [shellsplit $extdifftool] $difffromfile $difftofile]
3633 if {[catch {set fl [open |$cmd r]} err]} {
3634 file delete -force $diffdir
3635 error_popup "$extdifftool: [mc "command failed:"] $err"
3637 fconfigure $fl -blocking 0
3638 filerun $fl [list delete_at_eof $fl $diffdir]
3643 proc find_hunk_blamespec {base line} {
3646 # Find and parse the hunk header
3647 set s_lix [$ctext search -backwards -regexp ^@@ "$line.0 lineend" $base.0]
3648 if {$s_lix eq {}} return
3650 set s_line [$ctext get $s_lix "$s_lix + 1 lines"]
3651 if {![regexp {^@@@*(( -\d+(,\d+)?)+) \+(\d+)(,\d+)? @@} $s_line \
3652 s_line old_specs osz osz1 new_line nsz]} {
3656 # base lines for the parents
3657 set base_lines [list $new_line]
3658 foreach old_spec [lrange [split $old_specs " "] 1 end] {
3659 if {![regexp -- {-(\d+)(,\d+)?} $old_spec \
3660 old_spec old_line osz]} {
3663 lappend base_lines $old_line
3666 # Now scan the lines to determine offset within the hunk
3667 set max_parent [expr {[llength $base_lines]-2}]
3669 set s_lno [lindex [split $s_lix "."] 0]
3671 # Determine if the line is removed
3672 set chunk [$ctext get $line.0 "$line.1 + $max_parent chars"]
3673 if {[string match {[-+ ]*} $chunk]} {
3674 set removed_idx [string first "-" $chunk]
3675 # Choose a parent index
3676 if {$removed_idx >= 0} {
3677 set parent $removed_idx
3679 set unchanged_idx [string first " " $chunk]
3680 if {$unchanged_idx >= 0} {
3681 set parent $unchanged_idx
3683 # blame the current commit
3687 # then count other lines that belong to it
3688 for {set i $line} {[incr i -1] > $s_lno} {} {
3689 set chunk [$ctext get $i.0 "$i.1 + $max_parent chars"]
3690 # Determine if the line is removed
3691 set removed_idx [string first "-" $chunk]
3693 set code [string index $chunk $parent]
3694 if {$code eq "-" || ($removed_idx < 0 && $code ne "+")} {
3698 if {$removed_idx < 0} {
3708 incr dline [lindex $base_lines $parent]
3709 return [list $parent $dline]
3712 proc external_blame_diff {} {
3713 global currentid cmitmode
3714 global diff_menu_txtpos diff_menu_line
3715 global diff_menu_filebase flist_menu_file
3717 if {$cmitmode eq "tree"} {
3719 set line [expr {$diff_menu_line - $diff_menu_filebase}]
3721 set hinfo [find_hunk_blamespec $diff_menu_filebase $diff_menu_line]
3723 set parent_idx [lindex $hinfo 0]
3724 set line [lindex $hinfo 1]
3731 external_blame $parent_idx $line
3734 # Find the SHA1 ID of the blob for file $fname in the index
3736 proc index_sha1 {fname} {
3737 set f [open [list | git ls-files -s $fname] r]
3738 while {[gets $f line] >= 0} {
3739 set info [lindex [split $line "\t"] 0]
3740 set stage [lindex $info 2]
3741 if {$stage eq "0" || $stage eq "2"} {
3743 return [lindex $info 1]
3750 # Turn an absolute path into one relative to the current directory
3751 proc make_relative {f} {
3752 if {[file pathtype $f] eq "relative"} {
3755 set elts [file split $f]
3756 set here [file split [pwd]]
3761 if {$ei < $hi || $ei >= [llength $elts] || [lindex $elts $ei] ne $d} {
3768 set elts [concat $res [lrange $elts $ei end]]
3769 return [eval file join $elts]
3772 proc external_blame {parent_idx {line {}}} {
3773 global flist_menu_file cdup
3774 global nullid nullid2
3775 global parentlist selectedline currentid
3777 if {$parent_idx > 0} {
3778 set base_commit [lindex $parentlist $selectedline [expr {$parent_idx-1}]]
3780 set base_commit $currentid
3783 if {$base_commit eq {} || $base_commit eq $nullid || $base_commit eq $nullid2} {
3784 error_popup [mc "No such commit"]
3788 set cmdline [list git gui blame]
3789 if {$line ne {} && $line > 1} {
3790 lappend cmdline "--line=$line"
3792 set f [file join $cdup $flist_menu_file]
3793 # Unfortunately it seems git gui blame doesn't like
3794 # being given an absolute path...
3795 set f [make_relative $f]
3796 lappend cmdline $base_commit $f
3797 if {[catch {eval exec $cmdline &} err]} {
3798 error_popup "[mc "git gui blame: command failed:"] $err"
3802 proc show_line_source {} {
3803 global cmitmode currentid parents curview blamestuff blameinst
3804 global diff_menu_line diff_menu_filebase flist_menu_file
3805 global nullid nullid2 gitdir cdup
3808 if {$cmitmode eq "tree"} {
3810 set line [expr {$diff_menu_line - $diff_menu_filebase}]
3812 set h [find_hunk_blamespec $diff_menu_filebase $diff_menu_line]
3813 if {$h eq {}} return
3814 set pi [lindex $h 0]
3816 mark_ctext_line $diff_menu_line
3820 if {$currentid eq $nullid} {
3822 # must be a merge in progress...
3824 # get the last line from .git/MERGE_HEAD
3825 set f [open [file join $gitdir MERGE_HEAD] r]
3826 set id [lindex [split [read $f] "\n"] end-1]
3829 error_popup [mc "Couldn't read merge head: %s" $err]
3832 } elseif {$parents($curview,$currentid) eq $nullid2} {
3833 # need to do the blame from the index
3835 set from_index [index_sha1 $flist_menu_file]
3837 error_popup [mc "Error reading index: %s" $err]
3841 set id $parents($curview,$currentid)
3844 set id [lindex $parents($curview,$currentid) $pi]
3846 set line [lindex $h 1]
3849 if {$from_index ne {}} {
3850 lappend blameargs | git cat-file blob $from_index
3852 lappend blameargs | git blame -p -L$line,+1
3853 if {$from_index ne {}} {
3854 lappend blameargs --contents -
3856 lappend blameargs $id
3858 lappend blameargs -- [file join $cdup $flist_menu_file]
3860 set f [open $blameargs r]
3862 error_popup [mc "Couldn't start git blame: %s" $err]
3865 nowbusy blaming [mc "Searching"]
3866 fconfigure $f -blocking 0
3867 set i [reg_instance $f]
3868 set blamestuff($i) {}
3870 filerun $f [list read_line_source $f $i]
3873 proc stopblaming {} {
3876 if {[info exists blameinst]} {
3877 stop_instance $blameinst
3883 proc read_line_source {fd inst} {
3884 global blamestuff curview commfd blameinst nullid nullid2
3886 while {[gets $fd line] >= 0} {
3887 lappend blamestuff($inst) $line
3895 fconfigure $fd -blocking 1
3896 if {[catch {close $fd} err]} {
3897 error_popup [mc "Error running git blame: %s" $err]
3902 set line [split [lindex $blamestuff($inst) 0] " "]
3903 set id [lindex $line 0]
3904 set lnum [lindex $line 1]
3905 if {[string length $id] == 40 && [string is xdigit $id] &&
3906 [string is digit -strict $lnum]} {
3907 # look for "filename" line
3908 foreach l $blamestuff($inst) {
3909 if {[string match "filename *" $l]} {
3910 set fname [string range $l 9 end]
3916 # all looks good, select it
3917 if {$id eq $nullid} {
3918 # blame uses all-zeroes to mean not committed,
3919 # which would mean a change in the index
3922 if {[commitinview $id $curview]} {
3923 selectline [rowofcommit $id] 1 [list $fname $lnum] 1
3925 error_popup [mc "That line comes from commit %s, \
3926 which is not in this view" [shortids $id]]
3929 puts "oops couldn't parse git blame output"
3934 # delete $dir when we see eof on $f (presumably because the child has exited)
3935 proc delete_at_eof {f dir} {
3936 while {[gets $f line] >= 0} {}
3938 if {[catch {close $f} err]} {
3939 error_popup "[mc "External diff viewer failed:"] $err"
3941 file delete -force $dir
3947 # Functions for adding and removing shell-type quoting
3949 proc shellquote {str} {
3950 if {![string match "*\['\"\\ \t]*" $str]} {
3953 if {![string match "*\['\"\\]*" $str]} {
3956 if {![string match "*'*" $str]} {
3959 return "\"[string map {\" \\\" \\ \\\\} $str]\""
3962 proc shellarglist {l} {
3968 append str [shellquote $a]
3973 proc shelldequote {str} {
3978 if {![regexp -start $used -indices "\['\"\\\\ \t]" $str first]} {
3979 append ret [string range $str $used end]
3980 set used [string length $str]
3983 set first [lindex $first 0]
3984 set ch [string index $str $first]
3985 if {$first > $used} {
3986 append ret [string range $str $used [expr {$first - 1}]]
3989 if {$ch eq " " || $ch eq "\t"} break
3992 set first [string first "'" $str $used]
3994 error "unmatched single-quote"
3996 append ret [string range $str $used [expr {$first - 1}]]
4001 if {$used >= [string length $str]} {
4002 error "trailing backslash"
4004 append ret [string index $str $used]
4009 if {![regexp -start $used -indices "\[\"\\\\]" $str first]} {
4010 error "unmatched double-quote"
4012 set first [lindex $first 0]
4013 set ch [string index $str $first]
4014 if {$first > $used} {
4015 append ret [string range $str $used [expr {$first - 1}]]
4018 if {$ch eq "\""} break
4020 append ret [string index $str $used]
4024 return [list $used $ret]
4027 proc shellsplit {str} {
4030 set str [string trimleft $str]
4031 if {$str eq {}} break
4032 set dq [shelldequote $str]
4033 set n [lindex $dq 0]
4034 set word [lindex $dq 1]
4035 set str [string range $str $n end]
4041 proc set_window_title {} {
4042 global appname curview viewname vrevs
4043 set rev [mc "All files"]
4044 if {$curview ne 0} {
4045 if {$viewname($curview) eq [mc "Command line"]} {
4046 set rev [string map {"--gitk-symmetric-diff-marker" "--merge"} $vrevs($curview)]
4048 set rev $viewname($curview)
4051 wm title . "[reponame]: $rev - $appname"
4054 # Code to implement multiple views
4056 proc newview {ishighlight} {
4057 global nextviewnum newviewname newishighlight
4058 global revtreeargs viewargscmd newviewopts curview
4060 set newishighlight $ishighlight
4062 if {[winfo exists $top]} {
4066 decode_view_opts $nextviewnum $revtreeargs
4067 set newviewname($nextviewnum) "[mc "View"] $nextviewnum"
4068 set newviewopts($nextviewnum,perm) 0
4069 set newviewopts($nextviewnum,cmd) $viewargscmd($curview)
4070 vieweditor $top $nextviewnum [mc "Gitk view definition"]
4073 set known_view_options {
4074 {perm b . {} {mc "Remember this view"}}
4075 {reflabel l + {} {mc "References (space separated list):"}}
4076 {refs t15 .. {} {mc "Branches & tags:"}}
4077 {allrefs b *. "--all" {mc "All refs"}}
4078 {branches b . "--branches" {mc "All (local) branches"}}
4079 {tags b . "--tags" {mc "All tags"}}
4080 {remotes b . "--remotes" {mc "All remote-tracking branches"}}
4081 {commitlbl l + {} {mc "Commit Info (regular expressions):"}}
4082 {author t15 .. "--author=*" {mc "Author:"}}
4083 {committer t15 . "--committer=*" {mc "Committer:"}}
4084 {loginfo t15 .. "--grep=*" {mc "Commit Message:"}}
4085 {allmatch b .. "--all-match" {mc "Matches all Commit Info criteria"}}
4086 {igrep b .. "--invert-grep" {mc "Matches no Commit Info criteria"}}
4087 {changes_l l + {} {mc "Changes to Files:"}}
4088 {pickaxe_s r0 . {} {mc "Fixed String"}}
4089 {pickaxe_t r1 . "--pickaxe-regex" {mc "Regular Expression"}}
4090 {pickaxe t15 .. "-S*" {mc "Search string:"}}
4091 {datelabel l + {} {mc "Commit Dates (\"2 weeks ago\", \"2009-03-17 15:27:38\", \"March 17, 2009 15:27:38\"):"}}
4092 {since t15 .. {"--since=*" "--after=*"} {mc "Since:"}}
4093 {until t15 . {"--until=*" "--before=*"} {mc "Until:"}}
4094 {limit_lbl l + {} {mc "Limit and/or skip a number of revisions (positive integer):"}}
4095 {limit t10 *. "--max-count=*" {mc "Number to show:"}}
4096 {skip t10 . "--skip=*" {mc "Number to skip:"}}
4097 {misc_lbl l + {} {mc "Miscellaneous options:"}}
4098 {dorder b *. {"--date-order" "-d"} {mc "Strictly sort by date"}}
4099 {lright b . "--left-right" {mc "Mark branch sides"}}
4100 {first b . "--first-parent" {mc "Limit to first parent"}}
4101 {smplhst b . "--simplify-by-decoration" {mc "Simple history"}}
4102 {args t50 *. {} {mc "Additional arguments to git log:"}}
4103 {allpaths path + {} {mc "Enter files and directories to include, one per line:"}}
4104 {cmd t50= + {} {mc "Command to generate more commits to include:"}}
4107 # Convert $newviewopts($n, ...) into args for git log.
4108 proc encode_view_opts {n} {
4109 global known_view_options newviewopts
4112 foreach opt $known_view_options {
4113 set patterns [lindex $opt 3]
4114 if {$patterns eq {}} continue
4115 set pattern [lindex $patterns 0]
4117 if {[lindex $opt 1] eq "b"} {
4118 set val $newviewopts($n,[lindex $opt 0])
4120 lappend rargs $pattern
4122 } elseif {[regexp {^r(\d+)$} [lindex $opt 1] type value]} {
4123 regexp {^(.*_)} [lindex $opt 0] uselessvar button_id
4124 set val $newviewopts($n,$button_id)
4125 if {$val eq $value} {
4126 lappend rargs $pattern
4129 set val $newviewopts($n,[lindex $opt 0])
4130 set val [string trim $val]
4132 set pfix [string range $pattern 0 end-1]
4133 lappend rargs $pfix$val
4137 set rargs [concat $rargs [shellsplit $newviewopts($n,refs)]]
4138 return [concat $rargs [shellsplit $newviewopts($n,args)]]
4141 # Fill $newviewopts($n, ...) based on args for git log.
4142 proc decode_view_opts {n view_args} {
4143 global known_view_options newviewopts
4145 foreach opt $known_view_options {
4146 set id [lindex $opt 0]
4147 if {[lindex $opt 1] eq "b"} {
4150 } elseif {[regexp {^r(\d+)$} [lindex $opt 1]]} {
4152 regexp {^(.*_)} $id uselessvar id
4158 set newviewopts($n,$id) $val
4162 foreach arg $view_args {
4163 if {[regexp -- {^-([0-9]+)$} $arg arg cnt]
4164 && ![info exists found(limit)]} {
4165 set newviewopts($n,limit) $cnt
4170 foreach opt $known_view_options {
4171 set id [lindex $opt 0]
4172 if {[info exists found($id)]} continue
4173 foreach pattern [lindex $opt 3] {
4174 if {![string match $pattern $arg]} continue
4175 if {[lindex $opt 1] eq "b"} {
4178 } elseif {[regexp {^r(\d+)$} [lindex $opt 1] match num]} {
4180 regexp {^(.*_)} $id uselessvar id
4184 set size [string length $pattern]
4185 set val [string range $arg [expr {$size-1}] end]
4187 set newviewopts($n,$id) $val
4191 if {[info exists val]} break
4193 if {[info exists val]} continue
4194 if {[regexp {^-} $arg]} {
4197 lappend refargs $arg
4200 set newviewopts($n,refs) [shellarglist $refargs]
4201 set newviewopts($n,args) [shellarglist $oargs]
4204 proc edit_or_newview {} {
4216 global viewname viewperm newviewname newviewopts
4217 global viewargs viewargscmd
4219 set top .gitkvedit-$curview
4220 if {[winfo exists $top]} {
4224 decode_view_opts $curview $viewargs($curview)
4225 set newviewname($curview) $viewname($curview)
4226 set newviewopts($curview,perm) $viewperm($curview)
4227 set newviewopts($curview,cmd) $viewargscmd($curview)
4228 vieweditor $top $curview "[mc "Gitk: edit view"] $viewname($curview)"
4231 proc vieweditor {top n title} {
4232 global newviewname newviewopts viewfiles bgcolor
4233 global known_view_options NS
4236 wm title $top [concat $title [mc "-- criteria for selecting revisions"]]
4237 make_transient $top .
4240 ${NS}::frame $top.nfr
4241 ${NS}::label $top.nl -text [mc "View Name"]
4242 ${NS}::entry $top.name -width 20 -textvariable newviewname($n)
4243 pack $top.nfr -in $top -fill x -pady 5 -padx 3
4244 pack $top.nl -in $top.nfr -side left -padx {0 5}
4245 pack $top.name -in $top.nfr -side left -padx {0 25}
4251 foreach opt $known_view_options {
4252 set id [lindex $opt 0]
4253 set type [lindex $opt 1]
4254 set flags [lindex $opt 2]
4255 set title [eval [lindex $opt 4]]
4258 if {$flags eq "+" || $flags eq "*"} {
4259 set cframe $top.fr$cnt
4261 ${NS}::frame $cframe
4262 pack $cframe -in $top -fill x -pady 3 -padx 3
4263 set cexpand [expr {$flags eq "*"}]
4264 } elseif {$flags eq ".." || $flags eq "*."} {
4265 set cframe $top.fr$cnt
4267 ${NS}::frame $cframe
4268 pack $cframe -in $top -fill x -pady 3 -padx [list 15 3]
4269 set cexpand [expr {$flags eq "*."}]
4275 ${NS}::label $cframe.l_$id -text $title
4276 pack $cframe.l_$id -in $cframe -side left -pady [list 3 0] -anchor w
4277 } elseif {$type eq "b"} {
4278 ${NS}::checkbutton $cframe.c_$id -text $title -variable newviewopts($n,$id)
4279 pack $cframe.c_$id -in $cframe -side left \
4280 -padx [list $lxpad 0] -expand $cexpand -anchor w
4281 } elseif {[regexp {^r(\d+)$} $type type sz]} {
4282 regexp {^(.*_)} $id uselessvar button_id
4283 ${NS}::radiobutton $cframe.c_$id -text $title -variable newviewopts($n,$button_id) -value $sz
4284 pack $cframe.c_$id -in $cframe -side left \
4285 -padx [list $lxpad 0] -expand $cexpand -anchor w
4286 } elseif {[regexp {^t(\d+)$} $type type sz]} {
4287 ${NS}::label $cframe.l_$id -text $title
4288 ${NS}::entry $cframe.e_$id -width $sz -background $bgcolor \
4289 -textvariable newviewopts($n,$id)
4290 pack $cframe.l_$id -in $cframe -side left -padx [list $lxpad 0]
4291 pack $cframe.e_$id -in $cframe -side left -expand 1 -fill x
4292 } elseif {[regexp {^t(\d+)=$} $type type sz]} {
4293 ${NS}::label $cframe.l_$id -text $title
4294 ${NS}::entry $cframe.e_$id -width $sz -background $bgcolor \
4295 -textvariable newviewopts($n,$id)
4296 pack $cframe.l_$id -in $cframe -side top -pady [list 3 0] -anchor w
4297 pack $cframe.e_$id -in $cframe -side top -fill x
4298 } elseif {$type eq "path"} {
4299 ${NS}::label $top.l -text $title
4300 pack $top.l -in $top -side top -pady [list 3 0] -anchor w -padx 3
4301 text $top.t -width 40 -height 5 -background $bgcolor
4302 if {[info exists viewfiles($n)]} {
4303 foreach f $viewfiles($n) {
4304 $top.t insert end $f
4305 $top.t insert end "\n"
4307 $top.t delete {end - 1c} end
4308 $top.t mark set insert 0.0
4310 pack $top.t -in $top -side top -pady [list 0 5] -fill both -expand 1 -padx 3
4314 ${NS}::frame $top.buts
4315 ${NS}::button $top.buts.ok -text [mc "OK"] -command [list newviewok $top $n]
4316 ${NS}::button $top.buts.apply -text [mc "Apply (F5)"] -command [list newviewok $top $n 1]
4317 ${NS}::button $top.buts.can -text [mc "Cancel"] -command [list destroy $top]
4318 bind $top <Control-Return> [list newviewok $top $n]
4319 bind $top <F5> [list newviewok $top $n 1]
4320 bind $top <Escape> [list destroy $top]
4321 grid $top.buts.ok $top.buts.apply $top.buts.can
4322 grid columnconfigure $top.buts 0 -weight 1 -uniform a
4323 grid columnconfigure $top.buts 1 -weight 1 -uniform a
4324 grid columnconfigure $top.buts 2 -weight 1 -uniform a
4325 pack $top.buts -in $top -side top -fill x
4329 proc doviewmenu {m first cmd op argv} {
4330 set nmenu [$m index end]
4331 for {set i $first} {$i <= $nmenu} {incr i} {
4332 if {[$m entrycget $i -command] eq $cmd} {
4333 eval $m $op $i $argv
4339 proc allviewmenus {n op args} {
4342 doviewmenu .bar.view 5 [list showview $n] $op $args
4343 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] $op $args
4346 proc newviewok {top n {apply 0}} {
4347 global nextviewnum newviewperm newviewname newishighlight
4348 global viewname viewfiles viewperm viewchanged selectedview curview
4349 global viewargs viewargscmd newviewopts viewhlmenu
4352 set newargs [encode_view_opts $n]
4354 error_popup "[mc "Error in commit selection arguments:"] $err" $top
4358 foreach f [split [$top.t get 0.0 end] "\n"] {
4359 set ft [string trim $f]
4364 if {![info exists viewfiles($n)]} {
4365 # creating a new view
4367 set viewname($n) $newviewname($n)
4368 set viewperm($n) $newviewopts($n,perm)
4369 set viewchanged($n) 1
4370 set viewfiles($n) $files
4371 set viewargs($n) $newargs
4372 set viewargscmd($n) $newviewopts($n,cmd)
4374 if {!$newishighlight} {
4377 run addvhighlight $n
4380 # editing an existing view
4381 set viewperm($n) $newviewopts($n,perm)
4382 set viewchanged($n) 1
4383 if {$newviewname($n) ne $viewname($n)} {
4384 set viewname($n) $newviewname($n)
4385 doviewmenu .bar.view 5 [list showview $n] \
4386 entryconf [list -label $viewname($n)]
4387 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] \
4388 # entryconf [list -label $viewname($n) -value $viewname($n)]
4390 if {$files ne $viewfiles($n) || $newargs ne $viewargs($n) || \
4391 $newviewopts($n,cmd) ne $viewargscmd($n)} {
4392 set viewfiles($n) $files
4393 set viewargs($n) $newargs
4394 set viewargscmd($n) $newviewopts($n,cmd)
4395 if {$curview == $n} {
4401 catch {destroy $top}
4405 global curview viewperm hlview selectedhlview viewchanged
4407 if {$curview == 0} return
4408 if {[info exists hlview] && $hlview == $curview} {
4409 set selectedhlview [mc "None"]
4412 allviewmenus $curview delete
4413 set viewperm($curview) 0
4414 set viewchanged($curview) 1
4418 proc addviewmenu {n} {
4419 global viewname viewhlmenu
4421 .bar.view add radiobutton -label $viewname($n) \
4422 -command [list showview $n] -variable selectedview -value $n
4423 #$viewhlmenu add radiobutton -label $viewname($n) \
4424 # -command [list addvhighlight $n] -variable selectedhlview
4428 global curview cached_commitrow ordertok
4429 global displayorder parentlist rowidlist rowisopt rowfinal
4430 global colormap rowtextx nextcolor canvxmax
4431 global numcommits viewcomplete
4432 global selectedline currentid canv canvy0
4434 global pending_select mainheadid
4437 global hlview selectedhlview commitinterest
4439 if {$n == $curview} return
4441 set ymax [lindex [$canv cget -scrollregion] 3]
4442 set span [$canv yview]
4443 set ytop [expr {[lindex $span 0] * $ymax}]
4444 set ybot [expr {[lindex $span 1] * $ymax}]
4445 set yscreen [expr {($ybot - $ytop) / 2}]
4446 if {$selectedline ne {}} {
4447 set selid $currentid
4448 set y [yc $selectedline]
4449 if {$ytop < $y && $y < $ybot} {
4450 set yscreen [expr {$y - $ytop}]
4452 } elseif {[info exists pending_select]} {
4453 set selid $pending_select
4454 unset pending_select
4458 unset -nocomplain treediffs
4460 if {[info exists hlview] && $hlview == $n} {
4462 set selectedhlview [mc "None"]
4464 unset -nocomplain commitinterest
4465 unset -nocomplain cached_commitrow
4466 unset -nocomplain ordertok
4470 .bar.view entryconf [mca "Edit view..."] -state [expr {$n == 0? "disabled": "normal"}]
4471 .bar.view entryconf [mca "Delete view"] -state [expr {$n == 0? "disabled": "normal"}]
4474 if {![info exists viewcomplete($n)]} {
4484 set numcommits $commitidx($n)
4486 unset -nocomplain colormap
4487 unset -nocomplain rowtextx
4489 set canvxmax [$canv cget -width]
4495 if {$selid ne {} && [commitinview $selid $n]} {
4496 set row [rowofcommit $selid]
4497 # try to get the selected row in the same position on the screen
4498 set ymax [lindex [$canv cget -scrollregion] 3]
4499 set ytop [expr {[yc $row] - $yscreen}]
4503 set yf [expr {$ytop * 1.0 / $ymax}]
4505 allcanvs yview moveto $yf
4509 } elseif {!$viewcomplete($n)} {
4510 reset_pending_select $selid
4512 reset_pending_select {}
4514 if {[commitinview $pending_select $curview]} {
4515 selectline [rowofcommit $pending_select] 1
4517 set row [first_real_row]
4518 if {$row < $numcommits} {
4523 if {!$viewcomplete($n)} {
4524 if {$numcommits == 0} {
4525 show_status [mc "Reading commits..."]
4527 } elseif {$numcommits == 0} {
4528 show_status [mc "No commits selected"]
4533 # Stuff relating to the highlighting facility
4535 proc ishighlighted {id} {
4536 global vhighlights fhighlights nhighlights rhighlights
4538 if {[info exists nhighlights($id)] && $nhighlights($id) > 0} {
4539 return $nhighlights($id)
4541 if {[info exists vhighlights($id)] && $vhighlights($id) > 0} {
4542 return $vhighlights($id)
4544 if {[info exists fhighlights($id)] && $fhighlights($id) > 0} {
4545 return $fhighlights($id)
4547 if {[info exists rhighlights($id)] && $rhighlights($id) > 0} {
4548 return $rhighlights($id)
4553 proc bolden {id font} {
4554 global canv linehtag currentid boldids need_redisplay markedid
4556 # need_redisplay = 1 means the display is stale and about to be redrawn
4557 if {$need_redisplay} return
4559 $canv itemconf $linehtag($id) -font $font
4560 if {[info exists currentid] && $id eq $currentid} {
4562 set t [eval $canv create rect [$canv bbox $linehtag($id)] \
4563 -outline {{}} -tags secsel \
4564 -fill [$canv cget -selectbackground]]
4567 if {[info exists markedid] && $id eq $markedid} {
4572 proc bolden_name {id font} {
4573 global canv2 linentag currentid boldnameids need_redisplay
4575 if {$need_redisplay} return
4576 lappend boldnameids $id
4577 $canv2 itemconf $linentag($id) -font $font
4578 if {[info exists currentid] && $id eq $currentid} {
4579 $canv2 delete secsel
4580 set t [eval $canv2 create rect [$canv2 bbox $linentag($id)] \
4581 -outline {{}} -tags secsel \
4582 -fill [$canv2 cget -selectbackground]]
4591 foreach id $boldids {
4592 if {![ishighlighted $id]} {
4595 lappend stillbold $id
4598 set boldids $stillbold
4601 proc addvhighlight {n} {
4602 global hlview viewcomplete curview vhl_done commitidx
4604 if {[info exists hlview]} {
4608 if {$n != $curview && ![info exists viewcomplete($n)]} {
4611 set vhl_done $commitidx($hlview)
4612 if {$vhl_done > 0} {
4617 proc delvhighlight {} {
4618 global hlview vhighlights
4620 if {![info exists hlview]} return
4622 unset -nocomplain vhighlights
4626 proc vhighlightmore {} {
4627 global hlview vhl_done commitidx vhighlights curview
4629 set max $commitidx($hlview)
4630 set vr [visiblerows]
4631 set r0 [lindex $vr 0]
4632 set r1 [lindex $vr 1]
4633 for {set i $vhl_done} {$i < $max} {incr i} {
4634 set id [commitonrow $i $hlview]
4635 if {[commitinview $id $curview]} {
4636 set row [rowofcommit $id]
4637 if {$r0 <= $row && $row <= $r1} {
4638 if {![highlighted $row]} {
4639 bolden $id mainfontbold
4641 set vhighlights($id) 1
4649 proc askvhighlight {row id} {
4650 global hlview vhighlights iddrawn
4652 if {[commitinview $id $hlview]} {
4653 if {[info exists iddrawn($id)] && ![ishighlighted $id]} {
4654 bolden $id mainfontbold
4656 set vhighlights($id) 1
4658 set vhighlights($id) 0
4662 proc hfiles_change {} {
4663 global highlight_files filehighlight fhighlights fh_serial
4664 global highlight_paths
4666 if {[info exists filehighlight]} {
4667 # delete previous highlights
4668 catch {close $filehighlight}
4670 unset -nocomplain fhighlights
4672 unhighlight_filelist
4674 set highlight_paths {}
4675 after cancel do_file_hl $fh_serial
4677 if {$highlight_files ne {}} {
4678 after 300 do_file_hl $fh_serial
4682 proc gdttype_change {name ix op} {
4683 global gdttype highlight_files findstring findpattern
4686 if {$findstring ne {}} {
4687 if {$gdttype eq [mc "containing:"]} {
4688 if {$highlight_files ne {}} {
4689 set highlight_files {}
4694 if {$findpattern ne {}} {
4698 set highlight_files $findstring
4703 # enable/disable findtype/findloc menus too
4706 proc find_change {name ix op} {
4707 global gdttype findstring highlight_files
4710 if {$gdttype eq [mc "containing:"]} {
4713 if {$highlight_files ne $findstring} {
4714 set highlight_files $findstring
4721 proc findcom_change args {
4722 global nhighlights boldnameids
4723 global findpattern findtype findstring gdttype
4726 # delete previous highlights, if any
4727 foreach id $boldnameids {
4728 bolden_name $id mainfont
4731 unset -nocomplain nhighlights
4734 if {$gdttype ne [mc "containing:"] || $findstring eq {}} {
4736 } elseif {$findtype eq [mc "Regexp"]} {
4737 set findpattern $findstring
4739 set e [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} \
4741 set findpattern "*$e*"
4745 proc makepatterns {l} {
4748 set ee [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} $e]
4749 if {[string index $ee end] eq "/"} {
4759 proc do_file_hl {serial} {
4760 global highlight_files filehighlight highlight_paths gdttype fhl_list
4761 global cdup findtype
4763 if {$gdttype eq [mc "touching paths:"]} {
4764 # If "exact" match then convert backslashes to forward slashes.
4765 # Most useful to support Windows-flavoured file paths.
4766 if {$findtype eq [mc "Exact"]} {
4767 set highlight_files [string map {"\\" "/"} $highlight_files]
4769 if {[catch {set paths [shellsplit $highlight_files]}]} return
4770 set highlight_paths [makepatterns $paths]
4772 set relative_paths {}
4773 foreach path $paths {
4774 lappend relative_paths [file join $cdup $path]
4776 set gdtargs [concat -- $relative_paths]
4777 } elseif {$gdttype eq [mc "adding/removing string:"]} {
4778 set gdtargs [list "-S$highlight_files"]
4779 } elseif {$gdttype eq [mc "changing lines matching:"]} {
4780 set gdtargs [list "-G$highlight_files"]
4782 # must be "containing:", i.e. we're searching commit info
4785 set cmd [concat | git diff-tree -r -s --stdin $gdtargs]
4786 set filehighlight [open $cmd r+]
4787 fconfigure $filehighlight -blocking 0
4788 filerun $filehighlight readfhighlight
4794 proc flushhighlights {} {
4795 global filehighlight fhl_list
4797 if {[info exists filehighlight]} {
4799 puts $filehighlight ""
4800 flush $filehighlight
4804 proc askfilehighlight {row id} {
4805 global filehighlight fhighlights fhl_list
4807 lappend fhl_list $id
4808 set fhighlights($id) -1
4809 puts $filehighlight $id
4812 proc readfhighlight {} {
4813 global filehighlight fhighlights curview iddrawn
4814 global fhl_list find_dirn
4816 if {![info exists filehighlight]} {
4820 while {[incr nr] <= 100 && [gets $filehighlight line] >= 0} {
4821 set line [string trim $line]
4822 set i [lsearch -exact $fhl_list $line]
4823 if {$i < 0} continue
4824 for {set j 0} {$j < $i} {incr j} {
4825 set id [lindex $fhl_list $j]
4826 set fhighlights($id) 0
4828 set fhl_list [lrange $fhl_list [expr {$i+1}] end]
4829 if {$line eq {}} continue
4830 if {![commitinview $line $curview]} continue
4831 if {[info exists iddrawn($line)] && ![ishighlighted $line]} {
4832 bolden $line mainfontbold
4834 set fhighlights($line) 1
4836 if {[eof $filehighlight]} {
4838 puts "oops, git diff-tree died"
4839 catch {close $filehighlight}
4843 if {[info exists find_dirn]} {
4849 proc doesmatch {f} {
4850 global findtype findpattern
4852 if {$findtype eq [mc "Regexp"]} {
4853 return [regexp $findpattern $f]
4854 } elseif {$findtype eq [mc "IgnCase"]} {
4855 return [string match -nocase $findpattern $f]
4857 return [string match $findpattern $f]
4861 proc askfindhighlight {row id} {
4862 global nhighlights commitinfo iddrawn
4864 global markingmatches
4866 if {![info exists commitinfo($id)]} {
4869 set info $commitinfo($id)
4871 set fldtypes [list [mc Headline] [mc Author] "" [mc Committer] "" [mc Comments]]
4872 foreach f $info ty $fldtypes {
4873 if {$ty eq ""} continue
4874 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
4876 if {$ty eq [mc "Author"]} {
4883 if {$isbold && [info exists iddrawn($id)]} {
4884 if {![ishighlighted $id]} {
4885 bolden $id mainfontbold
4887 bolden_name $id mainfontbold
4890 if {$markingmatches} {
4891 markrowmatches $row $id
4894 set nhighlights($id) $isbold
4897 proc markrowmatches {row id} {
4898 global canv canv2 linehtag linentag commitinfo findloc
4900 set headline [lindex $commitinfo($id) 0]
4901 set author [lindex $commitinfo($id) 1]
4902 $canv delete match$row
4903 $canv2 delete match$row
4904 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Headline"]} {
4905 set m [findmatches $headline]
4907 markmatches $canv $row $headline $linehtag($id) $m \
4908 [$canv itemcget $linehtag($id) -font] $row
4911 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Author"]} {
4912 set m [findmatches $author]
4914 markmatches $canv2 $row $author $linentag($id) $m \
4915 [$canv2 itemcget $linentag($id) -font] $row
4920 proc vrel_change {name ix op} {
4921 global highlight_related
4924 if {$highlight_related ne [mc "None"]} {
4929 # prepare for testing whether commits are descendents or ancestors of a
4930 proc rhighlight_sel {a} {
4931 global descendent desc_todo ancestor anc_todo
4932 global highlight_related
4934 unset -nocomplain descendent
4935 set desc_todo [list $a]
4936 unset -nocomplain ancestor
4937 set anc_todo [list $a]
4938 if {$highlight_related ne [mc "None"]} {
4944 proc rhighlight_none {} {
4947 unset -nocomplain rhighlights
4951 proc is_descendent {a} {
4952 global curview children descendent desc_todo
4955 set la [rowofcommit $a]
4959 for {set i 0} {$i < [llength $todo]} {incr i} {
4960 set do [lindex $todo $i]
4961 if {[rowofcommit $do] < $la} {
4962 lappend leftover $do
4965 foreach nk $children($v,$do) {
4966 if {![info exists descendent($nk)]} {
4967 set descendent($nk) 1
4975 set desc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
4979 set descendent($a) 0
4980 set desc_todo $leftover
4983 proc is_ancestor {a} {
4984 global curview parents ancestor anc_todo
4987 set la [rowofcommit $a]
4991 for {set i 0} {$i < [llength $todo]} {incr i} {
4992 set do [lindex $todo $i]
4993 if {![commitinview $do $v] || [rowofcommit $do] > $la} {
4994 lappend leftover $do
4997 foreach np $parents($v,$do) {
4998 if {![info exists ancestor($np)]} {
5007 set anc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
5012 set anc_todo $leftover
5015 proc askrelhighlight {row id} {
5016 global descendent highlight_related iddrawn rhighlights
5017 global selectedline ancestor
5019 if {$selectedline eq {}} return
5021 if {$highlight_related eq [mc "Descendant"] ||
5022 $highlight_related eq [mc "Not descendant"]} {
5023 if {![info exists descendent($id)]} {
5026 if {$descendent($id) == ($highlight_related eq [mc "Descendant"])} {
5029 } elseif {$highlight_related eq [mc "Ancestor"] ||
5030 $highlight_related eq [mc "Not ancestor"]} {
5031 if {![info exists ancestor($id)]} {
5034 if {$ancestor($id) == ($highlight_related eq [mc "Ancestor"])} {
5038 if {[info exists iddrawn($id)]} {
5039 if {$isbold && ![ishighlighted $id]} {
5040 bolden $id mainfontbold
5043 set rhighlights($id) $isbold
5046 # Graph layout functions
5048 proc shortids {ids} {
5051 if {[llength $id] > 1} {
5052 lappend res [shortids $id]
5053 } elseif {[regexp {^[0-9a-f]{40}$} $id]} {
5054 lappend res [string range $id 0 7]
5065 for {set mask 1} {$mask <= $n} {incr mask $mask} {
5066 if {($n & $mask) != 0} {
5067 set ret [concat $ret $o]
5069 set o [concat $o $o]
5074 proc ordertoken {id} {
5075 global ordertok curview varcid varcstart varctok curview parents children
5076 global nullid nullid2
5078 if {[info exists ordertok($id)]} {
5079 return $ordertok($id)
5084 if {[info exists varcid($curview,$id)]} {
5085 set a $varcid($curview,$id)
5086 set p [lindex $varcstart($curview) $a]
5088 set p [lindex $children($curview,$id) 0]
5090 if {[info exists ordertok($p)]} {
5091 set tok $ordertok($p)
5094 set id [first_real_child $curview,$p]
5097 set tok [lindex $varctok($curview) $varcid($curview,$p)]
5100 if {[llength $parents($curview,$id)] == 1} {
5101 lappend todo [list $p {}]
5103 set j [lsearch -exact $parents($curview,$id) $p]
5105 puts "oops didn't find [shortids $p] in parents of [shortids $id]"
5107 lappend todo [list $p [strrep $j]]
5110 for {set i [llength $todo]} {[incr i -1] >= 0} {} {
5111 set p [lindex $todo $i 0]
5112 append tok [lindex $todo $i 1]
5113 set ordertok($p) $tok
5115 set ordertok($origid) $tok
5119 # Work out where id should go in idlist so that order-token
5120 # values increase from left to right
5121 proc idcol {idlist id {i 0}} {
5122 set t [ordertoken $id]
5126 if {$i >= [llength $idlist] || $t < [ordertoken [lindex $idlist $i]]} {
5127 if {$i > [llength $idlist]} {
5128 set i [llength $idlist]
5130 while {[incr i -1] >= 0 && $t < [ordertoken [lindex $idlist $i]]} {}
5133 if {$t > [ordertoken [lindex $idlist $i]]} {
5134 while {[incr i] < [llength $idlist] &&
5135 $t >= [ordertoken [lindex $idlist $i]]} {}
5141 proc initlayout {} {
5142 global rowidlist rowisopt rowfinal displayorder parentlist
5143 global numcommits canvxmax canv
5145 global colormap rowtextx
5154 set canvxmax [$canv cget -width]
5155 unset -nocomplain colormap
5156 unset -nocomplain rowtextx
5160 proc setcanvscroll {} {
5161 global canv canv2 canv3 numcommits linespc canvxmax canvy0
5162 global lastscrollset lastscrollrows
5164 set ymax [expr {$canvy0 + ($numcommits - 0.5) * $linespc + 2}]
5165 $canv conf -scrollregion [list 0 0 $canvxmax $ymax]
5166 $canv2 conf -scrollregion [list 0 0 0 $ymax]
5167 $canv3 conf -scrollregion [list 0 0 0 $ymax]
5168 set lastscrollset [clock clicks -milliseconds]
5169 set lastscrollrows $numcommits
5172 proc visiblerows {} {
5173 global canv numcommits linespc
5175 set ymax [lindex [$canv cget -scrollregion] 3]
5176 if {$ymax eq {} || $ymax == 0} return
5178 set y0 [expr {int([lindex $f 0] * $ymax)}]
5179 set r0 [expr {int(($y0 - 3) / $linespc) - 1}]
5183 set y1 [expr {int([lindex $f 1] * $ymax)}]
5184 set r1 [expr {int(($y1 - 3) / $linespc) + 1}]
5185 if {$r1 >= $numcommits} {
5186 set r1 [expr {$numcommits - 1}]
5188 return [list $r0 $r1]
5191 proc layoutmore {} {
5192 global commitidx viewcomplete curview
5193 global numcommits pending_select curview
5194 global lastscrollset lastscrollrows
5196 if {$lastscrollrows < 100 || $viewcomplete($curview) ||
5197 [clock clicks -milliseconds] - $lastscrollset > 500} {
5200 if {[info exists pending_select] &&
5201 [commitinview $pending_select $curview]} {
5203 selectline [rowofcommit $pending_select] 1
5208 # With path limiting, we mightn't get the actual HEAD commit,
5209 # so ask git rev-list what is the first ancestor of HEAD that
5210 # touches a file in the path limit.
5211 proc get_viewmainhead {view} {
5212 global viewmainheadid vfilelimit viewinstances mainheadid
5215 set rfd [open [concat | git rev-list -1 $mainheadid \
5216 -- $vfilelimit($view)] r]
5217 set j [reg_instance $rfd]
5218 lappend viewinstances($view) $j
5219 fconfigure $rfd -blocking 0
5220 filerun $rfd [list getviewhead $rfd $j $view]
5221 set viewmainheadid($curview) {}
5225 # git rev-list should give us just 1 line to use as viewmainheadid($view)
5226 proc getviewhead {fd inst view} {
5227 global viewmainheadid commfd curview viewinstances showlocalchanges
5230 if {[gets $fd line] < 0} {
5234 } elseif {[string length $line] == 40 && [string is xdigit $line]} {
5237 set viewmainheadid($view) $id
5240 set i [lsearch -exact $viewinstances($view) $inst]
5242 set viewinstances($view) [lreplace $viewinstances($view) $i $i]
5244 if {$showlocalchanges && $id ne {} && $view == $curview} {
5250 proc doshowlocalchanges {} {
5251 global curview viewmainheadid
5253 if {$viewmainheadid($curview) eq {}} return
5254 if {[commitinview $viewmainheadid($curview) $curview]} {
5257 interestedin $viewmainheadid($curview) dodiffindex
5261 proc dohidelocalchanges {} {
5262 global nullid nullid2 lserial curview
5264 if {[commitinview $nullid $curview]} {
5265 removefakerow $nullid
5267 if {[commitinview $nullid2 $curview]} {
5268 removefakerow $nullid2
5273 # spawn off a process to do git diff-index --cached HEAD
5274 proc dodiffindex {} {
5275 global lserial showlocalchanges vfilelimit curview
5276 global hasworktree git_version
5278 if {!$showlocalchanges || !$hasworktree} return
5280 if {[package vcompare $git_version "1.7.2"] >= 0} {
5281 set cmd "|git diff-index --cached --ignore-submodules=dirty HEAD"
5283 set cmd "|git diff-index --cached HEAD"
5285 if {$vfilelimit($curview) ne {}} {
5286 set cmd [concat $cmd -- $vfilelimit($curview)]
5288 set fd [open $cmd r]
5289 fconfigure $fd -blocking 0
5290 set i [reg_instance $fd]
5291 filerun $fd [list readdiffindex $fd $lserial $i]
5294 proc readdiffindex {fd serial inst} {
5295 global viewmainheadid nullid nullid2 curview commitinfo commitdata lserial
5299 if {[gets $fd line] < 0} {
5305 # we only need to see one line and we don't really care what it says...
5308 if {$serial != $lserial} {
5312 # now see if there are any local changes not checked in to the index
5313 set cmd "|git diff-files"
5314 if {$vfilelimit($curview) ne {}} {
5315 set cmd [concat $cmd -- $vfilelimit($curview)]
5317 set fd [open $cmd r]
5318 fconfigure $fd -blocking 0
5319 set i [reg_instance $fd]
5320 filerun $fd [list readdifffiles $fd $serial $i]
5322 if {$isdiff && ![commitinview $nullid2 $curview]} {
5323 # add the line for the changes in the index to the graph
5324 set hl [mc "Local changes checked in to index but not committed"]
5325 set commitinfo($nullid2) [list $hl {} {} {} {} " $hl\n"]
5326 set commitdata($nullid2) "\n $hl\n"
5327 if {[commitinview $nullid $curview]} {
5328 removefakerow $nullid
5330 insertfakerow $nullid2 $viewmainheadid($curview)
5331 } elseif {!$isdiff && [commitinview $nullid2 $curview]} {
5332 if {[commitinview $nullid $curview]} {
5333 removefakerow $nullid
5335 removefakerow $nullid2
5340 proc readdifffiles {fd serial inst} {
5341 global viewmainheadid nullid nullid2 curview
5342 global commitinfo commitdata lserial
5345 if {[gets $fd line] < 0} {
5351 # we only need to see one line and we don't really care what it says...
5354 if {$serial != $lserial} {
5358 if {$isdiff && ![commitinview $nullid $curview]} {
5359 # add the line for the local diff to the graph
5360 set hl [mc "Local uncommitted changes, not checked in to index"]
5361 set commitinfo($nullid) [list $hl {} {} {} {} " $hl\n"]
5362 set commitdata($nullid) "\n $hl\n"
5363 if {[commitinview $nullid2 $curview]} {
5366 set p $viewmainheadid($curview)
5368 insertfakerow $nullid $p
5369 } elseif {!$isdiff && [commitinview $nullid $curview]} {
5370 removefakerow $nullid
5375 proc nextuse {id row} {
5376 global curview children
5378 if {[info exists children($curview,$id)]} {
5379 foreach kid $children($curview,$id) {
5380 if {![commitinview $kid $curview]} {
5383 if {[rowofcommit $kid] > $row} {
5384 return [rowofcommit $kid]
5388 if {[commitinview $id $curview]} {
5389 return [rowofcommit $id]
5394 proc prevuse {id row} {
5395 global curview children
5398 if {[info exists children($curview,$id)]} {
5399 foreach kid $children($curview,$id) {
5400 if {![commitinview $kid $curview]} break
5401 if {[rowofcommit $kid] < $row} {
5402 set ret [rowofcommit $kid]
5409 proc make_idlist {row} {
5410 global displayorder parentlist uparrowlen downarrowlen mingaplen
5411 global commitidx curview children
5413 set r [expr {$row - $mingaplen - $downarrowlen - 1}]
5417 set ra [expr {$row - $downarrowlen}]
5421 set rb [expr {$row + $uparrowlen}]
5422 if {$rb > $commitidx($curview)} {
5423 set rb $commitidx($curview)
5425 make_disporder $r [expr {$rb + 1}]
5427 for {} {$r < $ra} {incr r} {
5428 set nextid [lindex $displayorder [expr {$r + 1}]]
5429 foreach p [lindex $parentlist $r] {
5430 if {$p eq $nextid} continue
5431 set rn [nextuse $p $r]
5433 $rn <= $r + $downarrowlen + $mingaplen + $uparrowlen} {
5434 lappend ids [list [ordertoken $p] $p]
5438 for {} {$r < $row} {incr r} {
5439 set nextid [lindex $displayorder [expr {$r + 1}]]
5440 foreach p [lindex $parentlist $r] {
5441 if {$p eq $nextid} continue
5442 set rn [nextuse $p $r]
5443 if {$rn < 0 || $rn >= $row} {
5444 lappend ids [list [ordertoken $p] $p]
5448 set id [lindex $displayorder $row]
5449 lappend ids [list [ordertoken $id] $id]
5451 foreach p [lindex $parentlist $r] {
5452 set firstkid [lindex $children($curview,$p) 0]
5453 if {[rowofcommit $firstkid] < $row} {
5454 lappend ids [list [ordertoken $p] $p]
5458 set id [lindex $displayorder $r]
5460 set firstkid [lindex $children($curview,$id) 0]
5461 if {$firstkid ne {} && [rowofcommit $firstkid] < $row} {
5462 lappend ids [list [ordertoken $id] $id]
5467 foreach idx [lsort -unique $ids] {
5468 lappend idlist [lindex $idx 1]
5473 proc rowsequal {a b} {
5474 while {[set i [lsearch -exact $a {}]] >= 0} {
5475 set a [lreplace $a $i $i]
5477 while {[set i [lsearch -exact $b {}]] >= 0} {
5478 set b [lreplace $b $i $i]
5480 return [expr {$a eq $b}]
5483 proc makeupline {id row rend col} {
5484 global rowidlist uparrowlen downarrowlen mingaplen
5486 for {set r $rend} {1} {set r $rstart} {
5487 set rstart [prevuse $id $r]
5488 if {$rstart < 0} return
5489 if {$rstart < $row} break
5491 if {$rstart + $uparrowlen + $mingaplen + $downarrowlen < $rend} {
5492 set rstart [expr {$rend - $uparrowlen - 1}]
5494 for {set r $rstart} {[incr r] <= $row} {} {
5495 set idlist [lindex $rowidlist $r]
5496 if {$idlist ne {} && [lsearch -exact $idlist $id] < 0} {
5497 set col [idcol $idlist $id $col]
5498 lset rowidlist $r [linsert $idlist $col $id]
5504 proc layoutrows {row endrow} {
5505 global rowidlist rowisopt rowfinal displayorder
5506 global uparrowlen downarrowlen maxwidth mingaplen
5507 global children parentlist
5508 global commitidx viewcomplete curview
5510 make_disporder [expr {$row - 1}] [expr {$endrow + $uparrowlen}]
5513 set rm1 [expr {$row - 1}]
5514 foreach id [lindex $rowidlist $rm1] {
5519 set final [lindex $rowfinal $rm1]
5521 for {} {$row < $endrow} {incr row} {
5522 set rm1 [expr {$row - 1}]
5523 if {$rm1 < 0 || $idlist eq {}} {
5524 set idlist [make_idlist $row]
5527 set id [lindex $displayorder $rm1]
5528 set col [lsearch -exact $idlist $id]
5529 set idlist [lreplace $idlist $col $col]
5530 foreach p [lindex $parentlist $rm1] {
5531 if {[lsearch -exact $idlist $p] < 0} {
5532 set col [idcol $idlist $p $col]
5533 set idlist [linsert $idlist $col $p]
5534 # if not the first child, we have to insert a line going up
5535 if {$id ne [lindex $children($curview,$p) 0]} {
5536 makeupline $p $rm1 $row $col
5540 set id [lindex $displayorder $row]
5541 if {$row > $downarrowlen} {
5542 set termrow [expr {$row - $downarrowlen - 1}]
5543 foreach p [lindex $parentlist $termrow] {
5544 set i [lsearch -exact $idlist $p]
5545 if {$i < 0} continue
5546 set nr [nextuse $p $termrow]
5547 if {$nr < 0 || $nr >= $row + $mingaplen + $uparrowlen} {
5548 set idlist [lreplace $idlist $i $i]
5552 set col [lsearch -exact $idlist $id]
5554 set col [idcol $idlist $id]
5555 set idlist [linsert $idlist $col $id]
5556 if {$children($curview,$id) ne {}} {
5557 makeupline $id $rm1 $row $col
5560 set r [expr {$row + $uparrowlen - 1}]
5561 if {$r < $commitidx($curview)} {
5563 foreach p [lindex $parentlist $r] {
5564 if {[lsearch -exact $idlist $p] >= 0} continue
5565 set fk [lindex $children($curview,$p) 0]
5566 if {[rowofcommit $fk] < $row} {
5567 set x [idcol $idlist $p $x]
5568 set idlist [linsert $idlist $x $p]
5571 if {[incr r] < $commitidx($curview)} {
5572 set p [lindex $displayorder $r]
5573 if {[lsearch -exact $idlist $p] < 0} {
5574 set fk [lindex $children($curview,$p) 0]
5575 if {$fk ne {} && [rowofcommit $fk] < $row} {
5576 set x [idcol $idlist $p $x]
5577 set idlist [linsert $idlist $x $p]
5583 if {$final && !$viewcomplete($curview) &&
5584 $row + $uparrowlen + $mingaplen + $downarrowlen
5585 >= $commitidx($curview)} {
5588 set l [llength $rowidlist]
5590 lappend rowidlist $idlist
5592 lappend rowfinal $final
5593 } elseif {$row < $l} {
5594 if {![rowsequal $idlist [lindex $rowidlist $row]]} {
5595 lset rowidlist $row $idlist
5598 lset rowfinal $row $final
5600 set pad [ntimes [expr {$row - $l}] {}]
5601 set rowidlist [concat $rowidlist $pad]
5602 lappend rowidlist $idlist
5603 set rowfinal [concat $rowfinal $pad]
5604 lappend rowfinal $final
5605 set rowisopt [concat $rowisopt [ntimes [expr {$row - $l + 1}] 0]]
5611 proc changedrow {row} {
5612 global displayorder iddrawn rowisopt need_redisplay
5614 set l [llength $rowisopt]
5616 lset rowisopt $row 0
5617 if {$row + 1 < $l} {
5618 lset rowisopt [expr {$row + 1}] 0
5619 if {$row + 2 < $l} {
5620 lset rowisopt [expr {$row + 2}] 0
5624 set id [lindex $displayorder $row]
5625 if {[info exists iddrawn($id)]} {
5626 set need_redisplay 1
5630 proc insert_pad {row col npad} {
5633 set pad [ntimes $npad {}]
5634 set idlist [lindex $rowidlist $row]
5635 set bef [lrange $idlist 0 [expr {$col - 1}]]
5636 set aft [lrange $idlist $col end]
5637 set i [lsearch -exact $aft {}]
5639 set aft [lreplace $aft $i $i]
5641 lset rowidlist $row [concat $bef $pad $aft]
5645 proc optimize_rows {row col endrow} {
5646 global rowidlist rowisopt displayorder curview children
5651 for {} {$row < $endrow} {incr row; set col 0} {
5652 if {[lindex $rowisopt $row]} continue
5654 set y0 [expr {$row - 1}]
5655 set ym [expr {$row - 2}]
5656 set idlist [lindex $rowidlist $row]
5657 set previdlist [lindex $rowidlist $y0]
5658 if {$idlist eq {} || $previdlist eq {}} continue
5660 set pprevidlist [lindex $rowidlist $ym]
5661 if {$pprevidlist eq {}} continue
5667 for {} {$col < [llength $idlist]} {incr col} {
5668 set id [lindex $idlist $col]
5669 if {[lindex $previdlist $col] eq $id} continue
5674 set x0 [lsearch -exact $previdlist $id]
5675 if {$x0 < 0} continue
5676 set z [expr {$x0 - $col}]
5680 set xm [lsearch -exact $pprevidlist $id]
5682 set z0 [expr {$xm - $x0}]
5686 # if row y0 is the first child of $id then it's not an arrow
5687 if {[lindex $children($curview,$id) 0] ne
5688 [lindex $displayorder $y0]} {
5692 if {!$isarrow && $id ne [lindex $displayorder $row] &&
5693 [lsearch -exact [lindex $rowidlist [expr {$row+1}]] $id] < 0} {
5696 # Looking at lines from this row to the previous row,
5697 # make them go straight up if they end in an arrow on
5698 # the previous row; otherwise make them go straight up
5700 if {$z < -1 || ($z < 0 && $isarrow)} {
5701 # Line currently goes left too much;
5702 # insert pads in the previous row, then optimize it
5703 set npad [expr {-1 - $z + $isarrow}]
5704 insert_pad $y0 $x0 $npad
5706 optimize_rows $y0 $x0 $row
5708 set previdlist [lindex $rowidlist $y0]
5709 set x0 [lsearch -exact $previdlist $id]
5710 set z [expr {$x0 - $col}]
5712 set pprevidlist [lindex $rowidlist $ym]
5713 set xm [lsearch -exact $pprevidlist $id]
5714 set z0 [expr {$xm - $x0}]
5716 } elseif {$z > 1 || ($z > 0 && $isarrow)} {
5717 # Line currently goes right too much;
5718 # insert pads in this line
5719 set npad [expr {$z - 1 + $isarrow}]
5720 insert_pad $row $col $npad
5721 set idlist [lindex $rowidlist $row]
5723 set z [expr {$x0 - $col}]
5726 if {$z0 eq {} && !$isarrow && $ym >= 0} {
5727 # this line links to its first child on row $row-2
5728 set id [lindex $displayorder $ym]
5729 set xc [lsearch -exact $pprevidlist $id]
5731 set z0 [expr {$xc - $x0}]
5734 # avoid lines jigging left then immediately right
5735 if {$z0 ne {} && $z < 0 && $z0 > 0} {
5736 insert_pad $y0 $x0 1
5738 optimize_rows $y0 $x0 $row
5739 set previdlist [lindex $rowidlist $y0]
5743 # Find the first column that doesn't have a line going right
5744 for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
5745 set id [lindex $idlist $col]
5746 if {$id eq {}} break
5747 set x0 [lsearch -exact $previdlist $id]
5749 # check if this is the link to the first child
5750 set kid [lindex $displayorder $y0]
5751 if {[lindex $children($curview,$id) 0] eq $kid} {
5752 # it is, work out offset to child
5753 set x0 [lsearch -exact $previdlist $kid]
5756 if {$x0 <= $col} break
5758 # Insert a pad at that column as long as it has a line and
5759 # isn't the last column
5760 if {$x0 >= 0 && [incr col] < [llength $idlist]} {
5761 set idlist [linsert $idlist $col {}]
5762 lset rowidlist $row $idlist
5770 global canvx0 linespc
5771 return [expr {$canvx0 + $col * $linespc}]
5775 global canvy0 linespc
5776 return [expr {$canvy0 + $row * $linespc}]
5779 proc linewidth {id} {
5780 global thickerline lthickness
5783 if {[info exists thickerline] && $id eq $thickerline} {
5784 set wid [expr {2 * $lthickness}]
5789 proc rowranges {id} {
5790 global curview children uparrowlen downarrowlen
5793 set kids $children($curview,$id)
5799 foreach child $kids {
5800 if {![commitinview $child $curview]} break
5801 set row [rowofcommit $child]
5802 if {![info exists prev]} {
5803 lappend ret [expr {$row + 1}]
5805 if {$row <= $prevrow} {
5806 puts "oops children of [shortids $id] out of order [shortids $child] $row <= [shortids $prev] $prevrow"
5808 # see if the line extends the whole way from prevrow to row
5809 if {$row > $prevrow + $uparrowlen + $downarrowlen &&
5810 [lsearch -exact [lindex $rowidlist \
5811 [expr {int(($row + $prevrow) / 2)}]] $id] < 0} {
5812 # it doesn't, see where it ends
5813 set r [expr {$prevrow + $downarrowlen}]
5814 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
5815 while {[incr r -1] > $prevrow &&
5816 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
5818 while {[incr r] <= $row &&
5819 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
5823 # see where it starts up again
5824 set r [expr {$row - $uparrowlen}]
5825 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
5826 while {[incr r] < $row &&
5827 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
5829 while {[incr r -1] >= $prevrow &&
5830 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
5836 if {$child eq $id} {
5845 proc drawlineseg {id row endrow arrowlow} {
5846 global rowidlist displayorder iddrawn linesegs
5847 global canv colormap linespc curview maxlinelen parentlist
5849 set cols [list [lsearch -exact [lindex $rowidlist $row] $id]]
5850 set le [expr {$row + 1}]
5853 set c [lsearch -exact [lindex $rowidlist $le] $id]
5859 set x [lindex $displayorder $le]
5864 if {[info exists iddrawn($x)] || $le == $endrow} {
5865 set c [lsearch -exact [lindex $rowidlist [expr {$le+1}]] $id]
5881 if {[info exists linesegs($id)]} {
5882 set lines $linesegs($id)
5884 set r0 [lindex $li 0]
5886 if {$r0 == $le && [lindex $li 1] - $row <= $maxlinelen} {
5896 set li [lindex $lines [expr {$i-1}]]
5897 set r1 [lindex $li 1]
5898 if {$r1 == $row && $le - [lindex $li 0] <= $maxlinelen} {
5903 set x [lindex $cols [expr {$le - $row}]]
5904 set xp [lindex $cols [expr {$le - 1 - $row}]]
5905 set dir [expr {$xp - $x}]
5907 set ith [lindex $lines $i 2]
5908 set coords [$canv coords $ith]
5909 set ah [$canv itemcget $ith -arrow]
5910 set arrowhigh [expr {$ah eq "first" || $ah eq "both"}]
5911 set x2 [lindex $cols [expr {$le + 1 - $row}]]
5912 if {$x2 ne {} && $x - $x2 == $dir} {
5913 set coords [lrange $coords 0 end-2]
5916 set coords [list [xc $le $x] [yc $le]]
5919 set itl [lindex $lines [expr {$i-1}] 2]
5920 set al [$canv itemcget $itl -arrow]
5921 set arrowlow [expr {$al eq "last" || $al eq "both"}]
5922 } elseif {$arrowlow} {
5923 if {[lsearch -exact [lindex $rowidlist [expr {$row-1}]] $id] >= 0 ||
5924 [lsearch -exact [lindex $parentlist [expr {$row-1}]] $id] >= 0} {
5928 set arrow [lindex {none first last both} [expr {$arrowhigh + 2*$arrowlow}]]
5929 for {set y $le} {[incr y -1] > $row} {} {
5931 set xp [lindex $cols [expr {$y - 1 - $row}]]
5932 set ndir [expr {$xp - $x}]
5933 if {$dir != $ndir || $xp < 0} {
5934 lappend coords [xc $y $x] [yc $y]
5940 # join parent line to first child
5941 set ch [lindex $displayorder $row]
5942 set xc [lsearch -exact [lindex $rowidlist $row] $ch]
5944 puts "oops: drawlineseg: child $ch not on row $row"
5945 } elseif {$xc != $x} {
5946 if {($arrowhigh && $le == $row + 1) || $dir == 0} {
5947 set d [expr {int(0.5 * $linespc)}]
5950 set x2 [expr {$x1 - $d}]
5952 set x2 [expr {$x1 + $d}]
5955 set y1 [expr {$y2 + $d}]
5956 lappend coords $x1 $y1 $x2 $y2
5957 } elseif {$xc < $x - 1} {
5958 lappend coords [xc $row [expr {$x-1}]] [yc $row]
5959 } elseif {$xc > $x + 1} {
5960 lappend coords [xc $row [expr {$x+1}]] [yc $row]
5964 lappend coords [xc $row $x] [yc $row]
5966 set xn [xc $row $xp]
5968 lappend coords $xn $yn
5972 set t [$canv create line $coords -width [linewidth $id] \
5973 -fill $colormap($id) -tags lines.$id -arrow $arrow]
5976 set lines [linsert $lines $i [list $row $le $t]]
5978 $canv coords $ith $coords
5979 if {$arrow ne $ah} {
5980 $canv itemconf $ith -arrow $arrow
5982 lset lines $i 0 $row
5985 set xo [lsearch -exact [lindex $rowidlist [expr {$row - 1}]] $id]
5986 set ndir [expr {$xo - $xp}]
5987 set clow [$canv coords $itl]
5988 if {$dir == $ndir} {
5989 set clow [lrange $clow 2 end]
5991 set coords [concat $coords $clow]
5993 lset lines [expr {$i-1}] 1 $le
5995 # coalesce two pieces
5997 set b [lindex $lines [expr {$i-1}] 0]
5998 set e [lindex $lines $i 1]
5999 set lines [lreplace $lines [expr {$i-1}] $i [list $b $e $itl]]
6001 $canv coords $itl $coords
6002 if {$arrow ne $al} {
6003 $canv itemconf $itl -arrow $arrow
6007 set linesegs($id) $lines
6011 proc drawparentlinks {id row} {
6012 global rowidlist canv colormap curview parentlist
6013 global idpos linespc
6015 set rowids [lindex $rowidlist $row]
6016 set col [lsearch -exact $rowids $id]
6017 if {$col < 0} return
6018 set olds [lindex $parentlist $row]
6019 set row2 [expr {$row + 1}]
6020 set x [xc $row $col]
6023 set d [expr {int(0.5 * $linespc)}]
6024 set ymid [expr {$y + $d}]
6025 set ids [lindex $rowidlist $row2]
6026 # rmx = right-most X coord used
6029 set i [lsearch -exact $ids $p]
6031 puts "oops, parent $p of $id not in list"
6034 set x2 [xc $row2 $i]
6038 set j [lsearch -exact $rowids $p]
6040 # drawlineseg will do this one for us
6044 # should handle duplicated parents here...
6045 set coords [list $x $y]
6047 # if attaching to a vertical segment, draw a smaller
6048 # slant for visual distinctness
6051 lappend coords [expr {$x2 + $d}] $y $x2 $ymid
6053 lappend coords [expr {$x2 - $d}] $y $x2 $ymid
6055 } elseif {$i < $col && $i < $j} {
6056 # segment slants towards us already
6057 lappend coords [xc $row $j] $y
6059 if {$i < $col - 1} {
6060 lappend coords [expr {$x2 + $linespc}] $y
6061 } elseif {$i > $col + 1} {
6062 lappend coords [expr {$x2 - $linespc}] $y
6064 lappend coords $x2 $y2
6067 lappend coords $x2 $y2
6069 set t [$canv create line $coords -width [linewidth $p] \
6070 -fill $colormap($p) -tags lines.$p]
6074 if {$rmx > [lindex $idpos($id) 1]} {
6075 lset idpos($id) 1 $rmx
6080 proc drawlines {id} {
6083 $canv itemconf lines.$id -width [linewidth $id]
6086 proc drawcmittext {id row col} {
6087 global linespc canv canv2 canv3 fgcolor curview
6088 global cmitlisted commitinfo rowidlist parentlist
6089 global rowtextx idpos idtags idheads idotherrefs
6090 global linehtag linentag linedtag selectedline
6091 global canvxmax boldids boldnameids fgcolor markedid
6092 global mainheadid nullid nullid2 circleitem circlecolors ctxbut
6093 global mainheadcirclecolor workingfilescirclecolor indexcirclecolor
6094 global circleoutlinecolor
6096 # listed is 0 for boundary, 1 for normal, 2 for negative, 3 for left, 4 for right
6097 set listed $cmitlisted($curview,$id)
6098 if {$id eq $nullid} {
6099 set ofill $workingfilescirclecolor
6100 } elseif {$id eq $nullid2} {
6101 set ofill $indexcirclecolor
6102 } elseif {$id eq $mainheadid} {
6103 set ofill $mainheadcirclecolor
6105 set ofill [lindex $circlecolors $listed]
6107 set x [xc $row $col]
6109 set orad [expr {$linespc / 3}]
6111 set t [$canv create oval [expr {$x - $orad}] [expr {$y - $orad}] \
6112 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
6113 -fill $ofill -outline $circleoutlinecolor -width 1 -tags circle]
6114 } elseif {$listed == 3} {
6115 # triangle pointing left for left-side commits
6116 set t [$canv create polygon \
6117 [expr {$x - $orad}] $y \
6118 [expr {$x + $orad - 1}] [expr {$y - $orad}] \
6119 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
6120 -fill $ofill -outline $circleoutlinecolor -width 1 -tags circle]
6122 # triangle pointing right for right-side commits
6123 set t [$canv create polygon \
6124 [expr {$x + $orad - 1}] $y \
6125 [expr {$x - $orad}] [expr {$y - $orad}] \
6126 [expr {$x - $orad}] [expr {$y + $orad - 1}] \
6127 -fill $ofill -outline $circleoutlinecolor -width 1 -tags circle]
6129 set circleitem($row) $t
6131 $canv bind $t <1> {selcanvline {} %x %y}
6132 set rmx [llength [lindex $rowidlist $row]]
6133 set olds [lindex $parentlist $row]
6135 set nextids [lindex $rowidlist [expr {$row + 1}]]
6137 set i [lsearch -exact $nextids $p]
6143 set xt [xc $row $rmx]
6144 set rowtextx($row) $xt
6145 set idpos($id) [list $x $xt $y]
6146 if {[info exists idtags($id)] || [info exists idheads($id)]
6147 || [info exists idotherrefs($id)]} {
6148 set xt [drawtags $id $x $xt $y]
6150 if {[lindex $commitinfo($id) 6] > 0} {
6151 set xt [drawnotesign $xt $y]
6153 set headline [lindex $commitinfo($id) 0]
6154 set name [lindex $commitinfo($id) 1]
6155 set date [lindex $commitinfo($id) 2]
6156 set date [formatdate $date]
6159 set isbold [ishighlighted $id]
6162 set font mainfontbold
6164 lappend boldnameids $id
6165 set nfont mainfontbold
6168 set linehtag($id) [$canv create text $xt $y -anchor w -fill $fgcolor \
6169 -text $headline -font $font -tags text]
6170 $canv bind $linehtag($id) $ctxbut "rowmenu %X %Y $id"
6171 set linentag($id) [$canv2 create text 3 $y -anchor w -fill $fgcolor \
6172 -text $name -font $nfont -tags text]
6173 set linedtag($id) [$canv3 create text 3 $y -anchor w -fill $fgcolor \
6174 -text $date -font mainfont -tags text]
6175 if {$selectedline == $row} {
6178 if {[info exists markedid] && $markedid eq $id} {
6181 set xr [expr {$xt + [font measure $font $headline]}]
6182 if {$xr > $canvxmax} {
6188 proc drawcmitrow {row} {
6189 global displayorder rowidlist nrows_drawn
6190 global iddrawn markingmatches
6191 global commitinfo numcommits
6192 global filehighlight fhighlights findpattern nhighlights
6193 global hlview vhighlights
6194 global highlight_related rhighlights
6196 if {$row >= $numcommits} return
6198 set id [lindex $displayorder $row]
6199 if {[info exists hlview] && ![info exists vhighlights($id)]} {
6200 askvhighlight $row $id
6202 if {[info exists filehighlight] && ![info exists fhighlights($id)]} {
6203 askfilehighlight $row $id
6205 if {$findpattern ne {} && ![info exists nhighlights($id)]} {
6206 askfindhighlight $row $id
6208 if {$highlight_related ne [mc "None"] && ![info exists rhighlights($id)]} {
6209 askrelhighlight $row $id
6211 if {![info exists iddrawn($id)]} {
6212 set col [lsearch -exact [lindex $rowidlist $row] $id]
6214 puts "oops, row $row id $id not in list"
6217 if {![info exists commitinfo($id)]} {
6221 drawcmittext $id $row $col
6225 if {$markingmatches} {
6226 markrowmatches $row $id
6230 proc drawcommits {row {endrow {}}} {
6231 global numcommits iddrawn displayorder curview need_redisplay
6232 global parentlist rowidlist rowfinal uparrowlen downarrowlen nrows_drawn
6237 if {$endrow eq {}} {
6240 if {$endrow >= $numcommits} {
6241 set endrow [expr {$numcommits - 1}]
6244 set rl1 [expr {$row - $downarrowlen - 3}]
6248 set ro1 [expr {$row - 3}]
6252 set r2 [expr {$endrow + $uparrowlen + 3}]
6253 if {$r2 > $numcommits} {
6256 for {set r $rl1} {$r < $r2} {incr r} {
6257 if {[lindex $rowidlist $r] ne {} && [lindex $rowfinal $r]} {
6261 set rl1 [expr {$r + 1}]
6267 optimize_rows $ro1 0 $r2
6268 if {$need_redisplay || $nrows_drawn > 2000} {
6272 # make the lines join to already-drawn rows either side
6273 set r [expr {$row - 1}]
6274 if {$r < 0 || ![info exists iddrawn([lindex $displayorder $r])]} {
6277 set er [expr {$endrow + 1}]
6278 if {$er >= $numcommits ||
6279 ![info exists iddrawn([lindex $displayorder $er])]} {
6282 for {} {$r <= $er} {incr r} {
6283 set id [lindex $displayorder $r]
6284 set wasdrawn [info exists iddrawn($id)]
6286 if {$r == $er} break
6287 set nextid [lindex $displayorder [expr {$r + 1}]]
6288 if {$wasdrawn && [info exists iddrawn($nextid)]} continue
6289 drawparentlinks $id $r
6291 set rowids [lindex $rowidlist $r]
6292 foreach lid $rowids {
6293 if {$lid eq {}} continue
6294 if {[info exists lineend($lid)] && $lineend($lid) > $r} continue
6296 # see if this is the first child of any of its parents
6297 foreach p [lindex $parentlist $r] {
6298 if {[lsearch -exact $rowids $p] < 0} {
6299 # make this line extend up to the child
6300 set lineend($p) [drawlineseg $p $r $er 0]
6304 set lineend($lid) [drawlineseg $lid $r $er 1]
6310 proc undolayout {row} {
6311 global uparrowlen mingaplen downarrowlen
6312 global rowidlist rowisopt rowfinal need_redisplay
6314 set r [expr {$row - ($uparrowlen + $mingaplen + $downarrowlen)}]
6318 if {[llength $rowidlist] > $r} {
6320 set rowidlist [lrange $rowidlist 0 $r]
6321 set rowfinal [lrange $rowfinal 0 $r]
6322 set rowisopt [lrange $rowisopt 0 $r]
6323 set need_redisplay 1
6328 proc drawvisible {} {
6329 global canv linespc curview vrowmod selectedline targetrow targetid
6330 global need_redisplay cscroll numcommits
6332 set fs [$canv yview]
6333 set ymax [lindex [$canv cget -scrollregion] 3]
6334 if {$ymax eq {} || $ymax == 0 || $numcommits == 0} return
6335 set f0 [lindex $fs 0]
6336 set f1 [lindex $fs 1]
6337 set y0 [expr {int($f0 * $ymax)}]
6338 set y1 [expr {int($f1 * $ymax)}]
6340 if {[info exists targetid]} {
6341 if {[commitinview $targetid $curview]} {
6342 set r [rowofcommit $targetid]
6343 if {$r != $targetrow} {
6344 # Fix up the scrollregion and change the scrolling position
6345 # now that our target row has moved.
6346 set diff [expr {($r - $targetrow) * $linespc}]
6349 set ymax [lindex [$canv cget -scrollregion] 3]
6352 set f0 [expr {$y0 / $ymax}]
6353 set f1 [expr {$y1 / $ymax}]
6354 allcanvs yview moveto $f0
6355 $cscroll set $f0 $f1
6356 set need_redisplay 1
6363 set row [expr {int(($y0 - 3) / $linespc) - 1}]
6364 set endrow [expr {int(($y1 - 3) / $linespc) + 1}]
6365 if {$endrow >= $vrowmod($curview)} {
6366 update_arcrows $curview
6368 if {$selectedline ne {} &&
6369 $row <= $selectedline && $selectedline <= $endrow} {
6370 set targetrow $selectedline
6371 } elseif {[info exists targetid]} {
6372 set targetrow [expr {int(($row + $endrow) / 2)}]
6374 if {[info exists targetrow]} {
6375 if {$targetrow >= $numcommits} {
6376 set targetrow [expr {$numcommits - 1}]
6378 set targetid [commitonrow $targetrow]
6380 drawcommits $row $endrow
6383 proc clear_display {} {
6384 global iddrawn linesegs need_redisplay nrows_drawn
6385 global vhighlights fhighlights nhighlights rhighlights
6386 global linehtag linentag linedtag boldids boldnameids
6389 unset -nocomplain iddrawn
6390 unset -nocomplain linesegs
6391 unset -nocomplain linehtag
6392 unset -nocomplain linentag
6393 unset -nocomplain linedtag
6396 unset -nocomplain vhighlights
6397 unset -nocomplain fhighlights
6398 unset -nocomplain nhighlights
6399 unset -nocomplain rhighlights
6400 set need_redisplay 0
6404 proc findcrossings {id} {
6405 global rowidlist parentlist numcommits displayorder
6409 foreach {s e} [rowranges $id] {
6410 if {$e >= $numcommits} {
6411 set e [expr {$numcommits - 1}]
6413 if {$e <= $s} continue
6414 for {set row $e} {[incr row -1] >= $s} {} {
6415 set x [lsearch -exact [lindex $rowidlist $row] $id]
6417 set olds [lindex $parentlist $row]
6418 set kid [lindex $displayorder $row]
6419 set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
6420 if {$kidx < 0} continue
6421 set nextrow [lindex $rowidlist [expr {$row + 1}]]
6423 set px [lsearch -exact $nextrow $p]
6424 if {$px < 0} continue
6425 if {($kidx < $x && $x < $px) || ($px < $x && $x < $kidx)} {
6426 if {[lsearch -exact $ccross $p] >= 0} continue
6427 if {$x == $px + ($kidx < $px? -1: 1)} {
6429 } elseif {[lsearch -exact $cross $p] < 0} {
6436 return [concat $ccross {{}} $cross]
6439 proc assigncolor {id} {
6440 global colormap colors nextcolor
6441 global parents children children curview
6443 if {[info exists colormap($id)]} return
6444 set ncolors [llength $colors]
6445 if {[info exists children($curview,$id)]} {
6446 set kids $children($curview,$id)
6450 if {[llength $kids] == 1} {
6451 set child [lindex $kids 0]
6452 if {[info exists colormap($child)]
6453 && [llength $parents($curview,$child)] == 1} {
6454 set colormap($id) $colormap($child)
6460 foreach x [findcrossings $id] {
6462 # delimiter between corner crossings and other crossings
6463 if {[llength $badcolors] >= $ncolors - 1} break
6464 set origbad $badcolors
6466 if {[info exists colormap($x)]
6467 && [lsearch -exact $badcolors $colormap($x)] < 0} {
6468 lappend badcolors $colormap($x)
6471 if {[llength $badcolors] >= $ncolors} {
6472 set badcolors $origbad
6474 set origbad $badcolors
6475 if {[llength $badcolors] < $ncolors - 1} {
6476 foreach child $kids {
6477 if {[info exists colormap($child)]
6478 && [lsearch -exact $badcolors $colormap($child)] < 0} {
6479 lappend badcolors $colormap($child)
6481 foreach p $parents($curview,$child) {
6482 if {[info exists colormap($p)]
6483 && [lsearch -exact $badcolors $colormap($p)] < 0} {
6484 lappend badcolors $colormap($p)
6488 if {[llength $badcolors] >= $ncolors} {
6489 set badcolors $origbad
6492 for {set i 0} {$i <= $ncolors} {incr i} {
6493 set c [lindex $colors $nextcolor]
6494 if {[incr nextcolor] >= $ncolors} {
6497 if {[lsearch -exact $badcolors $c]} break
6499 set colormap($id) $c
6502 proc bindline {t id} {
6505 $canv bind $t <Enter> "lineenter %x %y $id"
6506 $canv bind $t <Motion> "linemotion %x %y $id"
6507 $canv bind $t <Leave> "lineleave $id"
6508 $canv bind $t <Button-1> "lineclick %x %y $id 1"
6511 proc graph_pane_width {} {
6515 set g [.tf.histframe.pwclist sashpos 0]
6517 set g [.tf.histframe.pwclist sash coord 0]
6519 return [lindex $g 0]
6522 proc totalwidth {l font extra} {
6525 set tot [expr {$tot + [font measure $font $str] + $extra}]
6530 proc drawtags {id x xt y1} {
6531 global idtags idheads idotherrefs mainhead
6532 global linespc lthickness
6533 global canv rowtextx curview fgcolor bgcolor ctxbut
6534 global headbgcolor headfgcolor headoutlinecolor remotebgcolor
6535 global tagbgcolor tagfgcolor tagoutlinecolor
6544 set maxwidth [expr {[graph_pane_width] * $maxtagpct / 100}]
6545 set delta [expr {int(0.5 * ($linespc - $lthickness))}]
6546 set extra [expr {$delta + $lthickness + $linespc}]
6548 if {[info exists idtags($id)]} {
6549 set marks $idtags($id)
6550 set ntags [llength $marks]
6551 if {$ntags > $maxtags ||
6552 [totalwidth $marks mainfont $extra] > $maxwidth} {
6553 # show just a single "n tags..." tag
6556 set marks [list "tag..."]
6558 set marks [list [format "%d tags..." $ntags]]
6563 if {[info exists idheads($id)]} {
6564 set marks [concat $marks $idheads($id)]
6565 set nheads [llength $idheads($id)]
6567 if {[info exists idotherrefs($id)]} {
6568 set marks [concat $marks $idotherrefs($id)]
6574 set yt [expr {$y1 - 0.5 * $linespc}]
6575 set yb [expr {$yt + $linespc - 1}]
6579 foreach tag $marks {
6581 if {$i >= $ntags && $i < $ntags + $nheads && $tag eq $mainhead} {
6582 set wid [font measure mainfontbold $tag]
6584 set wid [font measure mainfont $tag]
6588 set xt [expr {$xt + $wid + $extra}]
6590 set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
6591 -width $lthickness -fill $reflinecolor -tags tag.$id]
6593 foreach tag $marks x $xvals wid $wvals {
6594 set tag_quoted [string map {% %%} $tag]
6595 set xl [expr {$x + $delta}]
6596 set xr [expr {$x + $delta + $wid + $lthickness}]
6598 if {[incr ntags -1] >= 0} {
6600 set t [$canv create polygon $x [expr {$yt + $delta}] $xl $yt \
6601 $xr $yt $xr $yb $xl $yb $x [expr {$yb - $delta}] \
6602 -width 1 -outline $tagoutlinecolor -fill $tagbgcolor \
6605 set tagclick [list showtags $id 1]
6607 set tagclick [list showtag $tag_quoted 1]
6609 $canv bind $t <1> $tagclick
6610 set rowtextx([rowofcommit $id]) [expr {$xr + $linespc}]
6612 # draw a head or other ref
6613 if {[incr nheads -1] >= 0} {
6614 set col $headbgcolor
6615 if {$tag eq $mainhead} {
6616 set font mainfontbold
6621 set xl [expr {$xl - $delta/2}]
6622 $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
6623 -width 1 -outline black -fill $col -tags tag.$id
6624 if {[regexp {^(remotes/.*/|remotes/)} $tag match remoteprefix]} {
6625 set rwid [font measure mainfont $remoteprefix]
6626 set xi [expr {$x + 1}]
6627 set yti [expr {$yt + 1}]
6628 set xri [expr {$x + $rwid}]
6629 $canv create polygon $xi $yti $xri $yti $xri $yb $xi $yb \
6630 -width 0 -fill $remotebgcolor -tags tag.$id
6633 set t [$canv create text $xl $y1 -anchor w -text $tag -fill $headfgcolor \
6634 -font $font -tags [list tag.$id text]]
6636 $canv bind $t <1> $tagclick
6637 } elseif {$nheads >= 0} {
6638 $canv bind $t $ctxbut [list headmenu %X %Y $id $tag_quoted]
6644 proc drawnotesign {xt y} {
6645 global linespc canv fgcolor
6647 set orad [expr {$linespc / 3}]
6648 set t [$canv create rectangle [expr {$xt - $orad}] [expr {$y - $orad}] \
6649 [expr {$xt + $orad - 1}] [expr {$y + $orad - 1}] \
6650 -fill yellow -outline $fgcolor -width 1 -tags circle]
6651 set xt [expr {$xt + $orad * 3}]
6655 proc xcoord {i level ln} {
6656 global canvx0 xspc1 xspc2
6658 set x [expr {$canvx0 + $i * $xspc1($ln)}]
6659 if {$i > 0 && $i == $level} {
6660 set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
6661 } elseif {$i > $level} {
6662 set x [expr {$x + $xspc2 - $xspc1($ln)}]
6667 proc show_status {msg} {
6672 $canv create text 3 3 -anchor nw -text $msg -font mainfont \
6673 -tags text -fill $fgcolor
6676 # Don't change the text pane cursor if it is currently the hand cursor,
6677 # showing that we are over a sha1 ID link.
6678 proc settextcursor {c} {
6679 global ctext curtextcursor
6681 if {[$ctext cget -cursor] == $curtextcursor} {
6682 $ctext config -cursor $c
6684 set curtextcursor $c
6687 proc nowbusy {what {name {}}} {
6688 global isbusy busyname statusw
6690 if {[array names isbusy] eq {}} {
6691 . config -cursor watch
6695 set busyname($what) $name
6697 $statusw conf -text $name
6701 proc notbusy {what} {
6702 global isbusy maincursor textcursor busyname statusw
6706 if {$busyname($what) ne {} &&
6707 [$statusw cget -text] eq $busyname($what)} {
6708 $statusw conf -text {}
6711 if {[array names isbusy] eq {}} {
6712 . config -cursor $maincursor
6713 settextcursor $textcursor
6717 proc findmatches {f} {
6718 global findtype findstring
6719 if {$findtype == [mc "Regexp"]} {
6720 set matches [regexp -indices -all -inline $findstring $f]
6723 if {$findtype == [mc "IgnCase"]} {
6724 set f [string tolower $f]
6725 set fs [string tolower $fs]
6729 set l [string length $fs]
6730 while {[set j [string first $fs $f $i]] >= 0} {
6731 lappend matches [list $j [expr {$j+$l-1}]]
6732 set i [expr {$j + $l}]
6738 proc dofind {{dirn 1} {wrap 1}} {
6739 global findstring findstartline findcurline selectedline numcommits
6740 global gdttype filehighlight fh_serial find_dirn findallowwrap
6742 if {[info exists find_dirn]} {
6743 if {$find_dirn == $dirn} return
6747 if {$findstring eq {} || $numcommits == 0} return
6748 if {$selectedline eq {}} {
6749 set findstartline [lindex [visiblerows] [expr {$dirn < 0}]]
6751 set findstartline $selectedline
6753 set findcurline $findstartline
6754 nowbusy finding [mc "Searching"]
6755 if {$gdttype ne [mc "containing:"] && ![info exists filehighlight]} {
6756 after cancel do_file_hl $fh_serial
6757 do_file_hl $fh_serial
6760 set findallowwrap $wrap
6764 proc stopfinding {} {
6765 global find_dirn findcurline fprogcoord
6767 if {[info exists find_dirn]} {
6778 global commitdata commitinfo numcommits findpattern findloc
6779 global findstartline findcurline findallowwrap
6780 global find_dirn gdttype fhighlights fprogcoord
6781 global curview varcorder vrownum varccommits vrowmod
6783 if {![info exists find_dirn]} {
6786 set fldtypes [list [mc "Headline"] [mc "Author"] "" [mc "Committer"] "" [mc "Comments"]]
6789 if {$find_dirn > 0} {
6791 if {$l >= $numcommits} {
6794 if {$l <= $findstartline} {
6795 set lim [expr {$findstartline + 1}]
6798 set moretodo $findallowwrap
6805 if {$l >= $findstartline} {
6806 set lim [expr {$findstartline - 1}]
6809 set moretodo $findallowwrap
6812 set n [expr {($lim - $l) * $find_dirn}]
6817 if {$l + ($find_dirn > 0? $n: 1) > $vrowmod($curview)} {
6818 update_arcrows $curview
6822 set ai [bsearch $vrownum($curview) $l]
6823 set a [lindex $varcorder($curview) $ai]
6824 set arow [lindex $vrownum($curview) $ai]
6825 set ids [lindex $varccommits($curview,$a)]
6826 set arowend [expr {$arow + [llength $ids]}]
6827 if {$gdttype eq [mc "containing:"]} {
6828 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
6829 if {$l < $arow || $l >= $arowend} {
6831 set a [lindex $varcorder($curview) $ai]
6832 set arow [lindex $vrownum($curview) $ai]
6833 set ids [lindex $varccommits($curview,$a)]
6834 set arowend [expr {$arow + [llength $ids]}]
6836 set id [lindex $ids [expr {$l - $arow}]]
6837 # shouldn't happen unless git log doesn't give all the commits...
6838 if {![info exists commitdata($id)] ||
6839 ![doesmatch $commitdata($id)]} {
6842 if {![info exists commitinfo($id)]} {
6845 set info $commitinfo($id)
6846 foreach f $info ty $fldtypes {
6847 if {$ty eq ""} continue
6848 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
6857 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
6858 if {$l < $arow || $l >= $arowend} {
6860 set a [lindex $varcorder($curview) $ai]
6861 set arow [lindex $vrownum($curview) $ai]
6862 set ids [lindex $varccommits($curview,$a)]
6863 set arowend [expr {$arow + [llength $ids]}]
6865 set id [lindex $ids [expr {$l - $arow}]]
6866 if {![info exists fhighlights($id)]} {
6867 # this sets fhighlights($id) to -1
6868 askfilehighlight $l $id
6870 if {$fhighlights($id) > 0} {
6874 if {$fhighlights($id) < 0} {
6877 set findcurline [expr {$l - $find_dirn}]
6882 if {$found || ($domore && !$moretodo)} {
6898 set findcurline [expr {$l - $find_dirn}]
6900 set n [expr {($findcurline - $findstartline) * $find_dirn - 1}]
6904 set fprogcoord [expr {$n * 1.0 / $numcommits}]
6909 proc findselectline {l} {
6910 global findloc commentend ctext findcurline markingmatches gdttype
6912 set markingmatches [expr {$gdttype eq [mc "containing:"]}]
6915 if {$markingmatches &&
6916 ($findloc eq [mc "All fields"] || $findloc eq [mc "Comments"])} {
6917 # highlight the matches in the comments
6918 set f [$ctext get 1.0 $commentend]
6919 set matches [findmatches $f]
6920 foreach match $matches {
6921 set start [lindex $match 0]
6922 set end [expr {[lindex $match 1] + 1}]
6923 $ctext tag add found "1.0 + $start c" "1.0 + $end c"
6929 # mark the bits of a headline or author that match a find string
6930 proc markmatches {canv l str tag matches font row} {
6933 set bbox [$canv bbox $tag]
6934 set x0 [lindex $bbox 0]
6935 set y0 [lindex $bbox 1]
6936 set y1 [lindex $bbox 3]
6937 foreach match $matches {
6938 set start [lindex $match 0]
6939 set end [lindex $match 1]
6940 if {$start > $end} continue
6941 set xoff [font measure $font [string range $str 0 [expr {$start-1}]]]
6942 set xlen [font measure $font [string range $str 0 [expr {$end}]]]
6943 set t [$canv create rect [expr {$x0+$xoff}] $y0 \
6944 [expr {$x0+$xlen+2}] $y1 \
6945 -outline {} -tags [list match$l matches] -fill yellow]
6947 if {$row == $selectedline} {
6948 $canv raise $t secsel
6953 proc unmarkmatches {} {
6954 global markingmatches
6956 allcanvs delete matches
6957 set markingmatches 0
6961 proc selcanvline {w x y} {
6962 global canv canvy0 ctext linespc
6964 set ymax [lindex [$canv cget -scrollregion] 3]
6965 if {$ymax == {}} return
6966 set yfrac [lindex [$canv yview] 0]
6967 set y [expr {$y + $yfrac * $ymax}]
6968 set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
6973 set xmax [lindex [$canv cget -scrollregion] 2]
6974 set xleft [expr {[lindex [$canv xview] 0] * $xmax}]
6975 if {![info exists rowtextx($l)] || $xleft + $x < $rowtextx($l)} return
6981 proc commit_descriptor {p} {
6983 if {![info exists commitinfo($p)]} {
6987 if {[llength $commitinfo($p)] > 1} {
6988 set l [lindex $commitinfo($p) 0]
6993 # append some text to the ctext widget, and make any SHA1 ID
6994 # that we know about be a clickable link.
6995 proc appendwithlinks {text tags} {
6996 global ctext linknum curview
6998 set start [$ctext index "end - 1c"]
6999 $ctext insert end $text $tags
7000 set links [regexp -indices -all -inline {(?:\m|-g)[0-9a-f]{6,40}\M} $text]
7004 set linkid [string range $text $s $e]
7006 $ctext tag delete link$linknum
7007 $ctext tag add link$linknum "$start + $s c" "$start + $e c"
7008 setlink $linkid link$linknum
7013 proc setlink {id lk} {
7014 global curview ctext pendinglinks
7017 if {[string range $id 0 1] eq "-g"} {
7018 set id [string range $id 2 end]
7022 if {[string length $id] < 40} {
7023 set matches [longid $id]
7024 if {[llength $matches] > 0} {
7025 if {[llength $matches] > 1} return
7027 set id [lindex $matches 0]
7030 set known [commitinview $id $curview]
7033 $ctext tag conf $lk -foreground $linkfgcolor -underline 1
7034 $ctext tag bind $lk <1> [list selbyid $id]
7035 $ctext tag bind $lk <Enter> {linkcursor %W 1}
7036 $ctext tag bind $lk <Leave> {linkcursor %W -1}
7038 lappend pendinglinks($id) $lk
7039 interestedin $id {makelink %P}
7043 proc appendshortlink {id {pre {}} {post {}}} {
7044 global ctext linknum
7046 $ctext insert end $pre
7047 $ctext tag delete link$linknum
7048 $ctext insert end [string range $id 0 7] link$linknum
7049 $ctext insert end $post
7050 setlink $id link$linknum
7054 proc makelink {id} {
7057 if {![info exists pendinglinks($id)]} return
7058 foreach lk $pendinglinks($id) {
7061 unset pendinglinks($id)
7064 proc linkcursor {w inc} {
7065 global linkentercount curtextcursor
7067 if {[incr linkentercount $inc] > 0} {
7068 $w configure -cursor hand2
7070 $w configure -cursor $curtextcursor
7071 if {$linkentercount < 0} {
7072 set linkentercount 0
7077 proc viewnextline {dir} {
7081 set ymax [lindex [$canv cget -scrollregion] 3]
7082 set wnow [$canv yview]
7083 set wtop [expr {[lindex $wnow 0] * $ymax}]
7084 set newtop [expr {$wtop + $dir * $linespc}]
7087 } elseif {$newtop > $ymax} {
7090 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
7093 # add a list of tag or branch names at position pos
7094 # returns the number of names inserted
7095 proc appendrefs {pos ids var} {
7096 global ctext linknum curview $var maxrefs visiblerefs mainheadid
7098 if {[catch {$ctext index $pos}]} {
7101 $ctext conf -state normal
7102 $ctext delete $pos "$pos lineend"
7105 foreach tag [set $var\($id\)] {
7106 lappend tags [list $tag $id]
7111 set tags [lsort -index 0 -decreasing $tags]
7114 if {[llength $tags] > $maxrefs} {
7115 # If we are displaying heads, and there are too many,
7116 # see if there are some important heads to display.
7117 # Currently that are the current head and heads listed in $visiblerefs option
7119 if {$var eq "idheads"} {
7122 set hname [lindex $ti 0]
7123 set id [lindex $ti 1]
7124 if {([lsearch -exact $visiblerefs $hname] != -1 || $id eq $mainheadid) &&
7125 [llength $itags] < $maxrefs} {
7134 set str [mc "and many more"]
7139 $ctext insert $pos "$str ([llength $tags])"
7140 set nutags [llength $tags]
7145 set id [lindex $ti 1]
7148 $ctext tag delete $lk
7149 $ctext insert $pos $sep
7150 $ctext insert $pos [lindex $ti 0] $lk
7154 $ctext tag add wwrap "$pos linestart" "$pos lineend"
7155 $ctext conf -state disabled
7156 return [expr {[llength $tags] + $nutags}]
7159 # called when we have finished computing the nearby tags
7160 proc dispneartags {delay} {
7161 global selectedline currentid showneartags tagphase
7163 if {$selectedline eq {} || !$showneartags} return
7164 after cancel dispnexttag
7166 after 200 dispnexttag
7169 after idle dispnexttag
7174 proc dispnexttag {} {
7175 global selectedline currentid showneartags tagphase ctext
7177 if {$selectedline eq {} || !$showneartags} return
7178 switch -- $tagphase {
7180 set dtags [desctags $currentid]
7182 appendrefs precedes $dtags idtags
7186 set atags [anctags $currentid]
7188 appendrefs follows $atags idtags
7192 set dheads [descheads $currentid]
7193 if {$dheads ne {}} {
7194 if {[appendrefs branch $dheads idheads] > 1
7195 && [$ctext get "branch -3c"] eq "h"} {
7196 # turn "Branch" into "Branches"
7197 $ctext conf -state normal
7198 $ctext insert "branch -2c" "es"
7199 $ctext conf -state disabled
7204 if {[incr tagphase] <= 2} {
7205 after idle dispnexttag
7209 proc make_secsel {id} {
7210 global linehtag linentag linedtag canv canv2 canv3
7212 if {![info exists linehtag($id)]} return
7214 set t [eval $canv create rect [$canv bbox $linehtag($id)] -outline {{}} \
7215 -tags secsel -fill [$canv cget -selectbackground]]
7217 $canv2 delete secsel
7218 set t [eval $canv2 create rect [$canv2 bbox $linentag($id)] -outline {{}} \
7219 -tags secsel -fill [$canv2 cget -selectbackground]]
7221 $canv3 delete secsel
7222 set t [eval $canv3 create rect [$canv3 bbox $linedtag($id)] -outline {{}} \
7223 -tags secsel -fill [$canv3 cget -selectbackground]]
7227 proc make_idmark {id} {
7228 global linehtag canv fgcolor
7230 if {![info exists linehtag($id)]} return
7232 set t [eval $canv create rect [$canv bbox $linehtag($id)] \
7233 -tags markid -outline $fgcolor]
7237 proc selectline {l isnew {desired_loc {}} {switch_to_patch 0}} {
7238 global canv ctext commitinfo selectedline
7239 global canvy0 linespc parents children curview
7240 global currentid sha1entry
7241 global commentend idtags linknum
7242 global mergemax numcommits pending_select
7243 global cmitmode showneartags allcommits
7244 global targetrow targetid lastscrollrows
7245 global autoselect autosellen jump_to_here
7248 unset -nocomplain pending_select
7253 if {$l < 0 || $l >= $numcommits} return
7254 set id [commitonrow $l]
7259 if {$lastscrollrows < $numcommits} {
7263 if {$cmitmode ne "patch" && $switch_to_patch} {
7264 set cmitmode "patch"
7267 set y [expr {$canvy0 + $l * $linespc}]
7268 set ymax [lindex [$canv cget -scrollregion] 3]
7269 set ytop [expr {$y - $linespc - 1}]
7270 set ybot [expr {$y + $linespc + 1}]
7271 set wnow [$canv yview]
7272 set wtop [expr {[lindex $wnow 0] * $ymax}]
7273 set wbot [expr {[lindex $wnow 1] * $ymax}]
7274 set wh [expr {$wbot - $wtop}]
7276 if {$ytop < $wtop} {
7277 if {$ybot < $wtop} {
7278 set newtop [expr {$y - $wh / 2.0}]
7281 if {$newtop > $wtop - $linespc} {
7282 set newtop [expr {$wtop - $linespc}]
7285 } elseif {$ybot > $wbot} {
7286 if {$ytop > $wbot} {
7287 set newtop [expr {$y - $wh / 2.0}]
7289 set newtop [expr {$ybot - $wh}]
7290 if {$newtop < $wtop + $linespc} {
7291 set newtop [expr {$wtop + $linespc}]
7295 if {$newtop != $wtop} {
7299 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
7306 addtohistory [list selbyid $id 0] savecmitpos
7309 $sha1entry delete 0 end
7310 $sha1entry insert 0 $id
7312 $sha1entry selection range 0 $autosellen
7316 $ctext conf -state normal
7319 if {![info exists commitinfo($id)]} {
7322 set info $commitinfo($id)
7323 set date [formatdate [lindex $info 2]]
7324 $ctext insert end "[mc "Author"]: [lindex $info 1] $date\n"
7325 set date [formatdate [lindex $info 4]]
7326 $ctext insert end "[mc "Committer"]: [lindex $info 3] $date\n"
7327 if {[info exists idtags($id)]} {
7328 $ctext insert end [mc "Tags:"]
7329 foreach tag $idtags($id) {
7330 $ctext insert end " $tag"
7332 $ctext insert end "\n"
7336 set olds $parents($curview,$id)
7337 if {[llength $olds] > 1} {
7340 if {$np >= $mergemax} {
7345 $ctext insert end "[mc "Parent"]: " $tag
7346 appendwithlinks [commit_descriptor $p] {}
7351 append headers "[mc "Parent"]: [commit_descriptor $p]"
7355 foreach c $children($curview,$id) {
7356 append headers "[mc "Child"]: [commit_descriptor $c]"
7359 # make anything that looks like a SHA1 ID be a clickable link
7360 appendwithlinks $headers {}
7361 if {$showneartags} {
7362 if {![info exists allcommits]} {
7365 $ctext insert end "[mc "Branch"]: "
7366 $ctext mark set branch "end -1c"
7367 $ctext mark gravity branch left
7368 $ctext insert end "\n[mc "Follows"]: "
7369 $ctext mark set follows "end -1c"
7370 $ctext mark gravity follows left
7371 $ctext insert end "\n[mc "Precedes"]: "
7372 $ctext mark set precedes "end -1c"
7373 $ctext mark gravity precedes left
7374 $ctext insert end "\n"
7377 $ctext insert end "\n"
7378 set comment [lindex $info 5]
7379 if {[string first "\r" $comment] >= 0} {
7380 set comment [string map {"\r" "\n "} $comment]
7382 appendwithlinks $comment {comment}
7384 $ctext tag remove found 1.0 end
7385 $ctext conf -state disabled
7386 set commentend [$ctext index "end - 1c"]
7388 set jump_to_here $desired_loc
7389 init_flist [mc "Comments"]
7390 if {$cmitmode eq "tree"} {
7392 } elseif {$vinlinediff($curview) == 1} {
7394 } elseif {[llength $olds] <= 1} {
7401 proc selfirstline {} {
7406 proc sellastline {} {
7409 set l [expr {$numcommits - 1}]
7413 proc selnextline {dir} {
7416 if {$selectedline eq {}} return
7417 set l [expr {$selectedline + $dir}]
7422 proc selnextpage {dir} {
7423 global canv linespc selectedline numcommits
7425 set lpp [expr {([winfo height $canv] - 2) / $linespc}]
7429 allcanvs yview scroll [expr {$dir * $lpp}] units
7431 if {$selectedline eq {}} return
7432 set l [expr {$selectedline + $dir * $lpp}]
7435 } elseif {$l >= $numcommits} {
7436 set l [expr $numcommits - 1]
7442 proc unselectline {} {
7443 global selectedline currentid
7446 unset -nocomplain currentid
7447 allcanvs delete secsel
7451 proc reselectline {} {
7454 if {$selectedline ne {}} {
7455 selectline $selectedline 0
7459 proc addtohistory {cmd {saveproc {}}} {
7460 global history historyindex curview
7464 set elt [list $curview $cmd $saveproc {}]
7465 if {$historyindex > 0
7466 && [lindex $history [expr {$historyindex - 1}]] == $elt} {
7470 if {$historyindex < [llength $history]} {
7471 set history [lreplace $history $historyindex end $elt]
7473 lappend history $elt
7476 if {$historyindex > 1} {
7477 .tf.bar.leftbut conf -state normal
7479 .tf.bar.leftbut conf -state disabled
7481 .tf.bar.rightbut conf -state disabled
7484 # save the scrolling position of the diff display pane
7485 proc save_position {} {
7486 global historyindex history
7488 if {$historyindex < 1} return
7489 set hi [expr {$historyindex - 1}]
7490 set fn [lindex $history $hi 2]
7492 lset history $hi 3 [eval $fn]
7496 proc unset_posvars {} {
7499 if {[info exists last_posvars]} {
7500 foreach {var val} $last_posvars {
7502 unset -nocomplain $var
7509 global curview last_posvars
7511 set view [lindex $elt 0]
7512 set cmd [lindex $elt 1]
7513 set pv [lindex $elt 3]
7514 if {$curview != $view} {
7518 foreach {var val} $pv {
7522 set last_posvars $pv
7527 global history historyindex
7530 if {$historyindex > 1} {
7532 incr historyindex -1
7533 godo [lindex $history [expr {$historyindex - 1}]]
7534 .tf.bar.rightbut conf -state normal
7536 if {$historyindex <= 1} {
7537 .tf.bar.leftbut conf -state disabled
7542 global history historyindex
7545 if {$historyindex < [llength $history]} {
7547 set cmd [lindex $history $historyindex]
7550 .tf.bar.leftbut conf -state normal
7552 if {$historyindex >= [llength $history]} {
7553 .tf.bar.rightbut conf -state disabled
7557 proc go_to_parent {i} {
7558 global parents curview targetid
7559 set ps $parents($curview,$targetid)
7560 if {[llength $ps] >= $i} {
7561 selbyid [lindex $ps [expr $i - 1]]
7566 global treefilelist treeidlist diffids diffmergeid treepending
7567 global nullid nullid2
7570 unset -nocomplain diffmergeid
7571 if {![info exists treefilelist($id)]} {
7572 if {![info exists treepending]} {
7573 if {$id eq $nullid} {
7574 set cmd [list | git ls-files]
7575 } elseif {$id eq $nullid2} {
7576 set cmd [list | git ls-files --stage -t]
7578 set cmd [list | git ls-tree -r $id]
7580 if {[catch {set gtf [open $cmd r]}]} {
7584 set treefilelist($id) {}
7585 set treeidlist($id) {}
7586 fconfigure $gtf -blocking 0 -encoding binary
7587 filerun $gtf [list gettreeline $gtf $id]
7594 proc gettreeline {gtf id} {
7595 global treefilelist treeidlist treepending cmitmode diffids nullid nullid2
7598 while {[incr nl] <= 1000 && [gets $gtf line] >= 0} {
7599 if {$diffids eq $nullid} {
7602 set i [string first "\t" $line]
7603 if {$i < 0} continue
7604 set fname [string range $line [expr {$i+1}] end]
7605 set line [string range $line 0 [expr {$i-1}]]
7606 if {$diffids ne $nullid2 && [lindex $line 1] ne "blob"} continue
7607 set sha1 [lindex $line 2]
7608 lappend treeidlist($id) $sha1
7610 if {[string index $fname 0] eq "\""} {
7611 set fname [lindex $fname 0]
7613 set fname [encoding convertfrom $fname]
7614 lappend treefilelist($id) $fname
7617 return [expr {$nl >= 1000? 2: 1}]
7621 if {$cmitmode ne "tree"} {
7622 if {![info exists diffmergeid]} {
7623 gettreediffs $diffids
7625 } elseif {$id ne $diffids} {
7634 global treefilelist treeidlist diffids nullid nullid2
7635 global ctext_file_names ctext_file_lines
7636 global ctext commentend
7638 set i [lsearch -exact $treefilelist($diffids) $f]
7640 puts "oops, $f not in list for id $diffids"
7643 if {$diffids eq $nullid} {
7644 if {[catch {set bf [open $f r]} err]} {
7645 puts "oops, can't read $f: $err"
7649 set blob [lindex $treeidlist($diffids) $i]
7650 if {[catch {set bf [open [concat | git cat-file blob $blob] r]} err]} {
7651 puts "oops, error reading blob $blob: $err"
7655 fconfigure $bf -blocking 0 -encoding [get_path_encoding $f]
7656 filerun $bf [list getblobline $bf $diffids]
7657 $ctext config -state normal
7658 clear_ctext $commentend
7659 lappend ctext_file_names $f
7660 lappend ctext_file_lines [lindex [split $commentend "."] 0]
7661 $ctext insert end "\n"
7662 $ctext insert end "$f\n" filesep
7663 $ctext config -state disabled
7664 $ctext yview $commentend
7668 proc getblobline {bf id} {
7669 global diffids cmitmode ctext
7671 if {$id ne $diffids || $cmitmode ne "tree"} {
7675 $ctext config -state normal
7677 while {[incr nl] <= 1000 && [gets $bf line] >= 0} {
7678 $ctext insert end "$line\n"
7681 global jump_to_here ctext_file_names commentend
7683 # delete last newline
7684 $ctext delete "end - 2c" "end - 1c"
7686 if {$jump_to_here ne {} &&
7687 [lindex $jump_to_here 0] eq [lindex $ctext_file_names 0]} {
7688 set lnum [expr {[lindex $jump_to_here 1] +
7689 [lindex [split $commentend .] 0]}]
7690 mark_ctext_line $lnum
7692 $ctext config -state disabled
7695 $ctext config -state disabled
7696 return [expr {$nl >= 1000? 2: 1}]
7699 proc mark_ctext_line {lnum} {
7700 global ctext markbgcolor
7702 $ctext tag delete omark
7703 $ctext tag add omark $lnum.0 "$lnum.0 + 1 line"
7704 $ctext tag conf omark -background $markbgcolor
7708 proc mergediff {id} {
7710 global diffids treediffs
7711 global parents curview
7715 set treediffs($id) {}
7716 set np [llength $parents($curview,$id)]
7721 proc startdiff {ids} {
7722 global treediffs diffids treepending diffmergeid nullid nullid2
7726 unset -nocomplain diffmergeid
7727 if {![info exists treediffs($ids)] ||
7728 [lsearch -exact $ids $nullid] >= 0 ||
7729 [lsearch -exact $ids $nullid2] >= 0} {
7730 if {![info exists treepending]} {
7738 proc showinlinediff {ids} {
7739 global commitinfo commitdata ctext
7742 set info $commitinfo($ids)
7743 set diff [lindex $info 7]
7744 set difflines [split $diff "\n"]
7750 foreach line $difflines {
7751 if {![string compare -length 5 "diff " $line]} {
7753 } elseif {$inhdr && ![string compare -length 4 "+++ " $line]} {
7754 # offset also accounts for the b/ prefix
7755 lappend treediff [string range $line 6 end]
7760 set treediffs($ids) $treediff
7763 $ctext conf -state normal
7764 foreach line $difflines {
7765 parseblobdiffline $ids $line
7767 maybe_scroll_ctext 1
7768 $ctext conf -state disabled
7771 # If the filename (name) is under any of the passed filter paths
7772 # then return true to include the file in the listing.
7773 proc path_filter {filter name} {
7774 set worktree [gitworktree]
7776 set fq_p [file normalize $p]
7777 set fq_n [file normalize [file join $worktree $name]]
7778 if {[string match [file normalize $fq_p]* $fq_n]} {
7785 proc addtocflist {ids} {
7788 add_flist $treediffs($ids)
7792 proc diffcmd {ids flags} {
7793 global log_showroot nullid nullid2 git_version
7795 set i [lsearch -exact $ids $nullid]
7796 set j [lsearch -exact $ids $nullid2]
7798 if {[llength $ids] > 1 && $j < 0} {
7799 # comparing working directory with some specific revision
7800 set cmd [concat | git diff-index $flags]
7802 lappend cmd -R [lindex $ids 1]
7804 lappend cmd [lindex $ids 0]
7807 # comparing working directory with index
7808 set cmd [concat | git diff-files $flags]
7813 } elseif {$j >= 0} {
7814 if {[package vcompare $git_version "1.7.2"] >= 0} {
7815 set flags "$flags --ignore-submodules=dirty"
7817 set cmd [concat | git diff-index --cached $flags]
7818 if {[llength $ids] > 1} {
7819 # comparing index with specific revision
7821 lappend cmd -R [lindex $ids 1]
7823 lappend cmd [lindex $ids 0]
7826 # comparing index with HEAD
7830 if {$log_showroot} {
7831 lappend flags --root
7833 set cmd [concat | git diff-tree -r $flags $ids]
7838 proc gettreediffs {ids} {
7839 global treediff treepending limitdiffs vfilelimit curview
7841 set cmd [diffcmd $ids {--no-commit-id}]
7842 if {$limitdiffs && $vfilelimit($curview) ne {}} {
7843 set cmd [concat $cmd -- $vfilelimit($curview)]
7845 if {[catch {set gdtf [open $cmd r]}]} return
7847 set treepending $ids
7849 fconfigure $gdtf -blocking 0 -encoding binary
7850 filerun $gdtf [list gettreediffline $gdtf $ids]
7853 proc gettreediffline {gdtf ids} {
7854 global treediff treediffs treepending diffids diffmergeid
7855 global cmitmode vfilelimit curview limitdiffs perfile_attrs
7860 if {$perfile_attrs} {
7861 # cache_gitattr is slow, and even slower on win32 where we
7862 # have to invoke it for only about 30 paths at a time
7864 if {[tk windowingsystem] == "win32"} {
7868 while {[incr nr] <= $max && [gets $gdtf line] >= 0} {
7869 set i [string first "\t" $line]
7871 set file [string range $line [expr {$i+1}] end]
7872 if {[string index $file 0] eq "\""} {
7873 set file [lindex $file 0]
7875 set file [encoding convertfrom $file]
7876 if {$file ne [lindex $treediff end]} {
7877 lappend treediff $file
7878 lappend sublist $file
7882 if {$perfile_attrs} {
7883 cache_gitattr encoding $sublist
7886 return [expr {$nr >= $max? 2: 1}]
7889 set treediffs($ids) $treediff
7891 if {$cmitmode eq "tree" && [llength $diffids] == 1} {
7893 } elseif {$ids != $diffids} {
7894 if {![info exists diffmergeid]} {
7895 gettreediffs $diffids
7903 # empty string or positive integer
7904 proc diffcontextvalidate {v} {
7905 return [regexp {^(|[1-9][0-9]*)$} $v]
7908 proc diffcontextchange {n1 n2 op} {
7909 global diffcontextstring diffcontext
7911 if {[string is integer -strict $diffcontextstring]} {
7912 if {$diffcontextstring >= 0} {
7913 set diffcontext $diffcontextstring
7919 proc changeignorespace {} {
7923 proc changeworddiff {name ix op} {
7927 proc initblobdiffvars {} {
7928 global diffencoding targetline diffnparents
7929 global diffinhdr currdiffsubmod diffseehere
7933 set diffencoding [get_path_encoding {}]
7934 set currdiffsubmod ""
7938 proc getblobdiffs {ids} {
7939 global blobdifffd diffids env
7944 global limitdiffs vfilelimit curview
7948 if {[package vcompare $git_version "1.6.1"] >= 0} {
7949 set textconv "--textconv"
7952 if {[package vcompare $git_version "1.6.6"] >= 0} {
7953 set submodule "--submodule"
7955 set cmd [diffcmd $ids "-p $textconv $submodule -C --cc --no-commit-id -U$diffcontext"]
7959 if {$worddiff ne [mc "Line diff"]} {
7960 append cmd " --word-diff=porcelain"
7962 if {$limitdiffs && $vfilelimit($curview) ne {}} {
7963 set cmd [concat $cmd -- $vfilelimit($curview)]
7965 if {[catch {set bdf [open $cmd r]} err]} {
7966 error_popup [mc "Error getting diffs: %s" $err]
7969 fconfigure $bdf -blocking 0 -encoding binary -eofchar {}
7970 set blobdifffd($ids) $bdf
7972 filerun $bdf [list getblobdiffline $bdf $diffids]
7975 proc savecmitpos {} {
7976 global ctext cmitmode
7978 if {$cmitmode eq "tree"} {
7981 return [list target_scrollpos [$ctext index @0,0]]
7984 proc savectextpos {} {
7987 return [list target_scrollpos [$ctext index @0,0]]
7990 proc maybe_scroll_ctext {ateof} {
7991 global ctext target_scrollpos
7993 if {![info exists target_scrollpos]} return
7995 set nlines [expr {[winfo height $ctext]
7996 / [font metrics textfont -linespace]}]
7997 if {[$ctext compare "$target_scrollpos + $nlines lines" <= end]} return
7999 $ctext yview $target_scrollpos
8000 unset target_scrollpos
8003 proc setinlist {var i val} {
8006 while {[llength [set $var]] < $i} {
8009 if {[llength [set $var]] == $i} {
8016 proc makediffhdr {fname ids} {
8017 global ctext curdiffstart treediffs diffencoding
8018 global ctext_file_names jump_to_here targetline diffline
8020 set fname [encoding convertfrom $fname]
8021 set diffencoding [get_path_encoding $fname]
8022 set i [lsearch -exact $treediffs($ids) $fname]
8024 setinlist difffilestart $i $curdiffstart
8026 lset ctext_file_names end $fname
8027 set l [expr {(78 - [string length $fname]) / 2}]
8028 set pad [string range "----------------------------------------" 1 $l]
8029 $ctext insert $curdiffstart "$pad $fname $pad" filesep
8031 if {$jump_to_here ne {} && [lindex $jump_to_here 0] eq $fname} {
8032 set targetline [lindex $jump_to_here 1]
8037 proc blobdiffmaybeseehere {ateof} {
8039 if {$diffseehere >= 0} {
8040 mark_ctext_line [lindex [split $diffseehere .] 0]
8042 maybe_scroll_ctext $ateof
8045 proc getblobdiffline {bdf ids} {
8046 global diffids blobdifffd
8050 $ctext conf -state normal
8051 while {[incr nr] <= 1000 && [gets $bdf line] >= 0} {
8052 if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
8056 parseblobdiffline $ids $line
8058 $ctext conf -state disabled
8059 blobdiffmaybeseehere [eof $bdf]
8064 return [expr {$nr >= 1000? 2: 1}]
8067 proc parseblobdiffline {ids line} {
8068 global ctext curdiffstart
8069 global diffnexthead diffnextnote difffilestart
8070 global ctext_file_names ctext_file_lines
8071 global diffinhdr treediffs mergemax diffnparents
8072 global diffencoding jump_to_here targetline diffline currdiffsubmod
8073 global worddiff diffseehere
8075 if {![string compare -length 5 "diff " $line]} {
8076 if {![regexp {^diff (--cc|--git) } $line m type]} {
8077 set line [encoding convertfrom $line]
8078 $ctext insert end "$line\n" hunksep
8081 # start of a new file
8083 $ctext insert end "\n"
8084 set curdiffstart [$ctext index "end - 1c"]
8085 lappend ctext_file_names ""
8086 lappend ctext_file_lines [lindex [split $curdiffstart "."] 0]
8087 $ctext insert end "\n" filesep
8089 if {$type eq "--cc"} {
8090 # start of a new file in a merge diff
8091 set fname [string range $line 10 end]
8092 if {[lsearch -exact $treediffs($ids) $fname] < 0} {
8093 lappend treediffs($ids) $fname
8094 add_flist [list $fname]
8098 set line [string range $line 11 end]
8099 # If the name hasn't changed the length will be odd,
8100 # the middle char will be a space, and the two bits either
8101 # side will be a/name and b/name, or "a/name" and "b/name".
8102 # If the name has changed we'll get "rename from" and
8103 # "rename to" or "copy from" and "copy to" lines following
8104 # this, and we'll use them to get the filenames.
8105 # This complexity is necessary because spaces in the
8106 # filename(s) don't get escaped.
8107 set l [string length $line]
8108 set i [expr {$l / 2}]
8109 if {!(($l & 1) && [string index $line $i] eq " " &&
8110 [string range $line 2 [expr {$i - 1}]] eq \
8111 [string range $line [expr {$i + 3}] end])} {
8114 # unescape if quoted and chop off the a/ from the front
8115 if {[string index $line 0] eq "\""} {
8116 set fname [string range [lindex $line 0] 2 end]
8118 set fname [string range $line 2 [expr {$i - 1}]]
8121 makediffhdr $fname $ids
8123 } elseif {![string compare -length 16 "* Unmerged path " $line]} {
8124 set fname [encoding convertfrom [string range $line 16 end]]
8125 $ctext insert end "\n"
8126 set curdiffstart [$ctext index "end - 1c"]
8127 lappend ctext_file_names $fname
8128 lappend ctext_file_lines [lindex [split $curdiffstart "."] 0]
8129 $ctext insert end "$line\n" filesep
8130 set i [lsearch -exact $treediffs($ids) $fname]
8132 setinlist difffilestart $i $curdiffstart
8135 } elseif {![string compare -length 2 "@@" $line]} {
8136 regexp {^@@+} $line ats
8137 set line [encoding convertfrom $diffencoding $line]
8138 $ctext insert end "$line\n" hunksep
8139 if {[regexp { \+(\d+),\d+ @@} $line m nl]} {
8142 set diffnparents [expr {[string length $ats] - 1}]
8145 } elseif {![string compare -length 10 "Submodule " $line]} {
8146 # start of a new submodule
8147 if {[regexp -indices "\[0-9a-f\]+\\.\\." $line nameend]} {
8148 set fname [string range $line 10 [expr [lindex $nameend 0] - 2]]
8150 set fname [string range $line 10 [expr [string first "contains " $line] - 2]]
8152 if {$currdiffsubmod != $fname} {
8153 $ctext insert end "\n"; # Add newline after commit message
8155 set curdiffstart [$ctext index "end - 1c"]
8156 lappend ctext_file_names ""
8157 if {$currdiffsubmod != $fname} {
8158 lappend ctext_file_lines $fname
8159 makediffhdr $fname $ids
8160 set currdiffsubmod $fname
8161 $ctext insert end "\n$line\n" filesep
8163 $ctext insert end "$line\n" filesep
8165 } elseif {![string compare -length 3 " >" $line]} {
8166 set $currdiffsubmod ""
8167 set line [encoding convertfrom $diffencoding $line]
8168 $ctext insert end "$line\n" dresult
8169 } elseif {![string compare -length 3 " <" $line]} {
8170 set $currdiffsubmod ""
8171 set line [encoding convertfrom $diffencoding $line]
8172 $ctext insert end "$line\n" d0
8173 } elseif {$diffinhdr} {
8174 if {![string compare -length 12 "rename from " $line]} {
8175 set fname [string range $line [expr 6 + [string first " from " $line] ] end]
8176 if {[string index $fname 0] eq "\""} {
8177 set fname [lindex $fname 0]
8179 set fname [encoding convertfrom $fname]
8180 set i [lsearch -exact $treediffs($ids) $fname]
8182 setinlist difffilestart $i $curdiffstart
8184 } elseif {![string compare -length 10 $line "rename to "] ||
8185 ![string compare -length 8 $line "copy to "]} {
8186 set fname [string range $line [expr 4 + [string first " to " $line] ] end]
8187 if {[string index $fname 0] eq "\""} {
8188 set fname [lindex $fname 0]
8190 makediffhdr $fname $ids
8191 } elseif {[string compare -length 3 $line "---"] == 0} {
8194 } elseif {[string compare -length 3 $line "+++"] == 0} {
8198 $ctext insert end "$line\n" filesep
8201 set line [string map {\x1A ^Z} \
8202 [encoding convertfrom $diffencoding $line]]
8203 # parse the prefix - one ' ', '-' or '+' for each parent
8204 set prefix [string range $line 0 [expr {$diffnparents - 1}]]
8205 set tag [expr {$diffnparents > 1? "m": "d"}]
8206 set dowords [expr {$worddiff ne [mc "Line diff"] && $diffnparents == 1}]
8207 set words_pre_markup ""
8208 set words_post_markup ""
8209 if {[string trim $prefix " -+"] eq {}} {
8210 # prefix only has " ", "-" and "+" in it: normal diff line
8211 set num [string first "-" $prefix]
8213 set line [string range $line 1 end]
8216 # removed line, first parent with line is $num
8217 if {$num >= $mergemax} {
8220 if {$dowords && $worddiff eq [mc "Markup words"]} {
8221 $ctext insert end "\[-$line-\]" $tag$num
8223 $ctext insert end "$line" $tag$num
8226 $ctext insert end "\n" $tag$num
8230 if {[string first "+" $prefix] >= 0} {
8232 lappend tags ${tag}result
8233 if {$diffnparents > 1} {
8234 set num [string first " " $prefix]
8236 if {$num >= $mergemax} {
8242 set words_pre_markup "{+"
8243 set words_post_markup "+}"
8245 if {$targetline ne {}} {
8246 if {$diffline == $targetline} {
8247 set diffseehere [$ctext index "end - 1 chars"]
8253 if {$dowords && $worddiff eq [mc "Markup words"]} {
8254 $ctext insert end "$words_pre_markup$line$words_post_markup" $tags
8256 $ctext insert end "$line" $tags
8259 $ctext insert end "\n" $tags
8262 } elseif {$dowords && $prefix eq "~"} {
8263 $ctext insert end "\n" {}
8265 # "\ No newline at end of file",
8266 # or something else we don't recognize
8267 $ctext insert end "$line\n" hunksep
8272 proc changediffdisp {} {
8273 global ctext diffelide
8275 $ctext tag conf d0 -elide [lindex $diffelide 0]
8276 $ctext tag conf dresult -elide [lindex $diffelide 1]
8279 proc highlightfile {cline} {
8280 global cflist cflist_top
8282 if {![info exists cflist_top]} return
8284 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
8285 $cflist tag add highlight $cline.0 "$cline.0 lineend"
8286 $cflist see $cline.0
8287 set cflist_top $cline
8290 proc highlightfile_for_scrollpos {topidx} {
8291 global cmitmode difffilestart
8293 if {$cmitmode eq "tree"} return
8294 if {![info exists difffilestart]} return
8296 set top [lindex [split $topidx .] 0]
8297 if {$difffilestart eq {} || $top < [lindex $difffilestart 0]} {
8300 highlightfile [expr {[bsearch $difffilestart $top] + 2}]
8305 global difffilestart ctext cmitmode
8307 if {$cmitmode eq "tree"} return
8309 set here [$ctext index @0,0]
8310 foreach loc $difffilestart {
8311 if {[$ctext compare $loc >= $here]} {
8321 global difffilestart ctext cmitmode
8323 if {$cmitmode eq "tree"} return
8324 set here [$ctext index @0,0]
8325 foreach loc $difffilestart {
8326 if {[$ctext compare $loc > $here]} {
8333 proc clear_ctext {{first 1.0}} {
8334 global ctext smarktop smarkbot
8335 global ctext_file_names ctext_file_lines
8338 set l [lindex [split $first .] 0]
8339 if {![info exists smarktop] || [$ctext compare $first < $smarktop.0]} {
8342 if {![info exists smarkbot] || [$ctext compare $first < $smarkbot.0]} {
8345 $ctext delete $first end
8346 if {$first eq "1.0"} {
8347 unset -nocomplain pendinglinks
8349 set ctext_file_names {}
8350 set ctext_file_lines {}
8353 proc settabs {{firstab {}}} {
8354 global firsttabstop tabstop ctext have_tk85
8356 if {$firstab ne {} && $have_tk85} {
8357 set firsttabstop $firstab
8359 set w [font measure textfont "0"]
8360 if {$firsttabstop != 0} {
8361 $ctext conf -tabs [list [expr {($firsttabstop + $tabstop) * $w}] \
8362 [expr {($firsttabstop + 2 * $tabstop) * $w}]]
8363 } elseif {$have_tk85 || $tabstop != 8} {
8364 $ctext conf -tabs [expr {$tabstop * $w}]
8366 $ctext conf -tabs {}
8370 proc incrsearch {name ix op} {
8371 global ctext searchstring searchdirn
8373 if {[catch {$ctext index anchor}]} {
8374 # no anchor set, use start of selection, or of visible area
8375 set sel [$ctext tag ranges sel]
8377 $ctext mark set anchor [lindex $sel 0]
8378 } elseif {$searchdirn eq "-forwards"} {
8379 $ctext mark set anchor @0,0
8381 $ctext mark set anchor @0,[winfo height $ctext]
8384 if {$searchstring ne {}} {
8385 set here [$ctext search -count mlen $searchdirn -- $searchstring anchor]
8388 set mend "$here + $mlen c"
8389 $ctext tag remove sel 1.0 end
8390 $ctext tag add sel $here $mend
8391 suppress_highlighting_file_for_current_scrollpos
8392 highlightfile_for_scrollpos $here
8395 rehighlight_search_results
8399 global sstring ctext searchstring searchdirn
8402 $sstring icursor end
8403 set searchdirn -forwards
8404 if {$searchstring ne {}} {
8405 set sel [$ctext tag ranges sel]
8407 set start "[lindex $sel 0] + 1c"
8408 } elseif {[catch {set start [$ctext index anchor]}]} {
8411 set match [$ctext search -count mlen -- $searchstring $start]
8412 $ctext tag remove sel 1.0 end
8418 suppress_highlighting_file_for_current_scrollpos
8419 highlightfile_for_scrollpos $match
8420 set mend "$match + $mlen c"
8421 $ctext tag add sel $match $mend
8422 $ctext mark unset anchor
8423 rehighlight_search_results
8427 proc dosearchback {} {
8428 global sstring ctext searchstring searchdirn
8431 $sstring icursor end
8432 set searchdirn -backwards
8433 if {$searchstring ne {}} {
8434 set sel [$ctext tag ranges sel]
8436 set start [lindex $sel 0]
8437 } elseif {[catch {set start [$ctext index anchor]}]} {
8438 set start @0,[winfo height $ctext]
8440 set match [$ctext search -backwards -count ml -- $searchstring $start]
8441 $ctext tag remove sel 1.0 end
8447 suppress_highlighting_file_for_current_scrollpos
8448 highlightfile_for_scrollpos $match
8449 set mend "$match + $ml c"
8450 $ctext tag add sel $match $mend
8451 $ctext mark unset anchor
8452 rehighlight_search_results
8456 proc rehighlight_search_results {} {
8457 global ctext searchstring
8459 $ctext tag remove found 1.0 end
8460 $ctext tag remove currentsearchhit 1.0 end
8462 if {$searchstring ne {}} {
8467 proc searchmark {first last} {
8468 global ctext searchstring
8470 set sel [$ctext tag ranges sel]
8474 set match [$ctext search -count mlen -- $searchstring $mend $last.end]
8475 if {$match eq {}} break
8476 set mend "$match + $mlen c"
8477 if {$sel ne {} && [$ctext compare $match == [lindex $sel 0]]} {
8478 $ctext tag add currentsearchhit $match $mend
8480 $ctext tag add found $match $mend
8485 proc searchmarkvisible {doall} {
8486 global ctext smarktop smarkbot
8488 set topline [lindex [split [$ctext index @0,0] .] 0]
8489 set botline [lindex [split [$ctext index @0,[winfo height $ctext]] .] 0]
8490 if {$doall || $botline < $smarktop || $topline > $smarkbot} {
8491 # no overlap with previous
8492 searchmark $topline $botline
8493 set smarktop $topline
8494 set smarkbot $botline
8496 if {$topline < $smarktop} {
8497 searchmark $topline [expr {$smarktop-1}]
8498 set smarktop $topline
8500 if {$botline > $smarkbot} {
8501 searchmark [expr {$smarkbot+1}] $botline
8502 set smarkbot $botline
8507 proc suppress_highlighting_file_for_current_scrollpos {} {
8508 global ctext suppress_highlighting_file_for_this_scrollpos
8510 set suppress_highlighting_file_for_this_scrollpos [$ctext index @0,0]
8513 proc scrolltext {f0 f1} {
8514 global searchstring cmitmode ctext
8515 global suppress_highlighting_file_for_this_scrollpos
8517 set topidx [$ctext index @0,0]
8518 if {![info exists suppress_highlighting_file_for_this_scrollpos]
8519 || $topidx ne $suppress_highlighting_file_for_this_scrollpos} {
8520 highlightfile_for_scrollpos $topidx
8523 unset -nocomplain suppress_highlighting_file_for_this_scrollpos
8525 .bleft.bottom.sb set $f0 $f1
8526 if {$searchstring ne {}} {
8532 global linespc charspc canvx0 canvy0
8533 global xspc1 xspc2 lthickness
8535 set linespc [font metrics mainfont -linespace]
8536 set charspc [font measure mainfont "m"]
8537 set canvy0 [expr {int(3 + 0.5 * $linespc)}]
8538 set canvx0 [expr {int(3 + 0.5 * $linespc)}]
8539 set lthickness [expr {int($linespc / 9) + 1}]
8540 set xspc1(0) $linespc
8548 set ymax [lindex [$canv cget -scrollregion] 3]
8549 if {$ymax eq {} || $ymax == 0} return
8550 set span [$canv yview]
8553 allcanvs yview moveto [lindex $span 0]
8555 if {$selectedline ne {}} {
8556 selectline $selectedline 0
8557 allcanvs yview moveto [lindex $span 0]
8561 proc parsefont {f n} {
8564 set fontattr($f,family) [lindex $n 0]
8566 if {$s eq {} || $s == 0} {
8569 set s [expr {int(-$s / [winfo fpixels . 1p] + 0.5)}]
8571 set fontattr($f,size) $s
8572 set fontattr($f,weight) normal
8573 set fontattr($f,slant) roman
8574 foreach style [lrange $n 2 end] {
8577 "bold" {set fontattr($f,weight) $style}
8579 "italic" {set fontattr($f,slant) $style}
8584 proc fontflags {f {isbold 0}} {
8587 return [list -family $fontattr($f,family) -size $fontattr($f,size) \
8588 -weight [expr {$isbold? "bold": $fontattr($f,weight)}] \
8589 -slant $fontattr($f,slant)]
8595 set n [list $fontattr($f,family) $fontattr($f,size)]
8596 if {$fontattr($f,weight) eq "bold"} {
8599 if {$fontattr($f,slant) eq "italic"} {
8605 proc incrfont {inc} {
8606 global mainfont textfont ctext canv cflist showrefstop
8607 global stopped entries fontattr
8610 set s $fontattr(mainfont,size)
8615 set fontattr(mainfont,size) $s
8616 font config mainfont -size $s
8617 font config mainfontbold -size $s
8618 set mainfont [fontname mainfont]
8619 set s $fontattr(textfont,size)
8624 set fontattr(textfont,size) $s
8625 font config textfont -size $s
8626 font config textfontbold -size $s
8627 set textfont [fontname textfont]
8634 global sha1entry sha1string
8635 if {[string length $sha1string] == 40} {
8636 $sha1entry delete 0 end
8640 proc sha1change {n1 n2 op} {
8641 global sha1string currentid sha1but
8642 if {$sha1string == {}
8643 || ([info exists currentid] && $sha1string == $currentid)} {
8648 if {[$sha1but cget -state] == $state} return
8649 if {$state == "normal"} {
8650 $sha1but conf -state normal -relief raised -text "[mc "Goto:"] "
8652 $sha1but conf -state disabled -relief flat -text "[mc "SHA1 ID:"] "
8656 proc gotocommit {} {
8657 global sha1string tagids headids curview varcid
8659 if {$sha1string == {}
8660 || ([info exists currentid] && $sha1string == $currentid)} return
8661 if {[info exists tagids($sha1string)]} {
8662 set id $tagids($sha1string)
8663 } elseif {[info exists headids($sha1string)]} {
8664 set id $headids($sha1string)
8666 set id [string tolower $sha1string]
8667 if {[regexp {^[0-9a-f]{4,39}$} $id]} {
8668 set matches [longid $id]
8669 if {$matches ne {}} {
8670 if {[llength $matches] > 1} {
8671 error_popup [mc "Short SHA1 id %s is ambiguous" $id]
8674 set id [lindex $matches 0]
8677 if {[catch {set id [exec git rev-parse --verify $sha1string]}]} {
8678 error_popup [mc "Revision %s is not known" $sha1string]
8683 if {[commitinview $id $curview]} {
8684 selectline [rowofcommit $id] 1
8687 if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
8688 set msg [mc "SHA1 id %s is not known" $sha1string]
8690 set msg [mc "Revision %s is not in the current view" $sha1string]
8695 proc lineenter {x y id} {
8696 global hoverx hovery hoverid hovertimer
8697 global commitinfo canv
8699 if {![info exists commitinfo($id)] && ![getcommit $id]} return
8703 if {[info exists hovertimer]} {
8704 after cancel $hovertimer
8706 set hovertimer [after 500 linehover]
8710 proc linemotion {x y id} {
8711 global hoverx hovery hoverid hovertimer
8713 if {[info exists hoverid] && $id == $hoverid} {
8716 if {[info exists hovertimer]} {
8717 after cancel $hovertimer
8719 set hovertimer [after 500 linehover]
8723 proc lineleave {id} {
8724 global hoverid hovertimer canv
8726 if {[info exists hoverid] && $id == $hoverid} {
8728 if {[info exists hovertimer]} {
8729 after cancel $hovertimer
8737 global hoverx hovery hoverid hovertimer
8738 global canv linespc lthickness
8739 global linehoverbgcolor linehoverfgcolor linehoveroutlinecolor
8743 set text [lindex $commitinfo($hoverid) 0]
8744 set ymax [lindex [$canv cget -scrollregion] 3]
8745 if {$ymax == {}} return
8746 set yfrac [lindex [$canv yview] 0]
8747 set x [expr {$hoverx + 2 * $linespc}]
8748 set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
8749 set x0 [expr {$x - 2 * $lthickness}]
8750 set y0 [expr {$y - 2 * $lthickness}]
8751 set x1 [expr {$x + [font measure mainfont $text] + 2 * $lthickness}]
8752 set y1 [expr {$y + $linespc + 2 * $lthickness}]
8753 set t [$canv create rectangle $x0 $y0 $x1 $y1 \
8754 -fill $linehoverbgcolor -outline $linehoveroutlinecolor \
8755 -width 1 -tags hover]
8757 set t [$canv create text $x $y -anchor nw -text $text -tags hover \
8758 -font mainfont -fill $linehoverfgcolor]
8762 proc clickisonarrow {id y} {
8765 set ranges [rowranges $id]
8766 set thresh [expr {2 * $lthickness + 6}]
8767 set n [expr {[llength $ranges] - 1}]
8768 for {set i 1} {$i < $n} {incr i} {
8769 set row [lindex $ranges $i]
8770 if {abs([yc $row] - $y) < $thresh} {
8777 proc arrowjump {id n y} {
8780 # 1 <-> 2, 3 <-> 4, etc...
8781 set n [expr {(($n - 1) ^ 1) + 1}]
8782 set row [lindex [rowranges $id] $n]
8784 set ymax [lindex [$canv cget -scrollregion] 3]
8785 if {$ymax eq {} || $ymax <= 0} return
8786 set view [$canv yview]
8787 set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
8788 set yfrac [expr {$yt / $ymax - $yspan / 2}]
8792 allcanvs yview moveto $yfrac
8795 proc lineclick {x y id isnew} {
8796 global ctext commitinfo children canv thickerline curview
8798 if {![info exists commitinfo($id)] && ![getcommit $id]} return
8803 # draw this line thicker than normal
8807 set ymax [lindex [$canv cget -scrollregion] 3]
8808 if {$ymax eq {}} return
8809 set yfrac [lindex [$canv yview] 0]
8810 set y [expr {$y + $yfrac * $ymax}]
8812 set dirn [clickisonarrow $id $y]
8814 arrowjump $id $dirn $y
8819 addtohistory [list lineclick $x $y $id 0] savectextpos
8821 # fill the details pane with info about this line
8822 $ctext conf -state normal
8825 $ctext insert end "[mc "Parent"]:\t"
8826 $ctext insert end $id link0
8828 set info $commitinfo($id)
8829 $ctext insert end "\n\t[lindex $info 0]\n"
8830 $ctext insert end "\t[mc "Author"]:\t[lindex $info 1]\n"
8831 set date [formatdate [lindex $info 2]]
8832 $ctext insert end "\t[mc "Date"]:\t$date\n"
8833 set kids $children($curview,$id)
8835 $ctext insert end "\n[mc "Children"]:"
8837 foreach child $kids {
8839 if {![info exists commitinfo($child)] && ![getcommit $child]} continue
8840 set info $commitinfo($child)
8841 $ctext insert end "\n\t"
8842 $ctext insert end $child link$i
8843 setlink $child link$i
8844 $ctext insert end "\n\t[lindex $info 0]"
8845 $ctext insert end "\n\t[mc "Author"]:\t[lindex $info 1]"
8846 set date [formatdate [lindex $info 2]]
8847 $ctext insert end "\n\t[mc "Date"]:\t$date\n"
8850 maybe_scroll_ctext 1
8851 $ctext conf -state disabled
8855 proc normalline {} {
8857 if {[info exists thickerline]} {
8864 proc selbyid {id {isnew 1}} {
8866 if {[commitinview $id $curview]} {
8867 selectline [rowofcommit $id] $isnew
8873 if {![info exists startmstime]} {
8874 set startmstime [clock clicks -milliseconds]
8876 return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
8879 proc rowmenu {x y id} {
8880 global rowctxmenu selectedline rowmenuid curview
8881 global nullid nullid2 fakerowmenu mainhead markedid
8885 if {$selectedline eq {} || [rowofcommit $id] eq $selectedline} {
8890 if {[info exists markedid] && $markedid ne $id} {
8895 if {$id ne $nullid && $id ne $nullid2} {
8896 set menu $rowctxmenu
8897 if {$mainhead ne {}} {
8898 $menu entryconfigure 7 -label [mc "Reset %s branch to here" $mainhead] -state normal
8900 $menu entryconfigure 7 -label [mc "Detached head: can't reset" $mainhead] -state disabled
8902 $menu entryconfigure 9 -state $mstate
8903 $menu entryconfigure 10 -state $mstate
8904 $menu entryconfigure 11 -state $mstate
8906 set menu $fakerowmenu
8908 $menu entryconfigure [mca "Diff this -> selected"] -state $state
8909 $menu entryconfigure [mca "Diff selected -> this"] -state $state
8910 $menu entryconfigure [mca "Make patch"] -state $state
8911 $menu entryconfigure [mca "Diff this -> marked commit"] -state $mstate
8912 $menu entryconfigure [mca "Diff marked commit -> this"] -state $mstate
8913 tk_popup $menu $x $y
8917 global rowmenuid markedid canv
8919 set markedid $rowmenuid
8920 make_idmark $markedid
8926 if {[info exists markedid]} {
8931 proc replace_by_kids {l r} {
8932 global curview children
8934 set id [commitonrow $r]
8935 set l [lreplace $l 0 0]
8936 foreach kid $children($curview,$id) {
8937 lappend l [rowofcommit $kid]
8939 return [lsort -integer -decreasing -unique $l]
8942 proc find_common_desc {} {
8943 global markedid rowmenuid curview children
8945 if {![info exists markedid]} return
8946 if {![commitinview $markedid $curview] ||
8947 ![commitinview $rowmenuid $curview]} return
8948 #set t1 [clock clicks -milliseconds]
8949 set l1 [list [rowofcommit $markedid]]
8950 set l2 [list [rowofcommit $rowmenuid]]
8952 set r1 [lindex $l1 0]
8953 set r2 [lindex $l2 0]
8954 if {$r1 eq {} || $r2 eq {}} break
8960 set l1 [replace_by_kids $l1 $r1]
8962 set l2 [replace_by_kids $l2 $r2]
8965 #set t2 [clock clicks -milliseconds]
8966 #puts "took [expr {$t2-$t1}]ms"
8969 proc compare_commits {} {
8970 global markedid rowmenuid curview children
8972 if {![info exists markedid]} return
8973 if {![commitinview $markedid $curview]} return
8974 addtohistory [list do_cmp_commits $markedid $rowmenuid]
8975 do_cmp_commits $markedid $rowmenuid
8978 proc getpatchid {id} {
8981 if {![info exists patchids($id)]} {
8982 set cmd [diffcmd [list $id] {-p --root}]
8983 # trim off the initial "|"
8984 set cmd [lrange $cmd 1 end]
8986 set x [eval exec $cmd | git patch-id]
8987 set patchids($id) [lindex $x 0]
8989 set patchids($id) "error"
8992 return $patchids($id)
8995 proc do_cmp_commits {a b} {
8996 global ctext curview parents children patchids commitinfo
8998 $ctext conf -state normal
9001 for {set i 0} {$i < 100} {incr i} {
9004 if {[llength $parents($curview,$a)] > 1} {
9005 appendshortlink $a [mc "Skipping merge commit "] "\n"
9008 set patcha [getpatchid $a]
9010 if {[llength $parents($curview,$b)] > 1} {
9011 appendshortlink $b [mc "Skipping merge commit "] "\n"
9014 set patchb [getpatchid $b]
9016 if {!$skipa && !$skipb} {
9017 set heada [lindex $commitinfo($a) 0]
9018 set headb [lindex $commitinfo($b) 0]
9019 if {$patcha eq "error"} {
9020 appendshortlink $a [mc "Error getting patch ID for "] \
9021 [mc " - stopping\n"]
9024 if {$patchb eq "error"} {
9025 appendshortlink $b [mc "Error getting patch ID for "] \
9026 [mc " - stopping\n"]
9029 if {$patcha eq $patchb} {
9030 if {$heada eq $headb} {
9031 appendshortlink $a [mc "Commit "]
9032 appendshortlink $b " == " " $heada\n"
9034 appendshortlink $a [mc "Commit "] " $heada\n"
9035 appendshortlink $b [mc " is the same patch as\n "] \
9041 $ctext insert end "\n"
9042 appendshortlink $a [mc "Commit "] " $heada\n"
9043 appendshortlink $b [mc " differs from\n "] \
9045 $ctext insert end [mc "Diff of commits:\n\n"]
9046 $ctext conf -state disabled
9053 set kids [real_children $curview,$a]
9054 if {[llength $kids] != 1} {
9055 $ctext insert end "\n"
9056 appendshortlink $a [mc "Commit "] \
9057 [mc " has %s children - stopping\n" [llength $kids]]
9060 set a [lindex $kids 0]
9063 set kids [real_children $curview,$b]
9064 if {[llength $kids] != 1} {
9065 appendshortlink $b [mc "Commit "] \
9066 [mc " has %s children - stopping\n" [llength $kids]]
9069 set b [lindex $kids 0]
9072 $ctext conf -state disabled
9075 proc diffcommits {a b} {
9076 global diffcontext diffids blobdifffd diffinhdr currdiffsubmod
9078 set tmpdir [gitknewtmpdir]
9079 set fna [file join $tmpdir "commit-[string range $a 0 7]"]
9080 set fnb [file join $tmpdir "commit-[string range $b 0 7]"]
9082 exec git diff-tree -p --pretty $a >$fna
9083 exec git diff-tree -p --pretty $b >$fnb
9085 error_popup [mc "Error writing commit to file: %s" $err]
9089 set fd [open "| diff -U$diffcontext $fna $fnb" r]
9091 error_popup [mc "Error diffing commits: %s" $err]
9094 set diffids [list commits $a $b]
9095 set blobdifffd($diffids) $fd
9097 set currdiffsubmod ""
9098 filerun $fd [list getblobdiffline $fd $diffids]
9101 proc diffvssel {dirn} {
9102 global rowmenuid selectedline
9104 if {$selectedline eq {}} return
9106 set oldid [commitonrow $selectedline]
9107 set newid $rowmenuid
9109 set oldid $rowmenuid
9110 set newid [commitonrow $selectedline]
9112 addtohistory [list doseldiff $oldid $newid] savectextpos
9113 doseldiff $oldid $newid
9116 proc diffvsmark {dirn} {
9117 global rowmenuid markedid
9119 if {![info exists markedid]} return
9122 set newid $rowmenuid
9124 set oldid $rowmenuid
9127 addtohistory [list doseldiff $oldid $newid] savectextpos
9128 doseldiff $oldid $newid
9131 proc doseldiff {oldid newid} {
9135 $ctext conf -state normal
9137 init_flist [mc "Top"]
9138 $ctext insert end "[mc "From"] "
9139 $ctext insert end $oldid link0
9140 setlink $oldid link0
9141 $ctext insert end "\n "
9142 $ctext insert end [lindex $commitinfo($oldid) 0]
9143 $ctext insert end "\n\n[mc "To"] "
9144 $ctext insert end $newid link1
9145 setlink $newid link1
9146 $ctext insert end "\n "
9147 $ctext insert end [lindex $commitinfo($newid) 0]
9148 $ctext insert end "\n"
9149 $ctext conf -state disabled
9150 $ctext tag remove found 1.0 end
9151 startdiff [list $oldid $newid]
9155 global rowmenuid currentid commitinfo patchtop patchnum NS
9157 if {![info exists currentid]} return
9158 set oldid $currentid
9159 set oldhead [lindex $commitinfo($oldid) 0]
9160 set newid $rowmenuid
9161 set newhead [lindex $commitinfo($newid) 0]
9164 catch {destroy $top}
9166 make_transient $top .
9167 ${NS}::label $top.title -text [mc "Generate patch"]
9168 grid $top.title - -pady 10
9169 ${NS}::label $top.from -text [mc "From:"]
9170 ${NS}::entry $top.fromsha1 -width 40
9171 $top.fromsha1 insert 0 $oldid
9172 $top.fromsha1 conf -state readonly
9173 grid $top.from $top.fromsha1 -sticky w
9174 ${NS}::entry $top.fromhead -width 60
9175 $top.fromhead insert 0 $oldhead
9176 $top.fromhead conf -state readonly
9177 grid x $top.fromhead -sticky w
9178 ${NS}::label $top.to -text [mc "To:"]
9179 ${NS}::entry $top.tosha1 -width 40
9180 $top.tosha1 insert 0 $newid
9181 $top.tosha1 conf -state readonly
9182 grid $top.to $top.tosha1 -sticky w
9183 ${NS}::entry $top.tohead -width 60
9184 $top.tohead insert 0 $newhead
9185 $top.tohead conf -state readonly
9186 grid x $top.tohead -sticky w
9187 ${NS}::button $top.rev -text [mc "Reverse"] -command mkpatchrev
9188 grid $top.rev x -pady 10 -padx 5
9189 ${NS}::label $top.flab -text [mc "Output file:"]
9190 ${NS}::entry $top.fname -width 60
9191 $top.fname insert 0 [file normalize "patch$patchnum.patch"]
9193 grid $top.flab $top.fname -sticky w
9194 ${NS}::frame $top.buts
9195 ${NS}::button $top.buts.gen -text [mc "Generate"] -command mkpatchgo
9196 ${NS}::button $top.buts.can -text [mc "Cancel"] -command mkpatchcan
9197 bind $top <Key-Return> mkpatchgo
9198 bind $top <Key-Escape> mkpatchcan
9199 grid $top.buts.gen $top.buts.can
9200 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9201 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9202 grid $top.buts - -pady 10 -sticky ew
9206 proc mkpatchrev {} {
9209 set oldid [$patchtop.fromsha1 get]
9210 set oldhead [$patchtop.fromhead get]
9211 set newid [$patchtop.tosha1 get]
9212 set newhead [$patchtop.tohead get]
9213 foreach e [list fromsha1 fromhead tosha1 tohead] \
9214 v [list $newid $newhead $oldid $oldhead] {
9215 $patchtop.$e conf -state normal
9216 $patchtop.$e delete 0 end
9217 $patchtop.$e insert 0 $v
9218 $patchtop.$e conf -state readonly
9223 global patchtop nullid nullid2
9225 set oldid [$patchtop.fromsha1 get]
9226 set newid [$patchtop.tosha1 get]
9227 set fname [$patchtop.fname get]
9228 set cmd [diffcmd [list $oldid $newid] -p]
9229 # trim off the initial "|"
9230 set cmd [lrange $cmd 1 end]
9231 lappend cmd >$fname &
9232 if {[catch {eval exec $cmd} err]} {
9233 error_popup "[mc "Error creating patch:"] $err" $patchtop
9235 catch {destroy $patchtop}
9239 proc mkpatchcan {} {
9242 catch {destroy $patchtop}
9247 global rowmenuid mktagtop commitinfo NS
9251 catch {destroy $top}
9253 make_transient $top .
9254 ${NS}::label $top.title -text [mc "Create tag"]
9255 grid $top.title - -pady 10
9256 ${NS}::label $top.id -text [mc "ID:"]
9257 ${NS}::entry $top.sha1 -width 40
9258 $top.sha1 insert 0 $rowmenuid
9259 $top.sha1 conf -state readonly
9260 grid $top.id $top.sha1 -sticky w
9261 ${NS}::entry $top.head -width 60
9262 $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
9263 $top.head conf -state readonly
9264 grid x $top.head -sticky w
9265 ${NS}::label $top.tlab -text [mc "Tag name:"]
9266 ${NS}::entry $top.tag -width 60
9267 grid $top.tlab $top.tag -sticky w
9268 ${NS}::label $top.op -text [mc "Tag message is optional"]
9269 grid $top.op -columnspan 2 -sticky we
9270 ${NS}::label $top.mlab -text [mc "Tag message:"]
9271 ${NS}::entry $top.msg -width 60
9272 grid $top.mlab $top.msg -sticky w
9273 ${NS}::frame $top.buts
9274 ${NS}::button $top.buts.gen -text [mc "Create"] -command mktaggo
9275 ${NS}::button $top.buts.can -text [mc "Cancel"] -command mktagcan
9276 bind $top <Key-Return> mktaggo
9277 bind $top <Key-Escape> mktagcan
9278 grid $top.buts.gen $top.buts.can
9279 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9280 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9281 grid $top.buts - -pady 10 -sticky ew
9286 global mktagtop env tagids idtags
9288 set id [$mktagtop.sha1 get]
9289 set tag [$mktagtop.tag get]
9290 set msg [$mktagtop.msg get]
9292 error_popup [mc "No tag name specified"] $mktagtop
9295 if {[info exists tagids($tag)]} {
9296 error_popup [mc "Tag \"%s\" already exists" $tag] $mktagtop
9301 exec git tag -a -m $msg $tag $id
9303 exec git tag $tag $id
9306 error_popup "[mc "Error creating tag:"] $err" $mktagtop
9310 set tagids($tag) $id
9311 lappend idtags($id) $tag
9319 proc redrawtags {id} {
9320 global canv linehtag idpos currentid curview cmitlisted markedid
9321 global canvxmax iddrawn circleitem mainheadid circlecolors
9322 global mainheadcirclecolor
9324 if {![commitinview $id $curview]} return
9325 if {![info exists iddrawn($id)]} return
9326 set row [rowofcommit $id]
9327 if {$id eq $mainheadid} {
9328 set ofill $mainheadcirclecolor
9330 set ofill [lindex $circlecolors $cmitlisted($curview,$id)]
9332 $canv itemconf $circleitem($row) -fill $ofill
9333 $canv delete tag.$id
9334 set xt [eval drawtags $id $idpos($id)]
9335 $canv coords $linehtag($id) $xt [lindex $idpos($id) 2]
9336 set text [$canv itemcget $linehtag($id) -text]
9337 set font [$canv itemcget $linehtag($id) -font]
9338 set xr [expr {$xt + [font measure $font $text]}]
9339 if {$xr > $canvxmax} {
9343 if {[info exists currentid] && $currentid == $id} {
9346 if {[info exists markedid] && $markedid eq $id} {
9354 catch {destroy $mktagtop}
9359 if {![domktag]} return
9363 proc writecommit {} {
9364 global rowmenuid wrcomtop commitinfo wrcomcmd NS
9366 set top .writecommit
9368 catch {destroy $top}
9370 make_transient $top .
9371 ${NS}::label $top.title -text [mc "Write commit to file"]
9372 grid $top.title - -pady 10
9373 ${NS}::label $top.id -text [mc "ID:"]
9374 ${NS}::entry $top.sha1 -width 40
9375 $top.sha1 insert 0 $rowmenuid
9376 $top.sha1 conf -state readonly
9377 grid $top.id $top.sha1 -sticky w
9378 ${NS}::entry $top.head -width 60
9379 $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
9380 $top.head conf -state readonly
9381 grid x $top.head -sticky w
9382 ${NS}::label $top.clab -text [mc "Command:"]
9383 ${NS}::entry $top.cmd -width 60 -textvariable wrcomcmd
9384 grid $top.clab $top.cmd -sticky w -pady 10
9385 ${NS}::label $top.flab -text [mc "Output file:"]
9386 ${NS}::entry $top.fname -width 60
9387 $top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
9388 grid $top.flab $top.fname -sticky w
9389 ${NS}::frame $top.buts
9390 ${NS}::button $top.buts.gen -text [mc "Write"] -command wrcomgo
9391 ${NS}::button $top.buts.can -text [mc "Cancel"] -command wrcomcan
9392 bind $top <Key-Return> wrcomgo
9393 bind $top <Key-Escape> wrcomcan
9394 grid $top.buts.gen $top.buts.can
9395 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9396 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9397 grid $top.buts - -pady 10 -sticky ew
9404 set id [$wrcomtop.sha1 get]
9405 set cmd "echo $id | [$wrcomtop.cmd get]"
9406 set fname [$wrcomtop.fname get]
9407 if {[catch {exec sh -c $cmd >$fname &} err]} {
9408 error_popup "[mc "Error writing commit:"] $err" $wrcomtop
9410 catch {destroy $wrcomtop}
9417 catch {destroy $wrcomtop}
9422 global rowmenuid mkbrtop NS
9425 catch {destroy $top}
9427 make_transient $top .
9428 ${NS}::label $top.title -text [mc "Create new branch"]
9429 grid $top.title - -pady 10
9430 ${NS}::label $top.id -text [mc "ID:"]
9431 ${NS}::entry $top.sha1 -width 40
9432 $top.sha1 insert 0 $rowmenuid
9433 $top.sha1 conf -state readonly
9434 grid $top.id $top.sha1 -sticky w
9435 ${NS}::label $top.nlab -text [mc "Name:"]
9436 ${NS}::entry $top.name -width 40
9437 grid $top.nlab $top.name -sticky w
9438 ${NS}::frame $top.buts
9439 ${NS}::button $top.buts.go -text [mc "Create"] -command [list mkbrgo $top]
9440 ${NS}::button $top.buts.can -text [mc "Cancel"] -command "catch {destroy $top}"
9441 bind $top <Key-Return> [list mkbrgo $top]
9442 bind $top <Key-Escape> "catch {destroy $top}"
9443 grid $top.buts.go $top.buts.can
9444 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9445 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9446 grid $top.buts - -pady 10 -sticky ew
9451 global headids idheads
9453 set name [$top.name get]
9454 set id [$top.sha1 get]
9458 error_popup [mc "Please specify a name for the new branch"] $top
9461 if {[info exists headids($name)]} {
9462 if {![confirm_popup [mc \
9463 "Branch '%s' already exists. Overwrite?" $name] $top]} {
9466 set old_id $headids($name)
9469 catch {destroy $top}
9470 lappend cmdargs $name $id
9474 eval exec git branch $cmdargs
9480 if {$old_id ne {}} {
9486 set headids($name) $id
9487 lappend idheads($id) $name
9496 proc exec_citool {tool_args {baseid {}}} {
9497 global commitinfo env
9499 set save_env [array get env GIT_AUTHOR_*]
9501 if {$baseid ne {}} {
9502 if {![info exists commitinfo($baseid)]} {
9505 set author [lindex $commitinfo($baseid) 1]
9506 set date [lindex $commitinfo($baseid) 2]
9507 if {[regexp {^\s*(\S.*\S|\S)\s*<(.*)>\s*$} \
9508 $author author name email]
9510 set env(GIT_AUTHOR_NAME) $name
9511 set env(GIT_AUTHOR_EMAIL) $email
9512 set env(GIT_AUTHOR_DATE) $date
9516 eval exec git citool $tool_args &
9518 array unset env GIT_AUTHOR_*
9519 array set env $save_env
9522 proc cherrypick {} {
9523 global rowmenuid curview
9524 global mainhead mainheadid
9527 set oldhead [exec git rev-parse HEAD]
9528 set dheads [descheads $rowmenuid]
9529 if {$dheads ne {} && [lsearch -exact $dheads $oldhead] >= 0} {
9530 set ok [confirm_popup [mc "Commit %s is already\
9531 included in branch %s -- really re-apply it?" \
9532 [string range $rowmenuid 0 7] $mainhead]]
9535 nowbusy cherrypick [mc "Cherry-picking"]
9537 # Unfortunately git-cherry-pick writes stuff to stderr even when
9538 # no error occurs, and exec takes that as an indication of error...
9539 if {[catch {exec sh -c "git cherry-pick -r $rowmenuid 2>&1"} err]} {
9542 {Entry '(.*)' (would be overwritten by merge|not uptodate)} \
9544 error_popup [mc "Cherry-pick failed because of local changes\
9545 to file '%s'.\nPlease commit, reset or stash\
9546 your changes and try again." $fname]
9547 } elseif {[regexp -line \
9548 {^(CONFLICT \(.*\):|Automatic cherry-pick failed|error: could not apply)} \
9550 if {[confirm_popup [mc "Cherry-pick failed because of merge\
9551 conflict.\nDo you wish to run git citool to\
9553 # Force citool to read MERGE_MSG
9554 file delete [file join $gitdir "GITGUI_MSG"]
9555 exec_citool {} $rowmenuid
9563 set newhead [exec git rev-parse HEAD]
9564 if {$newhead eq $oldhead} {
9566 error_popup [mc "No changes committed"]
9569 addnewchild $newhead $oldhead
9570 if {[commitinview $oldhead $curview]} {
9571 # XXX this isn't right if we have a path limit...
9572 insertrow $newhead $oldhead $curview
9573 if {$mainhead ne {}} {
9574 movehead $newhead $mainhead
9575 movedhead $newhead $mainhead
9577 set mainheadid $newhead
9586 global rowmenuid curview
9587 global mainhead mainheadid
9590 set oldhead [exec git rev-parse HEAD]
9591 set dheads [descheads $rowmenuid]
9592 if { $dheads eq {} || [lsearch -exact $dheads $oldhead] == -1 } {
9593 set ok [confirm_popup [mc "Commit %s is not\
9594 included in branch %s -- really revert it?" \
9595 [string range $rowmenuid 0 7] $mainhead]]
9598 nowbusy revert [mc "Reverting"]
9601 if [catch {exec git revert --no-edit $rowmenuid} err] {
9603 if [regexp {files would be overwritten by merge:(\n(( |\t)+[^\n]+\n)+)}\
9605 regsub {\n( |\t)+} $files "\n" files
9606 error_popup [mc "Revert failed because of local changes to\
9607 the following files:%s Please commit, reset or stash \
9608 your changes and try again." $files]
9609 } elseif [regexp {error: could not revert} $err] {
9610 if [confirm_popup [mc "Revert failed because of merge conflict.\n\
9611 Do you wish to run git citool to resolve it?"]] {
9612 # Force citool to read MERGE_MSG
9613 file delete [file join $gitdir "GITGUI_MSG"]
9614 exec_citool {} $rowmenuid
9616 } else { error_popup $err }
9621 set newhead [exec git rev-parse HEAD]
9622 if { $newhead eq $oldhead } {
9624 error_popup [mc "No changes committed"]
9628 addnewchild $newhead $oldhead
9630 if [commitinview $oldhead $curview] {
9631 # XXX this isn't right if we have a path limit...
9632 insertrow $newhead $oldhead $curview
9633 if {$mainhead ne {}} {
9634 movehead $newhead $mainhead
9635 movedhead $newhead $mainhead
9637 set mainheadid $newhead
9647 global mainhead rowmenuid confirm_ok resettype NS
9650 set w ".confirmreset"
9653 wm title $w [mc "Confirm reset"]
9654 ${NS}::label $w.m -text \
9655 [mc "Reset branch %s to %s?" $mainhead [string range $rowmenuid 0 7]]
9656 pack $w.m -side top -fill x -padx 20 -pady 20
9657 ${NS}::labelframe $w.f -text [mc "Reset type:"]
9659 ${NS}::radiobutton $w.f.soft -value soft -variable resettype \
9660 -text [mc "Soft: Leave working tree and index untouched"]
9661 grid $w.f.soft -sticky w
9662 ${NS}::radiobutton $w.f.mixed -value mixed -variable resettype \
9663 -text [mc "Mixed: Leave working tree untouched, reset index"]
9664 grid $w.f.mixed -sticky w
9665 ${NS}::radiobutton $w.f.hard -value hard -variable resettype \
9666 -text [mc "Hard: Reset working tree and index\n(discard ALL local changes)"]
9667 grid $w.f.hard -sticky w
9668 pack $w.f -side top -fill x -padx 4
9669 ${NS}::button $w.ok -text [mc OK] -command "set confirm_ok 1; destroy $w"
9670 pack $w.ok -side left -fill x -padx 20 -pady 20
9671 ${NS}::button $w.cancel -text [mc Cancel] -command "destroy $w"
9672 bind $w <Key-Escape> [list destroy $w]
9673 pack $w.cancel -side right -fill x -padx 20 -pady 20
9674 bind $w <Visibility> "grab $w; focus $w"
9676 if {!$confirm_ok} return
9677 if {[catch {set fd [open \
9678 [list | git reset --$resettype $rowmenuid 2>@1] r]} err]} {
9682 filerun $fd [list readresetstat $fd]
9683 nowbusy reset [mc "Resetting"]
9688 proc readresetstat {fd} {
9689 global mainhead mainheadid showlocalchanges rprogcoord
9691 if {[gets $fd line] >= 0} {
9692 if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
9693 set rprogcoord [expr {1.0 * $m / $n}]
9701 if {[catch {close $fd} err]} {
9704 set oldhead $mainheadid
9705 set newhead [exec git rev-parse HEAD]
9706 if {$newhead ne $oldhead} {
9707 movehead $newhead $mainhead
9708 movedhead $newhead $mainhead
9709 set mainheadid $newhead
9713 if {$showlocalchanges} {
9719 # context menu for a head
9720 proc headmenu {x y id head} {
9721 global headmenuid headmenuhead headctxmenu mainhead
9725 set headmenuhead $head
9727 if {[string match "remotes/*" $head]} {
9730 if {$head eq $mainhead} {
9733 $headctxmenu entryconfigure 0 -state $state
9734 $headctxmenu entryconfigure 1 -state $state
9735 tk_popup $headctxmenu $x $y
9739 global headmenuid headmenuhead headids
9740 global showlocalchanges
9742 # check the tree is clean first??
9743 nowbusy checkout [mc "Checking out"]
9747 set fd [open [list | git checkout $headmenuhead 2>@1] r]
9751 if {$showlocalchanges} {
9755 filerun $fd [list readcheckoutstat $fd $headmenuhead $headmenuid]
9759 proc readcheckoutstat {fd newhead newheadid} {
9760 global mainhead mainheadid headids showlocalchanges progresscoords
9761 global viewmainheadid curview
9763 if {[gets $fd line] >= 0} {
9764 if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
9765 set progresscoords [list 0 [expr {1.0 * $m / $n}]]
9770 set progresscoords {0 0}
9773 if {[catch {close $fd} err]} {
9776 set oldmainid $mainheadid
9777 set mainhead $newhead
9778 set mainheadid $newheadid
9779 set viewmainheadid($curview) $newheadid
9780 redrawtags $oldmainid
9781 redrawtags $newheadid
9783 if {$showlocalchanges} {
9789 global headmenuid headmenuhead mainhead
9792 set head $headmenuhead
9794 # this check shouldn't be needed any more...
9795 if {$head eq $mainhead} {
9796 error_popup [mc "Cannot delete the currently checked-out branch"]
9799 set dheads [descheads $id]
9800 if {[llength $dheads] == 1 && $idheads($dheads) eq $head} {
9801 # the stuff on this branch isn't on any other branch
9802 if {![confirm_popup [mc "The commits on branch %s aren't on any other\
9803 branch.\nReally delete branch %s?" $head $head]]} return
9807 if {[catch {exec git branch -D $head} err]} {
9812 removehead $id $head
9813 removedhead $id $head
9820 # Display a list of tags and heads
9822 global showrefstop bgcolor fgcolor selectbgcolor NS
9823 global bglist fglist reflistfilter reflist maincursor
9826 set showrefstop $top
9827 if {[winfo exists $top]} {
9833 wm title $top [mc "Tags and heads: %s" [file tail [pwd]]]
9834 make_transient $top .
9835 text $top.list -background $bgcolor -foreground $fgcolor \
9836 -selectbackground $selectbgcolor -font mainfont \
9837 -xscrollcommand "$top.xsb set" -yscrollcommand "$top.ysb set" \
9838 -width 30 -height 20 -cursor $maincursor \
9839 -spacing1 1 -spacing3 1 -state disabled
9840 $top.list tag configure highlight -background $selectbgcolor
9841 if {![lsearch -exact $bglist $top.list]} {
9842 lappend bglist $top.list
9843 lappend fglist $top.list
9845 ${NS}::scrollbar $top.ysb -command "$top.list yview" -orient vertical
9846 ${NS}::scrollbar $top.xsb -command "$top.list xview" -orient horizontal
9847 grid $top.list $top.ysb -sticky nsew
9848 grid $top.xsb x -sticky ew
9850 ${NS}::label $top.f.l -text "[mc "Filter"]: "
9851 ${NS}::entry $top.f.e -width 20 -textvariable reflistfilter
9852 set reflistfilter "*"
9853 trace add variable reflistfilter write reflistfilter_change
9854 pack $top.f.e -side right -fill x -expand 1
9855 pack $top.f.l -side left
9856 grid $top.f - -sticky ew -pady 2
9857 ${NS}::button $top.close -command [list destroy $top] -text [mc "Close"]
9858 bind $top <Key-Escape> [list destroy $top]
9860 grid columnconfigure $top 0 -weight 1
9861 grid rowconfigure $top 0 -weight 1
9862 bind $top.list <1> {break}
9863 bind $top.list <B1-Motion> {break}
9864 bind $top.list <ButtonRelease-1> {sel_reflist %W %x %y; break}
9869 proc sel_reflist {w x y} {
9870 global showrefstop reflist headids tagids otherrefids
9872 if {![winfo exists $showrefstop]} return
9873 set l [lindex [split [$w index "@$x,$y"] "."] 0]
9874 set ref [lindex $reflist [expr {$l-1}]]
9875 set n [lindex $ref 0]
9876 switch -- [lindex $ref 1] {
9877 "H" {selbyid $headids($n)}
9878 "T" {selbyid $tagids($n)}
9879 "o" {selbyid $otherrefids($n)}
9881 $showrefstop.list tag add highlight $l.0 "$l.0 lineend"
9884 proc unsel_reflist {} {
9887 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
9888 $showrefstop.list tag remove highlight 0.0 end
9891 proc reflistfilter_change {n1 n2 op} {
9892 global reflistfilter
9894 after cancel refill_reflist
9895 after 200 refill_reflist
9898 proc refill_reflist {} {
9899 global reflist reflistfilter showrefstop headids tagids otherrefids
9902 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
9904 foreach n [array names headids] {
9905 if {[string match $reflistfilter $n]} {
9906 if {[commitinview $headids($n) $curview]} {
9907 lappend refs [list $n H]
9909 interestedin $headids($n) {run refill_reflist}
9913 foreach n [array names tagids] {
9914 if {[string match $reflistfilter $n]} {
9915 if {[commitinview $tagids($n) $curview]} {
9916 lappend refs [list $n T]
9918 interestedin $tagids($n) {run refill_reflist}
9922 foreach n [array names otherrefids] {
9923 if {[string match $reflistfilter $n]} {
9924 if {[commitinview $otherrefids($n) $curview]} {
9925 lappend refs [list $n o]
9927 interestedin $otherrefids($n) {run refill_reflist}
9931 set refs [lsort -index 0 $refs]
9932 if {$refs eq $reflist} return
9934 # Update the contents of $showrefstop.list according to the
9935 # differences between $reflist (old) and $refs (new)
9936 $showrefstop.list conf -state normal
9937 $showrefstop.list insert end "\n"
9940 while {$i < [llength $reflist] || $j < [llength $refs]} {
9941 if {$i < [llength $reflist]} {
9942 if {$j < [llength $refs]} {
9943 set cmp [string compare [lindex $reflist $i 0] \
9944 [lindex $refs $j 0]]
9946 set cmp [string compare [lindex $reflist $i 1] \
9947 [lindex $refs $j 1]]
9957 $showrefstop.list delete "[expr {$j+1}].0" "[expr {$j+2}].0"
9965 set l [expr {$j + 1}]
9966 $showrefstop.list image create $l.0 -align baseline \
9967 -image reficon-[lindex $refs $j 1] -padx 2
9968 $showrefstop.list insert $l.1 "[lindex $refs $j 0]\n"
9974 # delete last newline
9975 $showrefstop.list delete end-2c end-1c
9976 $showrefstop.list conf -state disabled
9979 # Stuff for finding nearby tags
9980 proc getallcommits {} {
9981 global allcommits nextarc seeds allccache allcwait cachedarcs allcupdate
9982 global idheads idtags idotherrefs allparents tagobjid
9985 if {![info exists allcommits]} {
9991 set allccache [file join $gitdir "gitk.cache"]
9993 set f [open $allccache r]
10002 set cmd [list | git rev-list --parents]
10003 set allcupdate [expr {$seeds ne {}}]
10004 if {!$allcupdate} {
10007 set refs [concat [array names idheads] [array names idtags] \
10008 [array names idotherrefs]]
10011 foreach name [array names tagobjid] {
10012 lappend tagobjs $tagobjid($name)
10014 foreach id [lsort -unique $refs] {
10015 if {![info exists allparents($id)] &&
10016 [lsearch -exact $tagobjs $id] < 0} {
10021 foreach id $seeds {
10027 set fd [open [concat $cmd $ids] r]
10028 fconfigure $fd -blocking 0
10031 filerun $fd [list getallclines $fd]
10037 # Since most commits have 1 parent and 1 child, we group strings of
10038 # such commits into "arcs" joining branch/merge points (BMPs), which
10039 # are commits that either don't have 1 parent or don't have 1 child.
10041 # arcnos(id) - incoming arcs for BMP, arc we're on for other nodes
10042 # arcout(id) - outgoing arcs for BMP
10043 # arcids(a) - list of IDs on arc including end but not start
10044 # arcstart(a) - BMP ID at start of arc
10045 # arcend(a) - BMP ID at end of arc
10046 # growing(a) - arc a is still growing
10047 # arctags(a) - IDs out of arcids (excluding end) that have tags
10048 # archeads(a) - IDs out of arcids (excluding end) that have heads
10049 # The start of an arc is at the descendent end, so "incoming" means
10050 # coming from descendents, and "outgoing" means going towards ancestors.
10052 proc getallclines {fd} {
10053 global allparents allchildren idtags idheads nextarc
10054 global arcnos arcids arctags arcout arcend arcstart archeads growing
10055 global seeds allcommits cachedarcs allcupdate
10058 while {[incr nid] <= 1000 && [gets $fd line] >= 0} {
10059 set id [lindex $line 0]
10060 if {[info exists allparents($id)]} {
10065 set olds [lrange $line 1 end]
10066 set allparents($id) $olds
10067 if {![info exists allchildren($id)]} {
10068 set allchildren($id) {}
10073 if {[llength $olds] == 1 && [llength $a] == 1} {
10074 lappend arcids($a) $id
10075 if {[info exists idtags($id)]} {
10076 lappend arctags($a) $id
10078 if {[info exists idheads($id)]} {
10079 lappend archeads($a) $id
10081 if {[info exists allparents($olds)]} {
10082 # seen parent already
10083 if {![info exists arcout($olds)]} {
10086 lappend arcids($a) $olds
10087 set arcend($a) $olds
10090 lappend allchildren($olds) $id
10091 lappend arcnos($olds) $a
10095 foreach a $arcnos($id) {
10096 lappend arcids($a) $id
10103 lappend allchildren($p) $id
10104 set a [incr nextarc]
10105 set arcstart($a) $id
10106 set archeads($a) {}
10108 set archeads($a) {}
10112 if {[info exists allparents($p)]} {
10113 # seen it already, may need to make a new branch
10114 if {![info exists arcout($p)]} {
10117 lappend arcids($a) $p
10121 lappend arcnos($p) $a
10123 set arcout($id) $ao
10126 global cached_dheads cached_dtags cached_atags
10127 unset -nocomplain cached_dheads
10128 unset -nocomplain cached_dtags
10129 unset -nocomplain cached_atags
10132 return [expr {$nid >= 1000? 2: 1}]
10136 fconfigure $fd -blocking 1
10139 # got an error reading the list of commits
10140 # if we were updating, try rereading the whole thing again
10146 error_popup "[mc "Error reading commit topology information;\
10147 branch and preceding/following tag information\
10148 will be incomplete."]\n($err)"
10151 if {[incr allcommits -1] == 0} {
10161 proc recalcarc {a} {
10162 global arctags archeads arcids idtags idheads
10166 foreach id [lrange $arcids($a) 0 end-1] {
10167 if {[info exists idtags($id)]} {
10170 if {[info exists idheads($id)]} {
10174 set arctags($a) $at
10175 set archeads($a) $ah
10178 proc splitarc {p} {
10179 global arcnos arcids nextarc arctags archeads idtags idheads
10180 global arcstart arcend arcout allparents growing
10183 if {[llength $a] != 1} {
10184 puts "oops splitarc called but [llength $a] arcs already"
10187 set a [lindex $a 0]
10188 set i [lsearch -exact $arcids($a) $p]
10190 puts "oops splitarc $p not in arc $a"
10193 set na [incr nextarc]
10194 if {[info exists arcend($a)]} {
10195 set arcend($na) $arcend($a)
10197 set l [lindex $allparents([lindex $arcids($a) end]) 0]
10198 set j [lsearch -exact $arcnos($l) $a]
10199 set arcnos($l) [lreplace $arcnos($l) $j $j $na]
10201 set tail [lrange $arcids($a) [expr {$i+1}] end]
10202 set arcids($a) [lrange $arcids($a) 0 $i]
10204 set arcstart($na) $p
10206 set arcids($na) $tail
10207 if {[info exists growing($a)]} {
10213 if {[llength $arcnos($id)] == 1} {
10214 set arcnos($id) $na
10216 set j [lsearch -exact $arcnos($id) $a]
10217 set arcnos($id) [lreplace $arcnos($id) $j $j $na]
10221 # reconstruct tags and heads lists
10222 if {$arctags($a) ne {} || $archeads($a) ne {}} {
10226 set arctags($na) {}
10227 set archeads($na) {}
10231 # Update things for a new commit added that is a child of one
10232 # existing commit. Used when cherry-picking.
10233 proc addnewchild {id p} {
10234 global allparents allchildren idtags nextarc
10235 global arcnos arcids arctags arcout arcend arcstart archeads growing
10236 global seeds allcommits
10238 if {![info exists allcommits] || ![info exists arcnos($p)]} return
10239 set allparents($id) [list $p]
10240 set allchildren($id) {}
10243 lappend allchildren($p) $id
10244 set a [incr nextarc]
10245 set arcstart($a) $id
10246 set archeads($a) {}
10248 set arcids($a) [list $p]
10250 if {![info exists arcout($p)]} {
10253 lappend arcnos($p) $a
10254 set arcout($id) [list $a]
10257 # This implements a cache for the topology information.
10258 # The cache saves, for each arc, the start and end of the arc,
10259 # the ids on the arc, and the outgoing arcs from the end.
10260 proc readcache {f} {
10261 global arcnos arcids arcout arcstart arcend arctags archeads nextarc
10262 global idtags idheads allparents cachedarcs possible_seeds seeds growing
10266 set lim $cachedarcs
10267 if {$lim - $a > 500} {
10268 set lim [expr {$a + 500}]
10272 # finish reading the cache and setting up arctags, etc.
10274 if {$line ne "1"} {error "bad final version"}
10276 foreach id [array names idtags] {
10277 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
10278 [llength $allparents($id)] == 1} {
10279 set a [lindex $arcnos($id) 0]
10280 if {$arctags($a) eq {}} {
10285 foreach id [array names idheads] {
10286 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
10287 [llength $allparents($id)] == 1} {
10288 set a [lindex $arcnos($id) 0]
10289 if {$archeads($a) eq {}} {
10294 foreach id [lsort -unique $possible_seeds] {
10295 if {$arcnos($id) eq {}} {
10301 while {[incr a] <= $lim} {
10303 if {[llength $line] != 3} {error "bad line"}
10304 set s [lindex $line 0]
10305 set arcstart($a) $s
10306 lappend arcout($s) $a
10307 if {![info exists arcnos($s)]} {
10308 lappend possible_seeds $s
10311 set e [lindex $line 1]
10316 if {![info exists arcout($e)]} {
10320 set arcids($a) [lindex $line 2]
10321 foreach id $arcids($a) {
10322 lappend allparents($s) $id
10324 lappend arcnos($id) $a
10326 if {![info exists allparents($s)]} {
10327 set allparents($s) {}
10330 set archeads($a) {}
10332 set nextarc [expr {$a - 1}]
10344 proc getcache {f} {
10345 global nextarc cachedarcs possible_seeds
10349 if {[llength $line] != 2 || [lindex $line 0] ne "1"} {error "bad version"}
10350 # make sure it's an integer
10351 set cachedarcs [expr {int([lindex $line 1])}]
10352 if {$cachedarcs < 0} {error "bad number of arcs"}
10354 set possible_seeds {}
10362 proc dropcache {err} {
10363 global allcwait nextarc cachedarcs seeds
10365 #puts "dropping cache ($err)"
10366 foreach v {arcnos arcout arcids arcstart arcend growing \
10367 arctags archeads allparents allchildren} {
10369 unset -nocomplain $v
10378 proc writecache {f} {
10379 global cachearc cachedarcs allccache
10380 global arcstart arcend arcnos arcids arcout
10383 set lim $cachedarcs
10384 if {$lim - $a > 1000} {
10385 set lim [expr {$a + 1000}]
10388 while {[incr a] <= $lim} {
10389 if {[info exists arcend($a)]} {
10390 puts $f [list $arcstart($a) $arcend($a) $arcids($a)]
10392 puts $f [list $arcstart($a) {} $arcids($a)]
10397 catch {file delete $allccache}
10398 #puts "writing cache failed ($err)"
10401 set cachearc [expr {$a - 1}]
10402 if {$a > $cachedarcs} {
10410 proc savecache {} {
10411 global nextarc cachedarcs cachearc allccache
10413 if {$nextarc == $cachedarcs} return
10415 set cachedarcs $nextarc
10417 set f [open $allccache w]
10418 puts $f [list 1 $cachedarcs]
10423 # Returns 1 if a is an ancestor of b, -1 if b is an ancestor of a,
10424 # or 0 if neither is true.
10425 proc anc_or_desc {a b} {
10426 global arcout arcstart arcend arcnos cached_isanc
10428 if {$arcnos($a) eq $arcnos($b)} {
10429 # Both are on the same arc(s); either both are the same BMP,
10430 # or if one is not a BMP, the other is also not a BMP or is
10431 # the BMP at end of the arc (and it only has 1 incoming arc).
10432 # Or both can be BMPs with no incoming arcs.
10433 if {$a eq $b || $arcnos($a) eq {}} {
10436 # assert {[llength $arcnos($a)] == 1}
10437 set arc [lindex $arcnos($a) 0]
10438 set i [lsearch -exact $arcids($arc) $a]
10439 set j [lsearch -exact $arcids($arc) $b]
10440 if {$i < 0 || $i > $j} {
10447 if {![info exists arcout($a)]} {
10448 set arc [lindex $arcnos($a) 0]
10449 if {[info exists arcend($arc)]} {
10450 set aend $arcend($arc)
10454 set a $arcstart($arc)
10458 if {![info exists arcout($b)]} {
10459 set arc [lindex $arcnos($b) 0]
10460 if {[info exists arcend($arc)]} {
10461 set bend $arcend($arc)
10465 set b $arcstart($arc)
10475 if {[info exists cached_isanc($a,$bend)]} {
10476 if {$cached_isanc($a,$bend)} {
10480 if {[info exists cached_isanc($b,$aend)]} {
10481 if {$cached_isanc($b,$aend)} {
10484 if {[info exists cached_isanc($a,$bend)]} {
10489 set todo [list $a $b]
10492 for {set i 0} {$i < [llength $todo]} {incr i} {
10493 set x [lindex $todo $i]
10494 if {$anc($x) eq {}} {
10497 foreach arc $arcnos($x) {
10498 set xd $arcstart($arc)
10499 if {$xd eq $bend} {
10500 set cached_isanc($a,$bend) 1
10501 set cached_isanc($b,$aend) 0
10503 } elseif {$xd eq $aend} {
10504 set cached_isanc($b,$aend) 1
10505 set cached_isanc($a,$bend) 0
10508 if {![info exists anc($xd)]} {
10509 set anc($xd) $anc($x)
10511 } elseif {$anc($xd) ne $anc($x)} {
10516 set cached_isanc($a,$bend) 0
10517 set cached_isanc($b,$aend) 0
10521 # This identifies whether $desc has an ancestor that is
10522 # a growing tip of the graph and which is not an ancestor of $anc
10523 # and returns 0 if so and 1 if not.
10524 # If we subsequently discover a tag on such a growing tip, and that
10525 # turns out to be a descendent of $anc (which it could, since we
10526 # don't necessarily see children before parents), then $desc
10527 # isn't a good choice to display as a descendent tag of
10528 # $anc (since it is the descendent of another tag which is
10529 # a descendent of $anc). Similarly, $anc isn't a good choice to
10530 # display as a ancestor tag of $desc.
10532 proc is_certain {desc anc} {
10533 global arcnos arcout arcstart arcend growing problems
10536 if {[llength $arcnos($anc)] == 1} {
10537 # tags on the same arc are certain
10538 if {$arcnos($desc) eq $arcnos($anc)} {
10541 if {![info exists arcout($anc)]} {
10542 # if $anc is partway along an arc, use the start of the arc instead
10543 set a [lindex $arcnos($anc) 0]
10544 set anc $arcstart($a)
10547 if {[llength $arcnos($desc)] > 1 || [info exists arcout($desc)]} {
10550 set a [lindex $arcnos($desc) 0]
10556 set anclist [list $x]
10560 for {set i 0} {$i < [llength $anclist] && ($nnh > 0 || $ngrowanc > 0)} {incr i} {
10561 set x [lindex $anclist $i]
10566 foreach a $arcout($x) {
10567 if {[info exists growing($a)]} {
10568 if {![info exists growanc($x)] && $dl($x)} {
10574 if {[info exists dl($y)]} {
10578 if {![info exists done($y)]} {
10581 if {[info exists growanc($x)]} {
10585 for {set k 0} {$k < [llength $xl]} {incr k} {
10586 set z [lindex $xl $k]
10587 foreach c $arcout($z) {
10588 if {[info exists arcend($c)]} {
10590 if {[info exists dl($v)] && $dl($v)} {
10592 if {![info exists done($v)]} {
10595 if {[info exists growanc($v)]} {
10605 } elseif {$y eq $anc || !$dl($x)} {
10616 foreach x [array names growanc] {
10625 proc validate_arctags {a} {
10626 global arctags idtags
10629 set na $arctags($a)
10630 foreach id $arctags($a) {
10632 if {![info exists idtags($id)]} {
10633 set na [lreplace $na $i $i]
10637 set arctags($a) $na
10640 proc validate_archeads {a} {
10641 global archeads idheads
10644 set na $archeads($a)
10645 foreach id $archeads($a) {
10647 if {![info exists idheads($id)]} {
10648 set na [lreplace $na $i $i]
10652 set archeads($a) $na
10655 # Return the list of IDs that have tags that are descendents of id,
10656 # ignoring IDs that are descendents of IDs already reported.
10657 proc desctags {id} {
10658 global arcnos arcstart arcids arctags idtags allparents
10659 global growing cached_dtags
10661 if {![info exists allparents($id)]} {
10664 set t1 [clock clicks -milliseconds]
10666 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10667 # part-way along an arc; check that arc first
10668 set a [lindex $arcnos($id) 0]
10669 if {$arctags($a) ne {}} {
10670 validate_arctags $a
10671 set i [lsearch -exact $arcids($a) $id]
10673 foreach t $arctags($a) {
10674 set j [lsearch -exact $arcids($a) $t]
10675 if {$j >= $i} break
10682 set id $arcstart($a)
10683 if {[info exists idtags($id)]} {
10687 if {[info exists cached_dtags($id)]} {
10688 return $cached_dtags($id)
10692 set todo [list $id]
10695 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
10696 set id [lindex $todo $i]
10698 set ta [info exists hastaggedancestor($id)]
10702 # ignore tags on starting node
10703 if {!$ta && $i > 0} {
10704 if {[info exists idtags($id)]} {
10705 set tagloc($id) $id
10707 } elseif {[info exists cached_dtags($id)]} {
10708 set tagloc($id) $cached_dtags($id)
10712 foreach a $arcnos($id) {
10713 set d $arcstart($a)
10714 if {!$ta && $arctags($a) ne {}} {
10715 validate_arctags $a
10716 if {$arctags($a) ne {}} {
10717 lappend tagloc($id) [lindex $arctags($a) end]
10720 if {$ta || $arctags($a) ne {}} {
10721 set tomark [list $d]
10722 for {set j 0} {$j < [llength $tomark]} {incr j} {
10723 set dd [lindex $tomark $j]
10724 if {![info exists hastaggedancestor($dd)]} {
10725 if {[info exists done($dd)]} {
10726 foreach b $arcnos($dd) {
10727 lappend tomark $arcstart($b)
10729 if {[info exists tagloc($dd)]} {
10732 } elseif {[info exists queued($dd)]} {
10735 set hastaggedancestor($dd) 1
10739 if {![info exists queued($d)]} {
10742 if {![info exists hastaggedancestor($d)]} {
10749 foreach id [array names tagloc] {
10750 if {![info exists hastaggedancestor($id)]} {
10751 foreach t $tagloc($id) {
10752 if {[lsearch -exact $tags $t] < 0} {
10758 set t2 [clock clicks -milliseconds]
10761 # remove tags that are descendents of other tags
10762 for {set i 0} {$i < [llength $tags]} {incr i} {
10763 set a [lindex $tags $i]
10764 for {set j 0} {$j < $i} {incr j} {
10765 set b [lindex $tags $j]
10766 set r [anc_or_desc $a $b]
10768 set tags [lreplace $tags $j $j]
10771 } elseif {$r == -1} {
10772 set tags [lreplace $tags $i $i]
10779 if {[array names growing] ne {}} {
10780 # graph isn't finished, need to check if any tag could get
10781 # eclipsed by another tag coming later. Simply ignore any
10782 # tags that could later get eclipsed.
10785 if {[is_certain $t $origid]} {
10789 if {$tags eq $ctags} {
10790 set cached_dtags($origid) $tags
10795 set cached_dtags($origid) $tags
10797 set t3 [clock clicks -milliseconds]
10798 if {0 && $t3 - $t1 >= 100} {
10799 puts "iterating descendents ($loopix/[llength $todo] nodes) took\
10800 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
10805 proc anctags {id} {
10806 global arcnos arcids arcout arcend arctags idtags allparents
10807 global growing cached_atags
10809 if {![info exists allparents($id)]} {
10812 set t1 [clock clicks -milliseconds]
10814 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10815 # part-way along an arc; check that arc first
10816 set a [lindex $arcnos($id) 0]
10817 if {$arctags($a) ne {}} {
10818 validate_arctags $a
10819 set i [lsearch -exact $arcids($a) $id]
10820 foreach t $arctags($a) {
10821 set j [lsearch -exact $arcids($a) $t]
10827 if {![info exists arcend($a)]} {
10831 if {[info exists idtags($id)]} {
10835 if {[info exists cached_atags($id)]} {
10836 return $cached_atags($id)
10840 set todo [list $id]
10844 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
10845 set id [lindex $todo $i]
10847 set td [info exists hastaggeddescendent($id)]
10851 # ignore tags on starting node
10852 if {!$td && $i > 0} {
10853 if {[info exists idtags($id)]} {
10854 set tagloc($id) $id
10856 } elseif {[info exists cached_atags($id)]} {
10857 set tagloc($id) $cached_atags($id)
10861 foreach a $arcout($id) {
10862 if {!$td && $arctags($a) ne {}} {
10863 validate_arctags $a
10864 if {$arctags($a) ne {}} {
10865 lappend tagloc($id) [lindex $arctags($a) 0]
10868 if {![info exists arcend($a)]} continue
10870 if {$td || $arctags($a) ne {}} {
10871 set tomark [list $d]
10872 for {set j 0} {$j < [llength $tomark]} {incr j} {
10873 set dd [lindex $tomark $j]
10874 if {![info exists hastaggeddescendent($dd)]} {
10875 if {[info exists done($dd)]} {
10876 foreach b $arcout($dd) {
10877 if {[info exists arcend($b)]} {
10878 lappend tomark $arcend($b)
10881 if {[info exists tagloc($dd)]} {
10884 } elseif {[info exists queued($dd)]} {
10887 set hastaggeddescendent($dd) 1
10891 if {![info exists queued($d)]} {
10894 if {![info exists hastaggeddescendent($d)]} {
10900 set t2 [clock clicks -milliseconds]
10903 foreach id [array names tagloc] {
10904 if {![info exists hastaggeddescendent($id)]} {
10905 foreach t $tagloc($id) {
10906 if {[lsearch -exact $tags $t] < 0} {
10913 # remove tags that are ancestors of other tags
10914 for {set i 0} {$i < [llength $tags]} {incr i} {
10915 set a [lindex $tags $i]
10916 for {set j 0} {$j < $i} {incr j} {
10917 set b [lindex $tags $j]
10918 set r [anc_or_desc $a $b]
10920 set tags [lreplace $tags $j $j]
10923 } elseif {$r == 1} {
10924 set tags [lreplace $tags $i $i]
10931 if {[array names growing] ne {}} {
10932 # graph isn't finished, need to check if any tag could get
10933 # eclipsed by another tag coming later. Simply ignore any
10934 # tags that could later get eclipsed.
10937 if {[is_certain $origid $t]} {
10941 if {$tags eq $ctags} {
10942 set cached_atags($origid) $tags
10947 set cached_atags($origid) $tags
10949 set t3 [clock clicks -milliseconds]
10950 if {0 && $t3 - $t1 >= 100} {
10951 puts "iterating ancestors ($loopix/[llength $todo] nodes) took\
10952 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
10957 # Return the list of IDs that have heads that are descendents of id,
10958 # including id itself if it has a head.
10959 proc descheads {id} {
10960 global arcnos arcstart arcids archeads idheads cached_dheads
10961 global allparents arcout
10963 if {![info exists allparents($id)]} {
10967 if {![info exists arcout($id)]} {
10968 # part-way along an arc; check it first
10969 set a [lindex $arcnos($id) 0]
10970 if {$archeads($a) ne {}} {
10971 validate_archeads $a
10972 set i [lsearch -exact $arcids($a) $id]
10973 foreach t $archeads($a) {
10974 set j [lsearch -exact $arcids($a) $t]
10979 set id $arcstart($a)
10982 set todo [list $id]
10985 for {set i 0} {$i < [llength $todo]} {incr i} {
10986 set id [lindex $todo $i]
10987 if {[info exists cached_dheads($id)]} {
10988 set ret [concat $ret $cached_dheads($id)]
10990 if {[info exists idheads($id)]} {
10993 foreach a $arcnos($id) {
10994 if {$archeads($a) ne {}} {
10995 validate_archeads $a
10996 if {$archeads($a) ne {}} {
10997 set ret [concat $ret $archeads($a)]
11000 set d $arcstart($a)
11001 if {![info exists seen($d)]} {
11008 set ret [lsort -unique $ret]
11009 set cached_dheads($origid) $ret
11010 return [concat $ret $aret]
11013 proc addedtag {id} {
11014 global arcnos arcout cached_dtags cached_atags
11016 if {![info exists arcnos($id)]} return
11017 if {![info exists arcout($id)]} {
11018 recalcarc [lindex $arcnos($id) 0]
11020 unset -nocomplain cached_dtags
11021 unset -nocomplain cached_atags
11024 proc addedhead {hid head} {
11025 global arcnos arcout cached_dheads
11027 if {![info exists arcnos($hid)]} return
11028 if {![info exists arcout($hid)]} {
11029 recalcarc [lindex $arcnos($hid) 0]
11031 unset -nocomplain cached_dheads
11034 proc removedhead {hid head} {
11035 global cached_dheads
11037 unset -nocomplain cached_dheads
11040 proc movedhead {hid head} {
11041 global arcnos arcout cached_dheads
11043 if {![info exists arcnos($hid)]} return
11044 if {![info exists arcout($hid)]} {
11045 recalcarc [lindex $arcnos($hid) 0]
11047 unset -nocomplain cached_dheads
11050 proc changedrefs {} {
11051 global cached_dheads cached_dtags cached_atags cached_tagcontent
11052 global arctags archeads arcnos arcout idheads idtags
11054 foreach id [concat [array names idheads] [array names idtags]] {
11055 if {[info exists arcnos($id)] && ![info exists arcout($id)]} {
11056 set a [lindex $arcnos($id) 0]
11057 if {![info exists donearc($a)]} {
11063 unset -nocomplain cached_tagcontent
11064 unset -nocomplain cached_dtags
11065 unset -nocomplain cached_atags
11066 unset -nocomplain cached_dheads
11069 proc rereadrefs {} {
11070 global idtags idheads idotherrefs mainheadid
11072 set refids [concat [array names idtags] \
11073 [array names idheads] [array names idotherrefs]]
11074 foreach id $refids {
11075 if {![info exists ref($id)]} {
11076 set ref($id) [listrefs $id]
11079 set oldmainhead $mainheadid
11082 set refids [lsort -unique [concat $refids [array names idtags] \
11083 [array names idheads] [array names idotherrefs]]]
11084 foreach id $refids {
11085 set v [listrefs $id]
11086 if {![info exists ref($id)] || $ref($id) != $v} {
11090 if {$oldmainhead ne $mainheadid} {
11091 redrawtags $oldmainhead
11092 redrawtags $mainheadid
11097 proc listrefs {id} {
11098 global idtags idheads idotherrefs
11101 if {[info exists idtags($id)]} {
11105 if {[info exists idheads($id)]} {
11106 set y $idheads($id)
11109 if {[info exists idotherrefs($id)]} {
11110 set z $idotherrefs($id)
11112 return [list $x $y $z]
11115 proc add_tag_ctext {tag} {
11116 global ctext cached_tagcontent tagids
11118 if {![info exists cached_tagcontent($tag)]} {
11120 set cached_tagcontent($tag) [exec git cat-file -p $tag]
11123 $ctext insert end "[mc "Tag"]: $tag\n" bold
11124 if {[info exists cached_tagcontent($tag)]} {
11125 set text $cached_tagcontent($tag)
11127 set text "[mc "Id"]: $tagids($tag)"
11129 appendwithlinks $text {}
11132 proc showtag {tag isnew} {
11133 global ctext cached_tagcontent tagids linknum tagobjid
11136 addtohistory [list showtag $tag 0] savectextpos
11138 $ctext conf -state normal
11143 maybe_scroll_ctext 1
11144 $ctext conf -state disabled
11148 proc showtags {id isnew} {
11149 global idtags ctext linknum
11152 addtohistory [list showtags $id 0] savectextpos
11154 $ctext conf -state normal
11159 foreach tag $idtags($id) {
11160 $ctext insert end $sep
11164 maybe_scroll_ctext 1
11165 $ctext conf -state disabled
11177 if {[info exists gitktmpdir]} {
11178 catch {file delete -force $gitktmpdir}
11182 proc mkfontdisp {font top which} {
11183 global fontattr fontpref $font NS use_ttk
11185 set fontpref($font) [set $font]
11186 ${NS}::button $top.${font}but -text $which \
11187 -command [list choosefont $font $which]
11188 ${NS}::label $top.$font -relief flat -font $font \
11189 -text $fontattr($font,family) -justify left
11190 grid x $top.${font}but $top.$font -sticky w
11193 proc choosefont {font which} {
11194 global fontparam fontlist fonttop fontattr
11197 set fontparam(which) $which
11198 set fontparam(font) $font
11199 set fontparam(family) [font actual $font -family]
11200 set fontparam(size) $fontattr($font,size)
11201 set fontparam(weight) $fontattr($font,weight)
11202 set fontparam(slant) $fontattr($font,slant)
11205 if {![winfo exists $top]} {
11207 eval font config sample [font actual $font]
11209 make_transient $top $prefstop
11210 wm title $top [mc "Gitk font chooser"]
11211 ${NS}::label $top.l -textvariable fontparam(which)
11212 pack $top.l -side top
11213 set fontlist [lsort [font families]]
11214 ${NS}::frame $top.f
11215 listbox $top.f.fam -listvariable fontlist \
11216 -yscrollcommand [list $top.f.sb set]
11217 bind $top.f.fam <<ListboxSelect>> selfontfam
11218 ${NS}::scrollbar $top.f.sb -command [list $top.f.fam yview]
11219 pack $top.f.sb -side right -fill y
11220 pack $top.f.fam -side left -fill both -expand 1
11221 pack $top.f -side top -fill both -expand 1
11222 ${NS}::frame $top.g
11223 spinbox $top.g.size -from 4 -to 40 -width 4 \
11224 -textvariable fontparam(size) \
11225 -validatecommand {string is integer -strict %s}
11226 checkbutton $top.g.bold -padx 5 \
11227 -font {{Times New Roman} 12 bold} -text [mc "B"] -indicatoron 0 \
11228 -variable fontparam(weight) -onvalue bold -offvalue normal
11229 checkbutton $top.g.ital -padx 5 \
11230 -font {{Times New Roman} 12 italic} -text [mc "I"] -indicatoron 0 \
11231 -variable fontparam(slant) -onvalue italic -offvalue roman
11232 pack $top.g.size $top.g.bold $top.g.ital -side left
11233 pack $top.g -side top
11234 canvas $top.c -width 150 -height 50 -border 2 -relief sunk \
11236 $top.c create text 100 25 -anchor center -text $which -font sample \
11237 -fill black -tags text
11238 bind $top.c <Configure> [list centertext $top.c]
11239 pack $top.c -side top -fill x
11240 ${NS}::frame $top.buts
11241 ${NS}::button $top.buts.ok -text [mc "OK"] -command fontok -default active
11242 ${NS}::button $top.buts.can -text [mc "Cancel"] -command fontcan -default normal
11243 bind $top <Key-Return> fontok
11244 bind $top <Key-Escape> fontcan
11245 grid $top.buts.ok $top.buts.can
11246 grid columnconfigure $top.buts 0 -weight 1 -uniform a
11247 grid columnconfigure $top.buts 1 -weight 1 -uniform a
11248 pack $top.buts -side bottom -fill x
11249 trace add variable fontparam write chg_fontparam
11252 $top.c itemconf text -text $which
11254 set i [lsearch -exact $fontlist $fontparam(family)]
11256 $top.f.fam selection set $i
11261 proc centertext {w} {
11262 $w coords text [expr {[winfo width $w] / 2}] [expr {[winfo height $w] / 2}]
11266 global fontparam fontpref prefstop
11268 set f $fontparam(font)
11269 set fontpref($f) [list $fontparam(family) $fontparam(size)]
11270 if {$fontparam(weight) eq "bold"} {
11271 lappend fontpref($f) "bold"
11273 if {$fontparam(slant) eq "italic"} {
11274 lappend fontpref($f) "italic"
11276 set w $prefstop.notebook.fonts.$f
11277 $w conf -text $fontparam(family) -font $fontpref($f)
11283 global fonttop fontparam
11285 if {[info exists fonttop]} {
11286 catch {destroy $fonttop}
11287 catch {font delete sample}
11293 if {[package vsatisfies [package provide Tk] 8.6]} {
11294 # In Tk 8.6 we have a native font chooser dialog. Overwrite the above
11295 # function to make use of it.
11296 proc choosefont {font which} {
11297 tk fontchooser configure -title $which -font $font \
11298 -command [list on_choosefont $font $which]
11299 tk fontchooser show
11301 proc on_choosefont {font which newfont} {
11303 puts stderr "$font $newfont"
11304 array set f [font actual $newfont]
11305 set fontparam(which) $which
11306 set fontparam(font) $font
11307 set fontparam(family) $f(-family)
11308 set fontparam(size) $f(-size)
11309 set fontparam(weight) $f(-weight)
11310 set fontparam(slant) $f(-slant)
11315 proc selfontfam {} {
11316 global fonttop fontparam
11318 set i [$fonttop.f.fam curselection]
11320 set fontparam(family) [$fonttop.f.fam get $i]
11324 proc chg_fontparam {v sub op} {
11327 font config sample -$sub $fontparam($sub)
11330 # Create a property sheet tab page
11331 proc create_prefs_page {w} {
11333 set parent [join [lrange [split $w .] 0 end-1] .]
11334 if {[winfo class $parent] eq "TNotebook"} {
11337 ${NS}::labelframe $w
11341 proc prefspage_general {notebook} {
11342 global NS maxwidth maxgraphpct showneartags showlocalchanges
11343 global tabstop limitdiffs autoselect autosellen extdifftool perfile_attrs
11344 global hideremotes want_ttk have_ttk maxrefs
11346 set page [create_prefs_page $notebook.general]
11348 ${NS}::label $page.ldisp -text [mc "Commit list display options"]
11349 grid $page.ldisp - -sticky w -pady 10
11350 ${NS}::label $page.spacer -text " "
11351 ${NS}::label $page.maxwidthl -text [mc "Maximum graph width (lines)"]
11352 spinbox $page.maxwidth -from 0 -to 100 -width 4 -textvariable maxwidth
11353 grid $page.spacer $page.maxwidthl $page.maxwidth -sticky w
11354 #xgettext:no-tcl-format
11355 ${NS}::label $page.maxpctl -text [mc "Maximum graph width (% of pane)"]
11356 spinbox $page.maxpct -from 1 -to 100 -width 4 -textvariable maxgraphpct
11357 grid x $page.maxpctl $page.maxpct -sticky w
11358 ${NS}::checkbutton $page.showlocal -text [mc "Show local changes"] \
11359 -variable showlocalchanges
11360 grid x $page.showlocal -sticky w
11361 ${NS}::checkbutton $page.autoselect -text [mc "Auto-select SHA1 (length)"] \
11362 -variable autoselect
11363 spinbox $page.autosellen -from 1 -to 40 -width 4 -textvariable autosellen
11364 grid x $page.autoselect $page.autosellen -sticky w
11365 ${NS}::checkbutton $page.hideremotes -text [mc "Hide remote refs"] \
11366 -variable hideremotes
11367 grid x $page.hideremotes -sticky w
11369 ${NS}::label $page.ddisp -text [mc "Diff display options"]
11370 grid $page.ddisp - -sticky w -pady 10
11371 ${NS}::label $page.tabstopl -text [mc "Tab spacing"]
11372 spinbox $page.tabstop -from 1 -to 20 -width 4 -textvariable tabstop
11373 grid x $page.tabstopl $page.tabstop -sticky w
11374 ${NS}::checkbutton $page.ntag -text [mc "Display nearby tags/heads"] \
11375 -variable showneartags
11376 grid x $page.ntag -sticky w
11377 ${NS}::label $page.maxrefsl -text [mc "Maximum # tags/heads to show"]
11378 spinbox $page.maxrefs -from 1 -to 1000 -width 4 -textvariable maxrefs
11379 grid x $page.maxrefsl $page.maxrefs -sticky w
11380 ${NS}::checkbutton $page.ldiff -text [mc "Limit diffs to listed paths"] \
11381 -variable limitdiffs
11382 grid x $page.ldiff -sticky w
11383 ${NS}::checkbutton $page.lattr -text [mc "Support per-file encodings"] \
11384 -variable perfile_attrs
11385 grid x $page.lattr -sticky w
11387 ${NS}::entry $page.extdifft -textvariable extdifftool
11388 ${NS}::frame $page.extdifff
11389 ${NS}::label $page.extdifff.l -text [mc "External diff tool" ]
11390 ${NS}::button $page.extdifff.b -text [mc "Choose..."] -command choose_extdiff
11391 pack $page.extdifff.l $page.extdifff.b -side left
11392 pack configure $page.extdifff.l -padx 10
11393 grid x $page.extdifff $page.extdifft -sticky ew
11395 ${NS}::label $page.lgen -text [mc "General options"]
11396 grid $page.lgen - -sticky w -pady 10
11397 ${NS}::checkbutton $page.want_ttk -variable want_ttk \
11398 -text [mc "Use themed widgets"]
11400 ${NS}::label $page.ttk_note -text [mc "(change requires restart)"]
11402 ${NS}::label $page.ttk_note -text [mc "(currently unavailable)"]
11404 grid x $page.want_ttk $page.ttk_note -sticky w
11408 proc prefspage_colors {notebook} {
11409 global NS uicolor bgcolor fgcolor ctext diffcolors selectbgcolor markbgcolor
11411 set page [create_prefs_page $notebook.colors]
11413 ${NS}::label $page.cdisp -text [mc "Colors: press to choose"]
11414 grid $page.cdisp - -sticky w -pady 10
11415 label $page.ui -padx 40 -relief sunk -background $uicolor
11416 ${NS}::button $page.uibut -text [mc "Interface"] \
11417 -command [list choosecolor uicolor {} $page.ui [mc "interface"] setui]
11418 grid x $page.uibut $page.ui -sticky w
11419 label $page.bg -padx 40 -relief sunk -background $bgcolor
11420 ${NS}::button $page.bgbut -text [mc "Background"] \
11421 -command [list choosecolor bgcolor {} $page.bg [mc "background"] setbg]
11422 grid x $page.bgbut $page.bg -sticky w
11423 label $page.fg -padx 40 -relief sunk -background $fgcolor
11424 ${NS}::button $page.fgbut -text [mc "Foreground"] \
11425 -command [list choosecolor fgcolor {} $page.fg [mc "foreground"] setfg]
11426 grid x $page.fgbut $page.fg -sticky w
11427 label $page.diffold -padx 40 -relief sunk -background [lindex $diffcolors 0]
11428 ${NS}::button $page.diffoldbut -text [mc "Diff: old lines"] \
11429 -command [list choosecolor diffcolors 0 $page.diffold [mc "diff old lines"] \
11430 [list $ctext tag conf d0 -foreground]]
11431 grid x $page.diffoldbut $page.diffold -sticky w
11432 label $page.diffnew -padx 40 -relief sunk -background [lindex $diffcolors 1]
11433 ${NS}::button $page.diffnewbut -text [mc "Diff: new lines"] \
11434 -command [list choosecolor diffcolors 1 $page.diffnew [mc "diff new lines"] \
11435 [list $ctext tag conf dresult -foreground]]
11436 grid x $page.diffnewbut $page.diffnew -sticky w
11437 label $page.hunksep -padx 40 -relief sunk -background [lindex $diffcolors 2]
11438 ${NS}::button $page.hunksepbut -text [mc "Diff: hunk header"] \
11439 -command [list choosecolor diffcolors 2 $page.hunksep \
11440 [mc "diff hunk header"] \
11441 [list $ctext tag conf hunksep -foreground]]
11442 grid x $page.hunksepbut $page.hunksep -sticky w
11443 label $page.markbgsep -padx 40 -relief sunk -background $markbgcolor
11444 ${NS}::button $page.markbgbut -text [mc "Marked line bg"] \
11445 -command [list choosecolor markbgcolor {} $page.markbgsep \
11446 [mc "marked line background"] \
11447 [list $ctext tag conf omark -background]]
11448 grid x $page.markbgbut $page.markbgsep -sticky w
11449 label $page.selbgsep -padx 40 -relief sunk -background $selectbgcolor
11450 ${NS}::button $page.selbgbut -text [mc "Select bg"] \
11451 -command [list choosecolor selectbgcolor {} $page.selbgsep [mc "background"] setselbg]
11452 grid x $page.selbgbut $page.selbgsep -sticky w
11456 proc prefspage_fonts {notebook} {
11458 set page [create_prefs_page $notebook.fonts]
11459 ${NS}::label $page.cfont -text [mc "Fonts: press to choose"]
11460 grid $page.cfont - -sticky w -pady 10
11461 mkfontdisp mainfont $page [mc "Main font"]
11462 mkfontdisp textfont $page [mc "Diff display font"]
11463 mkfontdisp uifont $page [mc "User interface font"]
11468 global maxwidth maxgraphpct use_ttk NS
11469 global oldprefs prefstop showneartags showlocalchanges
11470 global uicolor bgcolor fgcolor ctext diffcolors selectbgcolor markbgcolor
11471 global tabstop limitdiffs autoselect autosellen extdifftool perfile_attrs
11472 global hideremotes want_ttk have_ttk
11476 if {[winfo exists $top]} {
11480 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
11481 limitdiffs tabstop perfile_attrs hideremotes want_ttk} {
11482 set oldprefs($v) [set $v]
11485 wm title $top [mc "Gitk preferences"]
11486 make_transient $top .
11488 if {[set use_notebook [expr {$use_ttk && [info command ::ttk::notebook] ne ""}]]} {
11489 set notebook [ttk::notebook $top.notebook]
11491 set notebook [${NS}::frame $top.notebook -borderwidth 0 -relief flat]
11494 lappend pages [prefspage_general $notebook] [mc "General"]
11495 lappend pages [prefspage_colors $notebook] [mc "Colors"]
11496 lappend pages [prefspage_fonts $notebook] [mc "Fonts"]
11498 foreach {page title} $pages {
11499 if {$use_notebook} {
11500 $notebook add $page -text $title
11502 set btn [${NS}::button $notebook.b_[string map {. X} $page] \
11503 -text $title -command [list raise $page]]
11504 $page configure -text $title
11505 grid $btn -row 0 -column [incr col] -sticky w
11506 grid $page -row 1 -column 0 -sticky news -columnspan 100
11510 if {!$use_notebook} {
11511 grid columnconfigure $notebook 0 -weight 1
11512 grid rowconfigure $notebook 1 -weight 1
11513 raise [lindex $pages 0]
11516 grid $notebook -sticky news -padx 2 -pady 2
11517 grid rowconfigure $top 0 -weight 1
11518 grid columnconfigure $top 0 -weight 1
11520 ${NS}::frame $top.buts
11521 ${NS}::button $top.buts.ok -text [mc "OK"] -command prefsok -default active
11522 ${NS}::button $top.buts.can -text [mc "Cancel"] -command prefscan -default normal
11523 bind $top <Key-Return> prefsok
11524 bind $top <Key-Escape> prefscan
11525 grid $top.buts.ok $top.buts.can
11526 grid columnconfigure $top.buts 0 -weight 1 -uniform a
11527 grid columnconfigure $top.buts 1 -weight 1 -uniform a
11528 grid $top.buts - - -pady 10 -sticky ew
11529 grid columnconfigure $top 2 -weight 1
11530 bind $top <Visibility> [list focus $top.buts.ok]
11533 proc choose_extdiff {} {
11536 set prog [tk_getOpenFile -title [mc "External diff tool"] -multiple false]
11538 set extdifftool $prog
11542 proc choosecolor {v vi w x cmd} {
11545 set c [tk_chooseColor -initialcolor [lindex [set $v] $vi] \
11546 -title [mc "Gitk: choose color for %s" $x]]
11547 if {$c eq {}} return
11548 $w conf -background $c
11553 proc setselbg {c} {
11554 global bglist cflist
11555 foreach w $bglist {
11556 if {[winfo exists $w]} {
11557 $w configure -selectbackground $c
11560 $cflist tag configure highlight \
11561 -background [$cflist cget -selectbackground]
11562 allcanvs itemconf secsel -fill $c
11565 # This sets the background color and the color scheme for the whole UI.
11566 # For some reason, tk_setPalette chooses a nasty dark red for selectColor
11567 # if we don't specify one ourselves, which makes the checkbuttons and
11568 # radiobuttons look bad. This chooses white for selectColor if the
11569 # background color is light, or black if it is dark.
11571 if {[tk windowingsystem] eq "win32"} { return }
11572 set bg [winfo rgb . $c]
11574 if {[lindex $bg 0] + 1.5 * [lindex $bg 1] + 0.5 * [lindex $bg 2] > 100000} {
11577 tk_setPalette background $c selectColor $selc
11583 foreach w $bglist {
11584 if {[winfo exists $w]} {
11585 $w conf -background $c
11593 foreach w $fglist {
11594 if {[winfo exists $w]} {
11595 $w conf -foreground $c
11598 allcanvs itemconf text -fill $c
11599 $canv itemconf circle -outline $c
11600 $canv itemconf markid -outline $c
11604 global oldprefs prefstop
11606 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
11607 limitdiffs tabstop perfile_attrs hideremotes want_ttk} {
11609 set $v $oldprefs($v)
11611 catch {destroy $prefstop}
11617 global maxwidth maxgraphpct
11618 global oldprefs prefstop showneartags showlocalchanges
11619 global fontpref mainfont textfont uifont
11620 global limitdiffs treediffs perfile_attrs
11623 catch {destroy $prefstop}
11627 if {$mainfont ne $fontpref(mainfont)} {
11628 set mainfont $fontpref(mainfont)
11629 parsefont mainfont $mainfont
11630 eval font configure mainfont [fontflags mainfont]
11631 eval font configure mainfontbold [fontflags mainfont 1]
11635 if {$textfont ne $fontpref(textfont)} {
11636 set textfont $fontpref(textfont)
11637 parsefont textfont $textfont
11638 eval font configure textfont [fontflags textfont]
11639 eval font configure textfontbold [fontflags textfont 1]
11641 if {$uifont ne $fontpref(uifont)} {
11642 set uifont $fontpref(uifont)
11643 parsefont uifont $uifont
11644 eval font configure uifont [fontflags uifont]
11647 if {$showlocalchanges != $oldprefs(showlocalchanges)} {
11648 if {$showlocalchanges} {
11654 if {$limitdiffs != $oldprefs(limitdiffs) ||
11655 ($perfile_attrs && !$oldprefs(perfile_attrs))} {
11656 # treediffs elements are limited by path;
11657 # won't have encodings cached if perfile_attrs was just turned on
11658 unset -nocomplain treediffs
11660 if {$fontchanged || $maxwidth != $oldprefs(maxwidth)
11661 || $maxgraphpct != $oldprefs(maxgraphpct)} {
11663 } elseif {$showneartags != $oldprefs(showneartags) ||
11664 $limitdiffs != $oldprefs(limitdiffs)} {
11667 if {$hideremotes != $oldprefs(hideremotes)} {
11672 proc formatdate {d} {
11673 global datetimeformat
11675 # If $datetimeformat includes a timezone, display in the
11676 # timezone of the argument. Otherwise, display in local time.
11677 if {[string match {*%[zZ]*} $datetimeformat]} {
11678 if {[catch {set d [clock format [lindex $d 0] -timezone [lindex $d 1] -format $datetimeformat]}]} {
11679 # Tcl < 8.5 does not support -timezone. Emulate it by
11680 # setting TZ (e.g. TZ=<-0430>+04:30).
11682 if {[info exists env(TZ)]} {
11683 set savedTZ $env(TZ)
11685 set zone [lindex $d 1]
11686 set sign [string map {+ - - +} [string index $zone 0]]
11687 set env(TZ) <$zone>$sign[string range $zone 1 2]:[string range $zone 3 4]
11688 set d [clock format [lindex $d 0] -format $datetimeformat]
11689 if {[info exists savedTZ]} {
11690 set env(TZ) $savedTZ
11696 set d [clock format [lindex $d 0] -format $datetimeformat]
11702 # This list of encoding names and aliases is distilled from
11703 # http://www.iana.org/assignments/character-sets.
11704 # Not all of them are supported by Tcl.
11705 set encoding_aliases {
11706 { ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991 ASCII
11707 ISO646-US US-ASCII us IBM367 cp367 csASCII }
11708 { ISO-10646-UTF-1 csISO10646UTF1 }
11709 { ISO_646.basic:1983 ref csISO646basic1983 }
11710 { INVARIANT csINVARIANT }
11711 { ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion }
11712 { BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom }
11713 { NATS-SEFI iso-ir-8-1 csNATSSEFI }
11714 { NATS-SEFI-ADD iso-ir-8-2 csNATSSEFIADD }
11715 { NATS-DANO iso-ir-9-1 csNATSDANO }
11716 { NATS-DANO-ADD iso-ir-9-2 csNATSDANOADD }
11717 { SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE se csISO10Swedish }
11718 { SEN_850200_C iso-ir-11 ISO646-SE2 se2 csISO11SwedishForNames }
11719 { KS_C_5601-1987 iso-ir-149 KS_C_5601-1989 KSC_5601 korean csKSC56011987 }
11720 { ISO-2022-KR csISO2022KR }
11722 { ISO-2022-JP csISO2022JP }
11723 { ISO-2022-JP-2 csISO2022JP2 }
11724 { JIS_C6220-1969-jp JIS_C6220-1969 iso-ir-13 katakana x0201-7
11725 csISO13JISC6220jp }
11726 { JIS_C6220-1969-ro iso-ir-14 jp ISO646-JP csISO14JISC6220ro }
11727 { IT iso-ir-15 ISO646-IT csISO15Italian }
11728 { PT iso-ir-16 ISO646-PT csISO16Portuguese }
11729 { ES iso-ir-17 ISO646-ES csISO17Spanish }
11730 { greek7-old iso-ir-18 csISO18Greek7Old }
11731 { latin-greek iso-ir-19 csISO19LatinGreek }
11732 { DIN_66003 iso-ir-21 de ISO646-DE csISO21German }
11733 { NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French }
11734 { Latin-greek-1 iso-ir-27 csISO27LatinGreek1 }
11735 { ISO_5427 iso-ir-37 csISO5427Cyrillic }
11736 { JIS_C6226-1978 iso-ir-42 csISO42JISC62261978 }
11737 { BS_viewdata iso-ir-47 csISO47BSViewdata }
11738 { INIS iso-ir-49 csISO49INIS }
11739 { INIS-8 iso-ir-50 csISO50INIS8 }
11740 { INIS-cyrillic iso-ir-51 csISO51INISCyrillic }
11741 { ISO_5427:1981 iso-ir-54 ISO5427Cyrillic1981 }
11742 { ISO_5428:1980 iso-ir-55 csISO5428Greek }
11743 { GB_1988-80 iso-ir-57 cn ISO646-CN csISO57GB1988 }
11744 { GB_2312-80 iso-ir-58 chinese csISO58GB231280 }
11745 { NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
11746 csISO60Norwegian1 }
11747 { NS_4551-2 ISO646-NO2 iso-ir-61 no2 csISO61Norwegian2 }
11748 { NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French }
11749 { videotex-suppl iso-ir-70 csISO70VideotexSupp1 }
11750 { PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2 }
11751 { ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2 }
11752 { MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian }
11753 { JIS_C6226-1983 iso-ir-87 x0208 JIS_X0208-1983 csISO87JISX0208 }
11754 { greek7 iso-ir-88 csISO88Greek7 }
11755 { ASMO_449 ISO_9036 arabic7 iso-ir-89 csISO89ASMO449 }
11756 { iso-ir-90 csISO90 }
11757 { JIS_C6229-1984-a iso-ir-91 jp-ocr-a csISO91JISC62291984a }
11758 { JIS_C6229-1984-b iso-ir-92 ISO646-JP-OCR-B jp-ocr-b
11759 csISO92JISC62991984b }
11760 { JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add csISO93JIS62291984badd }
11761 { JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand csISO94JIS62291984hand }
11762 { JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
11763 csISO95JIS62291984handadd }
11764 { JIS_C6229-1984-kana iso-ir-96 csISO96JISC62291984kana }
11765 { ISO_2033-1983 iso-ir-98 e13b csISO2033 }
11766 { ANSI_X3.110-1983 iso-ir-99 CSA_T500-1983 NAPLPS csISO99NAPLPS }
11767 { ISO_8859-1:1987 iso-ir-100 ISO_8859-1 ISO-8859-1 latin1 l1 IBM819
11768 CP819 csISOLatin1 }
11769 { ISO_8859-2:1987 iso-ir-101 ISO_8859-2 ISO-8859-2 latin2 l2 csISOLatin2 }
11770 { T.61-7bit iso-ir-102 csISO102T617bit }
11771 { T.61-8bit T.61 iso-ir-103 csISO103T618bit }
11772 { ISO_8859-3:1988 iso-ir-109 ISO_8859-3 ISO-8859-3 latin3 l3 csISOLatin3 }
11773 { ISO_8859-4:1988 iso-ir-110 ISO_8859-4 ISO-8859-4 latin4 l4 csISOLatin4 }
11774 { ECMA-cyrillic iso-ir-111 KOI8-E csISO111ECMACyrillic }
11775 { CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca csISO121Canadian1 }
11776 { CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2 csISO122Canadian2 }
11777 { CSA_Z243.4-1985-gr iso-ir-123 csISO123CSAZ24341985gr }
11778 { ISO_8859-6:1987 iso-ir-127 ISO_8859-6 ISO-8859-6 ECMA-114 ASMO-708
11779 arabic csISOLatinArabic }
11780 { ISO_8859-6-E csISO88596E ISO-8859-6-E }
11781 { ISO_8859-6-I csISO88596I ISO-8859-6-I }
11782 { ISO_8859-7:1987 iso-ir-126 ISO_8859-7 ISO-8859-7 ELOT_928 ECMA-118
11783 greek greek8 csISOLatinGreek }
11784 { T.101-G2 iso-ir-128 csISO128T101G2 }
11785 { ISO_8859-8:1988 iso-ir-138 ISO_8859-8 ISO-8859-8 hebrew
11787 { ISO_8859-8-E csISO88598E ISO-8859-8-E }
11788 { ISO_8859-8-I csISO88598I ISO-8859-8-I }
11789 { CSN_369103 iso-ir-139 csISO139CSN369103 }
11790 { JUS_I.B1.002 iso-ir-141 ISO646-YU js yu csISO141JUSIB1002 }
11791 { ISO_6937-2-add iso-ir-142 csISOTextComm }
11792 { IEC_P27-1 iso-ir-143 csISO143IECP271 }
11793 { ISO_8859-5:1988 iso-ir-144 ISO_8859-5 ISO-8859-5 cyrillic
11794 csISOLatinCyrillic }
11795 { JUS_I.B1.003-serb iso-ir-146 serbian csISO146Serbian }
11796 { JUS_I.B1.003-mac macedonian iso-ir-147 csISO147Macedonian }
11797 { ISO_8859-9:1989 iso-ir-148 ISO_8859-9 ISO-8859-9 latin5 l5 csISOLatin5 }
11798 { greek-ccitt iso-ir-150 csISO150 csISO150GreekCCITT }
11799 { NC_NC00-10:81 cuba iso-ir-151 ISO646-CU csISO151Cuba }
11800 { ISO_6937-2-25 iso-ir-152 csISO6937Add }
11801 { GOST_19768-74 ST_SEV_358-88 iso-ir-153 csISO153GOST1976874 }
11802 { ISO_8859-supp iso-ir-154 latin1-2-5 csISO8859Supp }
11803 { ISO_10367-box iso-ir-155 csISO10367Box }
11804 { ISO-8859-10 iso-ir-157 l6 ISO_8859-10:1992 csISOLatin6 latin6 }
11805 { latin-lap lap iso-ir-158 csISO158Lap }
11806 { JIS_X0212-1990 x0212 iso-ir-159 csISO159JISX02121990 }
11807 { DS_2089 DS2089 ISO646-DK dk csISO646Danish }
11810 { JIS_X0201 X0201 csHalfWidthKatakana }
11811 { KSC5636 ISO646-KR csKSC5636 }
11812 { ISO-10646-UCS-2 csUnicode }
11813 { ISO-10646-UCS-4 csUCS4 }
11814 { DEC-MCS dec csDECMCS }
11815 { hp-roman8 roman8 r8 csHPRoman8 }
11816 { macintosh mac csMacintosh }
11817 { IBM037 cp037 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl
11819 { IBM038 EBCDIC-INT cp038 csIBM038 }
11820 { IBM273 CP273 csIBM273 }
11821 { IBM274 EBCDIC-BE CP274 csIBM274 }
11822 { IBM275 EBCDIC-BR cp275 csIBM275 }
11823 { IBM277 EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 }
11824 { IBM278 CP278 ebcdic-cp-fi ebcdic-cp-se csIBM278 }
11825 { IBM280 CP280 ebcdic-cp-it csIBM280 }
11826 { IBM281 EBCDIC-JP-E cp281 csIBM281 }
11827 { IBM284 CP284 ebcdic-cp-es csIBM284 }
11828 { IBM285 CP285 ebcdic-cp-gb csIBM285 }
11829 { IBM290 cp290 EBCDIC-JP-kana csIBM290 }
11830 { IBM297 cp297 ebcdic-cp-fr csIBM297 }
11831 { IBM420 cp420 ebcdic-cp-ar1 csIBM420 }
11832 { IBM423 cp423 ebcdic-cp-gr csIBM423 }
11833 { IBM424 cp424 ebcdic-cp-he csIBM424 }
11834 { IBM437 cp437 437 csPC8CodePage437 }
11835 { IBM500 CP500 ebcdic-cp-be ebcdic-cp-ch csIBM500 }
11836 { IBM775 cp775 csPC775Baltic }
11837 { IBM850 cp850 850 csPC850Multilingual }
11838 { IBM851 cp851 851 csIBM851 }
11839 { IBM852 cp852 852 csPCp852 }
11840 { IBM855 cp855 855 csIBM855 }
11841 { IBM857 cp857 857 csIBM857 }
11842 { IBM860 cp860 860 csIBM860 }
11843 { IBM861 cp861 861 cp-is csIBM861 }
11844 { IBM862 cp862 862 csPC862LatinHebrew }
11845 { IBM863 cp863 863 csIBM863 }
11846 { IBM864 cp864 csIBM864 }
11847 { IBM865 cp865 865 csIBM865 }
11848 { IBM866 cp866 866 csIBM866 }
11849 { IBM868 CP868 cp-ar csIBM868 }
11850 { IBM869 cp869 869 cp-gr csIBM869 }
11851 { IBM870 CP870 ebcdic-cp-roece ebcdic-cp-yu csIBM870 }
11852 { IBM871 CP871 ebcdic-cp-is csIBM871 }
11853 { IBM880 cp880 EBCDIC-Cyrillic csIBM880 }
11854 { IBM891 cp891 csIBM891 }
11855 { IBM903 cp903 csIBM903 }
11856 { IBM904 cp904 904 csIBBM904 }
11857 { IBM905 CP905 ebcdic-cp-tr csIBM905 }
11858 { IBM918 CP918 ebcdic-cp-ar2 csIBM918 }
11859 { IBM1026 CP1026 csIBM1026 }
11860 { EBCDIC-AT-DE csIBMEBCDICATDE }
11861 { EBCDIC-AT-DE-A csEBCDICATDEA }
11862 { EBCDIC-CA-FR csEBCDICCAFR }
11863 { EBCDIC-DK-NO csEBCDICDKNO }
11864 { EBCDIC-DK-NO-A csEBCDICDKNOA }
11865 { EBCDIC-FI-SE csEBCDICFISE }
11866 { EBCDIC-FI-SE-A csEBCDICFISEA }
11867 { EBCDIC-FR csEBCDICFR }
11868 { EBCDIC-IT csEBCDICIT }
11869 { EBCDIC-PT csEBCDICPT }
11870 { EBCDIC-ES csEBCDICES }
11871 { EBCDIC-ES-A csEBCDICESA }
11872 { EBCDIC-ES-S csEBCDICESS }
11873 { EBCDIC-UK csEBCDICUK }
11874 { EBCDIC-US csEBCDICUS }
11875 { UNKNOWN-8BIT csUnknown8BiT }
11876 { MNEMONIC csMnemonic }
11878 { VISCII csVISCII }
11881 { IBM00858 CCSID00858 CP00858 PC-Multilingual-850+euro }
11882 { IBM00924 CCSID00924 CP00924 ebcdic-Latin9--euro }
11883 { IBM01140 CCSID01140 CP01140 ebcdic-us-37+euro }
11884 { IBM01141 CCSID01141 CP01141 ebcdic-de-273+euro }
11885 { IBM01142 CCSID01142 CP01142 ebcdic-dk-277+euro ebcdic-no-277+euro }
11886 { IBM01143 CCSID01143 CP01143 ebcdic-fi-278+euro ebcdic-se-278+euro }
11887 { IBM01144 CCSID01144 CP01144 ebcdic-it-280+euro }
11888 { IBM01145 CCSID01145 CP01145 ebcdic-es-284+euro }
11889 { IBM01146 CCSID01146 CP01146 ebcdic-gb-285+euro }
11890 { IBM01147 CCSID01147 CP01147 ebcdic-fr-297+euro }
11891 { IBM01148 CCSID01148 CP01148 ebcdic-international-500+euro }
11892 { IBM01149 CCSID01149 CP01149 ebcdic-is-871+euro }
11893 { IBM1047 IBM-1047 }
11894 { PTCP154 csPTCP154 PT154 CP154 Cyrillic-Asian }
11895 { Amiga-1251 Ami1251 Amiga1251 Ami-1251 }
11896 { UNICODE-1-1 csUnicode11 }
11897 { CESU-8 csCESU-8 }
11898 { BOCU-1 csBOCU-1 }
11899 { UNICODE-1-1-UTF-7 csUnicode11UTF7 }
11900 { ISO-8859-14 iso-ir-199 ISO_8859-14:1998 ISO_8859-14 latin8 iso-celtic
11902 { ISO-8859-15 ISO_8859-15 Latin-9 }
11903 { ISO-8859-16 iso-ir-226 ISO_8859-16:2001 ISO_8859-16 latin10 l10 }
11904 { GBK CP936 MS936 windows-936 }
11905 { JIS_Encoding csJISEncoding }
11906 { Shift_JIS MS_Kanji csShiftJIS ShiftJIS Shift-JIS }
11907 { Extended_UNIX_Code_Packed_Format_for_Japanese csEUCPkdFmtJapanese
11909 { Extended_UNIX_Code_Fixed_Width_for_Japanese csEUCFixWidJapanese }
11910 { ISO-10646-UCS-Basic csUnicodeASCII }
11911 { ISO-10646-Unicode-Latin1 csUnicodeLatin1 ISO-10646 }
11912 { ISO-Unicode-IBM-1261 csUnicodeIBM1261 }
11913 { ISO-Unicode-IBM-1268 csUnicodeIBM1268 }
11914 { ISO-Unicode-IBM-1276 csUnicodeIBM1276 }
11915 { ISO-Unicode-IBM-1264 csUnicodeIBM1264 }
11916 { ISO-Unicode-IBM-1265 csUnicodeIBM1265 }
11917 { ISO-8859-1-Windows-3.0-Latin-1 csWindows30Latin1 }
11918 { ISO-8859-1-Windows-3.1-Latin-1 csWindows31Latin1 }
11919 { ISO-8859-2-Windows-Latin-2 csWindows31Latin2 }
11920 { ISO-8859-9-Windows-Latin-5 csWindows31Latin5 }
11921 { Adobe-Standard-Encoding csAdobeStandardEncoding }
11922 { Ventura-US csVenturaUS }
11923 { Ventura-International csVenturaInternational }
11924 { PC8-Danish-Norwegian csPC8DanishNorwegian }
11925 { PC8-Turkish csPC8Turkish }
11926 { IBM-Symbols csIBMSymbols }
11927 { IBM-Thai csIBMThai }
11928 { HP-Legal csHPLegal }
11929 { HP-Pi-font csHPPiFont }
11930 { HP-Math8 csHPMath8 }
11931 { Adobe-Symbol-Encoding csHPPSMath }
11932 { HP-DeskTop csHPDesktop }
11933 { Ventura-Math csVenturaMath }
11934 { Microsoft-Publishing csMicrosoftPublishing }
11935 { Windows-31J csWindows31J }
11936 { GB2312 csGB2312 }
11940 proc tcl_encoding {enc} {
11941 global encoding_aliases tcl_encoding_cache
11942 if {[info exists tcl_encoding_cache($enc)]} {
11943 return $tcl_encoding_cache($enc)
11945 set names [encoding names]
11946 set lcnames [string tolower $names]
11947 set enc [string tolower $enc]
11948 set i [lsearch -exact $lcnames $enc]
11950 # look for "isonnn" instead of "iso-nnn" or "iso_nnn"
11951 if {[regsub {^(iso|cp|ibm|jis)[-_]} $enc {\1} encx]} {
11952 set i [lsearch -exact $lcnames $encx]
11956 foreach l $encoding_aliases {
11957 set ll [string tolower $l]
11958 if {[lsearch -exact $ll $enc] < 0} continue
11959 # look through the aliases for one that tcl knows about
11961 set i [lsearch -exact $lcnames $e]
11963 if {[regsub {^(iso|cp|ibm|jis)[-_]} $e {\1} ex]} {
11964 set i [lsearch -exact $lcnames $ex]
11974 set tclenc [lindex $names $i]
11976 set tcl_encoding_cache($enc) $tclenc
11980 proc gitattr {path attr default} {
11981 global path_attr_cache
11982 if {[info exists path_attr_cache($attr,$path)]} {
11983 set r $path_attr_cache($attr,$path)
11985 set r "unspecified"
11986 if {![catch {set line [exec git check-attr $attr -- $path]}]} {
11987 regexp "(.*): $attr: (.*)" $line m f r
11989 set path_attr_cache($attr,$path) $r
11991 if {$r eq "unspecified"} {
11997 proc cache_gitattr {attr pathlist} {
11998 global path_attr_cache
12000 foreach path $pathlist {
12001 if {![info exists path_attr_cache($attr,$path)]} {
12002 lappend newlist $path
12006 if {[tk windowingsystem] == "win32"} {
12007 # windows has a 32k limit on the arguments to a command...
12010 while {$newlist ne {}} {
12011 set head [lrange $newlist 0 [expr {$lim - 1}]]
12012 set newlist [lrange $newlist $lim end]
12013 if {![catch {set rlist [eval exec git check-attr $attr -- $head]}]} {
12014 foreach row [split $rlist "\n"] {
12015 if {[regexp "(.*): $attr: (.*)" $row m path value]} {
12016 if {[string index $path 0] eq "\""} {
12017 set path [encoding convertfrom [lindex $path 0]]
12019 set path_attr_cache($attr,$path) $value
12026 proc get_path_encoding {path} {
12027 global gui_encoding perfile_attrs
12028 set tcl_enc $gui_encoding
12029 if {$path ne {} && $perfile_attrs} {
12030 set enc2 [tcl_encoding [gitattr $path encoding $tcl_enc]]
12038 ## For msgcat loading, first locate the installation location.
12039 if { [info exists ::env(GITK_MSGSDIR)] } {
12040 ## Msgsdir was manually set in the environment.
12041 set gitk_msgsdir $::env(GITK_MSGSDIR)
12043 ## Let's guess the prefix from argv0.
12044 set gitk_prefix [file dirname [file dirname [file normalize $argv0]]]
12045 set gitk_libdir [file join $gitk_prefix share gitk lib]
12046 set gitk_msgsdir [file join $gitk_libdir msgs]
12050 ## Internationalization (i18n) through msgcat and gettext. See
12051 ## http://www.gnu.org/software/gettext/manual/html_node/Tcl.html
12052 package require msgcat
12053 namespace import ::msgcat::mc
12054 ## And eventually load the actual message catalog
12055 ::msgcat::mcload $gitk_msgsdir
12057 # First check that Tcl/Tk is recent enough
12058 if {[catch {package require Tk 8.4} err]} {
12059 show_error {} . [mc "Sorry, gitk cannot run with this version of Tcl/Tk.\n\
12060 Gitk requires at least Tcl/Tk 8.4."]
12064 # on OSX bring the current Wish process window to front
12065 if {[tk windowingsystem] eq "aqua"} {
12066 exec osascript -e [format {
12067 tell application "System Events"
12068 set frontmost of processes whose unix id is %d to true
12073 # Unset GIT_TRACE var if set
12074 if { [info exists ::env(GIT_TRACE)] } {
12075 unset ::env(GIT_TRACE)
12079 set wrcomcmd "git diff-tree --stdin -p --pretty=email"
12083 set gitencoding [exec git config --get i18n.commitencoding]
12086 set gitencoding [exec git config --get i18n.logoutputencoding]
12088 if {$gitencoding == ""} {
12089 set gitencoding "utf-8"
12091 set tclencoding [tcl_encoding $gitencoding]
12092 if {$tclencoding == {}} {
12093 puts stderr "Warning: encoding $gitencoding is not supported by Tcl/Tk"
12096 set gui_encoding [encoding system]
12098 set enc [exec git config --get gui.encoding]
12100 set tclenc [tcl_encoding $enc]
12101 if {$tclenc ne {}} {
12102 set gui_encoding $tclenc
12104 puts stderr "Warning: encoding $enc is not supported by Tcl/Tk"
12109 set log_showroot true
12111 set log_showroot [exec git config --bool --get log.showroot]
12114 if {[tk windowingsystem] eq "aqua"} {
12115 set mainfont {{Lucida Grande} 9}
12116 set textfont {Monaco 9}
12117 set uifont {{Lucida Grande} 9 bold}
12118 } elseif {![catch {::tk::pkgconfig get fontsystem} xft] && $xft eq "xft"} {
12120 set mainfont {sans 9}
12121 set textfont {monospace 9}
12122 set uifont {sans 9 bold}
12124 set mainfont {Helvetica 9}
12125 set textfont {Courier 9}
12126 set uifont {Helvetica 9 bold}
12129 set findmergefiles 0
12137 set cmitmode "patch"
12138 set wrapcomment "none"
12142 set visiblerefs {"master"}
12144 set showlocalchanges 1
12146 set datetimeformat "%Y-%m-%d %H:%M:%S"
12149 set perfile_attrs 0
12152 if {[tk windowingsystem] eq "aqua"} {
12153 set extdifftool "opendiff"
12155 set extdifftool "meld"
12158 set colors {green red blue magenta darkgrey brown orange}
12159 if {[tk windowingsystem] eq "win32"} {
12160 set uicolor SystemButtonFace
12161 set uifgcolor SystemButtonText
12162 set uifgdisabledcolor SystemDisabledText
12163 set bgcolor SystemWindow
12164 set fgcolor SystemWindowText
12165 set selectbgcolor SystemHighlight
12168 set uifgcolor black
12169 set uifgdisabledcolor "#999"
12172 set selectbgcolor gray85
12174 set diffcolors {red "#00a000" blue}
12176 set mergecolors {red blue green purple brown "#009090" magenta "#808000" "#009000" "#ff0080" cyan "#b07070" "#70b0f0" "#70f0b0" "#f0b070" "#ff70b0"}
12179 set markbgcolor "#e0e0ff"
12181 set headbgcolor green
12182 set headfgcolor black
12183 set headoutlinecolor black
12184 set remotebgcolor #ffddaa
12185 set tagbgcolor yellow
12186 set tagfgcolor black
12187 set tagoutlinecolor black
12188 set reflinecolor black
12189 set filesepbgcolor #aaaaaa
12190 set filesepfgcolor black
12191 set linehoverbgcolor #ffff80
12192 set linehoverfgcolor black
12193 set linehoveroutlinecolor black
12194 set mainheadcirclecolor yellow
12195 set workingfilescirclecolor red
12196 set indexcirclecolor green
12197 set circlecolors {white blue gray blue blue}
12198 set linkfgcolor blue
12199 set circleoutlinecolor $fgcolor
12200 set foundbgcolor yellow
12201 set currentsearchhitbgcolor orange
12203 # button for popping up context menus
12204 if {[tk windowingsystem] eq "aqua"} {
12205 set ctxbut <Button-2>
12207 set ctxbut <Button-3>
12211 # follow the XDG base directory specification by default. See
12212 # http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
12213 if {[info exists env(XDG_CONFIG_HOME)] && $env(XDG_CONFIG_HOME) ne ""} {
12214 # XDG_CONFIG_HOME environment variable is set
12215 set config_file [file join $env(XDG_CONFIG_HOME) git gitk]
12216 set config_file_tmp [file join $env(XDG_CONFIG_HOME) git gitk-tmp]
12218 # default XDG_CONFIG_HOME
12219 set config_file "~/.config/git/gitk"
12220 set config_file_tmp "~/.config/git/gitk-tmp"
12222 if {![file exists $config_file]} {
12223 # for backward compatibility use the old config file if it exists
12224 if {[file exists "~/.gitk"]} {
12225 set config_file "~/.gitk"
12226 set config_file_tmp "~/.gitk-tmp"
12227 } elseif {![file exists [file dirname $config_file]]} {
12228 file mkdir [file dirname $config_file]
12231 source $config_file
12233 config_check_tmp_exists 50
12235 set config_variables {
12236 mainfont textfont uifont tabstop findmergefiles maxgraphpct maxwidth
12237 cmitmode wrapcomment autoselect autosellen showneartags maxrefs visiblerefs
12238 hideremotes showlocalchanges datetimeformat limitdiffs uicolor want_ttk
12239 bgcolor fgcolor uifgcolor uifgdisabledcolor colors diffcolors mergecolors
12240 markbgcolor diffcontext selectbgcolor foundbgcolor currentsearchhitbgcolor
12241 extdifftool perfile_attrs headbgcolor headfgcolor headoutlinecolor
12242 remotebgcolor tagbgcolor tagfgcolor tagoutlinecolor reflinecolor
12243 filesepbgcolor filesepfgcolor linehoverbgcolor linehoverfgcolor
12244 linehoveroutlinecolor mainheadcirclecolor workingfilescirclecolor
12245 indexcirclecolor circlecolors linkfgcolor circleoutlinecolor
12247 foreach var $config_variables {
12248 config_init_trace $var
12249 trace add variable $var write config_variable_change_cb
12252 parsefont mainfont $mainfont
12253 eval font create mainfont [fontflags mainfont]
12254 eval font create mainfontbold [fontflags mainfont 1]
12256 parsefont textfont $textfont
12257 eval font create textfont [fontflags textfont]
12258 eval font create textfontbold [fontflags textfont 1]
12260 parsefont uifont $uifont
12261 eval font create uifont [fontflags uifont]
12267 # check that we can find a .git directory somewhere...
12268 if {[catch {set gitdir [exec git rev-parse --git-dir]}]} {
12269 show_error {} . [mc "Cannot find a git repository here."]
12274 set selectheadid {}
12277 set cmdline_files {}
12279 set revtreeargscmd {}
12280 foreach arg $argv {
12281 switch -glob -- $arg {
12284 set cmdline_files [lrange $argv [expr {$i + 1}] end]
12287 "--select-commit=*" {
12288 set selecthead [string range $arg 16 end]
12291 set revtreeargscmd [string range $arg 10 end]
12294 lappend revtreeargs $arg
12300 if {$selecthead eq "HEAD"} {
12304 if {$i >= [llength $argv] && $revtreeargs ne {}} {
12305 # no -- on command line, but some arguments (other than --argscmd)
12307 set f [eval exec git rev-parse --no-revs --no-flags $revtreeargs]
12308 set cmdline_files [split $f "\n"]
12309 set n [llength $cmdline_files]
12310 set revtreeargs [lrange $revtreeargs 0 end-$n]
12311 # Unfortunately git rev-parse doesn't produce an error when
12312 # something is both a revision and a filename. To be consistent
12313 # with git log and git rev-list, check revtreeargs for filenames.
12314 foreach arg $revtreeargs {
12315 if {[file exists $arg]} {
12316 show_error {} . [mc "Ambiguous argument '%s': both revision\
12317 and filename" $arg]
12322 # unfortunately we get both stdout and stderr in $err,
12323 # so look for "fatal:".
12324 set i [string first "fatal:" $err]
12326 set err [string range $err [expr {$i + 6}] end]
12328 show_error {} . "[mc "Bad arguments to gitk:"]\n$err"
12333 set nullid "0000000000000000000000000000000000000000"
12334 set nullid2 "0000000000000000000000000000000000000001"
12335 set nullfile "/dev/null"
12337 set have_tk85 [expr {[package vcompare $tk_version "8.5"] >= 0}]
12338 if {![info exists have_ttk]} {
12339 set have_ttk [llength [info commands ::ttk::style]]
12341 set use_ttk [expr {$have_ttk && $want_ttk}]
12342 set NS [expr {$use_ttk ? "ttk" : ""}]
12344 regexp {^git version ([\d.]*\d)} [exec git version] _ git_version
12347 if {[package vcompare $git_version "1.6.6.2"] >= 0} {
12348 set show_notes "--show-notes"
12358 set highlight_paths {}
12360 set searchdirn -forwards
12363 set diffelide {0 0}
12364 set markingmatches 0
12365 set linkentercount 0
12366 set need_redisplay 0
12373 set selectedhlview [mc "None"]
12374 set highlight_related [mc "None"]
12375 set highlight_files {}
12376 set viewfiles(0) {}
12378 set viewchanged(0) 0
12380 set viewargscmd(0) {}
12382 set selectedline {}
12390 set hasworktree [hasworktree]
12392 if {[expr {[exec git rev-parse --is-inside-work-tree] == "true"}]} {
12393 set cdup [exec git rev-parse --show-cdup]
12395 set worktree [exec git rev-parse --show-toplevel]
12399 image create photo gitlogo -width 16 -height 16
12401 image create photo gitlogominus -width 4 -height 2
12402 gitlogominus put #C00000 -to 0 0 4 2
12403 gitlogo copy gitlogominus -to 1 5
12404 gitlogo copy gitlogominus -to 6 5
12405 gitlogo copy gitlogominus -to 11 5
12406 image delete gitlogominus
12408 image create photo gitlogoplus -width 4 -height 4
12409 gitlogoplus put #008000 -to 1 0 3 4
12410 gitlogoplus put #008000 -to 0 1 4 3
12411 gitlogo copy gitlogoplus -to 1 9
12412 gitlogo copy gitlogoplus -to 6 9
12413 gitlogo copy gitlogoplus -to 11 9
12414 image delete gitlogoplus
12416 image create photo gitlogo32 -width 32 -height 32
12417 gitlogo32 copy gitlogo -zoom 2 2
12419 wm iconphoto . -default gitlogo gitlogo32
12421 # wait for the window to become visible
12422 tkwait visibility .
12427 if {$cmdline_files ne {} || $revtreeargs ne {} || $revtreeargscmd ne {}} {
12428 # create a view for the files/dirs specified on the command line
12432 set viewname(1) [mc "Command line"]
12433 set viewfiles(1) $cmdline_files
12434 set viewargs(1) $revtreeargs
12435 set viewargscmd(1) $revtreeargscmd
12437 set viewchanged(1) 0
12440 .bar.view entryconf [mca "Edit view..."] -state normal
12441 .bar.view entryconf [mca "Delete view"] -state normal
12444 if {[info exists permviews]} {
12445 foreach v $permviews {
12448 set viewname($n) [lindex $v 0]
12449 set viewfiles($n) [lindex $v 1]
12450 set viewargs($n) [lindex $v 2]
12451 set viewargscmd($n) [lindex $v 3]
12453 set viewchanged($n) 0
12458 if {[tk windowingsystem] eq "win32"} {
12466 # indent-tabs-mode: t