2 # Tcl ignores the next line -*- tcl -*- \
5 # Copyright © 2005-2011 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
159 global worddiff git_version
167 set origargs $arglist
171 foreach arg $arglist {
178 switch -glob -- $arg {
182 # remove from origargs in case we hit an unknown option
183 set origargs [lreplace $origargs $i $i]
187 "--no-renames" - "--full-index" - "--binary" - "--abbrev=*" -
188 "--find-copies-harder" - "-l*" - "--ext-diff" - "--no-ext-diff" -
189 "--src-prefix=*" - "--dst-prefix=*" - "--no-prefix" -
190 "-O*" - "--text" - "--full-diff" - "--ignore-space-at-eol" -
191 "--ignore-space-change" - "-U*" - "--unified=*" {
192 # These request or affect diff output, which we don't want.
193 # Some could be used to set our defaults for diff display.
194 lappend diffargs
$arg
196 "--raw" - "--patch-with-raw" - "--patch-with-stat" -
197 "--name-only" - "--name-status" - "--color" -
198 "--log-size" - "--pretty=*" - "--decorate" - "--abbrev-commit" -
199 "--cc" - "-z" - "--header" - "--parents" - "--boundary" -
200 "--no-color" - "-g" - "--walk-reflogs" - "--no-walk" -
201 "--timestamp" - "relative-date" - "--date=*" - "--stdin" -
202 "--objects" - "--objects-edge" - "--reverse" {
203 # These cause our parsing of git log's output to fail, or else
204 # they're options we want to set ourselves, so ignore them.
206 "--color-words*" - "--word-diff=color" {
207 # These trigger a word diff in the console interface,
208 # so help the user by enabling our own support
209 if {[package vcompare
$git_version "1.7.2"] >= 0} {
210 set worddiff
[mc
"Color words"]
214 if {[package vcompare
$git_version "1.7.2"] >= 0} {
215 set worddiff
[mc
"Markup words"]
218 "--stat=*" - "--numstat" - "--shortstat" - "--summary" -
219 "--check" - "--exit-code" - "--quiet" - "--topo-order" -
220 "--full-history" - "--dense" - "--sparse" -
221 "--follow" - "--left-right" - "--encoding=*" {
222 # These are harmless, and some are even useful
225 "--diff-filter=*" - "--no-merges" - "--unpacked" -
226 "--max-count=*" - "--skip=*" - "--since=*" - "--after=*" -
227 "--until=*" - "--before=*" - "--max-age=*" - "--min-age=*" -
228 "--author=*" - "--committer=*" - "--grep=*" - "-[iE]" -
229 "--remove-empty" - "--first-parent" - "--cherry-pick" -
230 "-S*" - "--pickaxe-all" - "--pickaxe-regex" -
231 "--simplify-by-decoration" {
232 # These mean that we get a subset of the commits
237 # This appears to be the only one that has a value as a
238 # separate word following it
248 # git rev-parse doesn't understand --merge
249 lappend revargs
--gitk-symmetric-diff-marker MERGE_HEAD...HEAD
251 "--no-replace-objects" {
252 set env
(GIT_NO_REPLACE_OBJECTS
) "1"
255 # Other flag arguments including -<n>
256 if {[string is digit
-strict [string range
$arg 1 end
]]} {
259 # a flag argument that we don't recognize;
260 # that means we can't optimize
266 # Non-flag arguments specify commits or ranges of commits
267 if {[string match
"*...*" $arg]} {
268 lappend revargs
--gitk-symmetric-diff-marker
274 set vdflags
($n) $diffargs
275 set vflags
($n) $glflags
276 set vrevs
($n) $revargs
277 set vfiltered
($n) $filtered
278 set vorigargs
($n) $origargs
282 proc parseviewrevs
{view revs
} {
283 global vposids vnegids
288 if {[catch
{set ids
[eval exec git rev-parse
$revs]} err
]} {
289 # we get stdout followed by stderr in $err
290 # for an unknown rev, git rev-parse echoes it and then errors out
291 set errlines
[split $err "\n"]
293 for {set l
0} {$l < [llength
$errlines]} {incr l
} {
294 set line
[lindex
$errlines $l]
295 if {!([string length
$line] == 40 && [string is xdigit
$line])} {
296 if {[string match
"fatal:*" $line]} {
297 if {[string match
"fatal: ambiguous argument*" $line]
299 if {[llength
$badrev] == 1} {
300 set err
"unknown revision $badrev"
302 set err
"unknown revisions: [join $badrev ", "]"
305 set err
[join [lrange
$errlines $l end
] "\n"]
312 error_popup
"[mc "Error parsing revisions
:"] $err"
319 foreach id
[split $ids "\n"] {
320 if {$id eq
"--gitk-symmetric-diff-marker"} {
322 } elseif
{[string match
"^*" $id]} {
329 lappend neg
[string range
$id 1 end
]
334 lset ret end
$id...
[lindex
$ret end
]
340 set vposids
($view) $pos
341 set vnegids
($view) $neg
345 # Start off a git log process and arrange to read its output
346 proc start_rev_list
{view
} {
347 global startmsecs commitidx viewcomplete curview
349 global viewargs viewargscmd viewfiles vfilelimit
350 global showlocalchanges
351 global viewactive viewinstances vmergeonly
352 global mainheadid viewmainheadid viewmainheadid_orig
353 global vcanopt vflags vrevs vorigargs
356 set startmsecs
[clock clicks
-milliseconds]
357 set commitidx
($view) 0
358 # these are set this way for the error exits
359 set viewcomplete
($view) 1
360 set viewactive
($view) 0
363 set args
$viewargs($view)
364 if {$viewargscmd($view) ne
{}} {
366 set str
[exec sh
-c $viewargscmd($view)]
368 error_popup
"[mc "Error executing
--argscmd command:"] $err"
371 set args
[concat
$args [split $str "\n"]]
373 set vcanopt
($view) [parseviewargs
$view $args]
375 set files
$viewfiles($view)
376 if {$vmergeonly($view)} {
377 set files
[unmerged_files
$files]
380 if {$nr_unmerged == 0} {
381 error_popup
[mc
"No files selected: --merge specified but\
382 no files are unmerged."]
384 error_popup
[mc
"No files selected: --merge specified but\
385 no unmerged files are within file limit."]
390 set vfilelimit
($view) $files
392 if {$vcanopt($view)} {
393 set revs
[parseviewrevs
$view $vrevs($view)]
397 set args
[concat
$vflags($view) $revs]
399 set args
$vorigargs($view)
403 set fd
[open
[concat | git log
--no-color -z --pretty=raw
$show_notes \
404 --parents --boundary $args "--" $files] r
]
406 error_popup
"[mc "Error executing git log
:"] $err"
409 set i
[reg_instance
$fd]
410 set viewinstances
($view) [list
$i]
411 set viewmainheadid
($view) $mainheadid
412 set viewmainheadid_orig
($view) $mainheadid
413 if {$files ne
{} && $mainheadid ne
{}} {
414 get_viewmainhead
$view
416 if {$showlocalchanges && $viewmainheadid($view) ne
{}} {
417 interestedin
$viewmainheadid($view) dodiffindex
419 fconfigure
$fd -blocking 0 -translation lf
-eofchar {}
420 if {$tclencoding != {}} {
421 fconfigure
$fd -encoding $tclencoding
423 filerun
$fd [list getcommitlines
$fd $i $view 0]
424 nowbusy
$view [mc
"Reading"]
425 set viewcomplete
($view) 0
426 set viewactive
($view) 1
430 proc stop_instance
{inst
} {
431 global commfd leftover
433 set fd
$commfd($inst)
437 if {$
::tcl_platform
(platform
) eq
{windows
}} {
446 unset leftover
($inst)
449 proc stop_backends
{} {
452 foreach inst
[array names commfd
] {
457 proc stop_rev_list
{view
} {
460 foreach inst
$viewinstances($view) {
463 set viewinstances
($view) {}
466 proc reset_pending_select
{selid
} {
467 global pending_select mainheadid selectheadid
470 set pending_select
$selid
471 } elseif
{$selectheadid ne
{}} {
472 set pending_select
$selectheadid
474 set pending_select
$mainheadid
478 proc getcommits
{selid
} {
479 global canv curview need_redisplay viewactive
482 if {[start_rev_list
$curview]} {
483 reset_pending_select
$selid
484 show_status
[mc
"Reading commits..."]
487 show_status
[mc
"No commits selected"]
491 proc updatecommits
{} {
492 global curview vcanopt vorigargs vfilelimit viewinstances
493 global viewactive viewcomplete tclencoding
494 global startmsecs showneartags showlocalchanges
495 global mainheadid viewmainheadid viewmainheadid_orig pending_select
497 global varcid vposids vnegids vflags vrevs
500 set hasworktree
[hasworktree
]
503 if {$mainheadid ne
$viewmainheadid_orig($view)} {
504 if {$showlocalchanges} {
507 set viewmainheadid
($view) $mainheadid
508 set viewmainheadid_orig
($view) $mainheadid
509 if {$vfilelimit($view) ne
{}} {
510 get_viewmainhead
$view
513 if {$showlocalchanges} {
516 if {$vcanopt($view)} {
517 set oldpos
$vposids($view)
518 set oldneg
$vnegids($view)
519 set revs
[parseviewrevs
$view $vrevs($view)]
523 # note: getting the delta when negative refs change is hard,
524 # and could require multiple git log invocations, so in that
525 # case we ask git log for all the commits (not just the delta)
526 if {$oldneg eq
$vnegids($view)} {
529 # take out positive refs that we asked for before or
530 # that we have already seen
532 if {[string length
$rev] == 40} {
533 if {[lsearch
-exact $oldpos $rev] < 0
534 && ![info exists varcid
($view,$rev)]} {
539 lappend
$newrevs $rev
542 if {$npos == 0} return
544 set vposids
($view) [lsort
-unique [concat
$oldpos $vposids($view)]]
546 set args
[concat
$vflags($view) $revs --not $oldpos]
548 set args
$vorigargs($view)
551 set fd
[open
[concat | git log
--no-color -z --pretty=raw
$show_notes \
552 --parents --boundary $args "--" $vfilelimit($view)] r
]
554 error_popup
"[mc "Error executing git log
:"] $err"
557 if {$viewactive($view) == 0} {
558 set startmsecs
[clock clicks
-milliseconds]
560 set i
[reg_instance
$fd]
561 lappend viewinstances
($view) $i
562 fconfigure
$fd -blocking 0 -translation lf
-eofchar {}
563 if {$tclencoding != {}} {
564 fconfigure
$fd -encoding $tclencoding
566 filerun
$fd [list getcommitlines
$fd $i $view 1]
567 incr viewactive
($view)
568 set viewcomplete
($view) 0
569 reset_pending_select
{}
570 nowbusy
$view [mc
"Reading"]
576 proc reloadcommits
{} {
577 global curview viewcomplete selectedline currentid thickerline
578 global showneartags treediffs commitinterest cached_commitrow
582 if {$selectedline ne
{}} {
586 if {!$viewcomplete($curview)} {
587 stop_rev_list
$curview
591 catch
{unset currentid
}
592 catch
{unset thickerline
}
593 catch
{unset treediffs
}
600 catch
{unset commitinterest
}
601 catch
{unset cached_commitrow
}
602 catch
{unset targetid
}
608 # This makes a string representation of a positive integer which
609 # sorts as a string in numerical order
612 return [format
"%x" $n]
613 } elseif
{$n < 256} {
614 return [format
"x%.2x" $n]
615 } elseif
{$n < 65536} {
616 return [format
"y%.4x" $n]
618 return [format
"z%.8x" $n]
621 # Procedures used in reordering commits from git log (without
622 # --topo-order) into the order for display.
624 proc varcinit
{view
} {
625 global varcstart vupptr vdownptr vleftptr vbackptr varctok varcrow
626 global vtokmod varcmod vrowmod varcix vlastins
628 set varcstart
($view) {{}}
629 set vupptr
($view) {0}
630 set vdownptr
($view) {0}
631 set vleftptr
($view) {0}
632 set vbackptr
($view) {0}
633 set varctok
($view) {{}}
634 set varcrow
($view) {{}}
635 set vtokmod
($view) {}
638 set varcix
($view) {{}}
639 set vlastins
($view) {0}
642 proc resetvarcs
{view
} {
643 global varcid varccommits parents children vseedcount ordertok
646 foreach vid
[array names varcid
$view,*] {
651 foreach vid
[array names vshortids
$view,*] {
652 unset vshortids
($vid)
654 # some commits might have children but haven't been seen yet
655 foreach vid
[array names children
$view,*] {
658 foreach va
[array names varccommits
$view,*] {
659 unset varccommits
($va)
661 foreach vd
[array names vseedcount
$view,*] {
662 unset vseedcount
($vd)
664 catch
{unset ordertok
}
667 # returns a list of the commits with no children
669 global vdownptr vleftptr varcstart
672 set a
[lindex
$vdownptr($v) 0]
674 lappend ret
[lindex
$varcstart($v) $a]
675 set a
[lindex
$vleftptr($v) $a]
680 proc newvarc
{view id
} {
681 global varcid varctok parents children vdatemode
682 global vupptr vdownptr vleftptr vbackptr varcrow varcix varcstart
683 global commitdata commitinfo vseedcount varccommits vlastins
685 set a
[llength
$varctok($view)]
687 if {[llength
$children($vid)] == 0 ||
$vdatemode($view)} {
688 if {![info exists commitinfo
($id)]} {
689 parsecommit
$id $commitdata($id) 1
691 set cdate
[lindex
[lindex
$commitinfo($id) 4] 0]
692 if {![string is integer
-strict $cdate]} {
695 if {![info exists vseedcount
($view,$cdate)]} {
696 set vseedcount
($view,$cdate) -1
698 set c
[incr vseedcount
($view,$cdate)]
699 set cdate
[expr {$cdate ^
0xffffffff}]
700 set tok
"s[strrep $cdate][strrep $c]"
705 if {[llength
$children($vid)] > 0} {
706 set kid
[lindex
$children($vid) end
]
707 set k
$varcid($view,$kid)
708 if {[string compare
[lindex
$varctok($view) $k] $tok] > 0} {
711 set tok
[lindex
$varctok($view) $k]
715 set i
[lsearch
-exact $parents($view,$ki) $id]
716 set j
[expr {[llength
$parents($view,$ki)] - 1 - $i}]
717 append tok
[strrep
$j]
719 set c
[lindex
$vlastins($view) $ka]
720 if {$c == 0 ||
[string compare
$tok [lindex
$varctok($view) $c]] < 0} {
722 set b
[lindex
$vdownptr($view) $ka]
724 set b
[lindex
$vleftptr($view) $c]
726 while {$b != 0 && [string compare
$tok [lindex
$varctok($view) $b]] >= 0} {
728 set b
[lindex
$vleftptr($view) $c]
731 lset vdownptr
($view) $ka $a
732 lappend vbackptr
($view) 0
734 lset vleftptr
($view) $c $a
735 lappend vbackptr
($view) $c
737 lset vlastins
($view) $ka $a
738 lappend vupptr
($view) $ka
739 lappend vleftptr
($view) $b
741 lset vbackptr
($view) $b $a
743 lappend varctok
($view) $tok
744 lappend varcstart
($view) $id
745 lappend vdownptr
($view) 0
746 lappend varcrow
($view) {}
747 lappend varcix
($view) {}
748 set varccommits
($view,$a) {}
749 lappend vlastins
($view) 0
753 proc splitvarc
{p v
} {
754 global varcid varcstart varccommits varctok vtokmod
755 global vupptr vdownptr vleftptr vbackptr varcix varcrow vlastins
757 set oa
$varcid($v,$p)
758 set otok
[lindex
$varctok($v) $oa]
759 set ac
$varccommits($v,$oa)
760 set i
[lsearch
-exact $varccommits($v,$oa) $p]
762 set na
[llength
$varctok($v)]
763 # "%" sorts before "0"...
764 set tok
"$otok%[strrep $i]"
765 lappend varctok
($v) $tok
766 lappend varcrow
($v) {}
767 lappend varcix
($v) {}
768 set varccommits
($v,$oa) [lrange
$ac 0 [expr {$i - 1}]]
769 set varccommits
($v,$na) [lrange
$ac $i end
]
770 lappend varcstart
($v) $p
771 foreach id
$varccommits($v,$na) {
772 set varcid
($v,$id) $na
774 lappend vdownptr
($v) [lindex
$vdownptr($v) $oa]
775 lappend vlastins
($v) [lindex
$vlastins($v) $oa]
776 lset vdownptr
($v) $oa $na
777 lset vlastins
($v) $oa 0
778 lappend vupptr
($v) $oa
779 lappend vleftptr
($v) 0
780 lappend vbackptr
($v) 0
781 for {set b
[lindex
$vdownptr($v) $na]} {$b != 0} {set b
[lindex
$vleftptr($v) $b]} {
782 lset vupptr
($v) $b $na
784 if {[string compare
$otok $vtokmod($v)] <= 0} {
789 proc renumbervarc
{a v
} {
790 global parents children varctok varcstart varccommits
791 global vupptr vdownptr vleftptr vbackptr vlastins varcid vtokmod vdatemode
793 set t1
[clock clicks
-milliseconds]
799 if {[info exists isrelated
($a)]} {
801 set id
[lindex
$varccommits($v,$a) end
]
802 foreach p
$parents($v,$id) {
803 if {[info exists varcid
($v,$p)]} {
804 set isrelated
($varcid($v,$p)) 1
809 set b
[lindex
$vdownptr($v) $a]
812 set b
[lindex
$vleftptr($v) $a]
814 set a
[lindex
$vupptr($v) $a]
820 if {![info exists kidchanged
($a)]} continue
821 set id
[lindex
$varcstart($v) $a]
822 if {[llength
$children($v,$id)] > 1} {
823 set children
($v,$id) [lsort
-command [list vtokcmp
$v] \
826 set oldtok
[lindex
$varctok($v) $a]
827 if {!$vdatemode($v)} {
833 set kid
[last_real_child
$v,$id]
835 set k
$varcid($v,$kid)
836 if {[string compare
[lindex
$varctok($v) $k] $tok] > 0} {
839 set tok
[lindex
$varctok($v) $k]
843 set i
[lsearch
-exact $parents($v,$ki) $id]
844 set j
[expr {[llength
$parents($v,$ki)] - 1 - $i}]
845 append tok
[strrep
$j]
847 if {$tok eq
$oldtok} {
850 set id
[lindex
$varccommits($v,$a) end
]
851 foreach p
$parents($v,$id) {
852 if {[info exists varcid
($v,$p)]} {
853 set kidchanged
($varcid($v,$p)) 1
858 lset varctok
($v) $a $tok
859 set b
[lindex
$vupptr($v) $a]
861 if {[string compare
[lindex
$varctok($v) $ka] $vtokmod($v)] < 0} {
864 if {[string compare
[lindex
$varctok($v) $b] $vtokmod($v)] < 0} {
867 set c
[lindex
$vbackptr($v) $a]
868 set d
[lindex
$vleftptr($v) $a]
870 lset vdownptr
($v) $b $d
872 lset vleftptr
($v) $c $d
875 lset vbackptr
($v) $d $c
877 if {[lindex
$vlastins($v) $b] == $a} {
878 lset vlastins
($v) $b $c
880 lset vupptr
($v) $a $ka
881 set c
[lindex
$vlastins($v) $ka]
883 [string compare
$tok [lindex
$varctok($v) $c]] < 0} {
885 set b
[lindex
$vdownptr($v) $ka]
887 set b
[lindex
$vleftptr($v) $c]
890 [string compare
$tok [lindex
$varctok($v) $b]] >= 0} {
892 set b
[lindex
$vleftptr($v) $c]
895 lset vdownptr
($v) $ka $a
896 lset vbackptr
($v) $a 0
898 lset vleftptr
($v) $c $a
899 lset vbackptr
($v) $a $c
901 lset vleftptr
($v) $a $b
903 lset vbackptr
($v) $b $a
905 lset vlastins
($v) $ka $a
908 foreach id
[array names sortkids
] {
909 if {[llength
$children($v,$id)] > 1} {
910 set children
($v,$id) [lsort
-command [list vtokcmp
$v] \
914 set t2
[clock clicks
-milliseconds]
915 #puts "renumbervarc did [llength $todo] of $ntot arcs in [expr {$t2-$t1}]ms"
918 # Fix up the graph after we have found out that in view $v,
919 # $p (a commit that we have already seen) is actually the parent
920 # of the last commit in arc $a.
921 proc fix_reversal
{p a v
} {
922 global varcid varcstart varctok vupptr
924 set pa
$varcid($v,$p)
925 if {$p ne
[lindex
$varcstart($v) $pa]} {
927 set pa
$varcid($v,$p)
929 # seeds always need to be renumbered
930 if {[lindex
$vupptr($v) $pa] == 0 ||
931 [string compare
[lindex
$varctok($v) $a] \
932 [lindex
$varctok($v) $pa]] > 0} {
937 proc insertrow
{id p v
} {
938 global cmitlisted children parents varcid varctok vtokmod
939 global varccommits ordertok commitidx numcommits curview
940 global targetid targetrow vshortids
944 set cmitlisted
($vid) 1
945 set children
($vid) {}
946 set parents
($vid) [list
$p]
947 set a
[newvarc
$v $id]
949 lappend vshortids
($v,[string range
$id 0 3]) $id
950 if {[string compare
[lindex
$varctok($v) $a] $vtokmod($v)] < 0} {
953 lappend varccommits
($v,$a) $id
955 if {[llength
[lappend children
($vp) $id]] > 1} {
956 set children
($vp) [lsort
-command [list vtokcmp
$v] $children($vp)]
957 catch
{unset ordertok
}
959 fix_reversal
$p $a $v
961 if {$v == $curview} {
962 set numcommits
$commitidx($v)
964 if {[info exists targetid
]} {
965 if {![comes_before
$targetid $p]} {
972 proc insertfakerow
{id p
} {
973 global varcid varccommits parents children cmitlisted
974 global commitidx varctok vtokmod targetid targetrow curview numcommits
978 set i
[lsearch
-exact $varccommits($v,$a) $p]
980 puts
"oops: insertfakerow can't find [shortids $p] on arc $a"
983 set children
($v,$id) {}
984 set parents
($v,$id) [list
$p]
985 set varcid
($v,$id) $a
986 lappend children
($v,$p) $id
987 set cmitlisted
($v,$id) 1
988 set numcommits
[incr commitidx
($v)]
989 # note we deliberately don't update varcstart($v) even if $i == 0
990 set varccommits
($v,$a) [linsert
$varccommits($v,$a) $i $id]
992 if {[info exists targetid
]} {
993 if {![comes_before
$targetid $p]} {
1001 proc removefakerow
{id
} {
1002 global varcid varccommits parents children commitidx
1003 global varctok vtokmod cmitlisted currentid selectedline
1004 global targetid curview numcommits
1007 if {[llength
$parents($v,$id)] != 1} {
1008 puts
"oops: removefakerow [shortids $id] has [llength $parents($v,$id)] parents"
1011 set p
[lindex
$parents($v,$id) 0]
1012 set a
$varcid($v,$id)
1013 set i
[lsearch
-exact $varccommits($v,$a) $id]
1015 puts
"oops: removefakerow can't find [shortids $id] on arc $a"
1018 unset varcid
($v,$id)
1019 set varccommits
($v,$a) [lreplace
$varccommits($v,$a) $i $i]
1020 unset parents
($v,$id)
1021 unset children
($v,$id)
1022 unset cmitlisted
($v,$id)
1023 set numcommits
[incr commitidx
($v) -1]
1024 set j
[lsearch
-exact $children($v,$p) $id]
1026 set children
($v,$p) [lreplace
$children($v,$p) $j $j]
1029 if {[info exist currentid
] && $id eq
$currentid} {
1033 if {[info exists targetid
] && $targetid eq
$id} {
1040 proc real_children
{vp
} {
1041 global children nullid nullid2
1044 foreach id
$children($vp) {
1045 if {$id ne
$nullid && $id ne
$nullid2} {
1052 proc first_real_child
{vp
} {
1053 global children nullid nullid2
1055 foreach id
$children($vp) {
1056 if {$id ne
$nullid && $id ne
$nullid2} {
1063 proc last_real_child
{vp
} {
1064 global children nullid nullid2
1066 set kids
$children($vp)
1067 for {set i
[llength
$kids]} {[incr i
-1] >= 0} {} {
1068 set id
[lindex
$kids $i]
1069 if {$id ne
$nullid && $id ne
$nullid2} {
1076 proc vtokcmp
{v a b
} {
1077 global varctok varcid
1079 return [string compare
[lindex
$varctok($v) $varcid($v,$a)] \
1080 [lindex
$varctok($v) $varcid($v,$b)]]
1083 # This assumes that if lim is not given, the caller has checked that
1084 # arc a's token is less than $vtokmod($v)
1085 proc modify_arc
{v a
{lim
{}}} {
1086 global varctok vtokmod varcmod varcrow vupptr curview vrowmod varccommits
1089 set c
[string compare
[lindex
$varctok($v) $a] $vtokmod($v)]
1092 set r
[lindex
$varcrow($v) $a]
1093 if {$r ne
{} && $vrowmod($v) <= $r + $lim} return
1096 set vtokmod
($v) [lindex
$varctok($v) $a]
1098 if {$v == $curview} {
1099 while {$a != 0 && [lindex
$varcrow($v) $a] eq
{}} {
1100 set a
[lindex
$vupptr($v) $a]
1106 set lim
[llength
$varccommits($v,$a)]
1108 set r
[expr {[lindex
$varcrow($v) $a] + $lim}]
1115 proc update_arcrows
{v
} {
1116 global vtokmod varcmod vrowmod varcrow commitidx currentid selectedline
1117 global varcid vrownum varcorder varcix varccommits
1118 global vupptr vdownptr vleftptr varctok
1119 global displayorder parentlist curview cached_commitrow
1121 if {$vrowmod($v) == $commitidx($v)} return
1122 if {$v == $curview} {
1123 if {[llength
$displayorder] > $vrowmod($v)} {
1124 set displayorder
[lrange
$displayorder 0 [expr {$vrowmod($v) - 1}]]
1125 set parentlist
[lrange
$parentlist 0 [expr {$vrowmod($v) - 1}]]
1127 catch
{unset cached_commitrow
}
1129 set narctot
[expr {[llength
$varctok($v)] - 1}]
1131 while {$a != 0 && [lindex
$varcix($v) $a] eq
{}} {
1132 # go up the tree until we find something that has a row number,
1133 # or we get to a seed
1134 set a
[lindex
$vupptr($v) $a]
1137 set a
[lindex
$vdownptr($v) 0]
1140 set varcorder
($v) [list
$a]
1141 lset varcix
($v) $a 0
1142 lset varcrow
($v) $a 0
1146 set arcn
[lindex
$varcix($v) $a]
1147 if {[llength
$vrownum($v)] > $arcn + 1} {
1148 set vrownum
($v) [lrange
$vrownum($v) 0 $arcn]
1149 set varcorder
($v) [lrange
$varcorder($v) 0 $arcn]
1151 set row
[lindex
$varcrow($v) $a]
1155 incr row
[llength
$varccommits($v,$a)]
1156 # go down if possible
1157 set b
[lindex
$vdownptr($v) $a]
1159 # if not, go left, or go up until we can go left
1161 set b
[lindex
$vleftptr($v) $a]
1163 set a
[lindex
$vupptr($v) $a]
1169 lappend vrownum
($v) $row
1170 lappend varcorder
($v) $a
1171 lset varcix
($v) $a $arcn
1172 lset varcrow
($v) $a $row
1174 set vtokmod
($v) [lindex
$varctok($v) $p]
1176 set vrowmod
($v) $row
1177 if {[info exists currentid
]} {
1178 set selectedline
[rowofcommit
$currentid]
1182 # Test whether view $v contains commit $id
1183 proc commitinview
{id v
} {
1186 return [info exists varcid
($v,$id)]
1189 # Return the row number for commit $id in the current view
1190 proc rowofcommit
{id
} {
1191 global varcid varccommits varcrow curview cached_commitrow
1192 global varctok vtokmod
1195 if {![info exists varcid
($v,$id)]} {
1196 puts
"oops rowofcommit no arc for [shortids $id]"
1199 set a
$varcid($v,$id)
1200 if {[string compare
[lindex
$varctok($v) $a] $vtokmod($v)] >= 0} {
1203 if {[info exists cached_commitrow
($id)]} {
1204 return $cached_commitrow($id)
1206 set i
[lsearch
-exact $varccommits($v,$a) $id]
1208 puts
"oops didn't find commit [shortids $id] in arc $a"
1211 incr i
[lindex
$varcrow($v) $a]
1212 set cached_commitrow
($id) $i
1216 # Returns 1 if a is on an earlier row than b, otherwise 0
1217 proc comes_before
{a b
} {
1218 global varcid varctok curview
1221 if {$a eq
$b ||
![info exists varcid
($v,$a)] || \
1222 ![info exists varcid
($v,$b)]} {
1225 if {$varcid($v,$a) != $varcid($v,$b)} {
1226 return [expr {[string compare
[lindex
$varctok($v) $varcid($v,$a)] \
1227 [lindex
$varctok($v) $varcid($v,$b)]] < 0}]
1229 return [expr {[rowofcommit
$a] < [rowofcommit
$b]}]
1232 proc bsearch
{l elt
} {
1233 if {[llength
$l] == 0 ||
$elt <= [lindex
$l 0]} {
1238 while {$hi - $lo > 1} {
1239 set mid
[expr {int
(($lo + $hi) / 2)}]
1240 set t
[lindex
$l $mid]
1243 } elseif
{$elt > $t} {
1252 # Make sure rows $start..$end-1 are valid in displayorder and parentlist
1253 proc make_disporder
{start end
} {
1254 global vrownum curview commitidx displayorder parentlist
1255 global varccommits varcorder parents vrowmod varcrow
1256 global d_valid_start d_valid_end
1258 if {$end > $vrowmod($curview)} {
1259 update_arcrows
$curview
1261 set ai
[bsearch
$vrownum($curview) $start]
1262 set start
[lindex
$vrownum($curview) $ai]
1263 set narc
[llength
$vrownum($curview)]
1264 for {set r
$start} {$ai < $narc && $r < $end} {incr ai
} {
1265 set a
[lindex
$varcorder($curview) $ai]
1266 set l
[llength
$displayorder]
1267 set al
[llength
$varccommits($curview,$a)]
1268 if {$l < $r + $al} {
1270 set pad
[ntimes
[expr {$r - $l}] {}]
1271 set displayorder
[concat
$displayorder $pad]
1272 set parentlist
[concat
$parentlist $pad]
1273 } elseif
{$l > $r} {
1274 set displayorder
[lrange
$displayorder 0 [expr {$r - 1}]]
1275 set parentlist
[lrange
$parentlist 0 [expr {$r - 1}]]
1277 foreach id
$varccommits($curview,$a) {
1278 lappend displayorder
$id
1279 lappend parentlist
$parents($curview,$id)
1281 } elseif
{[lindex
$displayorder [expr {$r + $al - 1}]] eq
{}} {
1283 foreach id
$varccommits($curview,$a) {
1284 lset displayorder
$i $id
1285 lset parentlist
$i $parents($curview,$id)
1293 proc commitonrow
{row
} {
1296 set id
[lindex
$displayorder $row]
1298 make_disporder
$row [expr {$row + 1}]
1299 set id
[lindex
$displayorder $row]
1304 proc closevarcs
{v
} {
1305 global varctok varccommits varcid parents children
1306 global cmitlisted commitidx vtokmod
1308 set missing_parents
0
1310 set narcs
[llength
$varctok($v)]
1311 for {set a
1} {$a < $narcs} {incr a
} {
1312 set id
[lindex
$varccommits($v,$a) end
]
1313 foreach p
$parents($v,$id) {
1314 if {[info exists varcid
($v,$p)]} continue
1315 # add p as a new commit
1316 incr missing_parents
1317 set cmitlisted
($v,$p) 0
1318 set parents
($v,$p) {}
1319 if {[llength
$children($v,$p)] == 1 &&
1320 [llength
$parents($v,$id)] == 1} {
1323 set b
[newvarc
$v $p]
1325 set varcid
($v,$p) $b
1326 if {[string compare
[lindex
$varctok($v) $b] $vtokmod($v)] < 0} {
1329 lappend varccommits
($v,$b) $p
1331 set scripts
[check_interest
$p $scripts]
1334 if {$missing_parents > 0} {
1335 foreach s
$scripts {
1341 # Use $rwid as a substitute for $id, i.e. reparent $id's children to $rwid
1342 # Assumes we already have an arc for $rwid.
1343 proc rewrite_commit
{v id rwid
} {
1344 global children parents varcid varctok vtokmod varccommits
1346 foreach ch
$children($v,$id) {
1347 # make $rwid be $ch's parent in place of $id
1348 set i
[lsearch
-exact $parents($v,$ch) $id]
1350 puts
"oops rewrite_commit didn't find $id in parent list for $ch"
1352 set parents
($v,$ch) [lreplace
$parents($v,$ch) $i $i $rwid]
1353 # add $ch to $rwid's children and sort the list if necessary
1354 if {[llength
[lappend children
($v,$rwid) $ch]] > 1} {
1355 set children
($v,$rwid) [lsort
-command [list vtokcmp
$v] \
1356 $children($v,$rwid)]
1358 # fix the graph after joining $id to $rwid
1359 set a
$varcid($v,$ch)
1360 fix_reversal
$rwid $a $v
1361 # parentlist is wrong for the last element of arc $a
1362 # even if displayorder is right, hence the 3rd arg here
1363 modify_arc
$v $a [expr {[llength
$varccommits($v,$a)] - 1}]
1367 # Mechanism for registering a command to be executed when we come
1368 # across a particular commit. To handle the case when only the
1369 # prefix of the commit is known, the commitinterest array is now
1370 # indexed by the first 4 characters of the ID. Each element is a
1371 # list of id, cmd pairs.
1372 proc interestedin
{id cmd
} {
1373 global commitinterest
1375 lappend commitinterest
([string range
$id 0 3]) $id $cmd
1378 proc check_interest
{id scripts
} {
1379 global commitinterest
1381 set prefix
[string range
$id 0 3]
1382 if {[info exists commitinterest
($prefix)]} {
1384 foreach
{i
script} $commitinterest($prefix) {
1385 if {[string match
"$i*" $id]} {
1386 lappend scripts
[string map
[list
"%I" $id "%P" $i] $script]
1388 lappend newlist
$i $script
1391 if {$newlist ne
{}} {
1392 set commitinterest
($prefix) $newlist
1394 unset commitinterest
($prefix)
1400 proc getcommitlines
{fd inst view updating
} {
1401 global cmitlisted leftover
1402 global commitidx commitdata vdatemode
1403 global parents children curview hlview
1404 global idpending ordertok
1405 global varccommits varcid varctok vtokmod vfilelimit vshortids
1407 set stuff
[read $fd 500000]
1408 # git log doesn't terminate the last commit with a null...
1409 if {$stuff == {} && $leftover($inst) ne
{} && [eof
$fd]} {
1416 global commfd viewcomplete viewactive viewname
1417 global viewinstances
1419 set i
[lsearch
-exact $viewinstances($view) $inst]
1421 set viewinstances
($view) [lreplace
$viewinstances($view) $i $i]
1423 # set it blocking so we wait for the process to terminate
1424 fconfigure
$fd -blocking 1
1425 if {[catch
{close
$fd} err
]} {
1427 if {$view != $curview} {
1428 set fv
" for the \"$viewname($view)\" view"
1430 if {[string range
$err 0 4] == "usage"} {
1431 set err
"Gitk: error reading commits$fv:\
1432 bad arguments to git log."
1433 if {$viewname($view) eq
"Command line"} {
1435 " (Note: arguments to gitk are passed to git log\
1436 to allow selection of commits to be displayed.)"
1439 set err
"Error reading commits$fv: $err"
1443 if {[incr viewactive
($view) -1] <= 0} {
1444 set viewcomplete
($view) 1
1445 # Check if we have seen any ids listed as parents that haven't
1446 # appeared in the list
1450 if {$view == $curview} {
1459 set i
[string first
"\0" $stuff $start]
1461 append leftover
($inst) [string range
$stuff $start end
]
1465 set cmit
$leftover($inst)
1466 append cmit
[string range
$stuff 0 [expr {$i - 1}]]
1467 set leftover
($inst) {}
1469 set cmit
[string range
$stuff $start [expr {$i - 1}]]
1471 set start
[expr {$i + 1}]
1472 set j
[string first
"\n" $cmit]
1475 if {$j >= 0 && [string match
"commit *" $cmit]} {
1476 set ids
[string range
$cmit 7 [expr {$j - 1}]]
1477 if {[string match
{[-^
<>]*} $ids]} {
1478 switch
-- [string index
$ids 0] {
1484 set ids
[string range
$ids 1 end
]
1488 if {[string length
$id] != 40} {
1496 if {[string length
$shortcmit] > 80} {
1497 set shortcmit
"[string range $shortcmit 0 80]..."
1499 error_popup
"[mc "Can
't parse git log output:"] {$shortcmit}"
1502 set id [lindex $ids 0]
1505 lappend vshortids($view,[string range $id 0 3]) $id
1507 if {!$listed && $updating && ![info exists varcid($vid)] &&
1508 $vfilelimit($view) ne {}} {
1509 # git log doesn't rewrite parents
for unlisted commits
1510 # when doing path limiting, so work around that here
1511 # by working out the rewritten parent with git rev-list
1512 # and if we already know about it, using the rewritten
1513 # parent as a substitute parent for $id's children.
1515 set rwid
[exec git rev-list
--first-parent --max-count=1 \
1516 $id -- $vfilelimit($view)]
1518 if {$rwid ne
{} && [info exists varcid
($view,$rwid)]} {
1519 # use $rwid in place of $id
1520 rewrite_commit
$view $id $rwid
1527 if {[info exists varcid
($vid)]} {
1528 if {$cmitlisted($vid) ||
!$listed} continue
1532 set olds
[lrange
$ids 1 end
]
1536 set commitdata
($id) [string range
$cmit [expr {$j + 1}] end
]
1537 set cmitlisted
($vid) $listed
1538 set parents
($vid) $olds
1539 if {![info exists children
($vid)]} {
1540 set children
($vid) {}
1541 } elseif
{$a == 0 && [llength
$children($vid)] == 1} {
1542 set k
[lindex
$children($vid) 0]
1543 if {[llength
$parents($view,$k)] == 1 &&
1544 (!$vdatemode($view) ||
1545 $varcid($view,$k) == [llength
$varctok($view)] - 1)} {
1546 set a
$varcid($view,$k)
1551 set a
[newvarc
$view $id]
1553 if {[string compare
[lindex
$varctok($view) $a] $vtokmod($view)] < 0} {
1556 if {![info exists varcid
($vid)]} {
1558 lappend varccommits
($view,$a) $id
1559 incr commitidx
($view)
1564 if {$i == 0 ||
[lsearch
-exact $olds $p] >= $i} {
1566 if {[llength
[lappend children
($vp) $id]] > 1 &&
1567 [vtokcmp
$view [lindex
$children($vp) end-1
] $id] > 0} {
1568 set children
($vp) [lsort
-command [list vtokcmp
$view] \
1570 catch
{unset ordertok
}
1572 if {[info exists varcid
($view,$p)]} {
1573 fix_reversal
$p $a $view
1579 set scripts
[check_interest
$id $scripts]
1583 global numcommits hlview
1585 if {$view == $curview} {
1586 set numcommits
$commitidx($view)
1589 if {[info exists hlview
] && $view == $hlview} {
1590 # we never actually get here...
1593 foreach s
$scripts {
1600 proc chewcommits
{} {
1601 global curview hlview viewcomplete
1602 global pending_select
1605 if {$viewcomplete($curview)} {
1606 global commitidx varctok
1607 global numcommits startmsecs
1609 if {[info exists pending_select
]} {
1611 reset_pending_select
{}
1613 if {[commitinview
$pending_select $curview]} {
1614 selectline
[rowofcommit
$pending_select] 1
1616 set row
[first_real_row
]
1620 if {$commitidx($curview) > 0} {
1621 #set ms [expr {[clock clicks -milliseconds] - $startmsecs}]
1622 #puts "overall $ms ms for $numcommits commits"
1623 #puts "[llength $varctok($view)] arcs, $commitidx($view) commits"
1625 show_status
[mc
"No commits selected"]
1632 proc do_readcommit
{id
} {
1635 # Invoke git-log to handle automatic encoding conversion
1636 set fd
[open
[concat | git log
--no-color --pretty=raw
-1 $id] r
]
1637 # Read the results using i18n.logoutputencoding
1638 fconfigure
$fd -translation lf
-eofchar {}
1639 if {$tclencoding != {}} {
1640 fconfigure
$fd -encoding $tclencoding
1642 set contents
[read $fd]
1644 # Remove the heading line
1645 regsub
{^commit
[0-9a-f]+\n} $contents {} contents
1650 proc readcommit
{id
} {
1651 if {[catch
{set contents
[do_readcommit
$id]}]} return
1652 parsecommit
$id $contents 1
1655 proc parsecommit
{id contents listed
} {
1665 set hdrend
[string first
"\n\n" $contents]
1667 # should never happen...
1668 set hdrend
[string length
$contents]
1670 set header
[string range
$contents 0 [expr {$hdrend - 1}]]
1671 set comment
[string range
$contents [expr {$hdrend + 2}] end
]
1672 foreach line
[split $header "\n"] {
1673 set line
[split $line " "]
1674 set tag
[lindex
$line 0]
1675 if {$tag == "author"} {
1676 set audate
[lrange
$line end-1 end
]
1677 set auname
[join [lrange
$line 1 end-2
] " "]
1678 } elseif
{$tag == "committer"} {
1679 set comdate
[lrange
$line end-1 end
]
1680 set comname
[join [lrange
$line 1 end-2
] " "]
1684 # take the first non-blank line of the comment as the headline
1685 set headline
[string trimleft
$comment]
1686 set i
[string first
"\n" $headline]
1688 set headline
[string range
$headline 0 $i]
1690 set headline
[string trimright
$headline]
1691 set i
[string first
"\r" $headline]
1693 set headline
[string trimright
[string range
$headline 0 $i]]
1696 # git log indents the comment by 4 spaces;
1697 # if we got this via git cat-file, add the indentation
1699 foreach line
[split $comment "\n"] {
1700 append newcomment
" "
1701 append newcomment
$line
1702 append newcomment
"\n"
1704 set comment
$newcomment
1706 set hasnote
[string first
"\nNotes:\n" $contents]
1707 set commitinfo
($id) [list
$headline $auname $audate \
1708 $comname $comdate $comment $hasnote]
1711 proc getcommit
{id
} {
1712 global commitdata commitinfo
1714 if {[info exists commitdata
($id)]} {
1715 parsecommit
$id $commitdata($id) 1
1718 if {![info exists commitinfo
($id)]} {
1719 set commitinfo
($id) [list
[mc
"No commit information available"]]
1725 # Expand an abbreviated commit ID to a list of full 40-char IDs that match
1726 # and are present in the current view.
1727 # This is fairly slow...
1728 proc longid
{prefix
} {
1729 global varcid curview vshortids
1732 if {[string length
$prefix] >= 4} {
1733 set vshortid
$curview,[string range
$prefix 0 3]
1734 if {[info exists vshortids
($vshortid)]} {
1735 foreach id
$vshortids($vshortid) {
1736 if {[string match
"$prefix*" $id]} {
1737 if {[lsearch
-exact $ids $id] < 0} {
1739 if {[llength
$ids] >= 2} break
1745 foreach match
[array names varcid
"$curview,$prefix*"] {
1746 lappend ids
[lindex
[split $match ","] 1]
1747 if {[llength
$ids] >= 2} break
1754 global tagids idtags headids idheads tagobjid
1755 global otherrefids idotherrefs mainhead mainheadid
1756 global selecthead selectheadid
1759 foreach v
{tagids idtags headids idheads otherrefids idotherrefs
} {
1762 set refd
[open
[list | git show-ref
-d] r
]
1763 while {[gets
$refd line
] >= 0} {
1764 if {[string index
$line 40] ne
" "} continue
1765 set id
[string range
$line 0 39]
1766 set ref
[string range
$line 41 end
]
1767 if {![string match
"refs/*" $ref]} continue
1768 set name
[string range
$ref 5 end
]
1769 if {[string match
"remotes/*" $name]} {
1770 if {![string match
"*/HEAD" $name] && !$hideremotes} {
1771 set headids
($name) $id
1772 lappend idheads
($id) $name
1774 } elseif
{[string match
"heads/*" $name]} {
1775 set name
[string range
$name 6 end
]
1776 set headids
($name) $id
1777 lappend idheads
($id) $name
1778 } elseif
{[string match
"tags/*" $name]} {
1779 # this lets refs/tags/foo^{} overwrite refs/tags/foo,
1780 # which is what we want since the former is the commit ID
1781 set name
[string range
$name 5 end
]
1782 if {[string match
"*^{}" $name]} {
1783 set name
[string range
$name 0 end-3
]
1785 set tagobjid
($name) $id
1787 set tagids
($name) $id
1788 lappend idtags
($id) $name
1790 set otherrefids
($name) $id
1791 lappend idotherrefs
($id) $name
1798 set mainheadid
[exec git rev-parse HEAD
]
1799 set thehead
[exec git symbolic-ref HEAD
]
1800 if {[string match
"refs/heads/*" $thehead]} {
1801 set mainhead
[string range
$thehead 11 end
]
1805 if {$selecthead ne
{}} {
1807 set selectheadid
[exec git rev-parse
--verify $selecthead]
1812 # skip over fake commits
1813 proc first_real_row
{} {
1814 global nullid nullid2 numcommits
1816 for {set row
0} {$row < $numcommits} {incr row
} {
1817 set id
[commitonrow
$row]
1818 if {$id ne
$nullid && $id ne
$nullid2} {
1825 # update things for a head moved to a child of its previous location
1826 proc movehead
{id name
} {
1827 global headids idheads
1829 removehead
$headids($name) $name
1830 set headids
($name) $id
1831 lappend idheads
($id) $name
1834 # update things when a head has been removed
1835 proc removehead
{id name
} {
1836 global headids idheads
1838 if {$idheads($id) eq
$name} {
1841 set i
[lsearch
-exact $idheads($id) $name]
1843 set idheads
($id) [lreplace
$idheads($id) $i $i]
1846 unset headids
($name)
1849 proc ttk_toplevel
{w args
} {
1851 eval [linsert
$args 0 ::toplevel
$w]
1853 place
[ttk
::frame
$w._toplevel_background
] -x 0 -y 0 -relwidth 1 -relheight 1
1858 proc make_transient
{window origin
} {
1861 # In MacOS Tk 8.4 transient appears to work by setting
1862 # overrideredirect, which is utterly useless, since the
1863 # windows get no border, and are not even kept above
1865 if {!$have_tk85 && [tk windowingsystem
] eq
{aqua
}} return
1867 wm transient
$window $origin
1869 # Windows fails to place transient windows normally, so
1870 # schedule a callback to center them on the parent.
1871 if {[tk windowingsystem
] eq
{win32
}} {
1872 after idle
[list tk
::PlaceWindow
$window widget
$origin]
1876 proc show_error
{w top msg
{mc mc
}} {
1878 if {![info exists NS
]} {set NS
""}
1879 if {[wm state
$top] eq
"withdrawn"} { wm deiconify
$top }
1880 message
$w.m
-text $msg -justify center
-aspect 400
1881 pack
$w.m
-side top
-fill x
-padx 20 -pady 20
1882 ${NS}::button
$w.ok
-default active
-text [$mc OK
] -command "destroy $top"
1883 pack
$w.ok
-side bottom
-fill x
1884 bind $top <Visibility
> "grab $top; focus $top"
1885 bind $top <Key-Return
> "destroy $top"
1886 bind $top <Key-space
> "destroy $top"
1887 bind $top <Key-Escape
> "destroy $top"
1891 proc error_popup
{msg
{owner .
}} {
1892 if {[tk windowingsystem
] eq
"win32"} {
1893 tk_messageBox
-icon error
-type ok
-title [wm title .
] \
1894 -parent $owner -message $msg
1898 make_transient
$w $owner
1899 show_error
$w $w $msg
1903 proc confirm_popup
{msg
{owner .
}} {
1904 global confirm_ok NS
1908 make_transient
$w $owner
1909 message
$w.m
-text $msg -justify center
-aspect 400
1910 pack
$w.m
-side top
-fill x
-padx 20 -pady 20
1911 ${NS}::button
$w.ok
-text [mc OK
] -command "set confirm_ok 1; destroy $w"
1912 pack
$w.ok
-side left
-fill x
1913 ${NS}::button
$w.cancel
-text [mc Cancel
] -command "destroy $w"
1914 pack
$w.cancel
-side right
-fill x
1915 bind $w <Visibility
> "grab $w; focus $w"
1916 bind $w <Key-Return
> "set confirm_ok 1; destroy $w"
1917 bind $w <Key-space
> "set confirm_ok 1; destroy $w"
1918 bind $w <Key-Escape
> "destroy $w"
1919 tk
::PlaceWindow
$w widget
$owner
1924 proc setoptions
{} {
1925 if {[tk windowingsystem
] ne
"win32"} {
1926 option add
*Panedwindow.showHandle
1 startupFile
1927 option add
*Panedwindow.sashRelief raised startupFile
1928 if {[tk windowingsystem
] ne
"aqua"} {
1929 option add
*Menu.font uifont startupFile
1932 option add
*Menu.TearOff
0 startupFile
1934 option add
*Button.font uifont startupFile
1935 option add
*Checkbutton.font uifont startupFile
1936 option add
*Radiobutton.font uifont startupFile
1937 option add
*Menubutton.font uifont startupFile
1938 option add
*Label.font uifont startupFile
1939 option add
*Message.font uifont startupFile
1940 option add
*Entry.font textfont startupFile
1941 option add
*Text.font textfont startupFile
1942 option add
*Labelframe.font uifont startupFile
1943 option add
*Spinbox.font textfont startupFile
1944 option add
*Listbox.font mainfont startupFile
1947 # Make a menu and submenus.
1948 # m is the window name for the menu, items is the list of menu items to add.
1949 # Each item is a list {mc label type description options...}
1950 # mc is ignored; it's so we can put mc there to alert xgettext
1951 # label is the string that appears in the menu
1952 # type is cascade, command or radiobutton (should add checkbutton)
1953 # description depends on type; it's the sublist for cascade, the
1954 # command to invoke for command, or {variable value} for radiobutton
1955 proc makemenu
{m items
} {
1957 if {[tk windowingsystem
] eq
{aqua
}} {
1963 set name
[mc
[lindex
$i 1]]
1964 set type [lindex
$i 2]
1965 set thing
[lindex
$i 3]
1966 set params
[list
$type]
1968 set u
[string first
"&" [string map
{&& x
} $name]]
1969 lappend params
-label [string map
{&& & & {}} $name]
1971 lappend params
-underline $u
1976 set submenu
[string tolower
[string map
{& ""} [lindex
$i 1]]]
1977 lappend params
-menu $m.
$submenu
1980 lappend params
-command $thing
1983 lappend params
-variable [lindex
$thing 0] \
1984 -value [lindex
$thing 1]
1987 set tail [lrange
$i 4 end
]
1988 regsub
-all {\yMeta1\y
} $tail $Meta1 tail
1989 eval $m add
$params $tail
1990 if {$type eq
"cascade"} {
1991 makemenu
$m.
$submenu $thing
1996 # translate string and remove ampersands
1998 return [string map
{&& & & {}} [mc
$str]]
2001 proc makedroplist
{w varname args
} {
2005 foreach label
$args {
2006 set cx
[string length
$label]
2007 if {$cx > $width} {set width
$cx}
2009 set gm
[ttk
::combobox
$w -width $width -state readonly\
2010 -textvariable $varname -values $args]
2012 set gm
[eval [linsert
$args 0 tk_optionMenu
$w $varname]]
2017 proc makewindow
{} {
2018 global canv canv2 canv3 linespc charspc ctext cflist cscroll
2020 global findtype findtypemenu findloc findstring fstring geometry
2021 global entries sha1entry sha1string sha1but
2022 global diffcontextstring diffcontext
2024 global maincursor textcursor curtextcursor
2025 global rowctxmenu fakerowmenu mergemax wrapcomment
2026 global highlight_files gdttype
2027 global searchstring sstring
2028 global bgcolor fgcolor bglist fglist diffcolors selectbgcolor
2029 global headctxmenu progresscanv progressitem progresscoords statusw
2030 global fprogitem fprogcoord lastprogupdate progupdatepending
2031 global rprogitem rprogcoord rownumsel numcommits
2032 global have_tk85 use_ttk NS
2036 # The "mc" arguments here are purely so that xgettext
2037 # sees the following string as needing to be translated
2040 {mc
"Update" command updatecommits
-accelerator F5
}
2041 {mc
"Reload" command reloadcommits
-accelerator Shift-F5
}
2042 {mc
"Reread references" command rereadrefs
}
2043 {mc
"List references" command showrefs
-accelerator F2
}
2045 {mc
"Start git gui" command {exec git gui
&}}
2047 {mc
"Quit" command doquit
-accelerator Meta1-Q
}
2051 {mc
"Preferences" command doprefs
}
2055 {mc
"New view..." command {newview
0} -accelerator Shift-F4
}
2056 {mc
"Edit view..." command editview
-state disabled
-accelerator F4
}
2057 {mc
"Delete view" command delview
-state disabled
}
2059 {mc
"All files" radiobutton
{selectedview
0} -command {showview
0}}
2061 if {[tk windowingsystem
] ne
"aqua"} {
2064 {mc
"About gitk" command about
}
2065 {mc
"Key bindings" command keys
}
2067 set bar
[list
$file $edit $view $help]
2069 proc
::tk
::mac
::ShowPreferences
{} {doprefs
}
2070 proc
::tk
::mac
::Quit
{} {doquit
}
2071 lset
file end
[lreplace
[lindex
$file end
] end-1 end
]
2073 xx
"Apple" cascade
{
2074 {mc
"About gitk" command about
}
2079 {mc
"Key bindings" command keys
}
2081 set bar
[list
$apple $file $view $help]
2084 . configure
-menu .bar
2087 # cover the non-themed toplevel with a themed frame.
2088 place
[ttk
::frame ._main_background
] -x 0 -y 0 -relwidth 1 -relheight 1
2091 # the gui has upper and lower half, parts of a paned window.
2092 ${NS}::panedwindow .ctop
-orient vertical
2094 # possibly use assumed geometry
2095 if {![info exists geometry
(pwsash0
)]} {
2096 set geometry
(topheight
) [expr {15 * $linespc}]
2097 set geometry
(topwidth
) [expr {80 * $charspc}]
2098 set geometry
(botheight
) [expr {15 * $linespc}]
2099 set geometry
(botwidth
) [expr {50 * $charspc}]
2100 set geometry
(pwsash0
) [list
[expr {40 * $charspc}] 2]
2101 set geometry
(pwsash1
) [list
[expr {60 * $charspc}] 2]
2104 # the upper half will have a paned window, a scroll bar to the right, and some stuff below
2105 ${NS}::frame .tf
-height $geometry(topheight
) -width $geometry(topwidth
)
2106 ${NS}::frame .tf.histframe
2107 ${NS}::panedwindow .tf.histframe.pwclist
-orient horizontal
2109 .tf.histframe.pwclist configure
-sashpad 0 -handlesize 4
2112 # create three canvases
2113 set cscroll .tf.histframe.csb
2114 set canv .tf.histframe.pwclist.canv
2116 -selectbackground $selectbgcolor \
2117 -background $bgcolor -bd 0 \
2118 -yscrollincr $linespc -yscrollcommand "scrollcanv $cscroll"
2119 .tf.histframe.pwclist add
$canv
2120 set canv2 .tf.histframe.pwclist.canv2
2122 -selectbackground $selectbgcolor \
2123 -background $bgcolor -bd 0 -yscrollincr $linespc
2124 .tf.histframe.pwclist add
$canv2
2125 set canv3 .tf.histframe.pwclist.canv3
2127 -selectbackground $selectbgcolor \
2128 -background $bgcolor -bd 0 -yscrollincr $linespc
2129 .tf.histframe.pwclist add
$canv3
2131 bind .tf.histframe.pwclist
<Map
> {
2133 .tf.histframe.pwclist sashpos
1 [lindex $
::geometry
(pwsash1
) 0]
2134 .tf.histframe.pwclist sashpos
0 [lindex $
::geometry
(pwsash0
) 0]
2137 eval .tf.histframe.pwclist sash place
0 $geometry(pwsash0
)
2138 eval .tf.histframe.pwclist sash place
1 $geometry(pwsash1
)
2141 # a scroll bar to rule them
2142 ${NS}::scrollbar
$cscroll -command {allcanvs yview
}
2143 if {!$use_ttk} {$cscroll configure
-highlightthickness 0}
2144 pack
$cscroll -side right
-fill y
2145 bind .tf.histframe.pwclist
<Configure
> {resizeclistpanes
%W
%w
}
2146 lappend bglist
$canv $canv2 $canv3
2147 pack .tf.histframe.pwclist
-fill both
-expand 1 -side left
2149 # we have two button bars at bottom of top frame. Bar 1
2150 ${NS}::frame .tf.bar
2151 ${NS}::frame .tf.lbar
-height 15
2153 set sha1entry .tf.bar.sha1
2154 set entries
$sha1entry
2155 set sha1but .tf.bar.sha1label
2156 button
$sha1but -text "[mc "SHA1 ID
:"] " -state disabled
-relief flat \
2157 -command gotocommit
-width 8
2158 $sha1but conf
-disabledforeground [$sha1but cget
-foreground]
2159 pack .tf.bar.sha1label
-side left
2160 ${NS}::entry
$sha1entry -width 40 -font textfont
-textvariable sha1string
2161 trace add variable sha1string
write sha1change
2162 pack
$sha1entry -side left
-pady 2
2164 image create bitmap bm-left
-data {
2165 #define left_width 16
2166 #define left_height 16
2167 static unsigned char left_bits
[] = {
2168 0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
2169 0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
2170 0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
2172 image create bitmap bm-right
-data {
2173 #define right_width 16
2174 #define right_height 16
2175 static unsigned char right_bits
[] = {
2176 0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
2177 0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
2178 0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
2180 ${NS}::button .tf.bar.leftbut
-image bm-left
-command goback \
2181 -state disabled
-width 26
2182 pack .tf.bar.leftbut
-side left
-fill y
2183 ${NS}::button .tf.bar.rightbut
-image bm-right
-command goforw \
2184 -state disabled
-width 26
2185 pack .tf.bar.rightbut
-side left
-fill y
2187 ${NS}::label .tf.bar.rowlabel
-text [mc
"Row"]
2189 ${NS}::label .tf.bar.rownum
-width 7 -textvariable rownumsel \
2190 -relief sunken
-anchor e
2191 ${NS}::label .tf.bar.rowlabel2
-text "/"
2192 ${NS}::label .tf.bar.numcommits
-width 7 -textvariable numcommits \
2193 -relief sunken
-anchor e
2194 pack .tf.bar.rowlabel .tf.bar.rownum .tf.bar.rowlabel2 .tf.bar.numcommits \
2197 foreach w
{rownum numcommits
} {.tf.bar.
$w configure
-font textfont
}
2200 trace add variable selectedline
write selectedline_change
2202 # Status label and progress bar
2203 set statusw .tf.bar.status
2204 ${NS}::label
$statusw -width 15 -relief sunken
2205 pack
$statusw -side left
-padx 5
2207 set progresscanv
[ttk
::progressbar .tf.bar.progress
]
2209 set h
[expr {[font metrics uifont
-linespace] + 2}]
2210 set progresscanv .tf.bar.progress
2211 canvas
$progresscanv -relief sunken
-height $h -borderwidth 2
2212 set progressitem
[$progresscanv create rect
-1 0 0 $h -fill green
]
2213 set fprogitem
[$progresscanv create rect
-1 0 0 $h -fill yellow
]
2214 set rprogitem
[$progresscanv create rect
-1 0 0 $h -fill red
]
2216 pack
$progresscanv -side right
-expand 1 -fill x
-padx {0 2}
2217 set progresscoords
{0 0}
2220 bind $progresscanv <Configure
> adjustprogress
2221 set lastprogupdate
[clock clicks
-milliseconds]
2222 set progupdatepending
0
2224 # build up the bottom bar of upper window
2225 ${NS}::label .tf.lbar.flabel
-text "[mc "Find
"] "
2226 ${NS}::button .tf.lbar.fnext
-text [mc
"next"] -command {dofind
1 1}
2227 ${NS}::button .tf.lbar.fprev
-text [mc
"prev"] -command {dofind
-1 1}
2228 ${NS}::label .tf.lbar.flab2
-text " [mc "commit
"] "
2229 pack .tf.lbar.flabel .tf.lbar.fnext .tf.lbar.fprev .tf.lbar.flab2 \
2231 set gdttype
[mc
"containing:"]
2232 set gm
[makedroplist .tf.lbar.gdttype gdttype \
2233 [mc
"containing:"] \
2234 [mc
"touching paths:"] \
2235 [mc
"adding/removing string:"]]
2236 trace add variable gdttype
write gdttype_change
2237 pack .tf.lbar.gdttype
-side left
-fill y
2240 set fstring .tf.lbar.findstring
2241 lappend entries
$fstring
2242 ${NS}::entry
$fstring -width 30 -textvariable findstring
2243 trace add variable findstring
write find_change
2244 set findtype
[mc
"Exact"]
2245 set findtypemenu
[makedroplist .tf.lbar.findtype \
2246 findtype
[mc
"Exact"] [mc
"IgnCase"] [mc
"Regexp"]]
2247 trace add variable findtype
write findcom_change
2248 set findloc
[mc
"All fields"]
2249 makedroplist .tf.lbar.findloc findloc
[mc
"All fields"] [mc
"Headline"] \
2250 [mc
"Comments"] [mc
"Author"] [mc
"Committer"]
2251 trace add variable findloc
write find_change
2252 pack .tf.lbar.findloc
-side right
2253 pack .tf.lbar.findtype
-side right
2254 pack
$fstring -side left
-expand 1 -fill x
2256 # Finish putting the upper half of the viewer together
2257 pack .tf.lbar
-in .tf
-side bottom
-fill x
2258 pack .tf.bar
-in .tf
-side bottom
-fill x
2259 pack .tf.histframe
-fill both
-side top
-expand 1
2262 .ctop paneconfigure .tf
-height $geometry(topheight
)
2263 .ctop paneconfigure .tf
-width $geometry(topwidth
)
2266 # now build up the bottom
2267 ${NS}::panedwindow .pwbottom
-orient horizontal
2269 # lower left, a text box over search bar, scroll bar to the right
2270 # if we know window height, then that will set the lower text height, otherwise
2271 # we set lower text height which will drive window height
2272 if {[info exists geometry
(main
)]} {
2273 ${NS}::frame .bleft
-width $geometry(botwidth
)
2275 ${NS}::frame .bleft
-width $geometry(botwidth
) -height $geometry(botheight
)
2277 ${NS}::frame .bleft.top
2278 ${NS}::frame .bleft.mid
2279 ${NS}::frame .bleft.bottom
2281 ${NS}::button .bleft.top.search
-text [mc
"Search"] -command dosearch
2282 pack .bleft.top.search
-side left
-padx 5
2283 set sstring .bleft.top.sstring
2285 ${NS}::entry
$sstring -width 20 -textvariable searchstring
2286 lappend entries
$sstring
2287 trace add variable searchstring
write incrsearch
2288 pack
$sstring -side left
-expand 1 -fill x
2289 ${NS}::radiobutton .bleft.mid.
diff -text [mc
"Diff"] \
2290 -command changediffdisp
-variable diffelide
-value {0 0}
2291 ${NS}::radiobutton .bleft.mid.old
-text [mc
"Old version"] \
2292 -command changediffdisp
-variable diffelide
-value {0 1}
2293 ${NS}::radiobutton .bleft.mid.new
-text [mc
"New version"] \
2294 -command changediffdisp
-variable diffelide
-value {1 0}
2295 ${NS}::label .bleft.mid.labeldiffcontext
-text " [mc "Lines of context
"]: "
2296 pack .bleft.mid.
diff .bleft.mid.old .bleft.mid.new
-side left
2297 spinbox .bleft.mid.diffcontext
-width 5 \
2298 -from 0 -increment 1 -to 10000000 \
2299 -validate all
-validatecommand "diffcontextvalidate %P" \
2300 -textvariable diffcontextstring
2301 .bleft.mid.diffcontext
set $diffcontext
2302 trace add variable diffcontextstring
write diffcontextchange
2303 lappend entries .bleft.mid.diffcontext
2304 pack .bleft.mid.labeldiffcontext .bleft.mid.diffcontext
-side left
2305 ${NS}::checkbutton .bleft.mid.ignspace
-text [mc
"Ignore space change"] \
2306 -command changeignorespace
-variable ignorespace
2307 pack .bleft.mid.ignspace
-side left
-padx 5
2309 set worddiff
[mc
"Line diff"]
2310 if {[package vcompare
$git_version "1.7.2"] >= 0} {
2311 makedroplist .bleft.mid.worddiff worddiff
[mc
"Line diff"] \
2312 [mc
"Markup words"] [mc
"Color words"]
2313 trace add variable worddiff
write changeworddiff
2314 pack .bleft.mid.worddiff
-side left
-padx 5
2317 set ctext .bleft.bottom.ctext
2318 text
$ctext -background $bgcolor -foreground $fgcolor \
2319 -state disabled
-font textfont \
2320 -yscrollcommand scrolltext
-wrap none \
2321 -xscrollcommand ".bleft.bottom.sbhorizontal set"
2323 $ctext conf
-tabstyle wordprocessor
2325 ${NS}::scrollbar .bleft.bottom.sb
-command "$ctext yview"
2326 ${NS}::scrollbar .bleft.bottom.sbhorizontal
-command "$ctext xview" -orient h
2327 pack .bleft.top
-side top
-fill x
2328 pack .bleft.mid
-side top
-fill x
2329 grid
$ctext .bleft.bottom.sb
-sticky nsew
2330 grid .bleft.bottom.sbhorizontal
-sticky ew
2331 grid columnconfigure .bleft.bottom
0 -weight 1
2332 grid rowconfigure .bleft.bottom
0 -weight 1
2333 grid rowconfigure .bleft.bottom
1 -weight 0
2334 pack .bleft.bottom
-side top
-fill both
-expand 1
2335 lappend bglist
$ctext
2336 lappend fglist
$ctext
2338 $ctext tag conf comment
-wrap $wrapcomment
2339 $ctext tag conf filesep
-font textfontbold
-back "#aaaaaa"
2340 $ctext tag conf hunksep
-fore [lindex
$diffcolors 2]
2341 $ctext tag conf d0
-fore [lindex
$diffcolors 0]
2342 $ctext tag conf dresult
-fore [lindex
$diffcolors 1]
2343 $ctext tag conf m0
-fore red
2344 $ctext tag conf m1
-fore blue
2345 $ctext tag conf m2
-fore green
2346 $ctext tag conf m3
-fore purple
2347 $ctext tag conf
m4 -fore brown
2348 $ctext tag conf m5
-fore "#009090"
2349 $ctext tag conf m6
-fore magenta
2350 $ctext tag conf m7
-fore "#808000"
2351 $ctext tag conf m8
-fore "#009000"
2352 $ctext tag conf m9
-fore "#ff0080"
2353 $ctext tag conf m10
-fore cyan
2354 $ctext tag conf m11
-fore "#b07070"
2355 $ctext tag conf m12
-fore "#70b0f0"
2356 $ctext tag conf m13
-fore "#70f0b0"
2357 $ctext tag conf m14
-fore "#f0b070"
2358 $ctext tag conf m15
-fore "#ff70b0"
2359 $ctext tag conf mmax
-fore darkgrey
2361 $ctext tag conf mresult
-font textfontbold
2362 $ctext tag conf msep
-font textfontbold
2363 $ctext tag conf found
-back yellow
2365 .pwbottom add .bleft
2367 .pwbottom paneconfigure .bleft
-width $geometry(botwidth
)
2371 ${NS}::frame .bright
2372 ${NS}::frame .bright.mode
2373 ${NS}::radiobutton .bright.mode.
patch -text [mc
"Patch"] \
2374 -command reselectline
-variable cmitmode
-value "patch"
2375 ${NS}::radiobutton .bright.mode.tree
-text [mc
"Tree"] \
2376 -command reselectline
-variable cmitmode
-value "tree"
2377 grid .bright.mode.
patch .bright.mode.tree
-sticky ew
2378 pack .bright.mode
-side top
-fill x
2379 set cflist .bright.cfiles
2380 set indent
[font measure mainfont
"nn"]
2382 -selectbackground $selectbgcolor \
2383 -background $bgcolor -foreground $fgcolor \
2385 -tabs [list
$indent [expr {2 * $indent}]] \
2386 -yscrollcommand ".bright.sb set" \
2387 -cursor [. cget
-cursor] \
2388 -spacing1 1 -spacing3 1
2389 lappend bglist
$cflist
2390 lappend fglist
$cflist
2391 ${NS}::scrollbar .bright.sb
-command "$cflist yview"
2392 pack .bright.sb
-side right
-fill y
2393 pack
$cflist -side left
-fill both
-expand 1
2394 $cflist tag configure highlight \
2395 -background [$cflist cget
-selectbackground]
2396 $cflist tag configure bold
-font mainfontbold
2398 .pwbottom add .bright
2401 # restore window width & height if known
2402 if {[info exists geometry
(main
)]} {
2403 if {[scan
$geometry(main
) "%dx%d" w h
] >= 2} {
2404 if {$w > [winfo screenwidth .
]} {
2405 set w
[winfo screenwidth .
]
2407 if {$h > [winfo screenheight .
]} {
2408 set h
[winfo screenheight .
]
2410 wm geometry .
"${w}x$h"
2414 if {[info exists geometry
(state
)] && $geometry(state
) eq
"zoomed"} {
2415 wm state .
$geometry(state
)
2418 if {[tk windowingsystem
] eq
{aqua
}} {
2429 %W sashpos
0 $
::geometry
(topheight
)
2431 bind .pwbottom
<Map
> {
2433 %W sashpos
0 $
::geometry
(botwidth
)
2437 bind .pwbottom
<Configure
> {resizecdetpanes
%W
%w
}
2438 pack .ctop
-fill both
-expand 1
2439 bindall
<1> {selcanvline
%W
%x
%y
}
2440 #bindall <B1-Motion> {selcanvline %W %x %y}
2441 if {[tk windowingsystem
] == "win32"} {
2442 bind .
<MouseWheel
> { windows_mousewheel_redirector
%W
%X
%Y
%D
}
2443 bind $ctext <MouseWheel
> { windows_mousewheel_redirector
%W
%X
%Y
%D
; break }
2445 bindall
<ButtonRelease-4
> "allcanvs yview scroll -5 units"
2446 bindall
<ButtonRelease-5
> "allcanvs yview scroll 5 units"
2447 if {[tk windowingsystem
] eq
"aqua"} {
2448 bindall
<MouseWheel
> {
2449 set delta
[expr {- (%D
)}]
2450 allcanvs yview scroll
$delta units
2452 bindall
<Shift-MouseWheel
> {
2453 set delta
[expr {- (%D
)}]
2454 $canv xview scroll
$delta units
2458 bindall
<$
::BM
> "canvscan mark %W %x %y"
2459 bindall
<B$
::BM-Motion
> "canvscan dragto %W %x %y"
2460 bind all
<$M1B-Key-w> {destroy
[winfo toplevel
%W
]}
2461 bind .
<$M1B-Key-w> doquit
2462 bindkey
<Home
> selfirstline
2463 bindkey
<End
> sellastline
2464 bind .
<Key-Up
> "selnextline -1"
2465 bind .
<Key-Down
> "selnextline 1"
2466 bind .
<Shift-Key-Up
> "dofind -1 0"
2467 bind .
<Shift-Key-Down
> "dofind 1 0"
2468 bindkey
<Key-Right
> "goforw"
2469 bindkey
<Key-Left
> "goback"
2470 bind .
<Key-Prior
> "selnextpage -1"
2471 bind .
<Key-Next
> "selnextpage 1"
2472 bind .
<$M1B-Home> "allcanvs yview moveto 0.0"
2473 bind .
<$M1B-End> "allcanvs yview moveto 1.0"
2474 bind .
<$M1B-Key-Up> "allcanvs yview scroll -1 units"
2475 bind .
<$M1B-Key-Down> "allcanvs yview scroll 1 units"
2476 bind .
<$M1B-Key-Prior> "allcanvs yview scroll -1 pages"
2477 bind .
<$M1B-Key-Next> "allcanvs yview scroll 1 pages"
2478 bindkey
<Key-Delete
> "$ctext yview scroll -1 pages"
2479 bindkey
<Key-BackSpace
> "$ctext yview scroll -1 pages"
2480 bindkey
<Key-space
> "$ctext yview scroll 1 pages"
2481 bindkey p
"selnextline -1"
2482 bindkey n
"selnextline 1"
2485 bindkey k
"selnextline -1"
2486 bindkey j
"selnextline 1"
2490 bindkey d
"$ctext yview scroll 18 units"
2491 bindkey u
"$ctext yview scroll -18 units"
2492 bindkey
/ {focus
$fstring}
2493 bindkey
<Key-KP_Divide
> {focus
$fstring}
2494 bindkey
<Key-Return
> {dofind
1 1}
2495 bindkey ?
{dofind
-1 1}
2497 bind .
<F5
> updatecommits
2498 bind .
<Shift-F5
> reloadcommits
2499 bind .
<F2
> showrefs
2500 bind .
<Shift-F4
> {newview
0}
2501 catch
{ bind .
<Shift-Key-XF86_Switch_VT_4
> {newview
0} }
2502 bind .
<F4
> edit_or_newview
2503 bind .
<$M1B-q> doquit
2504 bind .
<$M1B-f> {dofind
1 1}
2505 bind .
<$M1B-g> {dofind
1 0}
2506 bind .
<$M1B-r> dosearchback
2507 bind .
<$M1B-s> dosearch
2508 bind .
<$M1B-equal> {incrfont
1}
2509 bind .
<$M1B-plus> {incrfont
1}
2510 bind .
<$M1B-KP_Add> {incrfont
1}
2511 bind .
<$M1B-minus> {incrfont
-1}
2512 bind .
<$M1B-KP_Subtract> {incrfont
-1}
2513 wm protocol . WM_DELETE_WINDOW doquit
2514 bind .
<Destroy
> {stop_backends
}
2515 bind .
<Button-1
> "click %W"
2516 bind $fstring <Key-Return
> {dofind
1 1}
2517 bind $sha1entry <Key-Return
> {gotocommit
; break}
2518 bind $sha1entry <<PasteSelection>> clearsha1
2519 bind $cflist <1> {sel_flist %W %x %y; break}
2520 bind $cflist <B1-Motion> {sel_flist %W %x %y; break}
2521 bind $cflist <ButtonRelease-1> {treeclick %W %x %y}
2523 bind $cflist $ctxbut {pop_flist_menu %W %X %Y %x %y}
2524 bind $ctext $ctxbut {pop_diff_menu %W %X %Y %x %y}
2525 bind $ctext <Button-1> {focus %W}
2527 set maincursor [. cget -cursor]
2528 set textcursor [$ctext cget -cursor]
2529 set curtextcursor $textcursor
2531 set rowctxmenu .rowctxmenu
2532 makemenu $rowctxmenu {
2533 {mc "Diff this -> selected" command {diffvssel 0}}
2534 {mc "Diff selected -> this" command {diffvssel 1}}
2535 {mc "Make patch" command mkpatch}
2536 {mc "Create tag" command mktag}
2537 {mc "Write commit to file" command writecommit}
2538 {mc "Create new branch" command mkbranch}
2539 {mc "Cherry-pick this commit" command cherrypick}
2540 {mc "Reset HEAD branch to here" command resethead}
2541 {mc "Mark this commit" command markhere}
2542 {mc "Return to mark" command gotomark}
2543 {mc "Find descendant of this and mark" command find_common_desc}
2544 {mc "Compare with marked commit" command compare_commits}
2545 {mc "Diff this -> marked commit" command {diffvsmark 0}}
2546 {mc "Diff marked commit -> this" command {diffvsmark 1}}
2548 $rowctxmenu configure -tearoff 0
2550 set fakerowmenu .fakerowmenu
2551 makemenu $fakerowmenu {
2552 {mc "Diff this -> selected" command {diffvssel 0}}
2553 {mc "Diff selected -> this" command {diffvssel 1}}
2554 {mc "Make patch" command mkpatch}
2555 {mc "Diff this -> marked commit" command {diffvsmark 0}}
2556 {mc "Diff marked commit -> this" command {diffvsmark 1}}
2558 $fakerowmenu configure -tearoff 0
2560 set headctxmenu .headctxmenu
2561 makemenu $headctxmenu {
2562 {mc "Check out this branch" command cobranch}
2563 {mc "Remove this branch" command rmbranch}
2565 $headctxmenu configure -tearoff 0
2568 set flist_menu .flistctxmenu
2569 makemenu $flist_menu {
2570 {mc "Highlight this too" command {flist_hl 0}}
2571 {mc "Highlight this only" command {flist_hl 1}}
2572 {mc "External diff" command {external_diff}}
2573 {mc "Blame parent commit" command {external_blame 1}}
2575 $flist_menu configure -tearoff 0
2578 set diff_menu .diffctxmenu
2579 makemenu $diff_menu {
2580 {mc "Show origin of this line" command show_line_source}
2581 {mc "Run git gui blame on this line" command {external_blame_diff}}
2583 $diff_menu configure -tearoff 0
2586 # Windows sends all mouse wheel events to the current focused window, not
2587 # the one where the mouse hovers, so bind those events here and redirect
2588 # to the correct window
2589 proc windows_mousewheel_redirector {W X Y D} {
2590 global canv canv2 canv3
2591 set w [winfo containing -displayof $W $X $Y]
2593 set u [expr {$D < 0 ? 5 : -5}]
2594 if {$w == $canv || $w == $canv2 || $w == $canv3} {
2595 allcanvs yview scroll $u units
2598 $w yview scroll $u units
2604 # Update row number label when selectedline changes
2605 proc selectedline_change {n1 n2 op} {
2606 global selectedline rownumsel
2608 if {$selectedline eq {}} {
2611 set rownumsel [expr {$selectedline + 1}]
2615 # mouse-2 makes all windows scan vertically, but only the one
2616 # the cursor is in scans horizontally
2617 proc canvscan {op w x y} {
2618 global canv canv2 canv3
2619 foreach c [list $canv $canv2 $canv3] {
2628 proc scrollcanv {cscroll f0 f1} {
2629 $cscroll set $f0 $f1
2634 # when we make a key binding for the toplevel, make sure
2635 # it doesn't get triggered when that key is pressed in the
2636 # find string entry widget.
2637 proc bindkey {ev script} {
2640 set escript [bind Entry $ev]
2641 if {$escript == {}} {
2642 set escript [bind Entry <Key>]
2644 foreach e $entries {
2645 bind $e $ev "$escript; break"
2649 # set the focus back to the toplevel for any click outside
2652 global ctext entries
2653 foreach e [concat $entries $ctext] {
2654 if {$w == $e} return
2659 # Adjust the progress bar for a change in requested extent or canvas size
2660 proc adjustprogress {} {
2661 global progresscanv progressitem progresscoords
2662 global fprogitem fprogcoord lastprogupdate progupdatepending
2663 global rprogitem rprogcoord use_ttk
2666 $progresscanv configure -value [expr {int($fprogcoord * 100)}]
2670 set w [expr {[winfo width $progresscanv] - 4}]
2671 set x0 [expr {$w * [lindex $progresscoords 0]}]
2672 set x1 [expr {$w * [lindex $progresscoords 1]}]
2673 set h [winfo height $progresscanv]
2674 $progresscanv coords $progressitem $x0 0 $x1 $h
2675 $progresscanv coords $fprogitem 0 0 [expr {$w * $fprogcoord}] $h
2676 $progresscanv coords $rprogitem 0 0 [expr {$w * $rprogcoord}] $h
2677 set now [clock clicks -milliseconds]
2678 if {$now >= $lastprogupdate + 100} {
2679 set progupdatepending 0
2681 } elseif {!$progupdatepending} {
2682 set progupdatepending 1
2683 after [expr {$lastprogupdate + 100 - $now}] doprogupdate
2687 proc doprogupdate {} {
2688 global lastprogupdate progupdatepending
2690 if {$progupdatepending} {
2691 set progupdatepending 0
2692 set lastprogupdate [clock clicks -milliseconds]
2697 proc savestuff {w} {
2698 global canv canv2 canv3 mainfont textfont uifont tabstop
2699 global stuffsaved findmergefiles maxgraphpct
2700 global maxwidth showneartags showlocalchanges
2701 global viewname viewfiles viewargs viewargscmd viewperm nextviewnum
2702 global cmitmode wrapcomment datetimeformat limitdiffs
2703 global colors uicolor bgcolor fgcolor diffcolors diffcontext selectbgcolor
2704 global autoselect autosellen extdifftool perfile_attrs markbgcolor use_ttk
2705 global hideremotes want_ttk
2707 if {$stuffsaved} return
2708 if {![winfo viewable .]} return
2710 if {[file exists ~/.gitk-new]} {file delete -force ~/.gitk-new}
2711 set f [open "~/.gitk-new" w]
2712 if {$::tcl_platform(platform) eq {windows}} {
2713 file attributes "~/.gitk-new" -hidden true
2715 puts $f [list set mainfont $mainfont]
2716 puts $f [list set textfont $textfont]
2717 puts $f [list set uifont $uifont]
2718 puts $f [list set tabstop $tabstop]
2719 puts $f [list set findmergefiles $findmergefiles]
2720 puts $f [list set maxgraphpct $maxgraphpct]
2721 puts $f [list set maxwidth $maxwidth]
2722 puts $f [list set cmitmode $cmitmode]
2723 puts $f [list set wrapcomment $wrapcomment]
2724 puts $f [list set autoselect $autoselect]
2725 puts $f [list set autosellen $autosellen]
2726 puts $f [list set showneartags $showneartags]
2727 puts $f [list set hideremotes $hideremotes]
2728 puts $f [list set showlocalchanges $showlocalchanges]
2729 puts $f [list set datetimeformat $datetimeformat]
2730 puts $f [list set limitdiffs $limitdiffs]
2731 puts $f [list set uicolor $uicolor]
2732 puts $f [list set want_ttk $want_ttk]
2733 puts $f [list set bgcolor $bgcolor]
2734 puts $f [list set fgcolor $fgcolor]
2735 puts $f [list set colors $colors]
2736 puts $f [list set diffcolors $diffcolors]
2737 puts $f [list set markbgcolor $markbgcolor]
2738 puts $f [list set diffcontext $diffcontext]
2739 puts $f [list set selectbgcolor $selectbgcolor]
2740 puts $f [list set extdifftool $extdifftool]
2741 puts $f [list set perfile_attrs $perfile_attrs]
2743 puts $f "set geometry(main) [wm geometry .]"
2744 puts $f "set geometry(state) [wm state .]"
2745 puts $f "set geometry(topwidth) [winfo width .tf]"
2746 puts $f "set geometry(topheight) [winfo height .tf]"
2748 puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sashpos 0] 1\""
2749 puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sashpos 1] 1\""
2751 puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sash coord 0]\""
2752 puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sash coord 1]\""
2754 puts $f "set geometry(botwidth) [winfo width .bleft]"
2755 puts $f "set geometry(botheight) [winfo height .bleft]"
2757 puts -nonewline $f "set permviews {"
2758 for {set v 0} {$v < $nextviewnum} {incr v} {
2759 if {$viewperm($v)} {
2760 puts $f "{[list $viewname($v) $viewfiles($v) $viewargs($v) $viewargscmd($v)]}"
2765 catch {file delete "~/.gitk"}
2766 file rename -force "~/.gitk-new" "~/.gitk"
2771 proc resizeclistpanes {win w} {
2772 global oldwidth use_ttk
2773 if {[info exists oldwidth($win)]} {
2775 set s0 [$win sashpos 0]
2776 set s1 [$win sashpos 1]
2778 set s0 [$win sash coord 0]
2779 set s1 [$win sash coord 1]
2782 set sash0 [expr {int($w/2 - 2)}]
2783 set sash1 [expr {int($w*5/6 - 2)}]
2785 set factor [expr {1.0 * $w / $oldwidth($win)}]
2786 set sash0 [expr {int($factor * [lindex $s0 0])}]
2787 set sash1 [expr {int($factor * [lindex $s1 0])}]
2791 if {$sash1 < $sash0 + 20} {
2792 set sash1 [expr {$sash0 + 20}]
2794 if {$sash1 > $w - 10} {
2795 set sash1 [expr {$w - 10}]
2796 if {$sash0 > $sash1 - 20} {
2797 set sash0 [expr {$sash1 - 20}]
2802 $win sashpos 0 $sash0
2803 $win sashpos 1 $sash1
2805 $win sash place 0 $sash0 [lindex $s0 1]
2806 $win sash place 1 $sash1 [lindex $s1 1]
2809 set oldwidth($win) $w
2812 proc resizecdetpanes {win w} {
2813 global oldwidth use_ttk
2814 if {[info exists oldwidth($win)]} {
2816 set s0 [$win sashpos 0]
2818 set s0 [$win sash coord 0]
2821 set sash0 [expr {int($w*3/4 - 2)}]
2823 set factor [expr {1.0 * $w / $oldwidth($win)}]
2824 set sash0 [expr {int($factor * [lindex $s0 0])}]
2828 if {$sash0 > $w - 15} {
2829 set sash0 [expr {$w - 15}]
2833 $win sashpos 0 $sash0
2835 $win sash place 0 $sash0 [lindex $s0 1]
2838 set oldwidth($win) $w
2841 proc allcanvs args {
2842 global canv canv2 canv3
2848 proc bindall {event action} {
2849 global canv canv2 canv3
2850 bind $canv $event $action
2851 bind $canv2 $event $action
2852 bind $canv3 $event $action
2858 if {[winfo exists $w]} {
2863 wm title $w [mc "About gitk"]
2865 message $w.m -text [mc "
2866 Gitk - a commit viewer for git
2868 Copyright \u00a9 2005-2011 Paul Mackerras
2870 Use and redistribute under the terms of the GNU General Public License"] \
2871 -justify center -aspect 400 -border 2 -bg white -relief groove
2872 pack $w.m -side top -fill x -padx 2 -pady 2
2873 ${NS}::button $w.ok -text [mc "Close"] -command "destroy $w" -default active
2874 pack $w.ok -side bottom
2875 bind $w <Visibility> "focus $w.ok"
2876 bind $w <Key-Escape> "destroy $w"
2877 bind $w <Key-Return> "destroy $w"
2878 tk::PlaceWindow $w widget .
2884 if {[winfo exists $w]} {
2888 if {[tk windowingsystem] eq {aqua}} {
2894 wm title $w [mc "Gitk key bindings"]
2896 message $w.m -text "
2897 [mc "Gitk key bindings:"]
2899 [mc "<%s-Q> Quit" $M1T]
2900 [mc "<%s-W> Close window" $M1T]
2901 [mc "<Home> Move to first commit"]
2902 [mc "<End> Move to last commit"]
2903 [mc "<Up>, p, k Move up one commit"]
2904 [mc "<Down>, n, j Move down one commit"]
2905 [mc "<Left>, z, h Go back in history list"]
2906 [mc "<Right>, x, l Go forward in history list"]
2907 [mc "<PageUp> Move up one page in commit list"]
2908 [mc "<PageDown> Move down one page in commit list"]
2909 [mc "<%s-Home> Scroll to top of commit list" $M1T]
2910 [mc "<%s-End> Scroll to bottom of commit list" $M1T]
2911 [mc "<%s-Up> Scroll commit list up one line" $M1T]
2912 [mc "<%s-Down> Scroll commit list down one line" $M1T]
2913 [mc "<%s-PageUp> Scroll commit list up one page" $M1T]
2914 [mc "<%s-PageDown> Scroll commit list down one page" $M1T]
2915 [mc "<Shift-Up> Find backwards (upwards, later commits)"]
2916 [mc "<Shift-Down> Find forwards (downwards, earlier commits)"]
2917 [mc "<Delete>, b Scroll diff view up one page"]
2918 [mc "<Backspace> Scroll diff view up one page"]
2919 [mc "<Space> Scroll diff view down one page"]
2920 [mc "u Scroll diff view up 18 lines"]
2921 [mc "d Scroll diff view down 18 lines"]
2922 [mc "<%s-F> Find" $M1T]
2923 [mc "<%s-G> Move to next find hit" $M1T]
2924 [mc "<Return> Move to next find hit"]
2925 [mc "/ Focus the search box"]
2926 [mc "? Move to previous find hit"]
2927 [mc "f Scroll diff view to next file"]
2928 [mc "<%s-S> Search for next hit in diff view" $M1T]
2929 [mc "<%s-R> Search for previous hit in diff view" $M1T]
2930 [mc "<%s-KP+> Increase font size" $M1T]
2931 [mc "<%s-plus> Increase font size" $M1T]
2932 [mc "<%s-KP-> Decrease font size" $M1T]
2933 [mc "<%s-minus> Decrease font size" $M1T]
2936 -justify left -bg white -border 2 -relief groove
2937 pack $w.m -side top -fill both -padx 2 -pady 2
2938 ${NS}::button $w.ok -text [mc "Close"] -command "destroy $w" -default active
2939 bind $w <Key-Escape> [list destroy $w]
2940 pack $w.ok -side bottom
2941 bind $w <Visibility> "focus $w.ok"
2942 bind $w <Key-Escape> "destroy $w"
2943 bind $w <Key-Return> "destroy $w"
2946 # Procedures for manipulating the file list window at the
2947 # bottom right of the overall window.
2949 proc treeview {w l openlevs} {
2950 global treecontents treediropen treeheight treeparent treeindex
2960 set treecontents() {}
2961 $w conf -state normal
2963 while {[string range $f 0 $prefixend] ne $prefix} {
2964 if {$lev <= $openlevs} {
2965 $w mark set e:$treeindex($prefix) "end -1c"
2966 $w mark gravity e:$treeindex($prefix) left
2968 set treeheight($prefix) $ht
2969 incr ht [lindex $htstack end]
2970 set htstack [lreplace $htstack end end]
2971 set prefixend [lindex $prefendstack end]
2972 set prefendstack [lreplace $prefendstack end end]
2973 set prefix [string range $prefix 0 $prefixend]
2976 set tail [string range $f [expr {$prefixend+1}] end]
2977 while {[set slash [string first "/" $tail]] >= 0} {
2980 lappend prefendstack $prefixend
2981 incr prefixend [expr {$slash + 1}]
2982 set d [string range $tail 0 $slash]
2983 lappend treecontents($prefix) $d
2984 set oldprefix $prefix
2986 set treecontents($prefix) {}
2987 set treeindex($prefix) [incr ix]
2988 set treeparent($prefix) $oldprefix
2989 set tail [string range $tail [expr {$slash+1}] end]
2990 if {$lev <= $openlevs} {
2992 set treediropen($prefix) [expr {$lev < $openlevs}]
2993 set bm [expr {$lev == $openlevs? "tri-rt": "tri-dn"}]
2994 $w mark set d:$ix "end -1c"
2995 $w mark gravity d:$ix left
2997 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
2999 $w image create end -align center -image $bm -padx 1 \
3001 $w insert end $d [highlight_tag $prefix]
3002 $w mark set s:$ix "end -1c"
3003 $w mark gravity s:$ix left
3008 if {$lev <= $openlevs} {
3011 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
3013 $w insert end $tail [highlight_tag $f]
3015 lappend treecontents($prefix) $tail
3018 while {$htstack ne {}} {
3019 set treeheight($prefix) $ht
3020 incr ht [lindex $htstack end]
3021 set htstack [lreplace $htstack end end]
3022 set prefixend [lindex $prefendstack end]
3023 set prefendstack [lreplace $prefendstack end end]
3024 set prefix [string range $prefix 0 $prefixend]
3026 $w conf -state disabled
3029 proc linetoelt {l} {
3030 global treeheight treecontents
3035 foreach e $treecontents($prefix) {
3040 if {[string index $e end] eq "/"} {
3041 set n $treeheight($prefix$e)
3053 proc highlight_tree {y prefix} {
3054 global treeheight treecontents cflist
3056 foreach e $treecontents($prefix) {
3058 if {[highlight_tag $path] ne {}} {
3059 $cflist tag add bold $y.0 "$y.0 lineend"
3062 if {[string index $e end] eq "/" && $treeheight($path) > 1} {
3063 set y [highlight_tree $y $path]
3069 proc treeclosedir {w dir} {
3070 global treediropen treeheight treeparent treeindex
3072 set ix $treeindex($dir)
3073 $w conf -state normal
3074 $w delete s:$ix e:$ix
3075 set treediropen($dir) 0
3076 $w image configure a:$ix -image tri-rt
3077 $w conf -state disabled
3078 set n [expr {1 - $treeheight($dir)}]
3079 while {$dir ne {}} {
3080 incr treeheight($dir) $n
3081 set dir $treeparent($dir)
3085 proc treeopendir {w dir} {
3086 global treediropen treeheight treeparent treecontents treeindex
3088 set ix $treeindex($dir)
3089 $w conf -state normal
3090 $w image configure a:$ix -image tri-dn
3091 $w mark set e:$ix s:$ix
3092 $w mark gravity e:$ix right
3095 set n [llength $treecontents($dir)]
3096 for {set x $dir} {$x ne {}} {set x $treeparent($x)} {
3099 incr treeheight($x) $n
3101 foreach e $treecontents($dir) {
3103 if {[string index $e end] eq "/"} {
3104 set iy $treeindex($de)
3105 $w mark set d:$iy e:$ix
3106 $w mark gravity d:$iy left
3107 $w insert e:$ix $str
3108 set treediropen($de) 0
3109 $w image create e:$ix -align center -image tri-rt -padx 1 \
3111 $w insert e:$ix $e [highlight_tag $de]
3112 $w mark set s:$iy e:$ix
3113 $w mark gravity s:$iy left
3114 set treeheight($de) 1
3116 $w insert e:$ix $str
3117 $w insert e:$ix $e [highlight_tag $de]
3120 $w mark gravity e:$ix right
3121 $w conf -state disabled
3122 set treediropen($dir) 1
3123 set top [lindex [split [$w index @0,0] .] 0]
3124 set ht [$w cget -height]
3125 set l [lindex [split [$w index s:$ix] .] 0]
3128 } elseif {$l + $n + 1 > $top + $ht} {
3129 set top [expr {$l + $n + 2 - $ht}]
3137 proc treeclick {w x y} {
3138 global treediropen cmitmode ctext cflist cflist_top
3140 if {$cmitmode ne "tree"} return
3141 if {![info exists cflist_top]} return
3142 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3143 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
3144 $cflist tag add highlight $l.0 "$l.0 lineend"
3150 set e [linetoelt $l]
3151 if {[string index $e end] ne "/"} {
3153 } elseif {$treediropen($e)} {
3160 proc setfilelist {id} {
3161 global treefilelist cflist jump_to_here
3163 treeview $cflist $treefilelist($id) 0
3164 if {$jump_to_here ne {}} {
3165 set f [lindex $jump_to_here 0]
3166 if {[lsearch -exact $treefilelist($id) $f] >= 0} {
3172 image create bitmap tri-rt -background black -foreground blue -data {
3173 #define tri-rt_width 13
3174 #define tri-rt_height 13
3175 static unsigned char tri-rt_bits[] = {
3176 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00,
3177 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x30, 0x00, 0x10, 0x00, 0x00, 0x00,
3180 #define tri-rt-mask_width 13
3181 #define tri-rt-mask_height 13
3182 static unsigned char tri-rt-mask_bits[] = {
3183 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01,
3184 0xf8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0x38, 0x00, 0x18, 0x00,
3187 image create bitmap tri-dn -background black -foreground blue -data {
3188 #define tri-dn_width 13
3189 #define tri-dn_height 13
3190 static unsigned char tri-dn_bits[] = {
3191 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xf8, 0x03,
3192 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3195 #define tri-dn-mask_width 13
3196 #define tri-dn-mask_height 13
3197 static unsigned char tri-dn-mask_bits[] = {
3198 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07,
3199 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
3203 image create bitmap reficon-T -background black -foreground yellow -data {
3204 #define tagicon_width 13
3205 #define tagicon_height 9
3206 static unsigned char tagicon_bits[] = {
3207 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x07,
3208 0xfc, 0x07, 0xf8, 0x07, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00};
3210 #define tagicon-mask_width 13
3211 #define tagicon-mask_height 9
3212 static unsigned char tagicon-mask_bits[] = {
3213 0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x0f, 0xfc, 0x0f,
3214 0xfe, 0x0f, 0xfc, 0x0f, 0xf8, 0x0f, 0xf0, 0x0f, 0x00, 0x00};
3217 #define headicon_width 13
3218 #define headicon_height 9
3219 static unsigned char headicon_bits[] = {
3220 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0xf8, 0x07,
3221 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00};
3224 #define headicon-mask_width 13
3225 #define headicon-mask_height 9
3226 static unsigned char headicon-mask_bits[] = {
3227 0x00, 0x00, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f,
3228 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0x00, 0x00};
3230 image create bitmap reficon-H -background black -foreground green \
3231 -data $rectdata -maskdata $rectmask
3232 image create bitmap reficon-o -background black -foreground "#ddddff" \
3233 -data $rectdata -maskdata $rectmask
3235 proc init_flist {first} {
3236 global cflist cflist_top difffilestart
3238 $cflist conf -state normal
3239 $cflist delete 0.0 end
3241 $cflist insert end $first
3243 $cflist tag add highlight 1.0 "1.0 lineend"
3245 catch {unset cflist_top}
3247 $cflist conf -state disabled
3248 set difffilestart {}
3251 proc highlight_tag {f} {
3252 global highlight_paths
3254 foreach p $highlight_paths {
3255 if {[string match $p $f]} {
3262 proc highlight_filelist {} {
3263 global cmitmode cflist
3265 $cflist conf -state normal
3266 if {$cmitmode ne "tree"} {
3267 set end [lindex [split [$cflist index end] .] 0]
3268 for {set l 2} {$l < $end} {incr l} {
3269 set line [$cflist get $l.0 "$l.0 lineend"]
3270 if {[highlight_tag $line] ne {}} {
3271 $cflist tag add bold $l.0 "$l.0 lineend"
3277 $cflist conf -state disabled
3280 proc unhighlight_filelist {} {
3283 $cflist conf -state normal
3284 $cflist tag remove bold 1.0 end
3285 $cflist conf -state disabled
3288 proc add_flist {fl} {
3291 $cflist conf -state normal
3293 $cflist insert end "\n"
3294 $cflist insert end $f [highlight_tag $f]
3296 $cflist conf -state disabled
3299 proc sel_flist {w x y} {
3300 global ctext difffilestart cflist cflist_top cmitmode
3302 if {$cmitmode eq "tree"} return
3303 if {![info exists cflist_top]} return
3304 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3305 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
3306 $cflist tag add highlight $l.0 "$l.0 lineend"
3311 catch {$ctext yview [lindex $difffilestart [expr {$l - 2}]]}
3315 proc pop_flist_menu {w X Y x y} {
3316 global ctext cflist cmitmode flist_menu flist_menu_file
3317 global treediffs diffids
3320 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3322 if {$cmitmode eq "tree"} {
3323 set e [linetoelt $l]
3324 if {[string index $e end] eq "/"} return
3326 set e [lindex $treediffs($diffids) [expr {$l-2}]]
3328 set flist_menu_file $e
3329 set xdiffstate "normal"
3330 if {$cmitmode eq "tree"} {
3331 set xdiffstate "disabled"
3333 # Disable "External diff" item in tree mode
3334 $flist_menu entryconf 2 -state $xdiffstate
3335 tk_popup $flist_menu $X $Y
3338 proc find_ctext_fileinfo {line} {
3339 global ctext_file_names ctext_file_lines
3341 set ok [bsearch $ctext_file_lines $line]
3342 set tline [lindex $ctext_file_lines $ok]
3344 if {$ok >= [llength $ctext_file_lines] || $line < $tline} {
3347 return [list [lindex $ctext_file_names $ok] $tline]
3351 proc pop_diff_menu {w X Y x y} {
3352 global ctext diff_menu flist_menu_file
3353 global diff_menu_txtpos diff_menu_line
3354 global diff_menu_filebase
3356 set diff_menu_txtpos [split [$w index "@$x,$y"] "."]
3357 set diff_menu_line [lindex $diff_menu_txtpos 0]
3358 # don't pop up the menu on hunk-separator or file-separator lines
3359 if {[lsearch -glob [$ctext tag names $diff_menu_line.0] "*sep"] >= 0} {
3363 set f [find_ctext_fileinfo $diff_menu_line]
3364 if {$f eq {}} return
3365 set flist_menu_file [lindex $f 0]
3366 set diff_menu_filebase [lindex $f 1]
3367 tk_popup $diff_menu $X $Y
3370 proc flist_hl {only} {
3371 global flist_menu_file findstring gdttype
3373 set x [shellquote $flist_menu_file]
3374 if {$only || $findstring eq {} || $gdttype ne [mc "touching paths:"]} {
3377 append findstring " " $x
3379 set gdttype [mc "touching paths:"]
3382 proc gitknewtmpdir {} {
3383 global diffnum gitktmpdir gitdir
3385 if {![info exists gitktmpdir]} {
3386 set gitktmpdir [file join $gitdir [format ".gitk-tmp.%s" [pid]]]
3387 if {[catch {file mkdir $gitktmpdir} err]} {
3388 error_popup "[mc "Error creating temporary directory %s:" $gitktmpdir] $err"
3395 set diffdir [file join $gitktmpdir $diffnum]
3396 if {[catch {file mkdir $diffdir} err]} {
3397 error_popup "[mc "Error creating temporary directory %s:" $diffdir] $err"
3403 proc save_file_from_commit {filename output what} {
3406 if {[catch {exec git show $filename -- > $output} err]} {
3407 if {[string match "fatal: bad revision *" $err]} {
3410 error_popup "[mc "Error getting \"%s\" from %s:" $filename $what] $err"
3416 proc external_diff_get_one_file {diffid filename diffdir} {
3417 global nullid nullid2 nullfile
3420 if {$diffid == $nullid} {
3421 set difffile [file join $worktree $filename]
3422 if {[file exists $difffile]} {
3427 if {$diffid == $nullid2} {
3428 set difffile [file join $diffdir "\[index\] [file tail $filename]"]
3429 return [save_file_from_commit :$filename $difffile index]
3431 set difffile [file join $diffdir "\[$diffid\] [file tail $filename]"]
3432 return [save_file_from_commit $diffid:$filename $difffile \
3436 proc external_diff {} {
3437 global nullid nullid2
3438 global flist_menu_file
3442 if {[llength $diffids] == 1} {
3443 # no reference commit given
3444 set diffidto [lindex $diffids 0]
3445 if {$diffidto eq $nullid} {
3446 # diffing working copy with index
3447 set diffidfrom $nullid2
3448 } elseif {$diffidto eq $nullid2} {
3449 # diffing index with HEAD
3450 set diffidfrom "HEAD"
3452 # use first parent commit
3453 global parentlist selectedline
3454 set diffidfrom [lindex $parentlist $selectedline 0]
3457 set diffidfrom [lindex $diffids 0]
3458 set diffidto [lindex $diffids 1]
3461 # make sure that several diffs wont collide
3462 set diffdir [gitknewtmpdir]
3463 if {$diffdir eq {}} return
3465 # gather files to diff
3466 set difffromfile [external_diff_get_one_file $diffidfrom $flist_menu_file $diffdir]
3467 set difftofile [external_diff_get_one_file $diffidto $flist_menu_file $diffdir]
3469 if {$difffromfile ne {} && $difftofile ne {}} {
3470 set cmd [list [shellsplit $extdifftool] $difffromfile $difftofile]
3471 if {[catch {set fl [open |$cmd r]} err]} {
3472 file delete -force $diffdir
3473 error_popup "$extdifftool: [mc "command failed:"] $err"
3475 fconfigure $fl -blocking 0
3476 filerun $fl [list delete_at_eof $fl $diffdir]
3481 proc find_hunk_blamespec {base line} {
3484 # Find and parse the hunk header
3485 set s_lix [$ctext search -backwards -regexp ^@@ "$line.0 lineend" $base.0]
3486 if {$s_lix eq {}} return
3488 set s_line [$ctext get $s_lix "$s_lix + 1 lines"]
3489 if {![regexp {^@@@*(( -\d+(,\d+)?)+) \+(\d+)(,\d+)? @@} $s_line \
3490 s_line old_specs osz osz1 new_line nsz]} {
3494 # base lines for the parents
3495 set base_lines [list $new_line]
3496 foreach old_spec [lrange [split $old_specs " "] 1 end] {
3497 if {![regexp -- {-(\d+)(,\d+)?} $old_spec \
3498 old_spec old_line osz]} {
3501 lappend base_lines $old_line
3504 # Now scan the lines to determine offset within the hunk
3505 set max_parent [expr {[llength $base_lines]-2}]
3507 set s_lno [lindex [split $s_lix "."] 0]
3509 # Determine if the line is removed
3510 set chunk [$ctext get $line.0 "$line.1 + $max_parent chars"]
3511 if {[string match {[-+ ]*} $chunk]} {
3512 set removed_idx [string first "-" $chunk]
3513 # Choose a parent index
3514 if {$removed_idx >= 0} {
3515 set parent $removed_idx
3517 set unchanged_idx [string first " " $chunk]
3518 if {$unchanged_idx >= 0} {
3519 set parent $unchanged_idx
3521 # blame the current commit
3525 # then count other lines that belong to it
3526 for {set i $line} {[incr i -1] > $s_lno} {} {
3527 set chunk [$ctext get $i.0 "$i.1 + $max_parent chars"]
3528 # Determine if the line is removed
3529 set removed_idx [string first "-" $chunk]
3531 set code [string index $chunk $parent]
3532 if {$code eq "-" || ($removed_idx < 0 && $code ne "+")} {
3536 if {$removed_idx < 0} {
3546 incr dline [lindex $base_lines $parent]
3547 return [list $parent $dline]
3550 proc external_blame_diff {} {
3551 global currentid cmitmode
3552 global diff_menu_txtpos diff_menu_line
3553 global diff_menu_filebase flist_menu_file
3555 if {$cmitmode eq "tree"} {
3557 set line [expr {$diff_menu_line - $diff_menu_filebase}]
3559 set hinfo [find_hunk_blamespec $diff_menu_filebase $diff_menu_line]
3561 set parent_idx [lindex $hinfo 0]
3562 set line [lindex $hinfo 1]
3569 external_blame $parent_idx $line
3572 # Find the SHA1 ID of the blob for file $fname in the index
3574 proc index_sha1 {fname} {
3575 set f [open [list | git ls-files -s $fname] r]
3576 while {[gets $f line] >= 0} {
3577 set info [lindex [split $line "\t"] 0]
3578 set stage [lindex $info 2]
3579 if {$stage eq "0" || $stage eq "2"} {
3581 return [lindex $info 1]
3588 # Turn an absolute path into one relative to the current directory
3589 proc make_relative {f} {
3590 if {[file pathtype $f] eq "relative"} {
3593 set elts [file split $f]
3594 set here [file split [pwd]]
3599 if {$ei < $hi || $ei >= [llength $elts] || [lindex $elts $ei] ne $d} {
3606 set elts [concat $res [lrange $elts $ei end]]
3607 return [eval file join $elts]
3610 proc external_blame {parent_idx {line {}}} {
3611 global flist_menu_file cdup
3612 global nullid nullid2
3613 global parentlist selectedline currentid
3615 if {$parent_idx > 0} {
3616 set base_commit [lindex $parentlist $selectedline [expr {$parent_idx-1}]]
3618 set base_commit $currentid
3621 if {$base_commit eq {} || $base_commit eq $nullid || $base_commit eq $nullid2} {
3622 error_popup [mc "No such commit"]
3626 set cmdline [list git gui blame]
3627 if {$line ne {} && $line > 1} {
3628 lappend cmdline "--line=$line"
3630 set f [file join $cdup $flist_menu_file]
3631 # Unfortunately it seems git gui blame doesn't like
3632 # being given an absolute path...
3633 set f [make_relative $f]
3634 lappend cmdline $base_commit $f
3635 if {[catch {eval exec $cmdline &} err]} {
3636 error_popup "[mc "git gui blame: command failed:"] $err"
3640 proc show_line_source {} {
3641 global cmitmode currentid parents curview blamestuff blameinst
3642 global diff_menu_line diff_menu_filebase flist_menu_file
3643 global nullid nullid2 gitdir cdup
3646 if {$cmitmode eq "tree"} {
3648 set line [expr {$diff_menu_line - $diff_menu_filebase}]
3650 set h [find_hunk_blamespec $diff_menu_filebase $diff_menu_line]
3651 if {$h eq {}} return
3652 set pi [lindex $h 0]
3654 mark_ctext_line $diff_menu_line
3658 if {$currentid eq $nullid} {
3660 # must be a merge in progress...
3662 # get the last line from .git/MERGE_HEAD
3663 set f [open [file join $gitdir MERGE_HEAD] r]
3664 set id [lindex [split [read $f] "\n"] end-1]
3667 error_popup [mc "Couldn't read merge head: %s" $err]
3670 } elseif {$parents($curview,$currentid) eq $nullid2} {
3671 # need to do the blame from the index
3673 set from_index [index_sha1 $flist_menu_file]
3675 error_popup [mc "Error reading index: %s" $err]
3679 set id $parents($curview,$currentid)
3682 set id [lindex $parents($curview,$currentid) $pi]
3684 set line [lindex $h 1]
3687 if {$from_index ne {}} {
3688 lappend blameargs | git cat-file blob $from_index
3690 lappend blameargs | git blame -p -L$line,+1
3691 if {$from_index ne {}} {
3692 lappend blameargs --contents -
3694 lappend blameargs $id
3696 lappend blameargs -- [file join $cdup $flist_menu_file]
3698 set f [open $blameargs r]
3700 error_popup [mc "Couldn't start git blame: %s" $err]
3703 nowbusy blaming [mc "Searching"]
3704 fconfigure $f -blocking 0
3705 set i [reg_instance $f]
3706 set blamestuff($i) {}
3708 filerun $f [list read_line_source $f $i]
3711 proc stopblaming {} {
3714 if {[info exists blameinst]} {
3715 stop_instance $blameinst
3721 proc read_line_source {fd inst} {
3722 global blamestuff curview commfd blameinst nullid nullid2
3724 while {[gets $fd line] >= 0} {
3725 lappend blamestuff($inst) $line
3733 fconfigure $fd -blocking 1
3734 if {[catch {close $fd} err]} {
3735 error_popup [mc "Error running git blame: %s" $err]
3740 set line [split [lindex $blamestuff($inst) 0] " "]
3741 set id [lindex $line 0]
3742 set lnum [lindex $line 1]
3743 if {[string length $id] == 40 && [string is xdigit $id] &&
3744 [string is digit -strict $lnum]} {
3745 # look for "filename" line
3746 foreach l $blamestuff($inst) {
3747 if {[string match "filename *" $l]} {
3748 set fname [string range $l 9 end]
3754 # all looks good, select it
3755 if {$id eq $nullid} {
3756 # blame uses all-zeroes to mean not committed,
3757 # which would mean a change in the index
3760 if {[commitinview $id $curview]} {
3761 selectline [rowofcommit $id] 1 [list $fname $lnum]
3763 error_popup [mc "That line comes from commit %s, \
3764 which is not in this view" [shortids $id]]
3767 puts "oops couldn't parse git blame output"
3772 # delete $dir when we see eof on $f (presumably because the child has exited)
3773 proc delete_at_eof {f dir} {
3774 while {[gets $f line] >= 0} {}
3776 if {[catch {close $f} err]} {
3777 error_popup "[mc "External diff viewer failed:"] $err"
3779 file delete -force $dir
3785 # Functions for adding and removing shell-type quoting
3787 proc shellquote {str} {
3788 if {![string match "*\['\"\\ \t]*" $str]} {
3791 if {![string match "*\['\"\\]*" $str]} {
3794 if {![string match "*'*" $str]} {
3797 return "\"[string map {\" \\\" \\ \\\\} $str]\""
3800 proc shellarglist {l} {
3806 append str [shellquote $a]
3811 proc shelldequote {str} {
3816 if {![regexp -start $used -indices "\['\"\\\\ \t]" $str first]} {
3817 append ret [string range $str $used end]
3818 set used [string length $str]
3821 set first [lindex $first 0]
3822 set ch [string index $str $first]
3823 if {$first > $used} {
3824 append ret [string range $str $used [expr {$first - 1}]]
3827 if {$ch eq " " || $ch eq "\t"} break
3830 set first [string first "'" $str $used]
3832 error "unmatched single-quote"
3834 append ret [string range $str $used [expr {$first - 1}]]
3839 if {$used >= [string length $str]} {
3840 error "trailing backslash"
3842 append ret [string index $str $used]
3847 if {![regexp -start $used -indices "\[\"\\\\]" $str first]} {
3848 error "unmatched double-quote"
3850 set first [lindex $first 0]
3851 set ch [string index $str $first]
3852 if {$first > $used} {
3853 append ret [string range $str $used [expr {$first - 1}]]
3856 if {$ch eq "\""} break
3858 append ret [string index $str $used]
3862 return [list $used $ret]
3865 proc shellsplit {str} {
3868 set str [string trimleft $str]
3869 if {$str eq {}} break
3870 set dq [shelldequote $str]
3871 set n [lindex $dq 0]
3872 set word [lindex $dq 1]
3873 set str [string range $str $n end]
3879 # Code to implement multiple views
3881 proc newview {ishighlight} {
3882 global nextviewnum newviewname newishighlight
3883 global revtreeargs viewargscmd newviewopts curview
3885 set newishighlight $ishighlight
3887 if {[winfo exists $top]} {
3891 decode_view_opts $nextviewnum $revtreeargs
3892 set newviewname($nextviewnum) "[mc "View"] $nextviewnum"
3893 set newviewopts($nextviewnum,perm) 0
3894 set newviewopts($nextviewnum,cmd) $viewargscmd($curview)
3895 vieweditor $top $nextviewnum [mc "Gitk view definition"]
3898 set known_view_options {
3899 {perm b . {} {mc "Remember this view"}}
3900 {reflabel l + {} {mc "References (space separated list):"}}
3901 {refs t15 .. {} {mc "Branches & tags:"}}
3902 {allrefs b *. "--all" {mc "All refs"}}
3903 {branches b . "--branches" {mc "All (local) branches"}}
3904 {tags b . "--tags" {mc "All tags"}}
3905 {remotes b . "--remotes" {mc "All remote-tracking branches"}}
3906 {commitlbl l + {} {mc "Commit Info (regular expressions):"}}
3907 {author t15 .. "--author=*" {mc "Author:"}}
3908 {committer t15 . "--committer=*" {mc "Committer:"}}
3909 {loginfo t15 .. "--grep=*" {mc "Commit Message:"}}
3910 {allmatch b .. "--all-match" {mc "Matches all Commit Info criteria"}}
3911 {changes_l l + {} {mc "Changes to Files:"}}
3912 {pickaxe_s r0 . {} {mc "Fixed String"}}
3913 {pickaxe_t r1 . "--pickaxe-regex" {mc "Regular Expression"}}
3914 {pickaxe t15 .. "-S*" {mc "Search string:"}}
3915 {datelabel l + {} {mc "Commit Dates (\"2 weeks ago\", \"2009-03-17 15:27:38\", \"March 17, 2009 15:27:38\"):"}}
3916 {since t15 .. {"--since=*" "--after=*"} {mc "Since:"}}
3917 {until t15 . {"--until=*" "--before=*"} {mc "Until:"}}
3918 {limit_lbl l + {} {mc "Limit and/or skip a number of revisions (positive integer):"}}
3919 {limit t10 *. "--max-count=*" {mc "Number to show:"}}
3920 {skip t10 . "--skip=*" {mc "Number to skip:"}}
3921 {misc_lbl l + {} {mc "Miscellaneous options:"}}
3922 {dorder b *. {"--date-order" "-d"} {mc "Strictly sort by date"}}
3923 {lright b . "--left-right" {mc "Mark branch sides"}}
3924 {first b . "--first-parent" {mc "Limit to first parent"}}
3925 {smplhst b . "--simplify-by-decoration" {mc "Simple history"}}
3926 {args t50 *. {} {mc "Additional arguments to git log:"}}
3927 {allpaths path + {} {mc "Enter files and directories to include, one per line:"}}
3928 {cmd t50= + {} {mc "Command to generate more commits to include:"}}
3931 # Convert $newviewopts($n, ...) into args for git log.
3932 proc encode_view_opts {n} {
3933 global known_view_options newviewopts
3936 foreach opt $known_view_options {
3937 set patterns [lindex $opt 3]
3938 if {$patterns eq {}} continue
3939 set pattern [lindex $patterns 0]
3941 if {[lindex $opt 1] eq "b"} {
3942 set val $newviewopts($n,[lindex $opt 0])
3944 lappend rargs $pattern
3946 } elseif {[regexp {^r(\d+)$} [lindex $opt 1] type value]} {
3947 regexp {^(.*_)} [lindex $opt 0] uselessvar button_id
3948 set val $newviewopts($n,$button_id)
3949 if {$val eq $value} {
3950 lappend rargs $pattern
3953 set val $newviewopts($n,[lindex $opt 0])
3954 set val [string trim $val]
3956 set pfix [string range $pattern 0 end-1]
3957 lappend rargs $pfix$val
3961 set rargs [concat $rargs [shellsplit $newviewopts($n,refs)]]
3962 return [concat $rargs [shellsplit $newviewopts($n,args)]]
3965 # Fill $newviewopts($n, ...) based on args for git log.
3966 proc decode_view_opts {n view_args} {
3967 global known_view_options newviewopts
3969 foreach opt $known_view_options {
3970 set id [lindex $opt 0]
3971 if {[lindex $opt 1] eq "b"} {
3974 } elseif {[regexp {^r(\d+)$} [lindex $opt 1]]} {
3976 regexp {^(.*_)} $id uselessvar id
3982 set newviewopts($n,$id) $val
3986 foreach arg $view_args {
3987 if {[regexp -- {^-([0-9]+)$} $arg arg cnt]
3988 && ![info exists found(limit)]} {
3989 set newviewopts($n,limit) $cnt
3994 foreach opt $known_view_options {
3995 set id [lindex $opt 0]
3996 if {[info exists found($id)]} continue
3997 foreach pattern [lindex $opt 3] {
3998 if {![string match $pattern $arg]} continue
3999 if {[lindex $opt 1] eq "b"} {
4002 } elseif {[regexp {^r(\d+)$} [lindex $opt 1] match num]} {
4004 regexp {^(.*_)} $id uselessvar id
4008 set size [string length $pattern]
4009 set val [string range $arg [expr {$size-1}] end]
4011 set newviewopts($n,$id) $val
4015 if {[info exists val]} break
4017 if {[info exists val]} continue
4018 if {[regexp {^-} $arg]} {
4021 lappend refargs $arg
4024 set newviewopts($n,refs) [shellarglist $refargs]
4025 set newviewopts($n,args) [shellarglist $oargs]
4028 proc edit_or_newview {} {
4040 global viewname viewperm newviewname newviewopts
4041 global viewargs viewargscmd
4043 set top .gitkvedit-$curview
4044 if {[winfo exists $top]} {
4048 decode_view_opts $curview $viewargs($curview)
4049 set newviewname($curview) $viewname($curview)
4050 set newviewopts($curview,perm) $viewperm($curview)
4051 set newviewopts($curview,cmd) $viewargscmd($curview)
4052 vieweditor $top $curview "[mc "Gitk: edit view"] $viewname($curview)"
4055 proc vieweditor {top n title} {
4056 global newviewname newviewopts viewfiles bgcolor
4057 global known_view_options NS
4060 wm title $top [concat $title [mc "-- criteria for selecting revisions"]]
4061 make_transient $top .
4064 ${NS}::frame $top.nfr
4065 ${NS}::label $top.nl -text [mc "View Name"]
4066 ${NS}::entry $top.name -width 20 -textvariable newviewname($n)
4067 pack $top.nfr -in $top -fill x -pady 5 -padx 3
4068 pack $top.nl -in $top.nfr -side left -padx {0 5}
4069 pack $top.name -in $top.nfr -side left -padx {0 25}
4075 foreach opt $known_view_options {
4076 set id [lindex $opt 0]
4077 set type [lindex $opt 1]
4078 set flags [lindex $opt 2]
4079 set title [eval [lindex $opt 4]]
4082 if {$flags eq "+" || $flags eq "*"} {
4083 set cframe $top.fr$cnt
4085 ${NS}::frame $cframe
4086 pack $cframe -in $top -fill x -pady 3 -padx 3
4087 set cexpand [expr {$flags eq "*"}]
4088 } elseif {$flags eq ".." || $flags eq "*."} {
4089 set cframe $top.fr$cnt
4091 ${NS}::frame $cframe
4092 pack $cframe -in $top -fill x -pady 3 -padx [list 15 3]
4093 set cexpand [expr {$flags eq "*."}]
4099 ${NS}::label $cframe.l_$id -text $title
4100 pack $cframe.l_$id -in $cframe -side left -pady [list 3 0] -anchor w
4101 } elseif {$type eq "b"} {
4102 ${NS}::checkbutton $cframe.c_$id -text $title -variable newviewopts($n,$id)
4103 pack $cframe.c_$id -in $cframe -side left \
4104 -padx [list $lxpad 0] -expand $cexpand -anchor w
4105 } elseif {[regexp {^r(\d+)$} $type type sz]} {
4106 regexp {^(.*_)} $id uselessvar button_id
4107 ${NS}::radiobutton $cframe.c_$id -text $title -variable newviewopts($n,$button_id) -value $sz
4108 pack $cframe.c_$id -in $cframe -side left \
4109 -padx [list $lxpad 0] -expand $cexpand -anchor w
4110 } elseif {[regexp {^t(\d+)$} $type type sz]} {
4111 ${NS}::label $cframe.l_$id -text $title
4112 ${NS}::entry $cframe.e_$id -width $sz -background $bgcolor \
4113 -textvariable newviewopts($n,$id)
4114 pack $cframe.l_$id -in $cframe -side left -padx [list $lxpad 0]
4115 pack $cframe.e_$id -in $cframe -side left -expand 1 -fill x
4116 } elseif {[regexp {^t(\d+)=$} $type type sz]} {
4117 ${NS}::label $cframe.l_$id -text $title
4118 ${NS}::entry $cframe.e_$id -width $sz -background $bgcolor \
4119 -textvariable newviewopts($n,$id)
4120 pack $cframe.l_$id -in $cframe -side top -pady [list 3 0] -anchor w
4121 pack $cframe.e_$id -in $cframe -side top -fill x
4122 } elseif {$type eq "path"} {
4123 ${NS}::label $top.l -text $title
4124 pack $top.l -in $top -side top -pady [list 3 0] -anchor w -padx 3
4125 text $top.t -width 40 -height 5 -background $bgcolor
4126 if {[info exists viewfiles($n)]} {
4127 foreach f $viewfiles($n) {
4128 $top.t insert end $f
4129 $top.t insert end "\n"
4131 $top.t delete {end - 1c} end
4132 $top.t mark set insert 0.0
4134 pack $top.t -in $top -side top -pady [list 0 5] -fill both -expand 1 -padx 3
4138 ${NS}::frame $top.buts
4139 ${NS}::button $top.buts.ok -text [mc "OK"] -command [list newviewok $top $n]
4140 ${NS}::button $top.buts.apply -text [mc "Apply (F5)"] -command [list newviewok $top $n 1]
4141 ${NS}::button $top.buts.can -text [mc "Cancel"] -command [list destroy $top]
4142 bind $top <Control-Return> [list newviewok $top $n]
4143 bind $top <F5> [list newviewok $top $n 1]
4144 bind $top <Escape> [list destroy $top]
4145 grid $top.buts.ok $top.buts.apply $top.buts.can
4146 grid columnconfigure $top.buts 0 -weight 1 -uniform a
4147 grid columnconfigure $top.buts 1 -weight 1 -uniform a
4148 grid columnconfigure $top.buts 2 -weight 1 -uniform a
4149 pack $top.buts -in $top -side top -fill x
4153 proc doviewmenu {m first cmd op argv} {
4154 set nmenu [$m index end]
4155 for {set i $first} {$i <= $nmenu} {incr i} {
4156 if {[$m entrycget $i -command] eq $cmd} {
4157 eval $m $op $i $argv
4163 proc allviewmenus {n op args} {
4166 doviewmenu .bar.view 5 [list showview $n] $op $args
4167 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] $op $args
4170 proc newviewok {top n {apply 0}} {
4171 global nextviewnum newviewperm newviewname newishighlight
4172 global viewname viewfiles viewperm selectedview curview
4173 global viewargs viewargscmd newviewopts viewhlmenu
4176 set newargs [encode_view_opts $n]
4178 error_popup "[mc "Error in commit selection arguments:"] $err" $top
4182 foreach f [split [$top.t get 0.0 end] "\n"] {
4183 set ft [string trim $f]
4188 if {![info exists viewfiles($n)]} {
4189 # creating a new view
4191 set viewname($n) $newviewname($n)
4192 set viewperm($n) $newviewopts($n,perm)
4193 set viewfiles($n) $files
4194 set viewargs($n) $newargs
4195 set viewargscmd($n) $newviewopts($n,cmd)
4197 if {!$newishighlight} {
4200 run addvhighlight $n
4203 # editing an existing view
4204 set viewperm($n) $newviewopts($n,perm)
4205 if {$newviewname($n) ne $viewname($n)} {
4206 set viewname($n) $newviewname($n)
4207 doviewmenu .bar.view 5 [list showview $n] \
4208 entryconf [list -label $viewname($n)]
4209 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] \
4210 # entryconf [list -label $viewname($n) -value $viewname($n)]
4212 if {$files ne $viewfiles($n) || $newargs ne $viewargs($n) || \
4213 $newviewopts($n,cmd) ne $viewargscmd($n)} {
4214 set viewfiles($n) $files
4215 set viewargs($n) $newargs
4216 set viewargscmd($n) $newviewopts($n,cmd)
4217 if {$curview == $n} {
4223 catch {destroy $top}
4227 global curview viewperm hlview selectedhlview
4229 if {$curview == 0} return
4230 if {[info exists hlview] && $hlview == $curview} {
4231 set selectedhlview [mc "None"]
4234 allviewmenus $curview delete
4235 set viewperm($curview) 0
4239 proc addviewmenu {n} {
4240 global viewname viewhlmenu
4242 .bar.view add radiobutton -label $viewname($n) \
4243 -command [list showview $n] -variable selectedview -value $n
4244 #$viewhlmenu add radiobutton -label $viewname($n) \
4245 # -command [list addvhighlight $n] -variable selectedhlview
4249 global curview cached_commitrow ordertok
4250 global displayorder parentlist rowidlist rowisopt rowfinal
4251 global colormap rowtextx nextcolor canvxmax
4252 global numcommits viewcomplete
4253 global selectedline currentid canv canvy0
4255 global pending_select mainheadid
4258 global hlview selectedhlview commitinterest
4260 if {$n == $curview} return
4262 set ymax [lindex [$canv cget -scrollregion] 3]
4263 set span [$canv yview]
4264 set ytop [expr {[lindex $span 0] * $ymax}]
4265 set ybot [expr {[lindex $span 1] * $ymax}]
4266 set yscreen [expr {($ybot - $ytop) / 2}]
4267 if {$selectedline ne {}} {
4268 set selid $currentid
4269 set y [yc $selectedline]
4270 if {$ytop < $y && $y < $ybot} {
4271 set yscreen [expr {$y - $ytop}]
4273 } elseif {[info exists pending_select]} {
4274 set selid $pending_select
4275 unset pending_select
4279 catch {unset treediffs}
4281 if {[info exists hlview] && $hlview == $n} {
4283 set selectedhlview [mc "None"]
4285 catch {unset commitinterest}
4286 catch {unset cached_commitrow}
4287 catch {unset ordertok}
4291 .bar.view entryconf [mca "Edit view..."] -state [expr {$n == 0? "disabled": "normal"}]
4292 .bar.view entryconf [mca "Delete view"] -state [expr {$n == 0? "disabled": "normal"}]
4295 if {![info exists viewcomplete($n)]} {
4305 set numcommits $commitidx($n)
4307 catch {unset colormap}
4308 catch {unset rowtextx}
4310 set canvxmax [$canv cget -width]
4316 if {$selid ne {} && [commitinview $selid $n]} {
4317 set row [rowofcommit $selid]
4318 # try to get the selected row in the same position on the screen
4319 set ymax [lindex [$canv cget -scrollregion] 3]
4320 set ytop [expr {[yc $row] - $yscreen}]
4324 set yf [expr {$ytop * 1.0 / $ymax}]
4326 allcanvs yview moveto $yf
4330 } elseif {!$viewcomplete($n)} {
4331 reset_pending_select $selid
4333 reset_pending_select {}
4335 if {[commitinview $pending_select $curview]} {
4336 selectline [rowofcommit $pending_select] 1
4338 set row [first_real_row]
4339 if {$row < $numcommits} {
4344 if {!$viewcomplete($n)} {
4345 if {$numcommits == 0} {
4346 show_status [mc "Reading commits..."]
4348 } elseif {$numcommits == 0} {
4349 show_status [mc "No commits selected"]
4353 # Stuff relating to the highlighting facility
4355 proc ishighlighted {id} {
4356 global vhighlights fhighlights nhighlights rhighlights
4358 if {[info exists nhighlights($id)] && $nhighlights($id) > 0} {
4359 return $nhighlights($id)
4361 if {[info exists vhighlights($id)] && $vhighlights($id) > 0} {
4362 return $vhighlights($id)
4364 if {[info exists fhighlights($id)] && $fhighlights($id) > 0} {
4365 return $fhighlights($id)
4367 if {[info exists rhighlights($id)] && $rhighlights($id) > 0} {
4368 return $rhighlights($id)
4373 proc bolden {id font} {
4374 global canv linehtag currentid boldids need_redisplay markedid
4376 # need_redisplay = 1 means the display is stale and about to be redrawn
4377 if {$need_redisplay} return
4379 $canv itemconf $linehtag($id) -font $font
4380 if {[info exists currentid] && $id eq $currentid} {
4382 set t [eval $canv create rect [$canv bbox $linehtag($id)] \
4383 -outline {{}} -tags secsel \
4384 -fill [$canv cget -selectbackground]]
4387 if {[info exists markedid] && $id eq $markedid} {
4392 proc bolden_name {id font} {
4393 global canv2 linentag currentid boldnameids need_redisplay
4395 if {$need_redisplay} return
4396 lappend boldnameids $id
4397 $canv2 itemconf $linentag($id) -font $font
4398 if {[info exists currentid] && $id eq $currentid} {
4399 $canv2 delete secsel
4400 set t [eval $canv2 create rect [$canv2 bbox $linentag($id)] \
4401 -outline {{}} -tags secsel \
4402 -fill [$canv2 cget -selectbackground]]
4411 foreach id $boldids {
4412 if {![ishighlighted $id]} {
4415 lappend stillbold $id
4418 set boldids $stillbold
4421 proc addvhighlight {n} {
4422 global hlview viewcomplete curview vhl_done commitidx
4424 if {[info exists hlview]} {
4428 if {$n != $curview && ![info exists viewcomplete($n)]} {
4431 set vhl_done $commitidx($hlview)
4432 if {$vhl_done > 0} {
4437 proc delvhighlight {} {
4438 global hlview vhighlights
4440 if {![info exists hlview]} return
4442 catch {unset vhighlights}
4446 proc vhighlightmore {} {
4447 global hlview vhl_done commitidx vhighlights curview
4449 set max $commitidx($hlview)
4450 set vr [visiblerows]
4451 set r0 [lindex $vr 0]
4452 set r1 [lindex $vr 1]
4453 for {set i $vhl_done} {$i < $max} {incr i} {
4454 set id [commitonrow $i $hlview]
4455 if {[commitinview $id $curview]} {
4456 set row [rowofcommit $id]
4457 if {$r0 <= $row && $row <= $r1} {
4458 if {![highlighted $row]} {
4459 bolden $id mainfontbold
4461 set vhighlights($id) 1
4469 proc askvhighlight {row id} {
4470 global hlview vhighlights iddrawn
4472 if {[commitinview $id $hlview]} {
4473 if {[info exists iddrawn($id)] && ![ishighlighted $id]} {
4474 bolden $id mainfontbold
4476 set vhighlights($id) 1
4478 set vhighlights($id) 0
4482 proc hfiles_change {} {
4483 global highlight_files filehighlight fhighlights fh_serial
4484 global highlight_paths
4486 if {[info exists filehighlight]} {
4487 # delete previous highlights
4488 catch {close $filehighlight}
4490 catch {unset fhighlights}
4492 unhighlight_filelist
4494 set highlight_paths {}
4495 after cancel do_file_hl $fh_serial
4497 if {$highlight_files ne {}} {
4498 after 300 do_file_hl $fh_serial
4502 proc gdttype_change {name ix op} {
4503 global gdttype highlight_files findstring findpattern
4506 if {$findstring ne {}} {
4507 if {$gdttype eq [mc "containing:"]} {
4508 if {$highlight_files ne {}} {
4509 set highlight_files {}
4514 if {$findpattern ne {}} {
4518 set highlight_files $findstring
4523 # enable/disable findtype/findloc menus too
4526 proc find_change {name ix op} {
4527 global gdttype findstring highlight_files
4530 if {$gdttype eq [mc "containing:"]} {
4533 if {$highlight_files ne $findstring} {
4534 set highlight_files $findstring
4541 proc findcom_change args {
4542 global nhighlights boldnameids
4543 global findpattern findtype findstring gdttype
4546 # delete previous highlights, if any
4547 foreach id $boldnameids {
4548 bolden_name $id mainfont
4551 catch {unset nhighlights}
4554 if {$gdttype ne [mc "containing:"] || $findstring eq {}} {
4556 } elseif {$findtype eq [mc "Regexp"]} {
4557 set findpattern $findstring
4559 set e [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} \
4561 set findpattern "*$e*"
4565 proc makepatterns {l} {
4568 set ee [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} $e]
4569 if {[string index $ee end] eq "/"} {
4579 proc do_file_hl {serial} {
4580 global highlight_files filehighlight highlight_paths gdttype fhl_list
4581 global cdup findtype
4583 if {$gdttype eq [mc "touching paths:"]} {
4584 # If "exact" match then convert backslashes to forward slashes.
4585 # Most useful to support Windows-flavoured file paths.
4586 if {$findtype eq [mc "Exact"]} {
4587 set highlight_files [string map {"\\" "/"} $highlight_files]
4589 if {[catch {set paths [shellsplit $highlight_files]}]} return
4590 set highlight_paths [makepatterns $paths]
4592 set relative_paths {}
4593 foreach path $paths {
4594 lappend relative_paths [file join $cdup $path]
4596 set gdtargs [concat -- $relative_paths]
4597 } elseif {$gdttype eq [mc "adding/removing string:"]} {
4598 set gdtargs [list "-S$highlight_files"]
4600 # must be "containing:", i.e. we're searching commit info
4603 set cmd [concat | git diff-tree -r -s --stdin $gdtargs]
4604 set filehighlight [open $cmd r+]
4605 fconfigure $filehighlight -blocking 0
4606 filerun $filehighlight readfhighlight
4612 proc flushhighlights {} {
4613 global filehighlight fhl_list
4615 if {[info exists filehighlight]} {
4617 puts $filehighlight ""
4618 flush $filehighlight
4622 proc askfilehighlight {row id} {
4623 global filehighlight fhighlights fhl_list
4625 lappend fhl_list $id
4626 set fhighlights($id) -1
4627 puts $filehighlight $id
4630 proc readfhighlight {} {
4631 global filehighlight fhighlights curview iddrawn
4632 global fhl_list find_dirn
4634 if {![info exists filehighlight]} {
4638 while {[incr nr] <= 100 && [gets $filehighlight line] >= 0} {
4639 set line [string trim $line]
4640 set i [lsearch -exact $fhl_list $line]
4641 if {$i < 0} continue
4642 for {set j 0} {$j < $i} {incr j} {
4643 set id [lindex $fhl_list $j]
4644 set fhighlights($id) 0
4646 set fhl_list [lrange $fhl_list [expr {$i+1}] end]
4647 if {$line eq {}} continue
4648 if {![commitinview $line $curview]} continue
4649 if {[info exists iddrawn($line)] && ![ishighlighted $line]} {
4650 bolden $line mainfontbold
4652 set fhighlights($line) 1
4654 if {[eof $filehighlight]} {
4656 puts "oops, git diff-tree died"
4657 catch {close $filehighlight}
4661 if {[info exists find_dirn]} {
4667 proc doesmatch {f} {
4668 global findtype findpattern
4670 if {$findtype eq [mc "Regexp"]} {
4671 return [regexp $findpattern $f]
4672 } elseif {$findtype eq [mc "IgnCase"]} {
4673 return [string match -nocase $findpattern $f]
4675 return [string match $findpattern $f]
4679 proc askfindhighlight {row id} {
4680 global nhighlights commitinfo iddrawn
4682 global markingmatches
4684 if {![info exists commitinfo($id)]} {
4687 set info $commitinfo($id)
4689 set fldtypes [list [mc Headline] [mc Author] "" [mc Committer] "" [mc Comments]]
4690 foreach f $info ty $fldtypes {
4691 if {$ty eq ""} continue
4692 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
4694 if {$ty eq [mc "Author"]} {
4701 if {$isbold && [info exists iddrawn($id)]} {
4702 if {![ishighlighted $id]} {
4703 bolden $id mainfontbold
4705 bolden_name $id mainfontbold
4708 if {$markingmatches} {
4709 markrowmatches $row $id
4712 set nhighlights($id) $isbold
4715 proc markrowmatches {row id} {
4716 global canv canv2 linehtag linentag commitinfo findloc
4718 set headline [lindex $commitinfo($id) 0]
4719 set author [lindex $commitinfo($id) 1]
4720 $canv delete match$row
4721 $canv2 delete match$row
4722 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Headline"]} {
4723 set m [findmatches $headline]
4725 markmatches $canv $row $headline $linehtag($id) $m \
4726 [$canv itemcget $linehtag($id) -font] $row
4729 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Author"]} {
4730 set m [findmatches $author]
4732 markmatches $canv2 $row $author $linentag($id) $m \
4733 [$canv2 itemcget $linentag($id) -font] $row
4738 proc vrel_change {name ix op} {
4739 global highlight_related
4742 if {$highlight_related ne [mc "None"]} {
4747 # prepare for testing whether commits are descendents or ancestors of a
4748 proc rhighlight_sel {a} {
4749 global descendent desc_todo ancestor anc_todo
4750 global highlight_related
4752 catch {unset descendent}
4753 set desc_todo [list $a]
4754 catch {unset ancestor}
4755 set anc_todo [list $a]
4756 if {$highlight_related ne [mc "None"]} {
4762 proc rhighlight_none {} {
4765 catch {unset rhighlights}
4769 proc is_descendent {a} {
4770 global curview children descendent desc_todo
4773 set la [rowofcommit $a]
4777 for {set i 0} {$i < [llength $todo]} {incr i} {
4778 set do [lindex $todo $i]
4779 if {[rowofcommit $do] < $la} {
4780 lappend leftover $do
4783 foreach nk $children($v,$do) {
4784 if {![info exists descendent($nk)]} {
4785 set descendent($nk) 1
4793 set desc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
4797 set descendent($a) 0
4798 set desc_todo $leftover
4801 proc is_ancestor {a} {
4802 global curview parents ancestor anc_todo
4805 set la [rowofcommit $a]
4809 for {set i 0} {$i < [llength $todo]} {incr i} {
4810 set do [lindex $todo $i]
4811 if {![commitinview $do $v] || [rowofcommit $do] > $la} {
4812 lappend leftover $do
4815 foreach np $parents($v,$do) {
4816 if {![info exists ancestor($np)]} {
4825 set anc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
4830 set anc_todo $leftover
4833 proc askrelhighlight {row id} {
4834 global descendent highlight_related iddrawn rhighlights
4835 global selectedline ancestor
4837 if {$selectedline eq {}} return
4839 if {$highlight_related eq [mc "Descendant"] ||
4840 $highlight_related eq [mc "Not descendant"]} {
4841 if {![info exists descendent($id)]} {
4844 if {$descendent($id) == ($highlight_related eq [mc "Descendant"])} {
4847 } elseif {$highlight_related eq [mc "Ancestor"] ||
4848 $highlight_related eq [mc "Not ancestor"]} {
4849 if {![info exists ancestor($id)]} {
4852 if {$ancestor($id) == ($highlight_related eq [mc "Ancestor"])} {
4856 if {[info exists iddrawn($id)]} {
4857 if {$isbold && ![ishighlighted $id]} {
4858 bolden $id mainfontbold
4861 set rhighlights($id) $isbold
4864 # Graph layout functions
4866 proc shortids {ids} {
4869 if {[llength $id] > 1} {
4870 lappend res [shortids $id]
4871 } elseif {[regexp {^[0-9a-f]{40}$} $id]} {
4872 lappend res [string range $id 0 7]
4883 for {set mask 1} {$mask <= $n} {incr mask $mask} {
4884 if {($n & $mask) != 0} {
4885 set ret [concat $ret $o]
4887 set o [concat $o $o]
4892 proc ordertoken {id} {
4893 global ordertok curview varcid varcstart varctok curview parents children
4894 global nullid nullid2
4896 if {[info exists ordertok($id)]} {
4897 return $ordertok($id)
4902 if {[info exists varcid($curview,$id)]} {
4903 set a $varcid($curview,$id)
4904 set p [lindex $varcstart($curview) $a]
4906 set p [lindex $children($curview,$id) 0]
4908 if {[info exists ordertok($p)]} {
4909 set tok $ordertok($p)
4912 set id [first_real_child $curview,$p]
4915 set tok [lindex $varctok($curview) $varcid($curview,$p)]
4918 if {[llength $parents($curview,$id)] == 1} {
4919 lappend todo [list $p {}]
4921 set j [lsearch -exact $parents($curview,$id) $p]
4923 puts "oops didn't find [shortids $p] in parents of [shortids $id]"
4925 lappend todo [list $p [strrep $j]]
4928 for {set i [llength $todo]} {[incr i -1] >= 0} {} {
4929 set p [lindex $todo $i 0]
4930 append tok [lindex $todo $i 1]
4931 set ordertok($p) $tok
4933 set ordertok($origid) $tok
4937 # Work out where id should go in idlist so that order-token
4938 # values increase from left to right
4939 proc idcol {idlist id {i 0}} {
4940 set t [ordertoken $id]
4944 if {$i >= [llength $idlist] || $t < [ordertoken [lindex $idlist $i]]} {
4945 if {$i > [llength $idlist]} {
4946 set i [llength $idlist]
4948 while {[incr i -1] >= 0 && $t < [ordertoken [lindex $idlist $i]]} {}
4951 if {$t > [ordertoken [lindex $idlist $i]]} {
4952 while {[incr i] < [llength $idlist] &&
4953 $t >= [ordertoken [lindex $idlist $i]]} {}
4959 proc initlayout {} {
4960 global rowidlist rowisopt rowfinal displayorder parentlist
4961 global numcommits canvxmax canv
4963 global colormap rowtextx
4972 set canvxmax [$canv cget -width]
4973 catch {unset colormap}
4974 catch {unset rowtextx}
4978 proc setcanvscroll {} {
4979 global canv canv2 canv3 numcommits linespc canvxmax canvy0
4980 global lastscrollset lastscrollrows
4982 set ymax [expr {$canvy0 + ($numcommits - 0.5) * $linespc + 2}]
4983 $canv conf -scrollregion [list 0 0 $canvxmax $ymax]
4984 $canv2 conf -scrollregion [list 0 0 0 $ymax]
4985 $canv3 conf -scrollregion [list 0 0 0 $ymax]
4986 set lastscrollset [clock clicks -milliseconds]
4987 set lastscrollrows $numcommits
4990 proc visiblerows {} {
4991 global canv numcommits linespc
4993 set ymax [lindex [$canv cget -scrollregion] 3]
4994 if {$ymax eq {} || $ymax == 0} return
4996 set y0 [expr {int([lindex $f 0] * $ymax)}]
4997 set r0 [expr {int(($y0 - 3) / $linespc) - 1}]
5001 set y1 [expr {int([lindex $f 1] * $ymax)}]
5002 set r1 [expr {int(($y1 - 3) / $linespc) + 1}]
5003 if {$r1 >= $numcommits} {
5004 set r1 [expr {$numcommits - 1}]
5006 return [list $r0 $r1]
5009 proc layoutmore {} {
5010 global commitidx viewcomplete curview
5011 global numcommits pending_select curview
5012 global lastscrollset lastscrollrows
5014 if {$lastscrollrows < 100 || $viewcomplete($curview) ||
5015 [clock clicks -milliseconds] - $lastscrollset > 500} {
5018 if {[info exists pending_select] &&
5019 [commitinview $pending_select $curview]} {
5021 selectline [rowofcommit $pending_select] 1
5026 # With path limiting, we mightn't get the actual HEAD commit,
5027 # so ask git rev-list what is the first ancestor of HEAD that
5028 # touches a file in the path limit.
5029 proc get_viewmainhead {view} {
5030 global viewmainheadid vfilelimit viewinstances mainheadid
5033 set rfd [open [concat | git rev-list -1 $mainheadid \
5034 -- $vfilelimit($view)] r]
5035 set j [reg_instance $rfd]
5036 lappend viewinstances($view) $j
5037 fconfigure $rfd -blocking 0
5038 filerun $rfd [list getviewhead $rfd $j $view]
5039 set viewmainheadid($curview) {}
5043 # git rev-list should give us just 1 line to use as viewmainheadid($view)
5044 proc getviewhead {fd inst view} {
5045 global viewmainheadid commfd curview viewinstances showlocalchanges
5048 if {[gets $fd line] < 0} {
5052 } elseif {[string length $line] == 40 && [string is xdigit $line]} {
5055 set viewmainheadid($view) $id
5058 set i [lsearch -exact $viewinstances($view) $inst]
5060 set viewinstances($view) [lreplace $viewinstances($view) $i $i]
5062 if {$showlocalchanges && $id ne {} && $view == $curview} {
5068 proc doshowlocalchanges {} {
5069 global curview viewmainheadid
5071 if {$viewmainheadid($curview) eq {}} return
5072 if {[commitinview $viewmainheadid($curview) $curview]} {
5075 interestedin $viewmainheadid($curview) dodiffindex
5079 proc dohidelocalchanges {} {
5080 global nullid nullid2 lserial curview
5082 if {[commitinview $nullid $curview]} {
5083 removefakerow $nullid
5085 if {[commitinview $nullid2 $curview]} {
5086 removefakerow $nullid2
5091 # spawn off a process to do git diff-index --cached HEAD
5092 proc dodiffindex {} {
5093 global lserial showlocalchanges vfilelimit curview
5096 if {!$showlocalchanges || !$hasworktree} return
5098 set cmd "|git diff-index --cached HEAD"
5099 if {$vfilelimit($curview) ne {}} {
5100 set cmd [concat $cmd -- $vfilelimit($curview)]
5102 set fd [open $cmd r]
5103 fconfigure $fd -blocking 0
5104 set i [reg_instance $fd]
5105 filerun $fd [list readdiffindex $fd $lserial $i]
5108 proc readdiffindex {fd serial inst} {
5109 global viewmainheadid nullid nullid2 curview commitinfo commitdata lserial
5113 if {[gets $fd line] < 0} {
5119 # we only need to see one line and we don't really care what it says...
5122 if {$serial != $lserial} {
5126 # now see if there are any local changes not checked in to the index
5127 set cmd "|git diff-files"
5128 if {$vfilelimit($curview) ne {}} {
5129 set cmd [concat $cmd -- $vfilelimit($curview)]
5131 set fd [open $cmd r]
5132 fconfigure $fd -blocking 0
5133 set i [reg_instance $fd]
5134 filerun $fd [list readdifffiles $fd $serial $i]
5136 if {$isdiff && ![commitinview $nullid2 $curview]} {
5137 # add the line for the changes in the index to the graph
5138 set hl [mc "Local changes checked in to index but not committed"]
5139 set commitinfo($nullid2) [list $hl {} {} {} {} " $hl\n"]
5140 set commitdata($nullid2) "\n $hl\n"
5141 if {[commitinview $nullid $curview]} {
5142 removefakerow $nullid
5144 insertfakerow $nullid2 $viewmainheadid($curview)
5145 } elseif {!$isdiff && [commitinview $nullid2 $curview]} {
5146 if {[commitinview $nullid $curview]} {
5147 removefakerow $nullid
5149 removefakerow $nullid2
5154 proc readdifffiles {fd serial inst} {
5155 global viewmainheadid nullid nullid2 curview
5156 global commitinfo commitdata lserial
5159 if {[gets $fd line] < 0} {
5165 # we only need to see one line and we don't really care what it says...
5168 if {$serial != $lserial} {
5172 if {$isdiff && ![commitinview $nullid $curview]} {
5173 # add the line for the local diff to the graph
5174 set hl [mc "Local uncommitted changes, not checked in to index"]
5175 set commitinfo($nullid) [list $hl {} {} {} {} " $hl\n"]
5176 set commitdata($nullid) "\n $hl\n"
5177 if {[commitinview $nullid2 $curview]} {
5180 set p $viewmainheadid($curview)
5182 insertfakerow $nullid $p
5183 } elseif {!$isdiff && [commitinview $nullid $curview]} {
5184 removefakerow $nullid
5189 proc nextuse {id row} {
5190 global curview children
5192 if {[info exists children($curview,$id)]} {
5193 foreach kid $children($curview,$id) {
5194 if {![commitinview $kid $curview]} {
5197 if {[rowofcommit $kid] > $row} {
5198 return [rowofcommit $kid]
5202 if {[commitinview $id $curview]} {
5203 return [rowofcommit $id]
5208 proc prevuse {id row} {
5209 global curview children
5212 if {[info exists children($curview,$id)]} {
5213 foreach kid $children($curview,$id) {
5214 if {![commitinview $kid $curview]} break
5215 if {[rowofcommit $kid] < $row} {
5216 set ret [rowofcommit $kid]
5223 proc make_idlist {row} {
5224 global displayorder parentlist uparrowlen downarrowlen mingaplen
5225 global commitidx curview children
5227 set r [expr {$row - $mingaplen - $downarrowlen - 1}]
5231 set ra [expr {$row - $downarrowlen}]
5235 set rb [expr {$row + $uparrowlen}]
5236 if {$rb > $commitidx($curview)} {
5237 set rb $commitidx($curview)
5239 make_disporder $r [expr {$rb + 1}]
5241 for {} {$r < $ra} {incr r} {
5242 set nextid [lindex $displayorder [expr {$r + 1}]]
5243 foreach p [lindex $parentlist $r] {
5244 if {$p eq $nextid} continue
5245 set rn [nextuse $p $r]
5247 $rn <= $r + $downarrowlen + $mingaplen + $uparrowlen} {
5248 lappend ids [list [ordertoken $p] $p]
5252 for {} {$r < $row} {incr r} {
5253 set nextid [lindex $displayorder [expr {$r + 1}]]
5254 foreach p [lindex $parentlist $r] {
5255 if {$p eq $nextid} continue
5256 set rn [nextuse $p $r]
5257 if {$rn < 0 || $rn >= $row} {
5258 lappend ids [list [ordertoken $p] $p]
5262 set id [lindex $displayorder $row]
5263 lappend ids [list [ordertoken $id] $id]
5265 foreach p [lindex $parentlist $r] {
5266 set firstkid [lindex $children($curview,$p) 0]
5267 if {[rowofcommit $firstkid] < $row} {
5268 lappend ids [list [ordertoken $p] $p]
5272 set id [lindex $displayorder $r]
5274 set firstkid [lindex $children($curview,$id) 0]
5275 if {$firstkid ne {} && [rowofcommit $firstkid] < $row} {
5276 lappend ids [list [ordertoken $id] $id]
5281 foreach idx [lsort -unique $ids] {
5282 lappend idlist [lindex $idx 1]
5287 proc rowsequal {a b} {
5288 while {[set i [lsearch -exact $a {}]] >= 0} {
5289 set a [lreplace $a $i $i]
5291 while {[set i [lsearch -exact $b {}]] >= 0} {
5292 set b [lreplace $b $i $i]
5294 return [expr {$a eq $b}]
5297 proc makeupline {id row rend col} {
5298 global rowidlist uparrowlen downarrowlen mingaplen
5300 for {set r $rend} {1} {set r $rstart} {
5301 set rstart [prevuse $id $r]
5302 if {$rstart < 0} return
5303 if {$rstart < $row} break
5305 if {$rstart + $uparrowlen + $mingaplen + $downarrowlen < $rend} {
5306 set rstart [expr {$rend - $uparrowlen - 1}]
5308 for {set r $rstart} {[incr r] <= $row} {} {
5309 set idlist [lindex $rowidlist $r]
5310 if {$idlist ne {} && [lsearch -exact $idlist $id] < 0} {
5311 set col [idcol $idlist $id $col]
5312 lset rowidlist $r [linsert $idlist $col $id]
5318 proc layoutrows {row endrow} {
5319 global rowidlist rowisopt rowfinal displayorder
5320 global uparrowlen downarrowlen maxwidth mingaplen
5321 global children parentlist
5322 global commitidx viewcomplete curview
5324 make_disporder [expr {$row - 1}] [expr {$endrow + $uparrowlen}]
5327 set rm1 [expr {$row - 1}]
5328 foreach id [lindex $rowidlist $rm1] {
5333 set final [lindex $rowfinal $rm1]
5335 for {} {$row < $endrow} {incr row} {
5336 set rm1 [expr {$row - 1}]
5337 if {$rm1 < 0 || $idlist eq {}} {
5338 set idlist [make_idlist $row]
5341 set id [lindex $displayorder $rm1]
5342 set col [lsearch -exact $idlist $id]
5343 set idlist [lreplace $idlist $col $col]
5344 foreach p [lindex $parentlist $rm1] {
5345 if {[lsearch -exact $idlist $p] < 0} {
5346 set col [idcol $idlist $p $col]
5347 set idlist [linsert $idlist $col $p]
5348 # if not the first child, we have to insert a line going up
5349 if {$id ne [lindex $children($curview,$p) 0]} {
5350 makeupline $p $rm1 $row $col
5354 set id [lindex $displayorder $row]
5355 if {$row > $downarrowlen} {
5356 set termrow [expr {$row - $downarrowlen - 1}]
5357 foreach p [lindex $parentlist $termrow] {
5358 set i [lsearch -exact $idlist $p]
5359 if {$i < 0} continue
5360 set nr [nextuse $p $termrow]
5361 if {$nr < 0 || $nr >= $row + $mingaplen + $uparrowlen} {
5362 set idlist [lreplace $idlist $i $i]
5366 set col [lsearch -exact $idlist $id]
5368 set col [idcol $idlist $id]
5369 set idlist [linsert $idlist $col $id]
5370 if {$children($curview,$id) ne {}} {
5371 makeupline $id $rm1 $row $col
5374 set r [expr {$row + $uparrowlen - 1}]
5375 if {$r < $commitidx($curview)} {
5377 foreach p [lindex $parentlist $r] {
5378 if {[lsearch -exact $idlist $p] >= 0} continue
5379 set fk [lindex $children($curview,$p) 0]
5380 if {[rowofcommit $fk] < $row} {
5381 set x [idcol $idlist $p $x]
5382 set idlist [linsert $idlist $x $p]
5385 if {[incr r] < $commitidx($curview)} {
5386 set p [lindex $displayorder $r]
5387 if {[lsearch -exact $idlist $p] < 0} {
5388 set fk [lindex $children($curview,$p) 0]
5389 if {$fk ne {} && [rowofcommit $fk] < $row} {
5390 set x [idcol $idlist $p $x]
5391 set idlist [linsert $idlist $x $p]
5397 if {$final && !$viewcomplete($curview) &&
5398 $row + $uparrowlen + $mingaplen + $downarrowlen
5399 >= $commitidx($curview)} {
5402 set l [llength $rowidlist]
5404 lappend rowidlist $idlist
5406 lappend rowfinal $final
5407 } elseif {$row < $l} {
5408 if {![rowsequal $idlist [lindex $rowidlist $row]]} {
5409 lset rowidlist $row $idlist
5412 lset rowfinal $row $final
5414 set pad [ntimes [expr {$row - $l}] {}]
5415 set rowidlist [concat $rowidlist $pad]
5416 lappend rowidlist $idlist
5417 set rowfinal [concat $rowfinal $pad]
5418 lappend rowfinal $final
5419 set rowisopt [concat $rowisopt [ntimes [expr {$row - $l + 1}] 0]]
5425 proc changedrow {row} {
5426 global displayorder iddrawn rowisopt need_redisplay
5428 set l [llength $rowisopt]
5430 lset rowisopt $row 0
5431 if {$row + 1 < $l} {
5432 lset rowisopt [expr {$row + 1}] 0
5433 if {$row + 2 < $l} {
5434 lset rowisopt [expr {$row + 2}] 0
5438 set id [lindex $displayorder $row]
5439 if {[info exists iddrawn($id)]} {
5440 set need_redisplay 1
5444 proc insert_pad {row col npad} {
5447 set pad [ntimes $npad {}]
5448 set idlist [lindex $rowidlist $row]
5449 set bef [lrange $idlist 0 [expr {$col - 1}]]
5450 set aft [lrange $idlist $col end]
5451 set i [lsearch -exact $aft {}]
5453 set aft [lreplace $aft $i $i]
5455 lset rowidlist $row [concat $bef $pad $aft]
5459 proc optimize_rows {row col endrow} {
5460 global rowidlist rowisopt displayorder curview children
5465 for {} {$row < $endrow} {incr row; set col 0} {
5466 if {[lindex $rowisopt $row]} continue
5468 set y0 [expr {$row - 1}]
5469 set ym [expr {$row - 2}]
5470 set idlist [lindex $rowidlist $row]
5471 set previdlist [lindex $rowidlist $y0]
5472 if {$idlist eq {} || $previdlist eq {}} continue
5474 set pprevidlist [lindex $rowidlist $ym]
5475 if {$pprevidlist eq {}} continue
5481 for {} {$col < [llength $idlist]} {incr col} {
5482 set id [lindex $idlist $col]
5483 if {[lindex $previdlist $col] eq $id} continue
5488 set x0 [lsearch -exact $previdlist $id]
5489 if {$x0 < 0} continue
5490 set z [expr {$x0 - $col}]
5494 set xm [lsearch -exact $pprevidlist $id]
5496 set z0 [expr {$xm - $x0}]
5500 # if row y0 is the first child of $id then it's not an arrow
5501 if {[lindex $children($curview,$id) 0] ne
5502 [lindex $displayorder $y0]} {
5506 if {!$isarrow && $id ne [lindex $displayorder $row] &&
5507 [lsearch -exact [lindex $rowidlist [expr {$row+1}]] $id] < 0} {
5510 # Looking at lines from this row to the previous row,
5511 # make them go straight up if they end in an arrow on
5512 # the previous row; otherwise make them go straight up
5514 if {$z < -1 || ($z < 0 && $isarrow)} {
5515 # Line currently goes left too much;
5516 # insert pads in the previous row, then optimize it
5517 set npad [expr {-1 - $z + $isarrow}]
5518 insert_pad $y0 $x0 $npad
5520 optimize_rows $y0 $x0 $row
5522 set previdlist [lindex $rowidlist $y0]
5523 set x0 [lsearch -exact $previdlist $id]
5524 set z [expr {$x0 - $col}]
5526 set pprevidlist [lindex $rowidlist $ym]
5527 set xm [lsearch -exact $pprevidlist $id]
5528 set z0 [expr {$xm - $x0}]
5530 } elseif {$z > 1 || ($z > 0 && $isarrow)} {
5531 # Line currently goes right too much;
5532 # insert pads in this line
5533 set npad [expr {$z - 1 + $isarrow}]
5534 insert_pad $row $col $npad
5535 set idlist [lindex $rowidlist $row]
5537 set z [expr {$x0 - $col}]
5540 if {$z0 eq {} && !$isarrow && $ym >= 0} {
5541 # this line links to its first child on row $row-2
5542 set id [lindex $displayorder $ym]
5543 set xc [lsearch -exact $pprevidlist $id]
5545 set z0 [expr {$xc - $x0}]
5548 # avoid lines jigging left then immediately right
5549 if {$z0 ne {} && $z < 0 && $z0 > 0} {
5550 insert_pad $y0 $x0 1
5552 optimize_rows $y0 $x0 $row
5553 set previdlist [lindex $rowidlist $y0]
5557 # Find the first column that doesn't have a line going right
5558 for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
5559 set id [lindex $idlist $col]
5560 if {$id eq {}} break
5561 set x0 [lsearch -exact $previdlist $id]
5563 # check if this is the link to the first child
5564 set kid [lindex $displayorder $y0]
5565 if {[lindex $children($curview,$id) 0] eq $kid} {
5566 # it is, work out offset to child
5567 set x0 [lsearch -exact $previdlist $kid]
5570 if {$x0 <= $col} break
5572 # Insert a pad at that column as long as it has a line and
5573 # isn't the last column
5574 if {$x0 >= 0 && [incr col] < [llength $idlist]} {
5575 set idlist [linsert $idlist $col {}]
5576 lset rowidlist $row $idlist
5584 global canvx0 linespc
5585 return [expr {$canvx0 + $col * $linespc}]
5589 global canvy0 linespc
5590 return [expr {$canvy0 + $row * $linespc}]
5593 proc linewidth {id} {
5594 global thickerline lthickness
5597 if {[info exists thickerline] && $id eq $thickerline} {
5598 set wid [expr {2 * $lthickness}]
5603 proc rowranges {id} {
5604 global curview children uparrowlen downarrowlen
5607 set kids $children($curview,$id)
5613 foreach child $kids {
5614 if {![commitinview $child $curview]} break
5615 set row [rowofcommit $child]
5616 if {![info exists prev]} {
5617 lappend ret [expr {$row + 1}]
5619 if {$row <= $prevrow} {
5620 puts "oops children of [shortids $id] out of order [shortids $child] $row <= [shortids $prev] $prevrow"
5622 # see if the line extends the whole way from prevrow to row
5623 if {$row > $prevrow + $uparrowlen + $downarrowlen &&
5624 [lsearch -exact [lindex $rowidlist \
5625 [expr {int(($row + $prevrow) / 2)}]] $id] < 0} {
5626 # it doesn't, see where it ends
5627 set r [expr {$prevrow + $downarrowlen}]
5628 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
5629 while {[incr r -1] > $prevrow &&
5630 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
5632 while {[incr r] <= $row &&
5633 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
5637 # see where it starts up again
5638 set r [expr {$row - $uparrowlen}]
5639 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
5640 while {[incr r] < $row &&
5641 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
5643 while {[incr r -1] >= $prevrow &&
5644 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
5650 if {$child eq $id} {
5659 proc drawlineseg {id row endrow arrowlow} {
5660 global rowidlist displayorder iddrawn linesegs
5661 global canv colormap linespc curview maxlinelen parentlist
5663 set cols [list [lsearch -exact [lindex $rowidlist $row] $id]]
5664 set le [expr {$row + 1}]
5667 set c [lsearch -exact [lindex $rowidlist $le] $id]
5673 set x [lindex $displayorder $le]
5678 if {[info exists iddrawn($x)] || $le == $endrow} {
5679 set c [lsearch -exact [lindex $rowidlist [expr {$le+1}]] $id]
5695 if {[info exists linesegs($id)]} {
5696 set lines $linesegs($id)
5698 set r0 [lindex $li 0]
5700 if {$r0 == $le && [lindex $li 1] - $row <= $maxlinelen} {
5710 set li [lindex $lines [expr {$i-1}]]
5711 set r1 [lindex $li 1]
5712 if {$r1 == $row && $le - [lindex $li 0] <= $maxlinelen} {
5717 set x [lindex $cols [expr {$le - $row}]]
5718 set xp [lindex $cols [expr {$le - 1 - $row}]]
5719 set dir [expr {$xp - $x}]
5721 set ith [lindex $lines $i 2]
5722 set coords [$canv coords $ith]
5723 set ah [$canv itemcget $ith -arrow]
5724 set arrowhigh [expr {$ah eq "first" || $ah eq "both"}]
5725 set x2 [lindex $cols [expr {$le + 1 - $row}]]
5726 if {$x2 ne {} && $x - $x2 == $dir} {
5727 set coords [lrange $coords 0 end-2]
5730 set coords [list [xc $le $x] [yc $le]]
5733 set itl [lindex $lines [expr {$i-1}] 2]
5734 set al [$canv itemcget $itl -arrow]
5735 set arrowlow [expr {$al eq "last" || $al eq "both"}]
5736 } elseif {$arrowlow} {
5737 if {[lsearch -exact [lindex $rowidlist [expr {$row-1}]] $id] >= 0 ||
5738 [lsearch -exact [lindex $parentlist [expr {$row-1}]] $id] >= 0} {
5742 set arrow [lindex {none first last both} [expr {$arrowhigh + 2*$arrowlow}]]
5743 for {set y $le} {[incr y -1] > $row} {} {
5745 set xp [lindex $cols [expr {$y - 1 - $row}]]
5746 set ndir [expr {$xp - $x}]
5747 if {$dir != $ndir || $xp < 0} {
5748 lappend coords [xc $y $x] [yc $y]
5754 # join parent line to first child
5755 set ch [lindex $displayorder $row]
5756 set xc [lsearch -exact [lindex $rowidlist $row] $ch]
5758 puts "oops: drawlineseg: child $ch not on row $row"
5759 } elseif {$xc != $x} {
5760 if {($arrowhigh && $le == $row + 1) || $dir == 0} {
5761 set d [expr {int(0.5 * $linespc)}]
5764 set x2 [expr {$x1 - $d}]
5766 set x2 [expr {$x1 + $d}]
5769 set y1 [expr {$y2 + $d}]
5770 lappend coords $x1 $y1 $x2 $y2
5771 } elseif {$xc < $x - 1} {
5772 lappend coords [xc $row [expr {$x-1}]] [yc $row]
5773 } elseif {$xc > $x + 1} {
5774 lappend coords [xc $row [expr {$x+1}]] [yc $row]
5778 lappend coords [xc $row $x] [yc $row]
5780 set xn [xc $row $xp]
5782 lappend coords $xn $yn
5786 set t [$canv create line $coords -width [linewidth $id] \
5787 -fill $colormap($id) -tags lines.$id -arrow $arrow]
5790 set lines [linsert $lines $i [list $row $le $t]]
5792 $canv coords $ith $coords
5793 if {$arrow ne $ah} {
5794 $canv itemconf $ith -arrow $arrow
5796 lset lines $i 0 $row
5799 set xo [lsearch -exact [lindex $rowidlist [expr {$row - 1}]] $id]
5800 set ndir [expr {$xo - $xp}]
5801 set clow [$canv coords $itl]
5802 if {$dir == $ndir} {
5803 set clow [lrange $clow 2 end]
5805 set coords [concat $coords $clow]
5807 lset lines [expr {$i-1}] 1 $le
5809 # coalesce two pieces
5811 set b [lindex $lines [expr {$i-1}] 0]
5812 set e [lindex $lines $i 1]
5813 set lines [lreplace $lines [expr {$i-1}] $i [list $b $e $itl]]
5815 $canv coords $itl $coords
5816 if {$arrow ne $al} {
5817 $canv itemconf $itl -arrow $arrow
5821 set linesegs($id) $lines
5825 proc drawparentlinks {id row} {
5826 global rowidlist canv colormap curview parentlist
5827 global idpos linespc
5829 set rowids [lindex $rowidlist $row]
5830 set col [lsearch -exact $rowids $id]
5831 if {$col < 0} return
5832 set olds [lindex $parentlist $row]
5833 set row2 [expr {$row + 1}]
5834 set x [xc $row $col]
5837 set d [expr {int(0.5 * $linespc)}]
5838 set ymid [expr {$y + $d}]
5839 set ids [lindex $rowidlist $row2]
5840 # rmx = right-most X coord used
5843 set i [lsearch -exact $ids $p]
5845 puts "oops, parent $p of $id not in list"
5848 set x2 [xc $row2 $i]
5852 set j [lsearch -exact $rowids $p]
5854 # drawlineseg will do this one for us
5858 # should handle duplicated parents here...
5859 set coords [list $x $y]
5861 # if attaching to a vertical segment, draw a smaller
5862 # slant for visual distinctness
5865 lappend coords [expr {$x2 + $d}] $y $x2 $ymid
5867 lappend coords [expr {$x2 - $d}] $y $x2 $ymid
5869 } elseif {$i < $col && $i < $j} {
5870 # segment slants towards us already
5871 lappend coords [xc $row $j] $y
5873 if {$i < $col - 1} {
5874 lappend coords [expr {$x2 + $linespc}] $y
5875 } elseif {$i > $col + 1} {
5876 lappend coords [expr {$x2 - $linespc}] $y
5878 lappend coords $x2 $y2
5881 lappend coords $x2 $y2
5883 set t [$canv create line $coords -width [linewidth $p] \
5884 -fill $colormap($p) -tags lines.$p]
5888 if {$rmx > [lindex $idpos($id) 1]} {
5889 lset idpos($id) 1 $rmx
5894 proc drawlines {id} {
5897 $canv itemconf lines.$id -width [linewidth $id]
5900 proc drawcmittext {id row col} {
5901 global linespc canv canv2 canv3 fgcolor curview
5902 global cmitlisted commitinfo rowidlist parentlist
5903 global rowtextx idpos idtags idheads idotherrefs
5904 global linehtag linentag linedtag selectedline
5905 global canvxmax boldids boldnameids fgcolor markedid
5906 global mainheadid nullid nullid2 circleitem circlecolors ctxbut
5908 # listed is 0 for boundary, 1 for normal, 2 for negative, 3 for left, 4 for right
5909 set listed $cmitlisted($curview,$id)
5910 if {$id eq $nullid} {
5912 } elseif {$id eq $nullid2} {
5914 } elseif {$id eq $mainheadid} {
5917 set ofill [lindex $circlecolors $listed]
5919 set x [xc $row $col]
5921 set orad [expr {$linespc / 3}]
5923 set t [$canv create oval [expr {$x - $orad}] [expr {$y - $orad}] \
5924 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
5925 -fill $ofill -outline $fgcolor -width 1 -tags circle]
5926 } elseif {$listed == 3} {
5927 # triangle pointing left for left-side commits
5928 set t [$canv create polygon \
5929 [expr {$x - $orad}] $y \
5930 [expr {$x + $orad - 1}] [expr {$y - $orad}] \
5931 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
5932 -fill $ofill -outline $fgcolor -width 1 -tags circle]
5934 # triangle pointing right for right-side commits
5935 set t [$canv create polygon \
5936 [expr {$x + $orad - 1}] $y \
5937 [expr {$x - $orad}] [expr {$y - $orad}] \
5938 [expr {$x - $orad}] [expr {$y + $orad - 1}] \
5939 -fill $ofill -outline $fgcolor -width 1 -tags circle]
5941 set circleitem($row) $t
5943 $canv bind $t <1> {selcanvline {} %x %y}
5944 set rmx [llength [lindex $rowidlist $row]]
5945 set olds [lindex $parentlist $row]
5947 set nextids [lindex $rowidlist [expr {$row + 1}]]
5949 set i [lsearch -exact $nextids $p]
5955 set xt [xc $row $rmx]
5956 set rowtextx($row) $xt
5957 set idpos($id) [list $x $xt $y]
5958 if {[info exists idtags($id)] || [info exists idheads($id)]
5959 || [info exists idotherrefs($id)]} {
5960 set xt [drawtags $id $x $xt $y]
5962 if {[lindex $commitinfo($id) 6] > 0} {
5963 set xt [drawnotesign $xt $y]
5965 set headline [lindex $commitinfo($id) 0]
5966 set name [lindex $commitinfo($id) 1]
5967 set date [lindex $commitinfo($id) 2]
5968 set date [formatdate $date]
5971 set isbold [ishighlighted $id]
5974 set font mainfontbold
5976 lappend boldnameids $id
5977 set nfont mainfontbold
5980 set linehtag($id) [$canv create text $xt $y -anchor w -fill $fgcolor \
5981 -text $headline -font $font -tags text]
5982 $canv bind $linehtag($id) $ctxbut "rowmenu %X %Y $id"
5983 set linentag($id) [$canv2 create text 3 $y -anchor w -fill $fgcolor \
5984 -text $name -font $nfont -tags text]
5985 set linedtag($id) [$canv3 create text 3 $y -anchor w -fill $fgcolor \
5986 -text $date -font mainfont -tags text]
5987 if {$selectedline == $row} {
5990 if {[info exists markedid] && $markedid eq $id} {
5993 set xr [expr {$xt + [font measure $font $headline]}]
5994 if {$xr > $canvxmax} {
6000 proc drawcmitrow {row} {
6001 global displayorder rowidlist nrows_drawn
6002 global iddrawn markingmatches
6003 global commitinfo numcommits
6004 global filehighlight fhighlights findpattern nhighlights
6005 global hlview vhighlights
6006 global highlight_related rhighlights
6008 if {$row >= $numcommits} return
6010 set id [lindex $displayorder $row]
6011 if {[info exists hlview] && ![info exists vhighlights($id)]} {
6012 askvhighlight $row $id
6014 if {[info exists filehighlight] && ![info exists fhighlights($id)]} {
6015 askfilehighlight $row $id
6017 if {$findpattern ne {} && ![info exists nhighlights($id)]} {
6018 askfindhighlight $row $id
6020 if {$highlight_related ne [mc "None"] && ![info exists rhighlights($id)]} {
6021 askrelhighlight $row $id
6023 if {![info exists iddrawn($id)]} {
6024 set col [lsearch -exact [lindex $rowidlist $row] $id]
6026 puts "oops, row $row id $id not in list"
6029 if {![info exists commitinfo($id)]} {
6033 drawcmittext $id $row $col
6037 if {$markingmatches} {
6038 markrowmatches $row $id
6042 proc drawcommits {row {endrow {}}} {
6043 global numcommits iddrawn displayorder curview need_redisplay
6044 global parentlist rowidlist rowfinal uparrowlen downarrowlen nrows_drawn
6049 if {$endrow eq {}} {
6052 if {$endrow >= $numcommits} {
6053 set endrow [expr {$numcommits - 1}]
6056 set rl1 [expr {$row - $downarrowlen - 3}]
6060 set ro1 [expr {$row - 3}]
6064 set r2 [expr {$endrow + $uparrowlen + 3}]
6065 if {$r2 > $numcommits} {
6068 for {set r $rl1} {$r < $r2} {incr r} {
6069 if {[lindex $rowidlist $r] ne {} && [lindex $rowfinal $r]} {
6073 set rl1 [expr {$r + 1}]
6079 optimize_rows $ro1 0 $r2
6080 if {$need_redisplay || $nrows_drawn > 2000} {
6084 # make the lines join to already-drawn rows either side
6085 set r [expr {$row - 1}]
6086 if {$r < 0 || ![info exists iddrawn([lindex $displayorder $r])]} {
6089 set er [expr {$endrow + 1}]
6090 if {$er >= $numcommits ||
6091 ![info exists iddrawn([lindex $displayorder $er])]} {
6094 for {} {$r <= $er} {incr r} {
6095 set id [lindex $displayorder $r]
6096 set wasdrawn [info exists iddrawn($id)]
6098 if {$r == $er} break
6099 set nextid [lindex $displayorder [expr {$r + 1}]]
6100 if {$wasdrawn && [info exists iddrawn($nextid)]} continue
6101 drawparentlinks $id $r
6103 set rowids [lindex $rowidlist $r]
6104 foreach lid $rowids {
6105 if {$lid eq {}} continue
6106 if {[info exists lineend($lid)] && $lineend($lid) > $r} continue
6108 # see if this is the first child of any of its parents
6109 foreach p [lindex $parentlist $r] {
6110 if {[lsearch -exact $rowids $p] < 0} {
6111 # make this line extend up to the child
6112 set lineend($p) [drawlineseg $p $r $er 0]
6116 set lineend($lid) [drawlineseg $lid $r $er 1]
6122 proc undolayout {row} {
6123 global uparrowlen mingaplen downarrowlen
6124 global rowidlist rowisopt rowfinal need_redisplay
6126 set r [expr {$row - ($uparrowlen + $mingaplen + $downarrowlen)}]
6130 if {[llength $rowidlist] > $r} {
6132 set rowidlist [lrange $rowidlist 0 $r]
6133 set rowfinal [lrange $rowfinal 0 $r]
6134 set rowisopt [lrange $rowisopt 0 $r]
6135 set need_redisplay 1
6140 proc drawvisible {} {
6141 global canv linespc curview vrowmod selectedline targetrow targetid
6142 global need_redisplay cscroll numcommits
6144 set fs [$canv yview]
6145 set ymax [lindex [$canv cget -scrollregion] 3]
6146 if {$ymax eq {} || $ymax == 0 || $numcommits == 0} return
6147 set f0 [lindex $fs 0]
6148 set f1 [lindex $fs 1]
6149 set y0 [expr {int($f0 * $ymax)}]
6150 set y1 [expr {int($f1 * $ymax)}]
6152 if {[info exists targetid]} {
6153 if {[commitinview $targetid $curview]} {
6154 set r [rowofcommit $targetid]
6155 if {$r != $targetrow} {
6156 # Fix up the scrollregion and change the scrolling position
6157 # now that our target row has moved.
6158 set diff [expr {($r - $targetrow) * $linespc}]
6161 set ymax [lindex [$canv cget -scrollregion] 3]
6164 set f0 [expr {$y0 / $ymax}]
6165 set f1 [expr {$y1 / $ymax}]
6166 allcanvs yview moveto $f0
6167 $cscroll set $f0 $f1
6168 set need_redisplay 1
6175 set row [expr {int(($y0 - 3) / $linespc) - 1}]
6176 set endrow [expr {int(($y1 - 3) / $linespc) + 1}]
6177 if {$endrow >= $vrowmod($curview)} {
6178 update_arcrows $curview
6180 if {$selectedline ne {} &&
6181 $row <= $selectedline && $selectedline <= $endrow} {
6182 set targetrow $selectedline
6183 } elseif {[info exists targetid]} {
6184 set targetrow [expr {int(($row + $endrow) / 2)}]
6186 if {[info exists targetrow]} {
6187 if {$targetrow >= $numcommits} {
6188 set targetrow [expr {$numcommits - 1}]
6190 set targetid [commitonrow $targetrow]
6192 drawcommits $row $endrow
6195 proc clear_display {} {
6196 global iddrawn linesegs need_redisplay nrows_drawn
6197 global vhighlights fhighlights nhighlights rhighlights
6198 global linehtag linentag linedtag boldids boldnameids
6201 catch {unset iddrawn}
6202 catch {unset linesegs}
6203 catch {unset linehtag}
6204 catch {unset linentag}
6205 catch {unset linedtag}
6208 catch {unset vhighlights}
6209 catch {unset fhighlights}
6210 catch {unset nhighlights}
6211 catch {unset rhighlights}
6212 set need_redisplay 0
6216 proc findcrossings {id} {
6217 global rowidlist parentlist numcommits displayorder
6221 foreach {s e} [rowranges $id] {
6222 if {$e >= $numcommits} {
6223 set e [expr {$numcommits - 1}]
6225 if {$e <= $s} continue
6226 for {set row $e} {[incr row -1] >= $s} {} {
6227 set x [lsearch -exact [lindex $rowidlist $row] $id]
6229 set olds [lindex $parentlist $row]
6230 set kid [lindex $displayorder $row]
6231 set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
6232 if {$kidx < 0} continue
6233 set nextrow [lindex $rowidlist [expr {$row + 1}]]
6235 set px [lsearch -exact $nextrow $p]
6236 if {$px < 0} continue
6237 if {($kidx < $x && $x < $px) || ($px < $x && $x < $kidx)} {
6238 if {[lsearch -exact $ccross $p] >= 0} continue
6239 if {$x == $px + ($kidx < $px? -1: 1)} {
6241 } elseif {[lsearch -exact $cross $p] < 0} {
6248 return [concat $ccross {{}} $cross]
6251 proc assigncolor {id} {
6252 global colormap colors nextcolor
6253 global parents children children curview
6255 if {[info exists colormap($id)]} return
6256 set ncolors [llength $colors]
6257 if {[info exists children($curview,$id)]} {
6258 set kids $children($curview,$id)
6262 if {[llength $kids] == 1} {
6263 set child [lindex $kids 0]
6264 if {[info exists colormap($child)]
6265 && [llength $parents($curview,$child)] == 1} {
6266 set colormap($id) $colormap($child)
6272 foreach x [findcrossings $id] {
6274 # delimiter between corner crossings and other crossings
6275 if {[llength $badcolors] >= $ncolors - 1} break
6276 set origbad $badcolors
6278 if {[info exists colormap($x)]
6279 && [lsearch -exact $badcolors $colormap($x)] < 0} {
6280 lappend badcolors $colormap($x)
6283 if {[llength $badcolors] >= $ncolors} {
6284 set badcolors $origbad
6286 set origbad $badcolors
6287 if {[llength $badcolors] < $ncolors - 1} {
6288 foreach child $kids {
6289 if {[info exists colormap($child)]
6290 && [lsearch -exact $badcolors $colormap($child)] < 0} {
6291 lappend badcolors $colormap($child)
6293 foreach p $parents($curview,$child) {
6294 if {[info exists colormap($p)]
6295 && [lsearch -exact $badcolors $colormap($p)] < 0} {
6296 lappend badcolors $colormap($p)
6300 if {[llength $badcolors] >= $ncolors} {
6301 set badcolors $origbad
6304 for {set i 0} {$i <= $ncolors} {incr i} {
6305 set c [lindex $colors $nextcolor]
6306 if {[incr nextcolor] >= $ncolors} {
6309 if {[lsearch -exact $badcolors $c]} break
6311 set colormap($id) $c
6314 proc bindline {t id} {
6317 $canv bind $t <Enter> "lineenter %x %y $id"
6318 $canv bind $t <Motion> "linemotion %x %y $id"
6319 $canv bind $t <Leave> "lineleave $id"
6320 $canv bind $t <Button-1> "lineclick %x %y $id 1"
6323 proc drawtags {id x xt y1} {
6324 global idtags idheads idotherrefs mainhead
6325 global linespc lthickness
6326 global canv rowtextx curview fgcolor bgcolor ctxbut
6331 if {[info exists idtags($id)]} {
6332 set marks $idtags($id)
6333 set ntags [llength $marks]
6335 if {[info exists idheads($id)]} {
6336 set marks [concat $marks $idheads($id)]
6337 set nheads [llength $idheads($id)]
6339 if {[info exists idotherrefs($id)]} {
6340 set marks [concat $marks $idotherrefs($id)]
6346 set delta [expr {int(0.5 * ($linespc - $lthickness))}]
6347 set yt [expr {$y1 - 0.5 * $linespc}]
6348 set yb [expr {$yt + $linespc - 1}]
6352 foreach tag $marks {
6354 if {$i >= $ntags && $i < $ntags + $nheads && $tag eq $mainhead} {
6355 set wid [font measure mainfontbold $tag]
6357 set wid [font measure mainfont $tag]
6361 set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
6363 set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
6364 -width $lthickness -fill black -tags tag.$id]
6366 foreach tag $marks x $xvals wid $wvals {
6367 set tag_quoted [string map {% %%} $tag]
6368 set xl [expr {$x + $delta}]
6369 set xr [expr {$x + $delta + $wid + $lthickness}]
6371 if {[incr ntags -1] >= 0} {
6373 set t [$canv create polygon $x [expr {$yt + $delta}] $xl $yt \
6374 $xr $yt $xr $yb $xl $yb $x [expr {$yb - $delta}] \
6375 -width 1 -outline black -fill yellow -tags tag.$id]
6376 $canv bind $t <1> [list showtag $tag_quoted 1]
6377 set rowtextx([rowofcommit $id]) [expr {$xr + $linespc}]
6379 # draw a head or other ref
6380 if {[incr nheads -1] >= 0} {
6382 if {$tag eq $mainhead} {
6383 set font mainfontbold
6388 set xl [expr {$xl - $delta/2}]
6389 $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
6390 -width 1 -outline black -fill $col -tags tag.$id
6391 if {[regexp {^(remotes/.*/|remotes/)} $tag match remoteprefix]} {
6392 set rwid [font measure mainfont $remoteprefix]
6393 set xi [expr {$x + 1}]
6394 set yti [expr {$yt + 1}]
6395 set xri [expr {$x + $rwid}]
6396 $canv create polygon $xi $yti $xri $yti $xri $yb $xi $yb \
6397 -width 0 -fill "#ffddaa" -tags tag.$id
6400 set t [$canv create text $xl $y1 -anchor w -text $tag -fill $fgcolor \
6401 -font $font -tags [list tag.$id text]]
6403 $canv bind $t <1> [list showtag $tag_quoted 1]
6404 } elseif {$nheads >= 0} {
6405 $canv bind $t $ctxbut [list headmenu %X %Y $id $tag_quoted]
6411 proc drawnotesign {xt y} {
6412 global linespc canv fgcolor
6414 set orad [expr {$linespc / 3}]
6415 set t [$canv create rectangle [expr {$xt - $orad}] [expr {$y - $orad}] \
6416 [expr {$xt + $orad - 1}] [expr {$y + $orad - 1}] \
6417 -fill yellow -outline $fgcolor -width 1 -tags circle]
6418 set xt [expr {$xt + $orad * 3}]
6422 proc xcoord {i level ln} {
6423 global canvx0 xspc1 xspc2
6425 set x [expr {$canvx0 + $i * $xspc1($ln)}]
6426 if {$i > 0 && $i == $level} {
6427 set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
6428 } elseif {$i > $level} {
6429 set x [expr {$x + $xspc2 - $xspc1($ln)}]
6434 proc show_status {msg} {
6438 $canv create text 3 3 -anchor nw -text $msg -font mainfont \
6439 -tags text -fill $fgcolor
6442 # Don't change the text pane cursor if it is currently the hand cursor,
6443 # showing that we are over a sha1 ID link.
6444 proc settextcursor {c} {
6445 global ctext curtextcursor
6447 if {[$ctext cget -cursor] == $curtextcursor} {
6448 $ctext config -cursor $c
6450 set curtextcursor $c
6453 proc nowbusy {what {name {}}} {
6454 global isbusy busyname statusw
6456 if {[array names isbusy] eq {}} {
6457 . config -cursor watch
6461 set busyname($what) $name
6463 $statusw conf -text $name
6467 proc notbusy {what} {
6468 global isbusy maincursor textcursor busyname statusw
6472 if {$busyname($what) ne {} &&
6473 [$statusw cget -text] eq $busyname($what)} {
6474 $statusw conf -text {}
6477 if {[array names isbusy] eq {}} {
6478 . config -cursor $maincursor
6479 settextcursor $textcursor
6483 proc findmatches {f} {
6484 global findtype findstring
6485 if {$findtype == [mc "Regexp"]} {
6486 set matches [regexp -indices -all -inline $findstring $f]
6489 if {$findtype == [mc "IgnCase"]} {
6490 set f [string tolower $f]
6491 set fs [string tolower $fs]
6495 set l [string length $fs]
6496 while {[set j [string first $fs $f $i]] >= 0} {
6497 lappend matches [list $j [expr {$j+$l-1}]]
6498 set i [expr {$j + $l}]
6504 proc dofind {{dirn 1} {wrap 1}} {
6505 global findstring findstartline findcurline selectedline numcommits
6506 global gdttype filehighlight fh_serial find_dirn findallowwrap
6508 if {[info exists find_dirn]} {
6509 if {$find_dirn == $dirn} return
6513 if {$findstring eq {} || $numcommits == 0} return
6514 if {$selectedline eq {}} {
6515 set findstartline [lindex [visiblerows] [expr {$dirn < 0}]]
6517 set findstartline $selectedline
6519 set findcurline $findstartline
6520 nowbusy finding [mc "Searching"]
6521 if {$gdttype ne [mc "containing:"] && ![info exists filehighlight]} {
6522 after cancel do_file_hl $fh_serial
6523 do_file_hl $fh_serial
6526 set findallowwrap $wrap
6530 proc stopfinding {} {
6531 global find_dirn findcurline fprogcoord
6533 if {[info exists find_dirn]} {
6544 global commitdata commitinfo numcommits findpattern findloc
6545 global findstartline findcurline findallowwrap
6546 global find_dirn gdttype fhighlights fprogcoord
6547 global curview varcorder vrownum varccommits vrowmod
6549 if {![info exists find_dirn]} {
6552 set fldtypes [list [mc "Headline"] [mc "Author"] "" [mc "Committer"] "" [mc "Comments"]]
6555 if {$find_dirn > 0} {
6557 if {$l >= $numcommits} {
6560 if {$l <= $findstartline} {
6561 set lim [expr {$findstartline + 1}]
6564 set moretodo $findallowwrap
6571 if {$l >= $findstartline} {
6572 set lim [expr {$findstartline - 1}]
6575 set moretodo $findallowwrap
6578 set n [expr {($lim - $l) * $find_dirn}]
6583 if {$l + ($find_dirn > 0? $n: 1) > $vrowmod($curview)} {
6584 update_arcrows $curview
6588 set ai [bsearch $vrownum($curview) $l]
6589 set a [lindex $varcorder($curview) $ai]
6590 set arow [lindex $vrownum($curview) $ai]
6591 set ids [lindex $varccommits($curview,$a)]
6592 set arowend [expr {$arow + [llength $ids]}]
6593 if {$gdttype eq [mc "containing:"]} {
6594 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
6595 if {$l < $arow || $l >= $arowend} {
6597 set a [lindex $varcorder($curview) $ai]
6598 set arow [lindex $vrownum($curview) $ai]
6599 set ids [lindex $varccommits($curview,$a)]
6600 set arowend [expr {$arow + [llength $ids]}]
6602 set id [lindex $ids [expr {$l - $arow}]]
6603 # shouldn't happen unless git log doesn't give all the commits...
6604 if {![info exists commitdata($id)] ||
6605 ![doesmatch $commitdata($id)]} {
6608 if {![info exists commitinfo($id)]} {
6611 set info $commitinfo($id)
6612 foreach f $info ty $fldtypes {
6613 if {$ty eq ""} continue
6614 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
6623 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
6624 if {$l < $arow || $l >= $arowend} {
6626 set a [lindex $varcorder($curview) $ai]
6627 set arow [lindex $vrownum($curview) $ai]
6628 set ids [lindex $varccommits($curview,$a)]
6629 set arowend [expr {$arow + [llength $ids]}]
6631 set id [lindex $ids [expr {$l - $arow}]]
6632 if {![info exists fhighlights($id)]} {
6633 # this sets fhighlights($id) to -1
6634 askfilehighlight $l $id
6636 if {$fhighlights($id) > 0} {
6640 if {$fhighlights($id) < 0} {
6643 set findcurline [expr {$l - $find_dirn}]
6648 if {$found || ($domore && !$moretodo)} {
6664 set findcurline [expr {$l - $find_dirn}]
6666 set n [expr {($findcurline - $findstartline) * $find_dirn - 1}]
6670 set fprogcoord [expr {$n * 1.0 / $numcommits}]
6675 proc findselectline {l} {
6676 global findloc commentend ctext findcurline markingmatches gdttype
6678 set markingmatches [expr {$gdttype eq [mc "containing:"]}]
6681 if {$markingmatches &&
6682 ($findloc eq [mc "All fields"] || $findloc eq [mc "Comments"])} {
6683 # highlight the matches in the comments
6684 set f [$ctext get 1.0 $commentend]
6685 set matches [findmatches $f]
6686 foreach match $matches {
6687 set start [lindex $match 0]
6688 set end [expr {[lindex $match 1] + 1}]
6689 $ctext tag add found "1.0 + $start c" "1.0 + $end c"
6695 # mark the bits of a headline or author that match a find string
6696 proc markmatches {canv l str tag matches font row} {
6699 set bbox [$canv bbox $tag]
6700 set x0 [lindex $bbox 0]
6701 set y0 [lindex $bbox 1]
6702 set y1 [lindex $bbox 3]
6703 foreach match $matches {
6704 set start [lindex $match 0]
6705 set end [lindex $match 1]
6706 if {$start > $end} continue
6707 set xoff [font measure $font [string range $str 0 [expr {$start-1}]]]
6708 set xlen [font measure $font [string range $str 0 [expr {$end}]]]
6709 set t [$canv create rect [expr {$x0+$xoff}] $y0 \
6710 [expr {$x0+$xlen+2}] $y1 \
6711 -outline {} -tags [list match$l matches] -fill yellow]
6713 if {$row == $selectedline} {
6714 $canv raise $t secsel
6719 proc unmarkmatches {} {
6720 global markingmatches
6722 allcanvs delete matches
6723 set markingmatches 0
6727 proc selcanvline {w x y} {
6728 global canv canvy0 ctext linespc
6730 set ymax [lindex [$canv cget -scrollregion] 3]
6731 if {$ymax == {}} return
6732 set yfrac [lindex [$canv yview] 0]
6733 set y [expr {$y + $yfrac * $ymax}]
6734 set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
6739 set xmax [lindex [$canv cget -scrollregion] 2]
6740 set xleft [expr {[lindex [$canv xview] 0] * $xmax}]
6741 if {![info exists rowtextx($l)] || $xleft + $x < $rowtextx($l)} return
6747 proc commit_descriptor {p} {
6749 if {![info exists commitinfo($p)]} {
6753 if {[llength $commitinfo($p)] > 1} {
6754 set l [lindex $commitinfo($p) 0]
6759 # append some text to the ctext widget, and make any SHA1 ID
6760 # that we know about be a clickable link.
6761 proc appendwithlinks {text tags} {
6762 global ctext linknum curview
6764 set start [$ctext index "end - 1c"]
6765 $ctext insert end $text $tags
6766 set links [regexp -indices -all -inline {(?:\m|-g)[0-9a-f]{6,40}\M} $text]
6770 set linkid [string range $text $s $e]
6772 $ctext tag delete link$linknum
6773 $ctext tag add link$linknum "$start + $s c" "$start + $e c"
6774 setlink $linkid link$linknum
6779 proc setlink {id lk} {
6780 global curview ctext pendinglinks
6782 if {[string range $id 0 1] eq "-g"} {
6783 set id [string range $id 2 end]
6787 if {[string length $id] < 40} {
6788 set matches [longid $id]
6789 if {[llength $matches] > 0} {
6790 if {[llength $matches] > 1} return
6792 set id [lindex $matches 0]
6795 set known [commitinview $id $curview]
6798 $ctext tag conf $lk -foreground blue -underline 1
6799 $ctext tag bind $lk <1> [list selbyid $id]
6800 $ctext tag bind $lk <Enter> {linkcursor %W 1}
6801 $ctext tag bind $lk <Leave> {linkcursor %W -1}
6803 lappend pendinglinks($id) $lk
6804 interestedin $id {makelink %P}
6808 proc appendshortlink {id {pre {}} {post {}}} {
6809 global ctext linknum
6811 $ctext insert end $pre
6812 $ctext tag delete link$linknum
6813 $ctext insert end [string range $id 0 7] link$linknum
6814 $ctext insert end $post
6815 setlink $id link$linknum
6819 proc makelink {id} {
6822 if {![info exists pendinglinks($id)]} return
6823 foreach lk $pendinglinks($id) {
6826 unset pendinglinks($id)
6829 proc linkcursor {w inc} {
6830 global linkentercount curtextcursor
6832 if {[incr linkentercount $inc] > 0} {
6833 $w configure -cursor hand2
6835 $w configure -cursor $curtextcursor
6836 if {$linkentercount < 0} {
6837 set linkentercount 0
6842 proc viewnextline {dir} {
6846 set ymax [lindex [$canv cget -scrollregion] 3]
6847 set wnow [$canv yview]
6848 set wtop [expr {[lindex $wnow 0] * $ymax}]
6849 set newtop [expr {$wtop + $dir * $linespc}]
6852 } elseif {$newtop > $ymax} {
6855 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
6858 # add a list of tag or branch names at position pos
6859 # returns the number of names inserted
6860 proc appendrefs {pos ids var} {
6861 global ctext linknum curview $var maxrefs
6863 if {[catch {$ctext index $pos}]} {
6866 $ctext conf -state normal
6867 $ctext delete $pos "$pos lineend"
6870 foreach tag [set $var\($id\)] {
6871 lappend tags [list $tag $id]
6874 if {[llength $tags] > $maxrefs} {
6875 $ctext insert $pos "[mc "many"] ([llength $tags])"
6877 set tags [lsort -index 0 -decreasing $tags]
6880 set id [lindex $ti 1]
6883 $ctext tag delete $lk
6884 $ctext insert $pos $sep
6885 $ctext insert $pos [lindex $ti 0] $lk
6890 $ctext conf -state disabled
6891 return [llength $tags]
6894 # called when we have finished computing the nearby tags
6895 proc dispneartags {delay} {
6896 global selectedline currentid showneartags tagphase
6898 if {$selectedline eq {} || !$showneartags} return
6899 after cancel dispnexttag
6901 after 200 dispnexttag
6904 after idle dispnexttag
6909 proc dispnexttag {} {
6910 global selectedline currentid showneartags tagphase ctext
6912 if {$selectedline eq {} || !$showneartags} return
6913 switch -- $tagphase {
6915 set dtags [desctags $currentid]
6917 appendrefs precedes $dtags idtags
6921 set atags [anctags $currentid]
6923 appendrefs follows $atags idtags
6927 set dheads [descheads $currentid]
6928 if {$dheads ne {}} {
6929 if {[appendrefs branch $dheads idheads] > 1
6930 && [$ctext get "branch -3c"] eq "h"} {
6931 # turn "Branch" into "Branches"
6932 $ctext conf -state normal
6933 $ctext insert "branch -2c" "es"
6934 $ctext conf -state disabled
6939 if {[incr tagphase] <= 2} {
6940 after idle dispnexttag
6944 proc make_secsel {id} {
6945 global linehtag linentag linedtag canv canv2 canv3
6947 if {![info exists linehtag($id)]} return
6949 set t [eval $canv create rect [$canv bbox $linehtag($id)] -outline {{}} \
6950 -tags secsel -fill [$canv cget -selectbackground]]
6952 $canv2 delete secsel
6953 set t [eval $canv2 create rect [$canv2 bbox $linentag($id)] -outline {{}} \
6954 -tags secsel -fill [$canv2 cget -selectbackground]]
6956 $canv3 delete secsel
6957 set t [eval $canv3 create rect [$canv3 bbox $linedtag($id)] -outline {{}} \
6958 -tags secsel -fill [$canv3 cget -selectbackground]]
6962 proc make_idmark {id} {
6963 global linehtag canv fgcolor
6965 if {![info exists linehtag($id)]} return
6967 set t [eval $canv create rect [$canv bbox $linehtag($id)] \
6968 -tags markid -outline $fgcolor]
6972 proc selectline {l isnew {desired_loc {}}} {
6973 global canv ctext commitinfo selectedline
6974 global canvy0 linespc parents children curview
6975 global currentid sha1entry
6976 global commentend idtags linknum
6977 global mergemax numcommits pending_select
6978 global cmitmode showneartags allcommits
6979 global targetrow targetid lastscrollrows
6980 global autoselect autosellen jump_to_here
6982 catch {unset pending_select}
6987 if {$l < 0 || $l >= $numcommits} return
6988 set id [commitonrow $l]
6993 if {$lastscrollrows < $numcommits} {
6997 set y [expr {$canvy0 + $l * $linespc}]
6998 set ymax [lindex [$canv cget -scrollregion] 3]
6999 set ytop [expr {$y - $linespc - 1}]
7000 set ybot [expr {$y + $linespc + 1}]
7001 set wnow [$canv yview]
7002 set wtop [expr {[lindex $wnow 0] * $ymax}]
7003 set wbot [expr {[lindex $wnow 1] * $ymax}]
7004 set wh [expr {$wbot - $wtop}]
7006 if {$ytop < $wtop} {
7007 if {$ybot < $wtop} {
7008 set newtop [expr {$y - $wh / 2.0}]
7011 if {$newtop > $wtop - $linespc} {
7012 set newtop [expr {$wtop - $linespc}]
7015 } elseif {$ybot > $wbot} {
7016 if {$ytop > $wbot} {
7017 set newtop [expr {$y - $wh / 2.0}]
7019 set newtop [expr {$ybot - $wh}]
7020 if {$newtop < $wtop + $linespc} {
7021 set newtop [expr {$wtop + $linespc}]
7025 if {$newtop != $wtop} {
7029 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
7036 addtohistory [list selbyid $id 0] savecmitpos
7039 $sha1entry delete 0 end
7040 $sha1entry insert 0 $id
7042 $sha1entry selection range 0 $autosellen
7046 $ctext conf -state normal
7049 if {![info exists commitinfo($id)]} {
7052 set info $commitinfo($id)
7053 set date [formatdate [lindex $info 2]]
7054 $ctext insert end "[mc "Author"]: [lindex $info 1] $date\n"
7055 set date [formatdate [lindex $info 4]]
7056 $ctext insert end "[mc "Committer"]: [lindex $info 3] $date\n"
7057 if {[info exists idtags($id)]} {
7058 $ctext insert end [mc "Tags:"]
7059 foreach tag $idtags($id) {
7060 $ctext insert end " $tag"
7062 $ctext insert end "\n"
7066 set olds $parents($curview,$id)
7067 if {[llength $olds] > 1} {
7070 if {$np >= $mergemax} {
7075 $ctext insert end "[mc "Parent"]: " $tag
7076 appendwithlinks [commit_descriptor $p] {}
7081 append headers "[mc "Parent"]: [commit_descriptor $p]"
7085 foreach c $children($curview,$id) {
7086 append headers "[mc "Child"]: [commit_descriptor $c]"
7089 # make anything that looks like a SHA1 ID be a clickable link
7090 appendwithlinks $headers {}
7091 if {$showneartags} {
7092 if {![info exists allcommits]} {
7095 $ctext insert end "[mc "Branch"]: "
7096 $ctext mark set branch "end -1c"
7097 $ctext mark gravity branch left
7098 $ctext insert end "\n[mc "Follows"]: "
7099 $ctext mark set follows "end -1c"
7100 $ctext mark gravity follows left
7101 $ctext insert end "\n[mc "Precedes"]: "
7102 $ctext mark set precedes "end -1c"
7103 $ctext mark gravity precedes left
7104 $ctext insert end "\n"
7107 $ctext insert end "\n"
7108 set comment [lindex $info 5]
7109 if {[string first "\r" $comment] >= 0} {
7110 set comment [string map {"\r" "\n "} $comment]
7112 appendwithlinks $comment {comment}
7114 $ctext tag remove found 1.0 end
7115 $ctext conf -state disabled
7116 set commentend [$ctext index "end - 1c"]
7118 set jump_to_here $desired_loc
7119 init_flist [mc "Comments"]
7120 if {$cmitmode eq "tree"} {
7122 } elseif {[llength $olds] <= 1} {
7129 proc selfirstline {} {
7134 proc sellastline {} {
7137 set l [expr {$numcommits - 1}]
7141 proc selnextline {dir} {
7144 if {$selectedline eq {}} return
7145 set l [expr {$selectedline + $dir}]
7150 proc selnextpage {dir} {
7151 global canv linespc selectedline numcommits
7153 set lpp [expr {([winfo height $canv] - 2) / $linespc}]
7157 allcanvs yview scroll [expr {$dir * $lpp}] units
7159 if {$selectedline eq {}} return
7160 set l [expr {$selectedline + $dir * $lpp}]
7163 } elseif {$l >= $numcommits} {
7164 set l [expr $numcommits - 1]
7170 proc unselectline {} {
7171 global selectedline currentid
7174 catch {unset currentid}
7175 allcanvs delete secsel
7179 proc reselectline {} {
7182 if {$selectedline ne {}} {
7183 selectline $selectedline 0
7187 proc addtohistory {cmd {saveproc {}}} {
7188 global history historyindex curview
7192 set elt [list $curview $cmd $saveproc {}]
7193 if {$historyindex > 0
7194 && [lindex $history [expr {$historyindex - 1}]] == $elt} {
7198 if {$historyindex < [llength $history]} {
7199 set history [lreplace $history $historyindex end $elt]
7201 lappend history $elt
7204 if {$historyindex > 1} {
7205 .tf.bar.leftbut conf -state normal
7207 .tf.bar.leftbut conf -state disabled
7209 .tf.bar.rightbut conf -state disabled
7212 # save the scrolling position of the diff display pane
7213 proc save_position {} {
7214 global historyindex history
7216 if {$historyindex < 1} return
7217 set hi [expr {$historyindex - 1}]
7218 set fn [lindex $history $hi 2]
7220 lset history $hi 3 [eval $fn]
7224 proc unset_posvars {} {
7227 if {[info exists last_posvars]} {
7228 foreach {var val} $last_posvars {
7237 global curview last_posvars
7239 set view [lindex $elt 0]
7240 set cmd [lindex $elt 1]
7241 set pv [lindex $elt 3]
7242 if {$curview != $view} {
7246 foreach {var val} $pv {
7250 set last_posvars $pv
7255 global history historyindex
7258 if {$historyindex > 1} {
7260 incr historyindex -1
7261 godo [lindex $history [expr {$historyindex - 1}]]
7262 .tf.bar.rightbut conf -state normal
7264 if {$historyindex <= 1} {
7265 .tf.bar.leftbut conf -state disabled
7270 global history historyindex
7273 if {$historyindex < [llength $history]} {
7275 set cmd [lindex $history $historyindex]
7278 .tf.bar.leftbut conf -state normal
7280 if {$historyindex >= [llength $history]} {
7281 .tf.bar.rightbut conf -state disabled
7286 global treefilelist treeidlist diffids diffmergeid treepending
7287 global nullid nullid2
7290 catch {unset diffmergeid}
7291 if {![info exists treefilelist($id)]} {
7292 if {![info exists treepending]} {
7293 if {$id eq $nullid} {
7294 set cmd [list | git ls-files]
7295 } elseif {$id eq $nullid2} {
7296 set cmd [list | git ls-files --stage -t]
7298 set cmd [list | git ls-tree -r $id]
7300 if {[catch {set gtf [open $cmd r]}]} {
7304 set treefilelist($id) {}
7305 set treeidlist($id) {}
7306 fconfigure $gtf -blocking 0 -encoding binary
7307 filerun $gtf [list gettreeline $gtf $id]
7314 proc gettreeline {gtf id} {
7315 global treefilelist treeidlist treepending cmitmode diffids nullid nullid2
7318 while {[incr nl] <= 1000 && [gets $gtf line] >= 0} {
7319 if {$diffids eq $nullid} {
7322 set i [string first "\t" $line]
7323 if {$i < 0} continue
7324 set fname [string range $line [expr {$i+1}] end]
7325 set line [string range $line 0 [expr {$i-1}]]
7326 if {$diffids ne $nullid2 && [lindex $line 1] ne "blob"} continue
7327 set sha1 [lindex $line 2]
7328 lappend treeidlist($id) $sha1
7330 if {[string index $fname 0] eq "\""} {
7331 set fname [lindex $fname 0]
7333 set fname [encoding convertfrom $fname]
7334 lappend treefilelist($id) $fname
7337 return [expr {$nl >= 1000? 2: 1}]
7341 if {$cmitmode ne "tree"} {
7342 if {![info exists diffmergeid]} {
7343 gettreediffs $diffids
7345 } elseif {$id ne $diffids} {
7354 global treefilelist treeidlist diffids nullid nullid2
7355 global ctext_file_names ctext_file_lines
7356 global ctext commentend
7358 set i [lsearch -exact $treefilelist($diffids) $f]
7360 puts "oops, $f not in list for id $diffids"
7363 if {$diffids eq $nullid} {
7364 if {[catch {set bf [open $f r]} err]} {
7365 puts "oops, can't read $f: $err"
7369 set blob [lindex $treeidlist($diffids) $i]
7370 if {[catch {set bf [open [concat | git cat-file blob $blob] r]} err]} {
7371 puts "oops, error reading blob $blob: $err"
7375 fconfigure $bf -blocking 0 -encoding [get_path_encoding $f]
7376 filerun $bf [list getblobline $bf $diffids]
7377 $ctext config -state normal
7378 clear_ctext $commentend
7379 lappend ctext_file_names $f
7380 lappend ctext_file_lines [lindex [split $commentend "."] 0]
7381 $ctext insert end "\n"
7382 $ctext insert end "$f\n" filesep
7383 $ctext config -state disabled
7384 $ctext yview $commentend
7388 proc getblobline {bf id} {
7389 global diffids cmitmode ctext
7391 if {$id ne $diffids || $cmitmode ne "tree"} {
7395 $ctext config -state normal
7397 while {[incr nl] <= 1000 && [gets $bf line] >= 0} {
7398 $ctext insert end "$line\n"
7401 global jump_to_here ctext_file_names commentend
7403 # delete last newline
7404 $ctext delete "end - 2c" "end - 1c"
7406 if {$jump_to_here ne {} &&
7407 [lindex $jump_to_here 0] eq [lindex $ctext_file_names 0]} {
7408 set lnum [expr {[lindex $jump_to_here 1] +
7409 [lindex [split $commentend .] 0]}]
7410 mark_ctext_line $lnum
7412 $ctext config -state disabled
7415 $ctext config -state disabled
7416 return [expr {$nl >= 1000? 2: 1}]
7419 proc mark_ctext_line {lnum} {
7420 global ctext markbgcolor
7422 $ctext tag delete omark
7423 $ctext tag add omark $lnum.0 "$lnum.0 + 1 line"
7424 $ctext tag conf omark -background $markbgcolor
7428 proc mergediff {id} {
7430 global diffids treediffs
7431 global parents curview
7435 set treediffs($id) {}
7436 set np [llength $parents($curview,$id)]
7441 proc startdiff {ids} {
7442 global treediffs diffids treepending diffmergeid nullid nullid2
7446 catch {unset diffmergeid}
7447 if {![info exists treediffs($ids)] ||
7448 [lsearch -exact $ids $nullid] >= 0 ||
7449 [lsearch -exact $ids $nullid2] >= 0} {
7450 if {![info exists treepending]} {
7458 # If the filename (name) is under any of the passed filter paths
7459 # then return true to include the file in the listing.
7460 proc path_filter {filter name} {
7461 set worktree [gitworktree]
7463 set fq_p [file normalize $p]
7464 set fq_n [file normalize [file join $worktree $name]]
7465 if {[string match [file normalize $fq_p]* $fq_n]} {
7472 proc addtocflist {ids} {
7475 add_flist $treediffs($ids)
7479 proc diffcmd {ids flags} {
7480 global log_showroot nullid nullid2
7482 set i [lsearch -exact $ids $nullid]
7483 set j [lsearch -exact $ids $nullid2]
7485 if {[llength $ids] > 1 && $j < 0} {
7486 # comparing working directory with some specific revision
7487 set cmd [concat | git diff-index $flags]
7489 lappend cmd -R [lindex $ids 1]
7491 lappend cmd [lindex $ids 0]
7494 # comparing working directory with index
7495 set cmd [concat | git diff-files $flags]
7500 } elseif {$j >= 0} {
7501 set cmd [concat | git diff-index --cached $flags]
7502 if {[llength $ids] > 1} {
7503 # comparing index with specific revision
7505 lappend cmd -R [lindex $ids 1]
7507 lappend cmd [lindex $ids 0]
7510 # comparing index with HEAD
7514 if {$log_showroot} {
7515 lappend flags --root
7517 set cmd [concat | git diff-tree -r $flags $ids]
7522 proc gettreediffs {ids} {
7523 global treediff treepending
7525 if {[catch {set gdtf [open [diffcmd $ids {--no-commit-id}] r]}]} return
7527 set treepending $ids
7529 fconfigure $gdtf -blocking 0 -encoding binary
7530 filerun $gdtf [list gettreediffline $gdtf $ids]
7533 proc gettreediffline {gdtf ids} {
7534 global treediff treediffs treepending diffids diffmergeid
7535 global cmitmode vfilelimit curview limitdiffs perfile_attrs
7540 if {$perfile_attrs} {
7541 # cache_gitattr is slow, and even slower on win32 where we
7542 # have to invoke it for only about 30 paths at a time
7544 if {[tk windowingsystem] == "win32"} {
7548 while {[incr nr] <= $max && [gets $gdtf line] >= 0} {
7549 set i [string first "\t" $line]
7551 set file [string range $line [expr {$i+1}] end]
7552 if {[string index $file 0] eq "\""} {
7553 set file [lindex $file 0]
7555 set file [encoding convertfrom $file]
7556 if {$file ne [lindex $treediff end]} {
7557 lappend treediff $file
7558 lappend sublist $file
7562 if {$perfile_attrs} {
7563 cache_gitattr encoding $sublist
7566 return [expr {$nr >= $max? 2: 1}]
7569 if {$limitdiffs && $vfilelimit($curview) ne {}} {
7571 foreach f $treediff {
7572 if {[path_filter $vfilelimit($curview) $f]} {
7576 set treediffs($ids) $flist
7578 set treediffs($ids) $treediff
7581 if {$cmitmode eq "tree" && [llength $diffids] == 1} {
7583 } elseif {$ids != $diffids} {
7584 if {![info exists diffmergeid]} {
7585 gettreediffs $diffids
7593 # empty string or positive integer
7594 proc diffcontextvalidate {v} {
7595 return [regexp {^(|[1-9][0-9]*)$} $v]
7598 proc diffcontextchange {n1 n2 op} {
7599 global diffcontextstring diffcontext
7601 if {[string is integer -strict $diffcontextstring]} {
7602 if {$diffcontextstring >= 0} {
7603 set diffcontext $diffcontextstring
7609 proc changeignorespace {} {
7613 proc changeworddiff {name ix op} {
7617 proc getblobdiffs {ids} {
7618 global blobdifffd diffids env
7619 global diffinhdr treediffs
7623 global limitdiffs vfilelimit curview
7624 global diffencoding targetline diffnparents
7625 global git_version currdiffsubmod
7628 if {[package vcompare $git_version "1.6.1"] >= 0} {
7629 set textconv "--textconv"
7632 if {[package vcompare $git_version "1.6.6"] >= 0} {
7633 set submodule "--submodule"
7635 set cmd [diffcmd $ids "-p $textconv $submodule -C --cc --no-commit-id -U$diffcontext"]
7639 if {$worddiff ne [mc "Line diff"]} {
7640 append cmd " --word-diff=porcelain"
7642 if {$limitdiffs && $vfilelimit($curview) ne {}} {
7643 set cmd [concat $cmd -- $vfilelimit($curview)]
7645 if {[catch {set bdf [open $cmd r]} err]} {
7646 error_popup [mc "Error getting diffs: %s" $err]
7652 set diffencoding [get_path_encoding {}]
7653 fconfigure $bdf -blocking 0 -encoding binary -eofchar {}
7654 set blobdifffd($ids) $bdf
7655 set currdiffsubmod ""
7656 filerun $bdf [list getblobdiffline $bdf $diffids]
7659 proc savecmitpos {} {
7660 global ctext cmitmode
7662 if {$cmitmode eq "tree"} {
7665 return [list target_scrollpos [$ctext index @0,0]]
7668 proc savectextpos {} {
7671 return [list target_scrollpos [$ctext index @0,0]]
7674 proc maybe_scroll_ctext {ateof} {
7675 global ctext target_scrollpos
7677 if {![info exists target_scrollpos]} return
7679 set nlines [expr {[winfo height $ctext]
7680 / [font metrics textfont -linespace]}]
7681 if {[$ctext compare "$target_scrollpos + $nlines lines" <= end]} return
7683 $ctext yview $target_scrollpos
7684 unset target_scrollpos
7687 proc setinlist {var i val} {
7690 while {[llength [set $var]] < $i} {
7693 if {[llength [set $var]] == $i} {
7700 proc makediffhdr {fname ids} {
7701 global ctext curdiffstart treediffs diffencoding
7702 global ctext_file_names jump_to_here targetline diffline
7704 set fname [encoding convertfrom $fname]
7705 set diffencoding [get_path_encoding $fname]
7706 set i [lsearch -exact $treediffs($ids) $fname]
7708 setinlist difffilestart $i $curdiffstart
7710 lset ctext_file_names end $fname
7711 set l [expr {(78 - [string length $fname]) / 2}]
7712 set pad [string range "----------------------------------------" 1 $l]
7713 $ctext insert $curdiffstart "$pad $fname $pad" filesep
7715 if {$jump_to_here ne {} && [lindex $jump_to_here 0] eq $fname} {
7716 set targetline [lindex $jump_to_here 1]
7721 proc getblobdiffline {bdf ids} {
7722 global diffids blobdifffd ctext curdiffstart
7723 global diffnexthead diffnextnote difffilestart
7724 global ctext_file_names ctext_file_lines
7725 global diffinhdr treediffs mergemax diffnparents
7726 global diffencoding jump_to_here targetline diffline currdiffsubmod
7730 $ctext conf -state normal
7731 while {[incr nr] <= 1000 && [gets $bdf line] >= 0} {
7732 if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
7736 if {![string compare -length 5 "diff " $line]} {
7737 if {![regexp {^diff (--cc|--git) } $line m type]} {
7738 set line [encoding convertfrom $line]
7739 $ctext insert end "$line\n" hunksep
7742 # start of a new file
7744 $ctext insert end "\n"
7745 set curdiffstart [$ctext index "end - 1c"]
7746 lappend ctext_file_names ""
7747 lappend ctext_file_lines [lindex [split $curdiffstart "."] 0]
7748 $ctext insert end "\n" filesep
7750 if {$type eq "--cc"} {
7751 # start of a new file in a merge diff
7752 set fname [string range $line 10 end]
7753 if {[lsearch -exact $treediffs($ids) $fname] < 0} {
7754 lappend treediffs($ids) $fname
7755 add_flist [list $fname]
7759 set line [string range $line 11 end]
7760 # If the name hasn't changed the length will be odd,
7761 # the middle char will be a space, and the two bits either
7762 # side will be a/name and b/name, or "a/name" and "b/name".
7763 # If the name has changed we'll get "rename from" and
7764 # "rename to" or "copy from" and "copy to" lines following
7765 # this, and we'll use them to get the filenames.
7766 # This complexity is necessary because spaces in the
7767 # filename(s) don't get escaped.
7768 set l [string length $line]
7769 set i [expr {$l / 2}]
7770 if {!(($l & 1) && [string index $line $i] eq " " &&
7771 [string range $line 2 [expr {$i - 1}]] eq \
7772 [string range $line [expr {$i + 3}] end])} {
7775 # unescape if quoted and chop off the a/ from the front
7776 if {[string index $line 0] eq "\""} {
7777 set fname [string range [lindex $line 0] 2 end]
7779 set fname [string range $line 2 [expr {$i - 1}]]
7782 makediffhdr $fname $ids
7784 } elseif {![string compare -length 16 "* Unmerged path " $line]} {
7785 set fname [encoding convertfrom [string range $line 16 end]]
7786 $ctext insert end "\n"
7787 set curdiffstart [$ctext index "end - 1c"]
7788 lappend ctext_file_names $fname
7789 lappend ctext_file_lines [lindex [split $curdiffstart "."] 0]
7790 $ctext insert end "$line\n" filesep
7791 set i [lsearch -exact $treediffs($ids) $fname]
7793 setinlist difffilestart $i $curdiffstart
7796 } elseif {![string compare -length 2 "@@" $line]} {
7797 regexp {^@@+} $line ats
7798 set line [encoding convertfrom $diffencoding $line]
7799 $ctext insert end "$line\n" hunksep
7800 if {[regexp { \+(\d+),\d+ @@} $line m nl]} {
7803 set diffnparents [expr {[string length $ats] - 1}]
7806 } elseif {![string compare -length 10 "Submodule " $line]} {
7807 # start of a new submodule
7808 if {[regexp -indices "\[0-9a-f\]+\\.\\." $line nameend]} {
7809 set fname [string range $line 10 [expr [lindex $nameend 0] - 2]]
7811 set fname [string range $line 10 [expr [string first "contains " $line] - 2]]
7813 if {$currdiffsubmod != $fname} {
7814 $ctext insert end "\n"; # Add newline after commit message
7816 set curdiffstart [$ctext index "end - 1c"]
7817 lappend ctext_file_names ""
7818 if {$currdiffsubmod != $fname} {
7819 lappend ctext_file_lines $fname
7820 makediffhdr $fname $ids
7821 set currdiffsubmod $fname
7822 $ctext insert end "\n$line\n" filesep
7824 $ctext insert end "$line\n" filesep
7826 } elseif {![string compare -length 3 " >" $line]} {
7827 set $currdiffsubmod ""
7828 set line [encoding convertfrom $diffencoding $line]
7829 $ctext insert end "$line\n" dresult
7830 } elseif {![string compare -length 3 " <" $line]} {
7831 set $currdiffsubmod ""
7832 set line [encoding convertfrom $diffencoding $line]
7833 $ctext insert end "$line\n" d0
7834 } elseif {$diffinhdr} {
7835 if {![string compare -length 12 "rename from " $line]} {
7836 set fname [string range $line [expr 6 + [string first " from " $line] ] end]
7837 if {[string index $fname 0] eq "\""} {
7838 set fname [lindex $fname 0]
7840 set fname [encoding convertfrom $fname]
7841 set i [lsearch -exact $treediffs($ids) $fname]
7843 setinlist difffilestart $i $curdiffstart
7845 } elseif {![string compare -length 10 $line "rename to "] ||
7846 ![string compare -length 8 $line "copy to "]} {
7847 set fname [string range $line [expr 4 + [string first " to " $line] ] end]
7848 if {[string index $fname 0] eq "\""} {
7849 set fname [lindex $fname 0]
7851 makediffhdr $fname $ids
7852 } elseif {[string compare -length 3 $line "---"] == 0} {
7855 } elseif {[string compare -length 3 $line "+++"] == 0} {
7859 $ctext insert end "$line\n" filesep
7862 set line [string map {\x1A ^Z} \
7863 [encoding convertfrom $diffencoding $line]]
7864 # parse the prefix - one ' ', '-' or '+' for each parent
7865 set prefix [string range $line 0 [expr {$diffnparents - 1}]]
7866 set tag [expr {$diffnparents > 1? "m": "d"}]
7867 set dowords [expr {$worddiff ne [mc "Line diff"] && $diffnparents == 1}]
7868 set words_pre_markup ""
7869 set words_post_markup ""
7870 if {[string trim $prefix " -+"] eq {}} {
7871 # prefix only has " ", "-" and "+" in it: normal diff line
7872 set num [string first "-" $prefix]
7874 set line [string range $line 1 end]
7877 # removed line, first parent with line is $num
7878 if {$num >= $mergemax} {
7881 if {$dowords && $worddiff eq [mc "Markup words"]} {
7882 $ctext insert end "\[-$line-\]" $tag$num
7884 $ctext insert end "$line" $tag$num
7887 $ctext insert end "\n" $tag$num
7891 if {[string first "+" $prefix] >= 0} {
7893 lappend tags ${tag}result
7894 if {$diffnparents > 1} {
7895 set num [string first " " $prefix]
7897 if {$num >= $mergemax} {
7903 set words_pre_markup "{+"
7904 set words_post_markup "+}"
7906 if {$targetline ne {}} {
7907 if {$diffline == $targetline} {
7908 set seehere [$ctext index "end - 1 chars"]
7914 if {$dowords && $worddiff eq [mc "Markup words"]} {
7915 $ctext insert end "$words_pre_markup$line$words_post_markup" $tags
7917 $ctext insert end "$line" $tags
7920 $ctext insert end "\n" $tags
7923 } elseif {$dowords && $prefix eq "~"} {
7924 $ctext insert end "\n" {}
7926 # "\ No newline at end of file",
7927 # or something else we don't recognize
7928 $ctext insert end "$line\n" hunksep
7932 if {[info exists seehere]} {
7933 mark_ctext_line [lindex [split $seehere .] 0]
7935 maybe_scroll_ctext [eof $bdf]
7936 $ctext conf -state disabled
7941 return [expr {$nr >= 1000? 2: 1}]
7944 proc changediffdisp {} {
7945 global ctext diffelide
7947 $ctext tag conf d0 -elide [lindex $diffelide 0]
7948 $ctext tag conf dresult -elide [lindex $diffelide 1]
7951 proc highlightfile {loc cline} {
7952 global ctext cflist cflist_top
7955 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
7956 $cflist tag add highlight $cline.0 "$cline.0 lineend"
7957 $cflist see $cline.0
7958 set cflist_top $cline
7962 global difffilestart ctext cmitmode
7964 if {$cmitmode eq "tree"} return
7967 set here [$ctext index @0,0]
7968 foreach loc $difffilestart {
7969 if {[$ctext compare $loc >= $here]} {
7970 highlightfile $prev $prevline
7976 highlightfile $prev $prevline
7980 global difffilestart ctext cmitmode
7982 if {$cmitmode eq "tree"} return
7983 set here [$ctext index @0,0]
7985 foreach loc $difffilestart {
7987 if {[$ctext compare $loc > $here]} {
7988 highlightfile $loc $line
7994 proc clear_ctext {{first 1.0}} {
7995 global ctext smarktop smarkbot
7996 global ctext_file_names ctext_file_lines
7999 set l [lindex [split $first .] 0]
8000 if {![info exists smarktop] || [$ctext compare $first < $smarktop.0]} {
8003 if {![info exists smarkbot] || [$ctext compare $first < $smarkbot.0]} {
8006 $ctext delete $first end
8007 if {$first eq "1.0"} {
8008 catch {unset pendinglinks}
8010 set ctext_file_names {}
8011 set ctext_file_lines {}
8014 proc settabs {{firstab {}}} {
8015 global firsttabstop tabstop ctext have_tk85
8017 if {$firstab ne {} && $have_tk85} {
8018 set firsttabstop $firstab
8020 set w [font measure textfont "0"]
8021 if {$firsttabstop != 0} {
8022 $ctext conf -tabs [list [expr {($firsttabstop + $tabstop) * $w}] \
8023 [expr {($firsttabstop + 2 * $tabstop) * $w}]]
8024 } elseif {$have_tk85 || $tabstop != 8} {
8025 $ctext conf -tabs [expr {$tabstop * $w}]
8027 $ctext conf -tabs {}
8031 proc incrsearch {name ix op} {
8032 global ctext searchstring searchdirn
8034 $ctext tag remove found 1.0 end
8035 if {[catch {$ctext index anchor}]} {
8036 # no anchor set, use start of selection, or of visible area
8037 set sel [$ctext tag ranges sel]
8039 $ctext mark set anchor [lindex $sel 0]
8040 } elseif {$searchdirn eq "-forwards"} {
8041 $ctext mark set anchor @0,0
8043 $ctext mark set anchor @0,[winfo height $ctext]
8046 if {$searchstring ne {}} {
8047 set here [$ctext search $searchdirn -- $searchstring anchor]
8056 global sstring ctext searchstring searchdirn
8059 $sstring icursor end
8060 set searchdirn -forwards
8061 if {$searchstring ne {}} {
8062 set sel [$ctext tag ranges sel]
8064 set start "[lindex $sel 0] + 1c"
8065 } elseif {[catch {set start [$ctext index anchor]}]} {
8068 set match [$ctext search -count mlen -- $searchstring $start]
8069 $ctext tag remove sel 1.0 end
8075 set mend "$match + $mlen c"
8076 $ctext tag add sel $match $mend
8077 $ctext mark unset anchor
8081 proc dosearchback {} {
8082 global sstring ctext searchstring searchdirn
8085 $sstring icursor end
8086 set searchdirn -backwards
8087 if {$searchstring ne {}} {
8088 set sel [$ctext tag ranges sel]
8090 set start [lindex $sel 0]
8091 } elseif {[catch {set start [$ctext index anchor]}]} {
8092 set start @0,[winfo height $ctext]
8094 set match [$ctext search -backwards -count ml -- $searchstring $start]
8095 $ctext tag remove sel 1.0 end
8101 set mend "$match + $ml c"
8102 $ctext tag add sel $match $mend
8103 $ctext mark unset anchor
8107 proc searchmark {first last} {
8108 global ctext searchstring
8112 set match [$ctext search -count mlen -- $searchstring $mend $last.end]
8113 if {$match eq {}} break
8114 set mend "$match + $mlen c"
8115 $ctext tag add found $match $mend
8119 proc searchmarkvisible {doall} {
8120 global ctext smarktop smarkbot
8122 set topline [lindex [split [$ctext index @0,0] .] 0]
8123 set botline [lindex [split [$ctext index @0,[winfo height $ctext]] .] 0]
8124 if {$doall || $botline < $smarktop || $topline > $smarkbot} {
8125 # no overlap with previous
8126 searchmark $topline $botline
8127 set smarktop $topline
8128 set smarkbot $botline
8130 if {$topline < $smarktop} {
8131 searchmark $topline [expr {$smarktop-1}]
8132 set smarktop $topline
8134 if {$botline > $smarkbot} {
8135 searchmark [expr {$smarkbot+1}] $botline
8136 set smarkbot $botline
8141 proc scrolltext {f0 f1} {
8144 .bleft.bottom.sb set $f0 $f1
8145 if {$searchstring ne {}} {
8151 global linespc charspc canvx0 canvy0
8152 global xspc1 xspc2 lthickness
8154 set linespc [font metrics mainfont -linespace]
8155 set charspc [font measure mainfont "m"]
8156 set canvy0 [expr {int(3 + 0.5 * $linespc)}]
8157 set canvx0 [expr {int(3 + 0.5 * $linespc)}]
8158 set lthickness [expr {int($linespc / 9) + 1}]
8159 set xspc1(0) $linespc
8167 set ymax [lindex [$canv cget -scrollregion] 3]
8168 if {$ymax eq {} || $ymax == 0} return
8169 set span [$canv yview]
8172 allcanvs yview moveto [lindex $span 0]
8174 if {$selectedline ne {}} {
8175 selectline $selectedline 0
8176 allcanvs yview moveto [lindex $span 0]
8180 proc parsefont {f n} {
8183 set fontattr($f,family) [lindex $n 0]
8185 if {$s eq {} || $s == 0} {
8188 set s [expr {int(-$s / [winfo fpixels . 1p] + 0.5)}]
8190 set fontattr($f,size) $s
8191 set fontattr($f,weight) normal
8192 set fontattr($f,slant) roman
8193 foreach style [lrange $n 2 end] {
8196 "bold" {set fontattr($f,weight) $style}
8198 "italic" {set fontattr($f,slant) $style}
8203 proc fontflags {f {isbold 0}} {
8206 return [list -family $fontattr($f,family) -size $fontattr($f,size) \
8207 -weight [expr {$isbold? "bold": $fontattr($f,weight)}] \
8208 -slant $fontattr($f,slant)]
8214 set n [list $fontattr($f,family) $fontattr($f,size)]
8215 if {$fontattr($f,weight) eq "bold"} {
8218 if {$fontattr($f,slant) eq "italic"} {
8224 proc incrfont {inc} {
8225 global mainfont textfont ctext canv cflist showrefstop
8226 global stopped entries fontattr
8229 set s $fontattr(mainfont,size)
8234 set fontattr(mainfont,size) $s
8235 font config mainfont -size $s
8236 font config mainfontbold -size $s
8237 set mainfont [fontname mainfont]
8238 set s $fontattr(textfont,size)
8243 set fontattr(textfont,size) $s
8244 font config textfont -size $s
8245 font config textfontbold -size $s
8246 set textfont [fontname textfont]
8253 global sha1entry sha1string
8254 if {[string length $sha1string] == 40} {
8255 $sha1entry delete 0 end
8259 proc sha1change {n1 n2 op} {
8260 global sha1string currentid sha1but
8261 if {$sha1string == {}
8262 || ([info exists currentid] && $sha1string == $currentid)} {
8267 if {[$sha1but cget -state] == $state} return
8268 if {$state == "normal"} {
8269 $sha1but conf -state normal -relief raised -text "[mc "Goto:"] "
8271 $sha1but conf -state disabled -relief flat -text "[mc "SHA1 ID:"] "
8275 proc gotocommit {} {
8276 global sha1string tagids headids curview varcid
8278 if {$sha1string == {}
8279 || ([info exists currentid] && $sha1string == $currentid)} return
8280 if {[info exists tagids($sha1string)]} {
8281 set id $tagids($sha1string)
8282 } elseif {[info exists headids($sha1string)]} {
8283 set id $headids($sha1string)
8285 set id [string tolower $sha1string]
8286 if {[regexp {^[0-9a-f]{4,39}$} $id]} {
8287 set matches [longid $id]
8288 if {$matches ne {}} {
8289 if {[llength $matches] > 1} {
8290 error_popup [mc "Short SHA1 id %s is ambiguous" $id]
8293 set id [lindex $matches 0]
8296 if {[catch {set id [exec git rev-parse --verify $sha1string]}]} {
8297 error_popup [mc "Revision %s is not known" $sha1string]
8302 if {[commitinview $id $curview]} {
8303 selectline [rowofcommit $id] 1
8306 if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
8307 set msg [mc "SHA1 id %s is not known" $sha1string]
8309 set msg [mc "Revision %s is not in the current view" $sha1string]
8314 proc lineenter {x y id} {
8315 global hoverx hovery hoverid hovertimer
8316 global commitinfo canv
8318 if {![info exists commitinfo($id)] && ![getcommit $id]} return
8322 if {[info exists hovertimer]} {
8323 after cancel $hovertimer
8325 set hovertimer [after 500 linehover]
8329 proc linemotion {x y id} {
8330 global hoverx hovery hoverid hovertimer
8332 if {[info exists hoverid] && $id == $hoverid} {
8335 if {[info exists hovertimer]} {
8336 after cancel $hovertimer
8338 set hovertimer [after 500 linehover]
8342 proc lineleave {id} {
8343 global hoverid hovertimer canv
8345 if {[info exists hoverid] && $id == $hoverid} {
8347 if {[info exists hovertimer]} {
8348 after cancel $hovertimer
8356 global hoverx hovery hoverid hovertimer
8357 global canv linespc lthickness
8360 set text [lindex $commitinfo($hoverid) 0]
8361 set ymax [lindex [$canv cget -scrollregion] 3]
8362 if {$ymax == {}} return
8363 set yfrac [lindex [$canv yview] 0]
8364 set x [expr {$hoverx + 2 * $linespc}]
8365 set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
8366 set x0 [expr {$x - 2 * $lthickness}]
8367 set y0 [expr {$y - 2 * $lthickness}]
8368 set x1 [expr {$x + [font measure mainfont $text] + 2 * $lthickness}]
8369 set y1 [expr {$y + $linespc + 2 * $lthickness}]
8370 set t [$canv create rectangle $x0 $y0 $x1 $y1 \
8371 -fill \#ffff80 -outline black -width 1 -tags hover]
8373 set t [$canv create text $x $y -anchor nw -text $text -tags hover \
8378 proc clickisonarrow {id y} {
8381 set ranges [rowranges $id]
8382 set thresh [expr {2 * $lthickness + 6}]
8383 set n [expr {[llength $ranges] - 1}]
8384 for {set i 1} {$i < $n} {incr i} {
8385 set row [lindex $ranges $i]
8386 if {abs([yc $row] - $y) < $thresh} {
8393 proc arrowjump {id n y} {
8396 # 1 <-> 2, 3 <-> 4, etc...
8397 set n [expr {(($n - 1) ^ 1) + 1}]
8398 set row [lindex [rowranges $id] $n]
8400 set ymax [lindex [$canv cget -scrollregion] 3]
8401 if {$ymax eq {} || $ymax <= 0} return
8402 set view [$canv yview]
8403 set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
8404 set yfrac [expr {$yt / $ymax - $yspan / 2}]
8408 allcanvs yview moveto $yfrac
8411 proc lineclick {x y id isnew} {
8412 global ctext commitinfo children canv thickerline curview
8414 if {![info exists commitinfo($id)] && ![getcommit $id]} return
8419 # draw this line thicker than normal
8423 set ymax [lindex [$canv cget -scrollregion] 3]
8424 if {$ymax eq {}} return
8425 set yfrac [lindex [$canv yview] 0]
8426 set y [expr {$y + $yfrac * $ymax}]
8428 set dirn [clickisonarrow $id $y]
8430 arrowjump $id $dirn $y
8435 addtohistory [list lineclick $x $y $id 0] savectextpos
8437 # fill the details pane with info about this line
8438 $ctext conf -state normal
8441 $ctext insert end "[mc "Parent"]:\t"
8442 $ctext insert end $id link0
8444 set info $commitinfo($id)
8445 $ctext insert end "\n\t[lindex $info 0]\n"
8446 $ctext insert end "\t[mc "Author"]:\t[lindex $info 1]\n"
8447 set date [formatdate [lindex $info 2]]
8448 $ctext insert end "\t[mc "Date"]:\t$date\n"
8449 set kids $children($curview,$id)
8451 $ctext insert end "\n[mc "Children"]:"
8453 foreach child $kids {
8455 if {![info exists commitinfo($child)] && ![getcommit $child]} continue
8456 set info $commitinfo($child)
8457 $ctext insert end "\n\t"
8458 $ctext insert end $child link$i
8459 setlink $child link$i
8460 $ctext insert end "\n\t[lindex $info 0]"
8461 $ctext insert end "\n\t[mc "Author"]:\t[lindex $info 1]"
8462 set date [formatdate [lindex $info 2]]
8463 $ctext insert end "\n\t[mc "Date"]:\t$date\n"
8466 maybe_scroll_ctext 1
8467 $ctext conf -state disabled
8471 proc normalline {} {
8473 if {[info exists thickerline]} {
8480 proc selbyid {id {isnew 1}} {
8482 if {[commitinview $id $curview]} {
8483 selectline [rowofcommit $id] $isnew
8489 if {![info exists startmstime]} {
8490 set startmstime [clock clicks -milliseconds]
8492 return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
8495 proc rowmenu {x y id} {
8496 global rowctxmenu selectedline rowmenuid curview
8497 global nullid nullid2 fakerowmenu mainhead markedid
8501 if {$selectedline eq {} || [rowofcommit $id] eq $selectedline} {
8506 if {[info exists markedid] && $markedid ne $id} {
8511 if {$id ne $nullid && $id ne $nullid2} {
8512 set menu $rowctxmenu
8513 if {$mainhead ne {}} {
8514 $menu entryconfigure 7 -label [mc "Reset %s branch to here" $mainhead] -state normal
8516 $menu entryconfigure 7 -label [mc "Detached head: can't reset" $mainhead] -state disabled
8518 $menu entryconfigure 9 -state $mstate
8519 $menu entryconfigure 10 -state $mstate
8520 $menu entryconfigure 11 -state $mstate
8522 set menu $fakerowmenu
8524 $menu entryconfigure [mca "Diff this -> selected"] -state $state
8525 $menu entryconfigure [mca "Diff selected -> this"] -state $state
8526 $menu entryconfigure [mca "Make patch"] -state $state
8527 $menu entryconfigure [mca "Diff this -> marked commit"] -state $mstate
8528 $menu entryconfigure [mca "Diff marked commit -> this"] -state $mstate
8529 tk_popup $menu $x $y
8533 global rowmenuid markedid canv
8535 set markedid $rowmenuid
8536 make_idmark $markedid
8542 if {[info exists markedid]} {
8547 proc replace_by_kids {l r} {
8548 global curview children
8550 set id [commitonrow $r]
8551 set l [lreplace $l 0 0]
8552 foreach kid $children($curview,$id) {
8553 lappend l [rowofcommit $kid]
8555 return [lsort -integer -decreasing -unique $l]
8558 proc find_common_desc {} {
8559 global markedid rowmenuid curview children
8561 if {![info exists markedid]} return
8562 if {![commitinview $markedid $curview] ||
8563 ![commitinview $rowmenuid $curview]} return
8564 #set t1 [clock clicks -milliseconds]
8565 set l1 [list [rowofcommit $markedid]]
8566 set l2 [list [rowofcommit $rowmenuid]]
8568 set r1 [lindex $l1 0]
8569 set r2 [lindex $l2 0]
8570 if {$r1 eq {} || $r2 eq {}} break
8576 set l1 [replace_by_kids $l1 $r1]
8578 set l2 [replace_by_kids $l2 $r2]
8581 #set t2 [clock clicks -milliseconds]
8582 #puts "took [expr {$t2-$t1}]ms"
8585 proc compare_commits {} {
8586 global markedid rowmenuid curview children
8588 if {![info exists markedid]} return
8589 if {![commitinview $markedid $curview]} return
8590 addtohistory [list do_cmp_commits $markedid $rowmenuid]
8591 do_cmp_commits $markedid $rowmenuid
8594 proc getpatchid {id} {
8597 if {![info exists patchids($id)]} {
8598 set cmd [diffcmd [list $id] {-p --root}]
8599 # trim off the initial "|"
8600 set cmd [lrange $cmd 1 end]
8602 set x [eval exec $cmd | git patch-id]
8603 set patchids($id) [lindex $x 0]
8605 set patchids($id) "error"
8608 return $patchids($id)
8611 proc do_cmp_commits {a b} {
8612 global ctext curview parents children patchids commitinfo
8614 $ctext conf -state normal
8617 for {set i 0} {$i < 100} {incr i} {
8620 if {[llength $parents($curview,$a)] > 1} {
8621 appendshortlink $a [mc "Skipping merge commit "] "\n"
8624 set patcha [getpatchid $a]
8626 if {[llength $parents($curview,$b)] > 1} {
8627 appendshortlink $b [mc "Skipping merge commit "] "\n"
8630 set patchb [getpatchid $b]
8632 if {!$skipa && !$skipb} {
8633 set heada [lindex $commitinfo($a) 0]
8634 set headb [lindex $commitinfo($b) 0]
8635 if {$patcha eq "error"} {
8636 appendshortlink $a [mc "Error getting patch ID for "] \
8637 [mc " - stopping\n"]
8640 if {$patchb eq "error"} {
8641 appendshortlink $b [mc "Error getting patch ID for "] \
8642 [mc " - stopping\n"]
8645 if {$patcha eq $patchb} {
8646 if {$heada eq $headb} {
8647 appendshortlink $a [mc "Commit "]
8648 appendshortlink $b " == " " $heada\n"
8650 appendshortlink $a [mc "Commit "] " $heada\n"
8651 appendshortlink $b [mc " is the same patch as\n "] \
8657 $ctext insert end "\n"
8658 appendshortlink $a [mc "Commit "] " $heada\n"
8659 appendshortlink $b [mc " differs from\n "] \
8661 $ctext insert end [mc "Diff of commits:\n\n"]
8662 $ctext conf -state disabled
8669 set kids [real_children $curview,$a]
8670 if {[llength $kids] != 1} {
8671 $ctext insert end "\n"
8672 appendshortlink $a [mc "Commit "] \
8673 [mc " has %s children - stopping\n" [llength $kids]]
8676 set a [lindex $kids 0]
8679 set kids [real_children $curview,$b]
8680 if {[llength $kids] != 1} {
8681 appendshortlink $b [mc "Commit "] \
8682 [mc " has %s children - stopping\n" [llength $kids]]
8685 set b [lindex $kids 0]
8688 $ctext conf -state disabled
8691 proc diffcommits {a b} {
8692 global diffcontext diffids blobdifffd diffinhdr currdiffsubmod
8694 set tmpdir [gitknewtmpdir]
8695 set fna [file join $tmpdir "commit-[string range $a 0 7]"]
8696 set fnb [file join $tmpdir "commit-[string range $b 0 7]"]
8698 exec git diff-tree -p --pretty $a >$fna
8699 exec git diff-tree -p --pretty $b >$fnb
8701 error_popup [mc "Error writing commit to file: %s" $err]
8705 set fd [open "| diff -U$diffcontext $fna $fnb" r]
8707 error_popup [mc "Error diffing commits: %s" $err]
8710 set diffids [list commits $a $b]
8711 set blobdifffd($diffids) $fd
8713 set currdiffsubmod ""
8714 filerun $fd [list getblobdiffline $fd $diffids]
8717 proc diffvssel {dirn} {
8718 global rowmenuid selectedline
8720 if {$selectedline eq {}} return
8722 set oldid [commitonrow $selectedline]
8723 set newid $rowmenuid
8725 set oldid $rowmenuid
8726 set newid [commitonrow $selectedline]
8728 addtohistory [list doseldiff $oldid $newid] savectextpos
8729 doseldiff $oldid $newid
8732 proc diffvsmark {dirn} {
8733 global rowmenuid markedid
8735 if {![info exists markedid]} return
8738 set newid $rowmenuid
8740 set oldid $rowmenuid
8743 addtohistory [list doseldiff $oldid $newid] savectextpos
8744 doseldiff $oldid $newid
8747 proc doseldiff {oldid newid} {
8751 $ctext conf -state normal
8753 init_flist [mc "Top"]
8754 $ctext insert end "[mc "From"] "
8755 $ctext insert end $oldid link0
8756 setlink $oldid link0
8757 $ctext insert end "\n "
8758 $ctext insert end [lindex $commitinfo($oldid) 0]
8759 $ctext insert end "\n\n[mc "To"] "
8760 $ctext insert end $newid link1
8761 setlink $newid link1
8762 $ctext insert end "\n "
8763 $ctext insert end [lindex $commitinfo($newid) 0]
8764 $ctext insert end "\n"
8765 $ctext conf -state disabled
8766 $ctext tag remove found 1.0 end
8767 startdiff [list $oldid $newid]
8771 global rowmenuid currentid commitinfo patchtop patchnum NS
8773 if {![info exists currentid]} return
8774 set oldid $currentid
8775 set oldhead [lindex $commitinfo($oldid) 0]
8776 set newid $rowmenuid
8777 set newhead [lindex $commitinfo($newid) 0]
8780 catch {destroy $top}
8782 make_transient $top .
8783 ${NS}::label $top.title -text [mc "Generate patch"]
8784 grid $top.title - -pady 10
8785 ${NS}::label $top.from -text [mc "From:"]
8786 ${NS}::entry $top.fromsha1 -width 40
8787 $top.fromsha1 insert 0 $oldid
8788 $top.fromsha1 conf -state readonly
8789 grid $top.from $top.fromsha1 -sticky w
8790 ${NS}::entry $top.fromhead -width 60
8791 $top.fromhead insert 0 $oldhead
8792 $top.fromhead conf -state readonly
8793 grid x $top.fromhead -sticky w
8794 ${NS}::label $top.to -text [mc "To:"]
8795 ${NS}::entry $top.tosha1 -width 40
8796 $top.tosha1 insert 0 $newid
8797 $top.tosha1 conf -state readonly
8798 grid $top.to $top.tosha1 -sticky w
8799 ${NS}::entry $top.tohead -width 60
8800 $top.tohead insert 0 $newhead
8801 $top.tohead conf -state readonly
8802 grid x $top.tohead -sticky w
8803 ${NS}::button $top.rev -text [mc "Reverse"] -command mkpatchrev
8804 grid $top.rev x -pady 10 -padx 5
8805 ${NS}::label $top.flab -text [mc "Output file:"]
8806 ${NS}::entry $top.fname -width 60
8807 $top.fname insert 0 [file normalize "patch$patchnum.patch"]
8809 grid $top.flab $top.fname -sticky w
8810 ${NS}::frame $top.buts
8811 ${NS}::button $top.buts.gen -text [mc "Generate"] -command mkpatchgo
8812 ${NS}::button $top.buts.can -text [mc "Cancel"] -command mkpatchcan
8813 bind $top <Key-Return> mkpatchgo
8814 bind $top <Key-Escape> mkpatchcan
8815 grid $top.buts.gen $top.buts.can
8816 grid columnconfigure $top.buts 0 -weight 1 -uniform a
8817 grid columnconfigure $top.buts 1 -weight 1 -uniform a
8818 grid $top.buts - -pady 10 -sticky ew
8822 proc mkpatchrev {} {
8825 set oldid [$patchtop.fromsha1 get]
8826 set oldhead [$patchtop.fromhead get]
8827 set newid [$patchtop.tosha1 get]
8828 set newhead [$patchtop.tohead get]
8829 foreach e [list fromsha1 fromhead tosha1 tohead] \
8830 v [list $newid $newhead $oldid $oldhead] {
8831 $patchtop.$e conf -state normal
8832 $patchtop.$e delete 0 end
8833 $patchtop.$e insert 0 $v
8834 $patchtop.$e conf -state readonly
8839 global patchtop nullid nullid2
8841 set oldid [$patchtop.fromsha1 get]
8842 set newid [$patchtop.tosha1 get]
8843 set fname [$patchtop.fname get]
8844 set cmd [diffcmd [list $oldid $newid] -p]
8845 # trim off the initial "|"
8846 set cmd [lrange $cmd 1 end]
8847 lappend cmd >$fname &
8848 if {[catch {eval exec $cmd} err]} {
8849 error_popup "[mc "Error creating patch:"] $err" $patchtop
8851 catch {destroy $patchtop}
8855 proc mkpatchcan {} {
8858 catch {destroy $patchtop}
8863 global rowmenuid mktagtop commitinfo NS
8867 catch {destroy $top}
8869 make_transient $top .
8870 ${NS}::label $top.title -text [mc "Create tag"]
8871 grid $top.title - -pady 10
8872 ${NS}::label $top.id -text [mc "ID:"]
8873 ${NS}::entry $top.sha1 -width 40
8874 $top.sha1 insert 0 $rowmenuid
8875 $top.sha1 conf -state readonly
8876 grid $top.id $top.sha1 -sticky w
8877 ${NS}::entry $top.head -width 60
8878 $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
8879 $top.head conf -state readonly
8880 grid x $top.head -sticky w
8881 ${NS}::label $top.tlab -text [mc "Tag name:"]
8882 ${NS}::entry $top.tag -width 60
8883 grid $top.tlab $top.tag -sticky w
8884 ${NS}::label $top.op -text [mc "Tag message is optional"]
8885 grid $top.op -columnspan 2 -sticky we
8886 ${NS}::label $top.mlab -text [mc "Tag message:"]
8887 ${NS}::entry $top.msg -width 60
8888 grid $top.mlab $top.msg -sticky w
8889 ${NS}::frame $top.buts
8890 ${NS}::button $top.buts.gen -text [mc "Create"] -command mktaggo
8891 ${NS}::button $top.buts.can -text [mc "Cancel"] -command mktagcan
8892 bind $top <Key-Return> mktaggo
8893 bind $top <Key-Escape> mktagcan
8894 grid $top.buts.gen $top.buts.can
8895 grid columnconfigure $top.buts 0 -weight 1 -uniform a
8896 grid columnconfigure $top.buts 1 -weight 1 -uniform a
8897 grid $top.buts - -pady 10 -sticky ew
8902 global mktagtop env tagids idtags
8904 set id [$mktagtop.sha1 get]
8905 set tag [$mktagtop.tag get]
8906 set msg [$mktagtop.msg get]
8908 error_popup [mc "No tag name specified"] $mktagtop
8911 if {[info exists tagids($tag)]} {
8912 error_popup [mc "Tag \"%s\" already exists" $tag] $mktagtop
8917 exec git tag -a -m $msg $tag $id
8919 exec git tag $tag $id
8922 error_popup "[mc "Error creating tag:"] $err" $mktagtop
8926 set tagids($tag) $id
8927 lappend idtags($id) $tag
8935 proc redrawtags {id} {
8936 global canv linehtag idpos currentid curview cmitlisted markedid
8937 global canvxmax iddrawn circleitem mainheadid circlecolors
8939 if {![commitinview $id $curview]} return
8940 if {![info exists iddrawn($id)]} return
8941 set row [rowofcommit $id]
8942 if {$id eq $mainheadid} {
8945 set ofill [lindex $circlecolors $cmitlisted($curview,$id)]
8947 $canv itemconf $circleitem($row) -fill $ofill
8948 $canv delete tag.$id
8949 set xt [eval drawtags $id $idpos($id)]
8950 $canv coords $linehtag($id) $xt [lindex $idpos($id) 2]
8951 set text [$canv itemcget $linehtag($id) -text]
8952 set font [$canv itemcget $linehtag($id) -font]
8953 set xr [expr {$xt + [font measure $font $text]}]
8954 if {$xr > $canvxmax} {
8958 if {[info exists currentid] && $currentid == $id} {
8961 if {[info exists markedid] && $markedid eq $id} {
8969 catch {destroy $mktagtop}
8974 if {![domktag]} return
8978 proc writecommit {} {
8979 global rowmenuid wrcomtop commitinfo wrcomcmd NS
8981 set top .writecommit
8983 catch {destroy $top}
8985 make_transient $top .
8986 ${NS}::label $top.title -text [mc "Write commit to file"]
8987 grid $top.title - -pady 10
8988 ${NS}::label $top.id -text [mc "ID:"]
8989 ${NS}::entry $top.sha1 -width 40
8990 $top.sha1 insert 0 $rowmenuid
8991 $top.sha1 conf -state readonly
8992 grid $top.id $top.sha1 -sticky w
8993 ${NS}::entry $top.head -width 60
8994 $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
8995 $top.head conf -state readonly
8996 grid x $top.head -sticky w
8997 ${NS}::label $top.clab -text [mc "Command:"]
8998 ${NS}::entry $top.cmd -width 60 -textvariable wrcomcmd
8999 grid $top.clab $top.cmd -sticky w -pady 10
9000 ${NS}::label $top.flab -text [mc "Output file:"]
9001 ${NS}::entry $top.fname -width 60
9002 $top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
9003 grid $top.flab $top.fname -sticky w
9004 ${NS}::frame $top.buts
9005 ${NS}::button $top.buts.gen -text [mc "Write"] -command wrcomgo
9006 ${NS}::button $top.buts.can -text [mc "Cancel"] -command wrcomcan
9007 bind $top <Key-Return> wrcomgo
9008 bind $top <Key-Escape> wrcomcan
9009 grid $top.buts.gen $top.buts.can
9010 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9011 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9012 grid $top.buts - -pady 10 -sticky ew
9019 set id [$wrcomtop.sha1 get]
9020 set cmd "echo $id | [$wrcomtop.cmd get]"
9021 set fname [$wrcomtop.fname get]
9022 if {[catch {exec sh -c $cmd >$fname &} err]} {
9023 error_popup "[mc "Error writing commit:"] $err" $wrcomtop
9025 catch {destroy $wrcomtop}
9032 catch {destroy $wrcomtop}
9037 global rowmenuid mkbrtop NS
9040 catch {destroy $top}
9042 make_transient $top .
9043 ${NS}::label $top.title -text [mc "Create new branch"]
9044 grid $top.title - -pady 10
9045 ${NS}::label $top.id -text [mc "ID:"]
9046 ${NS}::entry $top.sha1 -width 40
9047 $top.sha1 insert 0 $rowmenuid
9048 $top.sha1 conf -state readonly
9049 grid $top.id $top.sha1 -sticky w
9050 ${NS}::label $top.nlab -text [mc "Name:"]
9051 ${NS}::entry $top.name -width 40
9052 grid $top.nlab $top.name -sticky w
9053 ${NS}::frame $top.buts
9054 ${NS}::button $top.buts.go -text [mc "Create"] -command [list mkbrgo $top]
9055 ${NS}::button $top.buts.can -text [mc "Cancel"] -command "catch {destroy $top}"
9056 bind $top <Key-Return> [list mkbrgo $top]
9057 bind $top <Key-Escape> "catch {destroy $top}"
9058 grid $top.buts.go $top.buts.can
9059 grid columnconfigure $top.buts 0 -weight 1 -uniform a
9060 grid columnconfigure $top.buts 1 -weight 1 -uniform a
9061 grid $top.buts - -pady 10 -sticky ew
9066 global headids idheads
9068 set name [$top.name get]
9069 set id [$top.sha1 get]
9073 error_popup [mc "Please specify a name for the new branch"] $top
9076 if {[info exists headids($name)]} {
9077 if {![confirm_popup [mc \
9078 "Branch '%s' already exists. Overwrite?" $name] $top]} {
9081 set old_id $headids($name)
9084 catch {destroy $top}
9085 lappend cmdargs $name $id
9089 eval exec git branch $cmdargs
9095 if {$old_id ne {}} {
9101 set headids($name) $id
9102 lappend idheads($id) $name
9111 proc exec_citool {tool_args {baseid {}}} {
9112 global commitinfo env
9114 set save_env [array get env GIT_AUTHOR_*]
9116 if {$baseid ne {}} {
9117 if {![info exists commitinfo($baseid)]} {
9120 set author [lindex $commitinfo($baseid) 1]
9121 set date [lindex $commitinfo($baseid) 2]
9122 if {[regexp {^\s*(\S.*\S|\S)\s*<(.*)>\s*$} \
9123 $author author name email]
9125 set env(GIT_AUTHOR_NAME) $name
9126 set env(GIT_AUTHOR_EMAIL) $email
9127 set env(GIT_AUTHOR_DATE) $date
9131 eval exec git citool $tool_args &
9133 array unset env GIT_AUTHOR_*
9134 array set env $save_env
9137 proc cherrypick {} {
9138 global rowmenuid curview
9139 global mainhead mainheadid
9142 set oldhead [exec git rev-parse HEAD]
9143 set dheads [descheads $rowmenuid]
9144 if {$dheads ne {} && [lsearch -exact $dheads $oldhead] >= 0} {
9145 set ok [confirm_popup [mc "Commit %s is already\
9146 included in branch %s -- really re-apply it?" \
9147 [string range $rowmenuid 0 7] $mainhead]]
9150 nowbusy cherrypick [mc "Cherry-picking"]
9152 # Unfortunately git-cherry-pick writes stuff to stderr even when
9153 # no error occurs, and exec takes that as an indication of error...
9154 if {[catch {exec sh -c "git cherry-pick -r $rowmenuid 2>&1"} err]} {
9157 {Entry '(.*)' (would be overwritten by merge|not uptodate)} \
9159 error_popup [mc "Cherry-pick failed because of local changes\
9160 to file '%s'.\nPlease commit, reset or stash\
9161 your changes and try again." $fname]
9162 } elseif {[regexp -line \
9163 {^(CONFLICT \(.*\):|Automatic cherry-pick failed|error: could not apply)} \
9165 if {[confirm_popup [mc "Cherry-pick failed because of merge\
9166 conflict.\nDo you wish to run git citool to\
9168 # Force citool to read MERGE_MSG
9169 file delete [file join $gitdir "GITGUI_MSG"]
9170 exec_citool {} $rowmenuid
9178 set newhead [exec git rev-parse HEAD]
9179 if {$newhead eq $oldhead} {
9181 error_popup [mc "No changes committed"]
9184 addnewchild $newhead $oldhead
9185 if {[commitinview $oldhead $curview]} {
9186 # XXX this isn't right if we have a path limit...
9187 insertrow $newhead $oldhead $curview
9188 if {$mainhead ne {}} {
9189 movehead $newhead $mainhead
9190 movedhead $newhead $mainhead
9192 set mainheadid $newhead
9201 global mainhead rowmenuid confirm_ok resettype NS
9204 set w ".confirmreset"
9207 wm title $w [mc "Confirm reset"]
9208 ${NS}::label $w.m -text \
9209 [mc "Reset branch %s to %s?" $mainhead [string range $rowmenuid 0 7]]
9210 pack $w.m -side top -fill x -padx 20 -pady 20
9211 ${NS}::labelframe $w.f -text [mc "Reset type:"]
9213 ${NS}::radiobutton $w.f.soft -value soft -variable resettype \
9214 -text [mc "Soft: Leave working tree and index untouched"]
9215 grid $w.f.soft -sticky w
9216 ${NS}::radiobutton $w.f.mixed -value mixed -variable resettype \
9217 -text [mc "Mixed: Leave working tree untouched, reset index"]
9218 grid $w.f.mixed -sticky w
9219 ${NS}::radiobutton $w.f.hard -value hard -variable resettype \
9220 -text [mc "Hard: Reset working tree and index\n(discard ALL local changes)"]
9221 grid $w.f.hard -sticky w
9222 pack $w.f -side top -fill x -padx 4
9223 ${NS}::button $w.ok -text [mc OK] -command "set confirm_ok 1; destroy $w"
9224 pack $w.ok -side left -fill x -padx 20 -pady 20
9225 ${NS}::button $w.cancel -text [mc Cancel] -command "destroy $w"
9226 bind $w <Key-Escape> [list destroy $w]
9227 pack $w.cancel -side right -fill x -padx 20 -pady 20
9228 bind $w <Visibility> "grab $w; focus $w"
9230 if {!$confirm_ok} return
9231 if {[catch {set fd [open \
9232 [list | git reset --$resettype $rowmenuid 2>@1] r]} err]} {
9236 filerun $fd [list readresetstat $fd]
9237 nowbusy reset [mc "Resetting"]
9242 proc readresetstat {fd} {
9243 global mainhead mainheadid showlocalchanges rprogcoord
9245 if {[gets $fd line] >= 0} {
9246 if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
9247 set rprogcoord [expr {1.0 * $m / $n}]
9255 if {[catch {close $fd} err]} {
9258 set oldhead $mainheadid
9259 set newhead [exec git rev-parse HEAD]
9260 if {$newhead ne $oldhead} {
9261 movehead $newhead $mainhead
9262 movedhead $newhead $mainhead
9263 set mainheadid $newhead
9267 if {$showlocalchanges} {
9273 # context menu for a head
9274 proc headmenu {x y id head} {
9275 global headmenuid headmenuhead headctxmenu mainhead
9279 set headmenuhead $head
9281 if {[string match "remotes/*" $head]} {
9284 if {$head eq $mainhead} {
9287 $headctxmenu entryconfigure 0 -state $state
9288 $headctxmenu entryconfigure 1 -state $state
9289 tk_popup $headctxmenu $x $y
9293 global headmenuid headmenuhead headids
9294 global showlocalchanges
9296 # check the tree is clean first??
9297 nowbusy checkout [mc "Checking out"]
9301 set fd [open [list | git checkout $headmenuhead 2>@1] r]
9305 if {$showlocalchanges} {
9309 filerun $fd [list readcheckoutstat $fd $headmenuhead $headmenuid]
9313 proc readcheckoutstat {fd newhead newheadid} {
9314 global mainhead mainheadid headids showlocalchanges progresscoords
9315 global viewmainheadid curview
9317 if {[gets $fd line] >= 0} {
9318 if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
9319 set progresscoords [list 0 [expr {1.0 * $m / $n}]]
9324 set progresscoords {0 0}
9327 if {[catch {close $fd} err]} {
9330 set oldmainid $mainheadid
9331 set mainhead $newhead
9332 set mainheadid $newheadid
9333 set viewmainheadid($curview) $newheadid
9334 redrawtags $oldmainid
9335 redrawtags $newheadid
9337 if {$showlocalchanges} {
9343 global headmenuid headmenuhead mainhead
9346 set head $headmenuhead
9348 # this check shouldn't be needed any more...
9349 if {$head eq $mainhead} {
9350 error_popup [mc "Cannot delete the currently checked-out branch"]
9353 set dheads [descheads $id]
9354 if {[llength $dheads] == 1 && $idheads($dheads) eq $head} {
9355 # the stuff on this branch isn't on any other branch
9356 if {![confirm_popup [mc "The commits on branch %s aren't on any other\
9357 branch.\nReally delete branch %s?" $head $head]]} return
9361 if {[catch {exec git branch -D $head} err]} {
9366 removehead $id $head
9367 removedhead $id $head
9374 # Display a list of tags and heads
9376 global showrefstop bgcolor fgcolor selectbgcolor NS
9377 global bglist fglist reflistfilter reflist maincursor
9380 set showrefstop $top
9381 if {[winfo exists $top]} {
9387 wm title $top [mc "Tags and heads: %s" [file tail [pwd]]]
9388 make_transient $top .
9389 text $top.list -background $bgcolor -foreground $fgcolor \
9390 -selectbackground $selectbgcolor -font mainfont \
9391 -xscrollcommand "$top.xsb set" -yscrollcommand "$top.ysb set" \
9392 -width 30 -height 20 -cursor $maincursor \
9393 -spacing1 1 -spacing3 1 -state disabled
9394 $top.list tag configure highlight -background $selectbgcolor
9395 lappend bglist $top.list
9396 lappend fglist $top.list
9397 ${NS}::scrollbar $top.ysb -command "$top.list yview" -orient vertical
9398 ${NS}::scrollbar $top.xsb -command "$top.list xview" -orient horizontal
9399 grid $top.list $top.ysb -sticky nsew
9400 grid $top.xsb x -sticky ew
9402 ${NS}::label $top.f.l -text "[mc "Filter"]: "
9403 ${NS}::entry $top.f.e -width 20 -textvariable reflistfilter
9404 set reflistfilter "*"
9405 trace add variable reflistfilter write reflistfilter_change
9406 pack $top.f.e -side right -fill x -expand 1
9407 pack $top.f.l -side left
9408 grid $top.f - -sticky ew -pady 2
9409 ${NS}::button $top.close -command [list destroy $top] -text [mc "Close"]
9410 bind $top <Key-Escape> [list destroy $top]
9412 grid columnconfigure $top 0 -weight 1
9413 grid rowconfigure $top 0 -weight 1
9414 bind $top.list <1> {break}
9415 bind $top.list <B1-Motion> {break}
9416 bind $top.list <ButtonRelease-1> {sel_reflist %W %x %y; break}
9421 proc sel_reflist {w x y} {
9422 global showrefstop reflist headids tagids otherrefids
9424 if {![winfo exists $showrefstop]} return
9425 set l [lindex [split [$w index "@$x,$y"] "."] 0]
9426 set ref [lindex $reflist [expr {$l-1}]]
9427 set n [lindex $ref 0]
9428 switch -- [lindex $ref 1] {
9429 "H" {selbyid $headids($n)}
9430 "T" {selbyid $tagids($n)}
9431 "o" {selbyid $otherrefids($n)}
9433 $showrefstop.list tag add highlight $l.0 "$l.0 lineend"
9436 proc unsel_reflist {} {
9439 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
9440 $showrefstop.list tag remove highlight 0.0 end
9443 proc reflistfilter_change {n1 n2 op} {
9444 global reflistfilter
9446 after cancel refill_reflist
9447 after 200 refill_reflist
9450 proc refill_reflist {} {
9451 global reflist reflistfilter showrefstop headids tagids otherrefids
9454 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
9456 foreach n [array names headids] {
9457 if {[string match $reflistfilter $n]} {
9458 if {[commitinview $headids($n) $curview]} {
9459 lappend refs [list $n H]
9461 interestedin $headids($n) {run refill_reflist}
9465 foreach n [array names tagids] {
9466 if {[string match $reflistfilter $n]} {
9467 if {[commitinview $tagids($n) $curview]} {
9468 lappend refs [list $n T]
9470 interestedin $tagids($n) {run refill_reflist}
9474 foreach n [array names otherrefids] {
9475 if {[string match $reflistfilter $n]} {
9476 if {[commitinview $otherrefids($n) $curview]} {
9477 lappend refs [list $n o]
9479 interestedin $otherrefids($n) {run refill_reflist}
9483 set refs [lsort -index 0 $refs]
9484 if {$refs eq $reflist} return
9486 # Update the contents of $showrefstop.list according to the
9487 # differences between $reflist (old) and $refs (new)
9488 $showrefstop.list conf -state normal
9489 $showrefstop.list insert end "\n"
9492 while {$i < [llength $reflist] || $j < [llength $refs]} {
9493 if {$i < [llength $reflist]} {
9494 if {$j < [llength $refs]} {
9495 set cmp [string compare [lindex $reflist $i 0] \
9496 [lindex $refs $j 0]]
9498 set cmp [string compare [lindex $reflist $i 1] \
9499 [lindex $refs $j 1]]
9509 $showrefstop.list delete "[expr {$j+1}].0" "[expr {$j+2}].0"
9517 set l [expr {$j + 1}]
9518 $showrefstop.list image create $l.0 -align baseline \
9519 -image reficon-[lindex $refs $j 1] -padx 2
9520 $showrefstop.list insert $l.1 "[lindex $refs $j 0]\n"
9526 # delete last newline
9527 $showrefstop.list delete end-2c end-1c
9528 $showrefstop.list conf -state disabled
9531 # Stuff for finding nearby tags
9532 proc getallcommits {} {
9533 global allcommits nextarc seeds allccache allcwait cachedarcs allcupdate
9534 global idheads idtags idotherrefs allparents tagobjid
9537 if {![info exists allcommits]} {
9543 set allccache [file join $gitdir "gitk.cache"]
9545 set f [open $allccache r]
9554 set cmd [list | git rev-list --parents]
9555 set allcupdate [expr {$seeds ne {}}]
9559 set refs [concat [array names idheads] [array names idtags] \
9560 [array names idotherrefs]]
9563 foreach name [array names tagobjid] {
9564 lappend tagobjs $tagobjid($name)
9566 foreach id [lsort -unique $refs] {
9567 if {![info exists allparents($id)] &&
9568 [lsearch -exact $tagobjs $id] < 0} {
9579 set fd [open [concat $cmd $ids] r]
9580 fconfigure $fd -blocking 0
9583 filerun $fd [list getallclines $fd]
9589 # Since most commits have 1 parent and 1 child, we group strings of
9590 # such commits into "arcs" joining branch/merge points (BMPs), which
9591 # are commits that either don't have 1 parent or don't have 1 child.
9593 # arcnos(id) - incoming arcs for BMP, arc we're on for other nodes
9594 # arcout(id) - outgoing arcs for BMP
9595 # arcids(a) - list of IDs on arc including end but not start
9596 # arcstart(a) - BMP ID at start of arc
9597 # arcend(a) - BMP ID at end of arc
9598 # growing(a) - arc a is still growing
9599 # arctags(a) - IDs out of arcids (excluding end) that have tags
9600 # archeads(a) - IDs out of arcids (excluding end) that have heads
9601 # The start of an arc is at the descendent end, so "incoming" means
9602 # coming from descendents, and "outgoing" means going towards ancestors.
9604 proc getallclines {fd} {
9605 global allparents allchildren idtags idheads nextarc
9606 global arcnos arcids arctags arcout arcend arcstart archeads growing
9607 global seeds allcommits cachedarcs allcupdate
9610 while {[incr nid] <= 1000 && [gets $fd line] >= 0} {
9611 set id [lindex $line 0]
9612 if {[info exists allparents($id)]} {
9617 set olds [lrange $line 1 end]
9618 set allparents($id) $olds
9619 if {![info exists allchildren($id)]} {
9620 set allchildren($id) {}
9625 if {[llength $olds] == 1 && [llength $a] == 1} {
9626 lappend arcids($a) $id
9627 if {[info exists idtags($id)]} {
9628 lappend arctags($a) $id
9630 if {[info exists idheads($id)]} {
9631 lappend archeads($a) $id
9633 if {[info exists allparents($olds)]} {
9634 # seen parent already
9635 if {![info exists arcout($olds)]} {
9638 lappend arcids($a) $olds
9639 set arcend($a) $olds
9642 lappend allchildren($olds) $id
9643 lappend arcnos($olds) $a
9647 foreach a $arcnos($id) {
9648 lappend arcids($a) $id
9655 lappend allchildren($p) $id
9656 set a [incr nextarc]
9657 set arcstart($a) $id
9664 if {[info exists allparents($p)]} {
9665 # seen it already, may need to make a new branch
9666 if {![info exists arcout($p)]} {
9669 lappend arcids($a) $p
9673 lappend arcnos($p) $a
9678 global cached_dheads cached_dtags cached_atags
9679 catch {unset cached_dheads}
9680 catch {unset cached_dtags}
9681 catch {unset cached_atags}
9684 return [expr {$nid >= 1000? 2: 1}]
9688 fconfigure $fd -blocking 1
9691 # got an error reading the list of commits
9692 # if we were updating, try rereading the whole thing again
9698 error_popup "[mc "Error reading commit topology information;\
9699 branch and preceding/following tag information\
9700 will be incomplete."]\n($err)"
9703 if {[incr allcommits -1] == 0} {
9713 proc recalcarc {a} {
9714 global arctags archeads arcids idtags idheads
9718 foreach id [lrange $arcids($a) 0 end-1] {
9719 if {[info exists idtags($id)]} {
9722 if {[info exists idheads($id)]} {
9727 set archeads($a) $ah
9731 global arcnos arcids nextarc arctags archeads idtags idheads
9732 global arcstart arcend arcout allparents growing
9735 if {[llength $a] != 1} {
9736 puts "oops splitarc called but [llength $a] arcs already"
9740 set i [lsearch -exact $arcids($a) $p]
9742 puts "oops splitarc $p not in arc $a"
9745 set na [incr nextarc]
9746 if {[info exists arcend($a)]} {
9747 set arcend($na) $arcend($a)
9749 set l [lindex $allparents([lindex $arcids($a) end]) 0]
9750 set j [lsearch -exact $arcnos($l) $a]
9751 set arcnos($l) [lreplace $arcnos($l) $j $j $na]
9753 set tail [lrange $arcids($a) [expr {$i+1}] end]
9754 set arcids($a) [lrange $arcids($a) 0 $i]
9756 set arcstart($na) $p
9758 set arcids($na) $tail
9759 if {[info exists growing($a)]} {
9765 if {[llength $arcnos($id)] == 1} {
9768 set j [lsearch -exact $arcnos($id) $a]
9769 set arcnos($id) [lreplace $arcnos($id) $j $j $na]
9773 # reconstruct tags and heads lists
9774 if {$arctags($a) ne {} || $archeads($a) ne {}} {
9779 set archeads($na) {}
9783 # Update things for a new commit added that is a child of one
9784 # existing commit. Used when cherry-picking.
9785 proc addnewchild {id p} {
9786 global allparents allchildren idtags nextarc
9787 global arcnos arcids arctags arcout arcend arcstart archeads growing
9788 global seeds allcommits
9790 if {![info exists allcommits] || ![info exists arcnos($p)]} return
9791 set allparents($id) [list $p]
9792 set allchildren($id) {}
9795 lappend allchildren($p) $id
9796 set a [incr nextarc]
9797 set arcstart($a) $id
9800 set arcids($a) [list $p]
9802 if {![info exists arcout($p)]} {
9805 lappend arcnos($p) $a
9806 set arcout($id) [list $a]
9809 # This implements a cache for the topology information.
9810 # The cache saves, for each arc, the start and end of the arc,
9811 # the ids on the arc, and the outgoing arcs from the end.
9812 proc readcache {f} {
9813 global arcnos arcids arcout arcstart arcend arctags archeads nextarc
9814 global idtags idheads allparents cachedarcs possible_seeds seeds growing
9819 if {$lim - $a > 500} {
9820 set lim [expr {$a + 500}]
9824 # finish reading the cache and setting up arctags, etc.
9826 if {$line ne "1"} {error "bad final version"}
9828 foreach id [array names idtags] {
9829 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
9830 [llength $allparents($id)] == 1} {
9831 set a [lindex $arcnos($id) 0]
9832 if {$arctags($a) eq {}} {
9837 foreach id [array names idheads] {
9838 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
9839 [llength $allparents($id)] == 1} {
9840 set a [lindex $arcnos($id) 0]
9841 if {$archeads($a) eq {}} {
9846 foreach id [lsort -unique $possible_seeds] {
9847 if {$arcnos($id) eq {}} {
9853 while {[incr a] <= $lim} {
9855 if {[llength $line] != 3} {error "bad line"}
9856 set s [lindex $line 0]
9858 lappend arcout($s) $a
9859 if {![info exists arcnos($s)]} {
9860 lappend possible_seeds $s
9863 set e [lindex $line 1]
9868 if {![info exists arcout($e)]} {
9872 set arcids($a) [lindex $line 2]
9873 foreach id $arcids($a) {
9874 lappend allparents($s) $id
9876 lappend arcnos($id) $a
9878 if {![info exists allparents($s)]} {
9879 set allparents($s) {}
9884 set nextarc [expr {$a - 1}]
9897 global nextarc cachedarcs possible_seeds
9901 if {[llength $line] != 2 || [lindex $line 0] ne "1"} {error "bad version"}
9902 # make sure it's an integer
9903 set cachedarcs [expr {int([lindex $line 1])}]
9904 if {$cachedarcs < 0} {error "bad number of arcs"}
9906 set possible_seeds {}
9914 proc dropcache {err} {
9915 global allcwait nextarc cachedarcs seeds
9917 #puts "dropping cache ($err)"
9918 foreach v {arcnos arcout arcids arcstart arcend growing \
9919 arctags archeads allparents allchildren} {
9930 proc writecache {f} {
9931 global cachearc cachedarcs allccache
9932 global arcstart arcend arcnos arcids arcout
9936 if {$lim - $a > 1000} {
9937 set lim [expr {$a + 1000}]
9940 while {[incr a] <= $lim} {
9941 if {[info exists arcend($a)]} {
9942 puts $f [list $arcstart($a) $arcend($a) $arcids($a)]
9944 puts $f [list $arcstart($a) {} $arcids($a)]
9949 catch {file delete $allccache}
9950 #puts "writing cache failed ($err)"
9953 set cachearc [expr {$a - 1}]
9954 if {$a > $cachedarcs} {
9963 global nextarc cachedarcs cachearc allccache
9965 if {$nextarc == $cachedarcs} return
9967 set cachedarcs $nextarc
9969 set f [open $allccache w]
9970 puts $f [list 1 $cachedarcs]
9975 # Returns 1 if a is an ancestor of b, -1 if b is an ancestor of a,
9976 # or 0 if neither is true.
9977 proc anc_or_desc {a b} {
9978 global arcout arcstart arcend arcnos cached_isanc
9980 if {$arcnos($a) eq $arcnos($b)} {
9981 # Both are on the same arc(s); either both are the same BMP,
9982 # or if one is not a BMP, the other is also not a BMP or is
9983 # the BMP at end of the arc (and it only has 1 incoming arc).
9984 # Or both can be BMPs with no incoming arcs.
9985 if {$a eq $b || $arcnos($a) eq {}} {
9988 # assert {[llength $arcnos($a)] == 1}
9989 set arc [lindex $arcnos($a) 0]
9990 set i [lsearch -exact $arcids($arc) $a]
9991 set j [lsearch -exact $arcids($arc) $b]
9992 if {$i < 0 || $i > $j} {
9999 if {![info exists arcout($a)]} {
10000 set arc [lindex $arcnos($a) 0]
10001 if {[info exists arcend($arc)]} {
10002 set aend $arcend($arc)
10006 set a $arcstart($arc)
10010 if {![info exists arcout($b)]} {
10011 set arc [lindex $arcnos($b) 0]
10012 if {[info exists arcend($arc)]} {
10013 set bend $arcend($arc)
10017 set b $arcstart($arc)
10027 if {[info exists cached_isanc($a,$bend)]} {
10028 if {$cached_isanc($a,$bend)} {
10032 if {[info exists cached_isanc($b,$aend)]} {
10033 if {$cached_isanc($b,$aend)} {
10036 if {[info exists cached_isanc($a,$bend)]} {
10041 set todo [list $a $b]
10044 for {set i 0} {$i < [llength $todo]} {incr i} {
10045 set x [lindex $todo $i]
10046 if {$anc($x) eq {}} {
10049 foreach arc $arcnos($x) {
10050 set xd $arcstart($arc)
10051 if {$xd eq $bend} {
10052 set cached_isanc($a,$bend) 1
10053 set cached_isanc($b,$aend) 0
10055 } elseif {$xd eq $aend} {
10056 set cached_isanc($b,$aend) 1
10057 set cached_isanc($a,$bend) 0
10060 if {![info exists anc($xd)]} {
10061 set anc($xd) $anc($x)
10063 } elseif {$anc($xd) ne $anc($x)} {
10068 set cached_isanc($a,$bend) 0
10069 set cached_isanc($b,$aend) 0
10073 # This identifies whether $desc has an ancestor that is
10074 # a growing tip of the graph and which is not an ancestor of $anc
10075 # and returns 0 if so and 1 if not.
10076 # If we subsequently discover a tag on such a growing tip, and that
10077 # turns out to be a descendent of $anc (which it could, since we
10078 # don't necessarily see children before parents), then $desc
10079 # isn't a good choice to display as a descendent tag of
10080 # $anc (since it is the descendent of another tag which is
10081 # a descendent of $anc). Similarly, $anc isn't a good choice to
10082 # display as a ancestor tag of $desc.
10084 proc is_certain {desc anc} {
10085 global arcnos arcout arcstart arcend growing problems
10088 if {[llength $arcnos($anc)] == 1} {
10089 # tags on the same arc are certain
10090 if {$arcnos($desc) eq $arcnos($anc)} {
10093 if {![info exists arcout($anc)]} {
10094 # if $anc is partway along an arc, use the start of the arc instead
10095 set a [lindex $arcnos($anc) 0]
10096 set anc $arcstart($a)
10099 if {[llength $arcnos($desc)] > 1 || [info exists arcout($desc)]} {
10102 set a [lindex $arcnos($desc) 0]
10108 set anclist [list $x]
10112 for {set i 0} {$i < [llength $anclist] && ($nnh > 0 || $ngrowanc > 0)} {incr i} {
10113 set x [lindex $anclist $i]
10118 foreach a $arcout($x) {
10119 if {[info exists growing($a)]} {
10120 if {![info exists growanc($x)] && $dl($x)} {
10126 if {[info exists dl($y)]} {
10130 if {![info exists done($y)]} {
10133 if {[info exists growanc($x)]} {
10137 for {set k 0} {$k < [llength $xl]} {incr k} {
10138 set z [lindex $xl $k]
10139 foreach c $arcout($z) {
10140 if {[info exists arcend($c)]} {
10142 if {[info exists dl($v)] && $dl($v)} {
10144 if {![info exists done($v)]} {
10147 if {[info exists growanc($v)]} {
10157 } elseif {$y eq $anc || !$dl($x)} {
10168 foreach x [array names growanc] {
10177 proc validate_arctags {a} {
10178 global arctags idtags
10181 set na $arctags($a)
10182 foreach id $arctags($a) {
10184 if {![info exists idtags($id)]} {
10185 set na [lreplace $na $i $i]
10189 set arctags($a) $na
10192 proc validate_archeads {a} {
10193 global archeads idheads
10196 set na $archeads($a)
10197 foreach id $archeads($a) {
10199 if {![info exists idheads($id)]} {
10200 set na [lreplace $na $i $i]
10204 set archeads($a) $na
10207 # Return the list of IDs that have tags that are descendents of id,
10208 # ignoring IDs that are descendents of IDs already reported.
10209 proc desctags {id} {
10210 global arcnos arcstart arcids arctags idtags allparents
10211 global growing cached_dtags
10213 if {![info exists allparents($id)]} {
10216 set t1 [clock clicks -milliseconds]
10218 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10219 # part-way along an arc; check that arc first
10220 set a [lindex $arcnos($id) 0]
10221 if {$arctags($a) ne {}} {
10222 validate_arctags $a
10223 set i [lsearch -exact $arcids($a) $id]
10225 foreach t $arctags($a) {
10226 set j [lsearch -exact $arcids($a) $t]
10227 if {$j >= $i} break
10234 set id $arcstart($a)
10235 if {[info exists idtags($id)]} {
10239 if {[info exists cached_dtags($id)]} {
10240 return $cached_dtags($id)
10244 set todo [list $id]
10247 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
10248 set id [lindex $todo $i]
10250 set ta [info exists hastaggedancestor($id)]
10254 # ignore tags on starting node
10255 if {!$ta && $i > 0} {
10256 if {[info exists idtags($id)]} {
10257 set tagloc($id) $id
10259 } elseif {[info exists cached_dtags($id)]} {
10260 set tagloc($id) $cached_dtags($id)
10264 foreach a $arcnos($id) {
10265 set d $arcstart($a)
10266 if {!$ta && $arctags($a) ne {}} {
10267 validate_arctags $a
10268 if {$arctags($a) ne {}} {
10269 lappend tagloc($id) [lindex $arctags($a) end]
10272 if {$ta || $arctags($a) ne {}} {
10273 set tomark [list $d]
10274 for {set j 0} {$j < [llength $tomark]} {incr j} {
10275 set dd [lindex $tomark $j]
10276 if {![info exists hastaggedancestor($dd)]} {
10277 if {[info exists done($dd)]} {
10278 foreach b $arcnos($dd) {
10279 lappend tomark $arcstart($b)
10281 if {[info exists tagloc($dd)]} {
10284 } elseif {[info exists queued($dd)]} {
10287 set hastaggedancestor($dd) 1
10291 if {![info exists queued($d)]} {
10294 if {![info exists hastaggedancestor($d)]} {
10301 foreach id [array names tagloc] {
10302 if {![info exists hastaggedancestor($id)]} {
10303 foreach t $tagloc($id) {
10304 if {[lsearch -exact $tags $t] < 0} {
10310 set t2 [clock clicks -milliseconds]
10313 # remove tags that are descendents of other tags
10314 for {set i 0} {$i < [llength $tags]} {incr i} {
10315 set a [lindex $tags $i]
10316 for {set j 0} {$j < $i} {incr j} {
10317 set b [lindex $tags $j]
10318 set r [anc_or_desc $a $b]
10320 set tags [lreplace $tags $j $j]
10323 } elseif {$r == -1} {
10324 set tags [lreplace $tags $i $i]
10331 if {[array names growing] ne {}} {
10332 # graph isn't finished, need to check if any tag could get
10333 # eclipsed by another tag coming later. Simply ignore any
10334 # tags that could later get eclipsed.
10337 if {[is_certain $t $origid]} {
10341 if {$tags eq $ctags} {
10342 set cached_dtags($origid) $tags
10347 set cached_dtags($origid) $tags
10349 set t3 [clock clicks -milliseconds]
10350 if {0 && $t3 - $t1 >= 100} {
10351 puts "iterating descendents ($loopix/[llength $todo] nodes) took\
10352 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
10357 proc anctags {id} {
10358 global arcnos arcids arcout arcend arctags idtags allparents
10359 global growing cached_atags
10361 if {![info exists allparents($id)]} {
10364 set t1 [clock clicks -milliseconds]
10366 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10367 # part-way along an arc; check that arc first
10368 set a [lindex $arcnos($id) 0]
10369 if {$arctags($a) ne {}} {
10370 validate_arctags $a
10371 set i [lsearch -exact $arcids($a) $id]
10372 foreach t $arctags($a) {
10373 set j [lsearch -exact $arcids($a) $t]
10379 if {![info exists arcend($a)]} {
10383 if {[info exists idtags($id)]} {
10387 if {[info exists cached_atags($id)]} {
10388 return $cached_atags($id)
10392 set todo [list $id]
10396 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
10397 set id [lindex $todo $i]
10399 set td [info exists hastaggeddescendent($id)]
10403 # ignore tags on starting node
10404 if {!$td && $i > 0} {
10405 if {[info exists idtags($id)]} {
10406 set tagloc($id) $id
10408 } elseif {[info exists cached_atags($id)]} {
10409 set tagloc($id) $cached_atags($id)
10413 foreach a $arcout($id) {
10414 if {!$td && $arctags($a) ne {}} {
10415 validate_arctags $a
10416 if {$arctags($a) ne {}} {
10417 lappend tagloc($id) [lindex $arctags($a) 0]
10420 if {![info exists arcend($a)]} continue
10422 if {$td || $arctags($a) ne {}} {
10423 set tomark [list $d]
10424 for {set j 0} {$j < [llength $tomark]} {incr j} {
10425 set dd [lindex $tomark $j]
10426 if {![info exists hastaggeddescendent($dd)]} {
10427 if {[info exists done($dd)]} {
10428 foreach b $arcout($dd) {
10429 if {[info exists arcend($b)]} {
10430 lappend tomark $arcend($b)
10433 if {[info exists tagloc($dd)]} {
10436 } elseif {[info exists queued($dd)]} {
10439 set hastaggeddescendent($dd) 1
10443 if {![info exists queued($d)]} {
10446 if {![info exists hastaggeddescendent($d)]} {
10452 set t2 [clock clicks -milliseconds]
10455 foreach id [array names tagloc] {
10456 if {![info exists hastaggeddescendent($id)]} {
10457 foreach t $tagloc($id) {
10458 if {[lsearch -exact $tags $t] < 0} {
10465 # remove tags that are ancestors of other tags
10466 for {set i 0} {$i < [llength $tags]} {incr i} {
10467 set a [lindex $tags $i]
10468 for {set j 0} {$j < $i} {incr j} {
10469 set b [lindex $tags $j]
10470 set r [anc_or_desc $a $b]
10472 set tags [lreplace $tags $j $j]
10475 } elseif {$r == 1} {
10476 set tags [lreplace $tags $i $i]
10483 if {[array names growing] ne {}} {
10484 # graph isn't finished, need to check if any tag could get
10485 # eclipsed by another tag coming later. Simply ignore any
10486 # tags that could later get eclipsed.
10489 if {[is_certain $origid $t]} {
10493 if {$tags eq $ctags} {
10494 set cached_atags($origid) $tags
10499 set cached_atags($origid) $tags
10501 set t3 [clock clicks -milliseconds]
10502 if {0 && $t3 - $t1 >= 100} {
10503 puts "iterating ancestors ($loopix/[llength $todo] nodes) took\
10504 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
10509 # Return the list of IDs that have heads that are descendents of id,
10510 # including id itself if it has a head.
10511 proc descheads {id} {
10512 global arcnos arcstart arcids archeads idheads cached_dheads
10515 if {![info exists allparents($id)]} {
10519 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10520 # part-way along an arc; check it first
10521 set a [lindex $arcnos($id) 0]
10522 if {$archeads($a) ne {}} {
10523 validate_archeads $a
10524 set i [lsearch -exact $arcids($a) $id]
10525 foreach t $archeads($a) {
10526 set j [lsearch -exact $arcids($a) $t]
10531 set id $arcstart($a)
10534 set todo [list $id]
10537 for {set i 0} {$i < [llength $todo]} {incr i} {
10538 set id [lindex $todo $i]
10539 if {[info exists cached_dheads($id)]} {
10540 set ret [concat $ret $cached_dheads($id)]
10542 if {[info exists idheads($id)]} {
10545 foreach a $arcnos($id) {
10546 if {$archeads($a) ne {}} {
10547 validate_archeads $a
10548 if {$archeads($a) ne {}} {
10549 set ret [concat $ret $archeads($a)]
10552 set d $arcstart($a)
10553 if {![info exists seen($d)]} {
10560 set ret [lsort -unique $ret]
10561 set cached_dheads($origid) $ret
10562 return [concat $ret $aret]
10565 proc addedtag {id} {
10566 global arcnos arcout cached_dtags cached_atags
10568 if {![info exists arcnos($id)]} return
10569 if {![info exists arcout($id)]} {
10570 recalcarc [lindex $arcnos($id) 0]
10572 catch {unset cached_dtags}
10573 catch {unset cached_atags}
10576 proc addedhead {hid head} {
10577 global arcnos arcout cached_dheads
10579 if {![info exists arcnos($hid)]} return
10580 if {![info exists arcout($hid)]} {
10581 recalcarc [lindex $arcnos($hid) 0]
10583 catch {unset cached_dheads}
10586 proc removedhead {hid head} {
10587 global cached_dheads
10589 catch {unset cached_dheads}
10592 proc movedhead {hid head} {
10593 global arcnos arcout cached_dheads
10595 if {![info exists arcnos($hid)]} return
10596 if {![info exists arcout($hid)]} {
10597 recalcarc [lindex $arcnos($hid) 0]
10599 catch {unset cached_dheads}
10602 proc changedrefs {} {
10603 global cached_dheads cached_dtags cached_atags cached_tagcontent
10604 global arctags archeads arcnos arcout idheads idtags
10606 foreach id [concat [array names idheads] [array names idtags]] {
10607 if {[info exists arcnos($id)] && ![info exists arcout($id)]} {
10608 set a [lindex $arcnos($id) 0]
10609 if {![info exists donearc($a)]} {
10615 catch {unset cached_tagcontent}
10616 catch {unset cached_dtags}
10617 catch {unset cached_atags}
10618 catch {unset cached_dheads}
10621 proc rereadrefs {} {
10622 global idtags idheads idotherrefs mainheadid
10624 set refids [concat [array names idtags] \
10625 [array names idheads] [array names idotherrefs]]
10626 foreach id $refids {
10627 if {![info exists ref($id)]} {
10628 set ref($id) [listrefs $id]
10631 set oldmainhead $mainheadid
10634 set refids [lsort -unique [concat $refids [array names idtags] \
10635 [array names idheads] [array names idotherrefs]]]
10636 foreach id $refids {
10637 set v [listrefs $id]
10638 if {![info exists ref($id)] || $ref($id) != $v} {
10642 if {$oldmainhead ne $mainheadid} {
10643 redrawtags $oldmainhead
10644 redrawtags $mainheadid
10649 proc listrefs {id} {
10650 global idtags idheads idotherrefs
10653 if {[info exists idtags($id)]} {
10657 if {[info exists idheads($id)]} {
10658 set y $idheads($id)
10661 if {[info exists idotherrefs($id)]} {
10662 set z $idotherrefs($id)
10664 return [list $x $y $z]
10667 proc showtag {tag isnew} {
10668 global ctext cached_tagcontent tagids linknum tagobjid
10671 addtohistory [list showtag $tag 0] savectextpos
10673 $ctext conf -state normal
10677 if {![info exists cached_tagcontent($tag)]} {
10679 set cached_tagcontent($tag) [exec git cat-file tag $tag]
10682 if {[info exists cached_tagcontent($tag)]} {
10683 set text $cached_tagcontent($tag)
10685 set text "[mc "Tag"]: $tag\n[mc "Id"]: $tagids($tag)"
10687 appendwithlinks $text {}
10688 maybe_scroll_ctext 1
10689 $ctext conf -state disabled
10701 if {[info exists gitktmpdir]} {
10702 catch {file delete -force $gitktmpdir}
10706 proc mkfontdisp {font top which} {
10707 global fontattr fontpref $font NS use_ttk
10709 set fontpref($font) [set $font]
10710 ${NS}::button $top.${font}but -text $which \
10711 -command [list choosefont $font $which]
10712 ${NS}::label $top.$font -relief flat -font $font \
10713 -text $fontattr($font,family) -justify left
10714 grid x $top.${font}but $top.$font -sticky w
10717 proc choosefont {font which} {
10718 global fontparam fontlist fonttop fontattr
10721 set fontparam(which) $which
10722 set fontparam(font) $font
10723 set fontparam(family) [font actual $font -family]
10724 set fontparam(size) $fontattr($font,size)
10725 set fontparam(weight) $fontattr($font,weight)
10726 set fontparam(slant) $fontattr($font,slant)
10729 if {![winfo exists $top]} {
10731 eval font config sample [font actual $font]
10733 make_transient $top $prefstop
10734 wm title $top [mc "Gitk font chooser"]
10735 ${NS}::label $top.l -textvariable fontparam(which)
10736 pack $top.l -side top
10737 set fontlist [lsort [font families]]
10738 ${NS}::frame $top.f
10739 listbox $top.f.fam -listvariable fontlist \
10740 -yscrollcommand [list $top.f.sb set]
10741 bind $top.f.fam <<ListboxSelect>> selfontfam
10742 ${NS}::scrollbar $top.f.sb -command [list $top.f.fam yview]
10743 pack $top.f.sb -side right -fill y
10744 pack $top.f.fam -side left -fill both -expand 1
10745 pack $top.f -side top -fill both -expand 1
10746 ${NS}::frame $top.g
10747 spinbox $top.g.size -from 4 -to 40 -width 4 \
10748 -textvariable fontparam(size) \
10749 -validatecommand {string is integer -strict %s}
10750 checkbutton $top.g.bold -padx 5 \
10751 -font {{Times New Roman} 12 bold} -text [mc "B"] -indicatoron 0 \
10752 -variable fontparam(weight) -onvalue bold -offvalue normal
10753 checkbutton $top.g.ital -padx 5 \
10754 -font {{Times New Roman} 12 italic} -text [mc "I"] -indicatoron 0 \
10755 -variable fontparam(slant) -onvalue italic -offvalue roman
10756 pack $top.g.size $top.g.bold $top.g.ital -side left
10757 pack $top.g -side top
10758 canvas $top.c -width 150 -height 50 -border 2 -relief sunk \
10760 $top.c create text 100 25 -anchor center -text $which -font sample \
10761 -fill black -tags text
10762 bind $top.c <Configure> [list centertext $top.c]
10763 pack $top.c -side top -fill x
10764 ${NS}::frame $top.buts
10765 ${NS}::button $top.buts.ok -text [mc "OK"] -command fontok -default active
10766 ${NS}::button $top.buts.can -text [mc "Cancel"] -command fontcan -default normal
10767 bind $top <Key-Return> fontok
10768 bind $top <Key-Escape> fontcan
10769 grid $top.buts.ok $top.buts.can
10770 grid columnconfigure $top.buts 0 -weight 1 -uniform a
10771 grid columnconfigure $top.buts 1 -weight 1 -uniform a
10772 pack $top.buts -side bottom -fill x
10773 trace add variable fontparam write chg_fontparam
10776 $top.c itemconf text -text $which
10778 set i [lsearch -exact $fontlist $fontparam(family)]
10780 $top.f.fam selection set $i
10785 proc centertext {w} {
10786 $w coords text [expr {[winfo width $w] / 2}] [expr {[winfo height $w] / 2}]
10790 global fontparam fontpref prefstop
10792 set f $fontparam(font)
10793 set fontpref($f) [list $fontparam(family) $fontparam(size)]
10794 if {$fontparam(weight) eq "bold"} {
10795 lappend fontpref($f) "bold"
10797 if {$fontparam(slant) eq "italic"} {
10798 lappend fontpref($f) "italic"
10800 set w $prefstop.notebook.fonts.$f
10801 $w conf -text $fontparam(family) -font $fontpref($f)
10807 global fonttop fontparam
10809 if {[info exists fonttop]} {
10810 catch {destroy $fonttop}
10811 catch {font delete sample}
10817 if {[package vsatisfies [package provide Tk] 8.6]} {
10818 # In Tk 8.6 we have a native font chooser dialog. Overwrite the above
10819 # function to make use of it.
10820 proc choosefont {font which} {
10821 tk fontchooser configure -title $which -font $font \
10822 -command [list on_choosefont $font $which]
10823 tk fontchooser show
10825 proc on_choosefont {font which newfont} {
10827 puts stderr "$font $newfont"
10828 array set f [font actual $newfont]
10829 set fontparam(which) $which
10830 set fontparam(font) $font
10831 set fontparam(family) $f(-family)
10832 set fontparam(size) $f(-size)
10833 set fontparam(weight) $f(-weight)
10834 set fontparam(slant) $f(-slant)
10839 proc selfontfam {} {
10840 global fonttop fontparam
10842 set i [$fonttop.f.fam curselection]
10844 set fontparam(family) [$fonttop.f.fam get $i]
10848 proc chg_fontparam {v sub op} {
10851 font config sample -$sub $fontparam($sub)
10854 # Create a property sheet tab page
10855 proc create_prefs_page {w} {
10857 set parent [join [lrange [split $w .] 0 end-1] .]
10858 if {[winfo class $parent] eq "TNotebook"} {
10861 ${NS}::labelframe $w
10865 proc prefspage_general {notebook} {
10866 global NS maxwidth maxgraphpct showneartags showlocalchanges
10867 global tabstop limitdiffs autoselect autosellen extdifftool perfile_attrs
10868 global hideremotes want_ttk have_ttk
10870 set page [create_prefs_page $notebook.general]
10872 ${NS}::label $page.ldisp -text [mc "Commit list display options"]
10873 grid $page.ldisp - -sticky w -pady 10
10874 ${NS}::label $page.spacer -text " "
10875 ${NS}::label $page.maxwidthl -text [mc "Maximum graph width (lines)"]
10876 spinbox $page.maxwidth -from 0 -to 100 -width 4 -textvariable maxwidth
10877 grid $page.spacer $page.maxwidthl $page.maxwidth -sticky w
10878 ${NS}::label $page.maxpctl -text [mc "Maximum graph width (% of pane)"]
10879 spinbox $page.maxpct -from 1 -to 100 -width 4 -textvariable maxgraphpct
10880 grid x $page.maxpctl $page.maxpct -sticky w
10881 ${NS}::checkbutton $page.showlocal -text [mc "Show local changes"] \
10882 -variable showlocalchanges
10883 grid x $page.showlocal -sticky w
10884 ${NS}::checkbutton $page.autoselect -text [mc "Auto-select SHA1 (length)"] \
10885 -variable autoselect
10886 spinbox $page.autosellen -from 1 -to 40 -width 4 -textvariable autosellen
10887 grid x $page.autoselect $page.autosellen -sticky w
10888 ${NS}::checkbutton $page.hideremotes -text [mc "Hide remote refs"] \
10889 -variable hideremotes
10890 grid x $page.hideremotes -sticky w
10892 ${NS}::label $page.ddisp -text [mc "Diff display options"]
10893 grid $page.ddisp - -sticky w -pady 10
10894 ${NS}::label $page.tabstopl -text [mc "Tab spacing"]
10895 spinbox $page.tabstop -from 1 -to 20 -width 4 -textvariable tabstop
10896 grid x $page.tabstopl $page.tabstop -sticky w
10897 ${NS}::checkbutton $page.ntag -text [mc "Display nearby tags"] \
10898 -variable showneartags
10899 grid x $page.ntag -sticky w
10900 ${NS}::checkbutton $page.ldiff -text [mc "Limit diffs to listed paths"] \
10901 -variable limitdiffs
10902 grid x $page.ldiff -sticky w
10903 ${NS}::checkbutton $page.lattr -text [mc "Support per-file encodings"] \
10904 -variable perfile_attrs
10905 grid x $page.lattr -sticky w
10907 ${NS}::entry $page.extdifft -textvariable extdifftool
10908 ${NS}::frame $page.extdifff
10909 ${NS}::label $page.extdifff.l -text [mc "External diff tool" ]
10910 ${NS}::button $page.extdifff.b -text [mc "Choose..."] -command choose_extdiff
10911 pack $page.extdifff.l $page.extdifff.b -side left
10912 pack configure $page.extdifff.l -padx 10
10913 grid x $page.extdifff $page.extdifft -sticky ew
10915 ${NS}::label $page.lgen -text [mc "General options"]
10916 grid $page.lgen - -sticky w -pady 10
10917 ${NS}::checkbutton $page.want_ttk -variable want_ttk \
10918 -text [mc "Use themed widgets"]
10920 ${NS}::label $page.ttk_note -text [mc "(change requires restart)"]
10922 ${NS}::label $page.ttk_note -text [mc "(currently unavailable)"]
10924 grid x $page.want_ttk $page.ttk_note -sticky w
10928 proc prefspage_colors {notebook} {
10929 global NS uicolor bgcolor fgcolor ctext diffcolors selectbgcolor markbgcolor
10931 set page [create_prefs_page $notebook.colors]
10933 ${NS}::label $page.cdisp -text [mc "Colors: press to choose"]
10934 grid $page.cdisp - -sticky w -pady 10
10935 label $page.ui -padx 40 -relief sunk -background $uicolor
10936 ${NS}::button $page.uibut -text [mc "Interface"] \
10937 -command [list choosecolor uicolor {} $page.ui [mc "interface"] setui]
10938 grid x $page.uibut $page.ui -sticky w
10939 label $page.bg -padx 40 -relief sunk -background $bgcolor
10940 ${NS}::button $page.bgbut -text [mc "Background"] \
10941 -command [list choosecolor bgcolor {} $page.bg [mc "background"] setbg]
10942 grid x $page.bgbut $page.bg -sticky w
10943 label $page.fg -padx 40 -relief sunk -background $fgcolor
10944 ${NS}::button $page.fgbut -text [mc "Foreground"] \
10945 -command [list choosecolor fgcolor {} $page.fg [mc "foreground"] setfg]
10946 grid x $page.fgbut $page.fg -sticky w
10947 label $page.diffold -padx 40 -relief sunk -background [lindex $diffcolors 0]
10948 ${NS}::button $page.diffoldbut -text [mc "Diff: old lines"] \
10949 -command [list choosecolor diffcolors 0 $page.diffold [mc "diff old lines"] \
10950 [list $ctext tag conf d0 -foreground]]
10951 grid x $page.diffoldbut $page.diffold -sticky w
10952 label $page.diffnew -padx 40 -relief sunk -background [lindex $diffcolors 1]
10953 ${NS}::button $page.diffnewbut -text [mc "Diff: new lines"] \
10954 -command [list choosecolor diffcolors 1 $page.diffnew [mc "diff new lines"] \
10955 [list $ctext tag conf dresult -foreground]]
10956 grid x $page.diffnewbut $page.diffnew -sticky w
10957 label $page.hunksep -padx 40 -relief sunk -background [lindex $diffcolors 2]
10958 ${NS}::button $page.hunksepbut -text [mc "Diff: hunk header"] \
10959 -command [list choosecolor diffcolors 2 $page.hunksep \
10960 [mc "diff hunk header"] \
10961 [list $ctext tag conf hunksep -foreground]]
10962 grid x $page.hunksepbut $page.hunksep -sticky w
10963 label $page.markbgsep -padx 40 -relief sunk -background $markbgcolor
10964 ${NS}::button $page.markbgbut -text [mc "Marked line bg"] \
10965 -command [list choosecolor markbgcolor {} $page.markbgsep \
10966 [mc "marked line background"] \
10967 [list $ctext tag conf omark -background]]
10968 grid x $page.markbgbut $page.markbgsep -sticky w
10969 label $page.selbgsep -padx 40 -relief sunk -background $selectbgcolor
10970 ${NS}::button $page.selbgbut -text [mc "Select bg"] \
10971 -command [list choosecolor selectbgcolor {} $page.selbgsep [mc "background"] setselbg]
10972 grid x $page.selbgbut $page.selbgsep -sticky w
10976 proc prefspage_fonts {notebook} {
10978 set page [create_prefs_page $notebook.fonts]
10979 ${NS}::label $page.cfont -text [mc "Fonts: press to choose"]
10980 grid $page.cfont - -sticky w -pady 10
10981 mkfontdisp mainfont $page [mc "Main font"]
10982 mkfontdisp textfont $page [mc "Diff display font"]
10983 mkfontdisp uifont $page [mc "User interface font"]
10988 global maxwidth maxgraphpct use_ttk NS
10989 global oldprefs prefstop showneartags showlocalchanges
10990 global uicolor bgcolor fgcolor ctext diffcolors selectbgcolor markbgcolor
10991 global tabstop limitdiffs autoselect autosellen extdifftool perfile_attrs
10992 global hideremotes want_ttk have_ttk
10996 if {[winfo exists $top]} {
11000 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
11001 limitdiffs tabstop perfile_attrs hideremotes want_ttk} {
11002 set oldprefs($v) [set $v]
11005 wm title $top [mc "Gitk preferences"]
11006 make_transient $top .
11008 if {[set use_notebook [expr {$use_ttk && [info command ::ttk::notebook] ne ""}]]} {
11009 set notebook [ttk::notebook $top.notebook]
11011 set notebook [${NS}::frame $top.notebook -borderwidth 0 -relief flat]
11014 lappend pages [prefspage_general $notebook] [mc "General"]
11015 lappend pages [prefspage_colors $notebook] [mc "Colors"]
11016 lappend pages [prefspage_fonts $notebook] [mc "Fonts"]
11018 foreach {page title} $pages {
11019 if {$use_notebook} {
11020 $notebook add $page -text $title
11022 set btn [${NS}::button $notebook.b_[string map {. X} $page] \
11023 -text $title -command [list raise $page]]
11024 $page configure -text $title
11025 grid $btn -row 0 -column [incr col] -sticky w
11026 grid $page -row 1 -column 0 -sticky news -columnspan 100
11030 if {!$use_notebook} {
11031 grid columnconfigure $notebook 0 -weight 1
11032 grid rowconfigure $notebook 1 -weight 1
11033 raise [lindex $pages 0]
11036 grid $notebook -sticky news -padx 2 -pady 2
11037 grid rowconfigure $top 0 -weight 1
11038 grid columnconfigure $top 0 -weight 1
11040 ${NS}::frame $top.buts
11041 ${NS}::button $top.buts.ok -text [mc "OK"] -command prefsok -default active
11042 ${NS}::button $top.buts.can -text [mc "Cancel"] -command prefscan -default normal
11043 bind $top <Key-Return> prefsok
11044 bind $top <Key-Escape> prefscan
11045 grid $top.buts.ok $top.buts.can
11046 grid columnconfigure $top.buts 0 -weight 1 -uniform a
11047 grid columnconfigure $top.buts 1 -weight 1 -uniform a
11048 grid $top.buts - - -pady 10 -sticky ew
11049 grid columnconfigure $top 2 -weight 1
11050 bind $top <Visibility> [list focus $top.buts.ok]
11053 proc choose_extdiff {} {
11056 set prog [tk_getOpenFile -title [mc "External diff tool"] -multiple false]
11058 set extdifftool $prog
11062 proc choosecolor {v vi w x cmd} {
11065 set c [tk_chooseColor -initialcolor [lindex [set $v] $vi] \
11066 -title [mc "Gitk: choose color for %s" $x]]
11067 if {$c eq {}} return
11068 $w conf -background $c
11073 proc setselbg {c} {
11074 global bglist cflist
11075 foreach w $bglist {
11076 $w configure -selectbackground $c
11078 $cflist tag configure highlight \
11079 -background [$cflist cget -selectbackground]
11080 allcanvs itemconf secsel -fill $c
11083 # This sets the background color and the color scheme for the whole UI.
11084 # For some reason, tk_setPalette chooses a nasty dark red for selectColor
11085 # if we don't specify one ourselves, which makes the checkbuttons and
11086 # radiobuttons look bad. This chooses white for selectColor if the
11087 # background color is light, or black if it is dark.
11089 if {[tk windowingsystem] eq "win32"} { return }
11090 set bg [winfo rgb . $c]
11092 if {[lindex $bg 0] + 1.5 * [lindex $bg 1] + 0.5 * [lindex $bg 2] > 100000} {
11095 tk_setPalette background $c selectColor $selc
11101 foreach w $bglist {
11102 $w conf -background $c
11109 foreach w $fglist {
11110 $w conf -foreground $c
11112 allcanvs itemconf text -fill $c
11113 $canv itemconf circle -outline $c
11114 $canv itemconf markid -outline $c
11118 global oldprefs prefstop
11120 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
11121 limitdiffs tabstop perfile_attrs hideremotes want_ttk} {
11123 set $v $oldprefs($v)
11125 catch {destroy $prefstop}
11131 global maxwidth maxgraphpct
11132 global oldprefs prefstop showneartags showlocalchanges
11133 global fontpref mainfont textfont uifont
11134 global limitdiffs treediffs perfile_attrs
11137 catch {destroy $prefstop}
11141 if {$mainfont ne $fontpref(mainfont)} {
11142 set mainfont $fontpref(mainfont)
11143 parsefont mainfont $mainfont
11144 eval font configure mainfont [fontflags mainfont]
11145 eval font configure mainfontbold [fontflags mainfont 1]
11149 if {$textfont ne $fontpref(textfont)} {
11150 set textfont $fontpref(textfont)
11151 parsefont textfont $textfont
11152 eval font configure textfont [fontflags textfont]
11153 eval font configure textfontbold [fontflags textfont 1]
11155 if {$uifont ne $fontpref(uifont)} {
11156 set uifont $fontpref(uifont)
11157 parsefont uifont $uifont
11158 eval font configure uifont [fontflags uifont]
11161 if {$showlocalchanges != $oldprefs(showlocalchanges)} {
11162 if {$showlocalchanges} {
11168 if {$limitdiffs != $oldprefs(limitdiffs) ||
11169 ($perfile_attrs && !$oldprefs(perfile_attrs))} {
11170 # treediffs elements are limited by path;
11171 # won't have encodings cached if perfile_attrs was just turned on
11172 catch {unset treediffs}
11174 if {$fontchanged || $maxwidth != $oldprefs(maxwidth)
11175 || $maxgraphpct != $oldprefs(maxgraphpct)} {
11177 } elseif {$showneartags != $oldprefs(showneartags) ||
11178 $limitdiffs != $oldprefs(limitdiffs)} {
11181 if {$hideremotes != $oldprefs(hideremotes)} {
11186 proc formatdate {d} {
11187 global datetimeformat
11189 set d [clock format [lindex $d 0] -format $datetimeformat]
11194 # This list of encoding names and aliases is distilled from
11195 # http://www.iana.org/assignments/character-sets.
11196 # Not all of them are supported by Tcl.
11197 set encoding_aliases {
11198 { ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991 ASCII
11199 ISO646-US US-ASCII us IBM367 cp367 csASCII }
11200 { ISO-10646-UTF-1 csISO10646UTF1 }
11201 { ISO_646.basic:1983 ref csISO646basic1983 }
11202 { INVARIANT csINVARIANT }
11203 { ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion }
11204 { BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom }
11205 { NATS-SEFI iso-ir-8-1 csNATSSEFI }
11206 { NATS-SEFI-ADD iso-ir-8-2 csNATSSEFIADD }
11207 { NATS-DANO iso-ir-9-1 csNATSDANO }
11208 { NATS-DANO-ADD iso-ir-9-2 csNATSDANOADD }
11209 { SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE se csISO10Swedish }
11210 { SEN_850200_C iso-ir-11 ISO646-SE2 se2 csISO11SwedishForNames }
11211 { KS_C_5601-1987 iso-ir-149 KS_C_5601-1989 KSC_5601 korean csKSC56011987 }
11212 { ISO-2022-KR csISO2022KR }
11214 { ISO-2022-JP csISO2022JP }
11215 { ISO-2022-JP-2 csISO2022JP2 }
11216 { JIS_C6220-1969-jp JIS_C6220-1969 iso-ir-13 katakana x0201-7
11217 csISO13JISC6220jp }
11218 { JIS_C6220-1969-ro iso-ir-14 jp ISO646-JP csISO14JISC6220ro }
11219 { IT iso-ir-15 ISO646-IT csISO15Italian }
11220 { PT iso-ir-16 ISO646-PT csISO16Portuguese }
11221 { ES iso-ir-17 ISO646-ES csISO17Spanish }
11222 { greek7-old iso-ir-18 csISO18Greek7Old }
11223 { latin-greek iso-ir-19 csISO19LatinGreek }
11224 { DIN_66003 iso-ir-21 de ISO646-DE csISO21German }
11225 { NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French }
11226 { Latin-greek-1 iso-ir-27 csISO27LatinGreek1 }
11227 { ISO_5427 iso-ir-37 csISO5427Cyrillic }
11228 { JIS_C6226-1978 iso-ir-42 csISO42JISC62261978 }
11229 { BS_viewdata iso-ir-47 csISO47BSViewdata }
11230 { INIS iso-ir-49 csISO49INIS }
11231 { INIS-8 iso-ir-50 csISO50INIS8 }
11232 { INIS-cyrillic iso-ir-51 csISO51INISCyrillic }
11233 { ISO_5427:1981 iso-ir-54 ISO5427Cyrillic1981 }
11234 { ISO_5428:1980 iso-ir-55 csISO5428Greek }
11235 { GB_1988-80 iso-ir-57 cn ISO646-CN csISO57GB1988 }
11236 { GB_2312-80 iso-ir-58 chinese csISO58GB231280 }
11237 { NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
11238 csISO60Norwegian1 }
11239 { NS_4551-2 ISO646-NO2 iso-ir-61 no2 csISO61Norwegian2 }
11240 { NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French }
11241 { videotex-suppl iso-ir-70 csISO70VideotexSupp1 }
11242 { PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2 }
11243 { ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2 }
11244 { MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian }
11245 { JIS_C6226-1983 iso-ir-87 x0208 JIS_X0208-1983 csISO87JISX0208 }
11246 { greek7 iso-ir-88 csISO88Greek7 }
11247 { ASMO_449 ISO_9036 arabic7 iso-ir-89 csISO89ASMO449 }
11248 { iso-ir-90 csISO90 }
11249 { JIS_C6229-1984-a iso-ir-91 jp-ocr-a csISO91JISC62291984a }
11250 { JIS_C6229-1984-b iso-ir-92 ISO646-JP-OCR-B jp-ocr-b
11251 csISO92JISC62991984b }
11252 { JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add csISO93JIS62291984badd }
11253 { JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand csISO94JIS62291984hand }
11254 { JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
11255 csISO95JIS62291984handadd }
11256 { JIS_C6229-1984-kana iso-ir-96 csISO96JISC62291984kana }
11257 { ISO_2033-1983 iso-ir-98 e13b csISO2033 }
11258 { ANSI_X3.110-1983 iso-ir-99 CSA_T500-1983 NAPLPS csISO99NAPLPS }
11259 { ISO_8859-1:1987 iso-ir-100 ISO_8859-1 ISO-8859-1 latin1 l1 IBM819
11260 CP819 csISOLatin1 }
11261 { ISO_8859-2:1987 iso-ir-101 ISO_8859-2 ISO-8859-2 latin2 l2 csISOLatin2 }
11262 { T.61-7bit iso-ir-102 csISO102T617bit }
11263 { T.61-8bit T.61 iso-ir-103 csISO103T618bit }
11264 { ISO_8859-3:1988 iso-ir-109 ISO_8859-3 ISO-8859-3 latin3 l3 csISOLatin3 }
11265 { ISO_8859-4:1988 iso-ir-110 ISO_8859-4 ISO-8859-4 latin4 l4 csISOLatin4 }
11266 { ECMA-cyrillic iso-ir-111 KOI8-E csISO111ECMACyrillic }
11267 { CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca csISO121Canadian1 }
11268 { CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2 csISO122Canadian2 }
11269 { CSA_Z243.4-1985-gr iso-ir-123 csISO123CSAZ24341985gr }
11270 { ISO_8859-6:1987 iso-ir-127 ISO_8859-6 ISO-8859-6 ECMA-114 ASMO-708
11271 arabic csISOLatinArabic }
11272 { ISO_8859-6-E csISO88596E ISO-8859-6-E }
11273 { ISO_8859-6-I csISO88596I ISO-8859-6-I }
11274 { ISO_8859-7:1987 iso-ir-126 ISO_8859-7 ISO-8859-7 ELOT_928 ECMA-118
11275 greek greek8 csISOLatinGreek }
11276 { T.101-G2 iso-ir-128 csISO128T101G2 }
11277 { ISO_8859-8:1988 iso-ir-138 ISO_8859-8 ISO-8859-8 hebrew
11279 { ISO_8859-8-E csISO88598E ISO-8859-8-E }
11280 { ISO_8859-8-I csISO88598I ISO-8859-8-I }
11281 { CSN_369103 iso-ir-139 csISO139CSN369103 }
11282 { JUS_I.B1.002 iso-ir-141 ISO646-YU js yu csISO141JUSIB1002 }
11283 { ISO_6937-2-add iso-ir-142 csISOTextComm }
11284 { IEC_P27-1 iso-ir-143 csISO143IECP271 }
11285 { ISO_8859-5:1988 iso-ir-144 ISO_8859-5 ISO-8859-5 cyrillic
11286 csISOLatinCyrillic }
11287 { JUS_I.B1.003-serb iso-ir-146 serbian csISO146Serbian }
11288 { JUS_I.B1.003-mac macedonian iso-ir-147 csISO147Macedonian }
11289 { ISO_8859-9:1989 iso-ir-148 ISO_8859-9 ISO-8859-9 latin5 l5 csISOLatin5 }
11290 { greek-ccitt iso-ir-150 csISO150 csISO150GreekCCITT }
11291 { NC_NC00-10:81 cuba iso-ir-151 ISO646-CU csISO151Cuba }
11292 { ISO_6937-2-25 iso-ir-152 csISO6937Add }
11293 { GOST_19768-74 ST_SEV_358-88 iso-ir-153 csISO153GOST1976874 }
11294 { ISO_8859-supp iso-ir-154 latin1-2-5 csISO8859Supp }
11295 { ISO_10367-box iso-ir-155 csISO10367Box }
11296 { ISO-8859-10 iso-ir-157 l6 ISO_8859-10:1992 csISOLatin6 latin6 }
11297 { latin-lap lap iso-ir-158 csISO158Lap }
11298 { JIS_X0212-1990 x0212 iso-ir-159 csISO159JISX02121990 }
11299 { DS_2089 DS2089 ISO646-DK dk csISO646Danish }
11302 { JIS_X0201 X0201 csHalfWidthKatakana }
11303 { KSC5636 ISO646-KR csKSC5636 }
11304 { ISO-10646-UCS-2 csUnicode }
11305 { ISO-10646-UCS-4 csUCS4 }
11306 { DEC-MCS dec csDECMCS }
11307 { hp-roman8 roman8 r8 csHPRoman8 }
11308 { macintosh mac csMacintosh }
11309 { IBM037 cp037 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl
11311 { IBM038 EBCDIC-INT cp038 csIBM038 }
11312 { IBM273 CP273 csIBM273 }
11313 { IBM274 EBCDIC-BE CP274 csIBM274 }
11314 { IBM275 EBCDIC-BR cp275 csIBM275 }
11315 { IBM277 EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 }
11316 { IBM278 CP278 ebcdic-cp-fi ebcdic-cp-se csIBM278 }
11317 { IBM280 CP280 ebcdic-cp-it csIBM280 }
11318 { IBM281 EBCDIC-JP-E cp281 csIBM281 }
11319 { IBM284 CP284 ebcdic-cp-es csIBM284 }
11320 { IBM285 CP285 ebcdic-cp-gb csIBM285 }
11321 { IBM290 cp290 EBCDIC-JP-kana csIBM290 }
11322 { IBM297 cp297 ebcdic-cp-fr csIBM297 }
11323 { IBM420 cp420 ebcdic-cp-ar1 csIBM420 }
11324 { IBM423 cp423 ebcdic-cp-gr csIBM423 }
11325 { IBM424 cp424 ebcdic-cp-he csIBM424 }
11326 { IBM437 cp437 437 csPC8CodePage437 }
11327 { IBM500 CP500 ebcdic-cp-be ebcdic-cp-ch csIBM500 }
11328 { IBM775 cp775 csPC775Baltic }
11329 { IBM850 cp850 850 csPC850Multilingual }
11330 { IBM851 cp851 851 csIBM851 }
11331 { IBM852 cp852 852 csPCp852 }
11332 { IBM855 cp855 855 csIBM855 }
11333 { IBM857 cp857 857 csIBM857 }
11334 { IBM860 cp860 860 csIBM860 }
11335 { IBM861 cp861 861 cp-is csIBM861 }
11336 { IBM862 cp862 862 csPC862LatinHebrew }
11337 { IBM863 cp863 863 csIBM863 }
11338 { IBM864 cp864 csIBM864 }
11339 { IBM865 cp865 865 csIBM865 }
11340 { IBM866 cp866 866 csIBM866 }
11341 { IBM868 CP868 cp-ar csIBM868 }
11342 { IBM869 cp869 869 cp-gr csIBM869 }
11343 { IBM870 CP870 ebcdic-cp-roece ebcdic-cp-yu csIBM870 }
11344 { IBM871 CP871 ebcdic-cp-is csIBM871 }
11345 { IBM880 cp880 EBCDIC-Cyrillic csIBM880 }
11346 { IBM891 cp891 csIBM891 }
11347 { IBM903 cp903 csIBM903 }
11348 { IBM904 cp904 904 csIBBM904 }
11349 { IBM905 CP905 ebcdic-cp-tr csIBM905 }
11350 { IBM918 CP918 ebcdic-cp-ar2 csIBM918 }
11351 { IBM1026 CP1026 csIBM1026 }
11352 { EBCDIC-AT-DE csIBMEBCDICATDE }
11353 { EBCDIC-AT-DE-A csEBCDICATDEA }
11354 { EBCDIC-CA-FR csEBCDICCAFR }
11355 { EBCDIC-DK-NO csEBCDICDKNO }
11356 { EBCDIC-DK-NO-A csEBCDICDKNOA }
11357 { EBCDIC-FI-SE csEBCDICFISE }
11358 { EBCDIC-FI-SE-A csEBCDICFISEA }
11359 { EBCDIC-FR csEBCDICFR }
11360 { EBCDIC-IT csEBCDICIT }
11361 { EBCDIC-PT csEBCDICPT }
11362 { EBCDIC-ES csEBCDICES }
11363 { EBCDIC-ES-A csEBCDICESA }
11364 { EBCDIC-ES-S csEBCDICESS }
11365 { EBCDIC-UK csEBCDICUK }
11366 { EBCDIC-US csEBCDICUS }
11367 { UNKNOWN-8BIT csUnknown8BiT }
11368 { MNEMONIC csMnemonic }
11370 { VISCII csVISCII }
11373 { IBM00858 CCSID00858 CP00858 PC-Multilingual-850+euro }
11374 { IBM00924 CCSID00924 CP00924 ebcdic-Latin9--euro }
11375 { IBM01140 CCSID01140 CP01140 ebcdic-us-37+euro }
11376 { IBM01141 CCSID01141 CP01141 ebcdic-de-273+euro }
11377 { IBM01142 CCSID01142 CP01142 ebcdic-dk-277+euro ebcdic-no-277+euro }
11378 { IBM01143 CCSID01143 CP01143 ebcdic-fi-278+euro ebcdic-se-278+euro }
11379 { IBM01144 CCSID01144 CP01144 ebcdic-it-280+euro }
11380 { IBM01145 CCSID01145 CP01145 ebcdic-es-284+euro }
11381 { IBM01146 CCSID01146 CP01146 ebcdic-gb-285+euro }
11382 { IBM01147 CCSID01147 CP01147 ebcdic-fr-297+euro }
11383 { IBM01148 CCSID01148 CP01148 ebcdic-international-500+euro }
11384 { IBM01149 CCSID01149 CP01149 ebcdic-is-871+euro }
11385 { IBM1047 IBM-1047 }
11386 { PTCP154 csPTCP154 PT154 CP154 Cyrillic-Asian }
11387 { Amiga-1251 Ami1251 Amiga1251 Ami-1251 }
11388 { UNICODE-1-1 csUnicode11 }
11389 { CESU-8 csCESU-8 }
11390 { BOCU-1 csBOCU-1 }
11391 { UNICODE-1-1-UTF-7 csUnicode11UTF7 }
11392 { ISO-8859-14 iso-ir-199 ISO_8859-14:1998 ISO_8859-14 latin8 iso-celtic
11394 { ISO-8859-15 ISO_8859-15 Latin-9 }
11395 { ISO-8859-16 iso-ir-226 ISO_8859-16:2001 ISO_8859-16 latin10 l10 }
11396 { GBK CP936 MS936 windows-936 }
11397 { JIS_Encoding csJISEncoding }
11398 { Shift_JIS MS_Kanji csShiftJIS ShiftJIS Shift-JIS }
11399 { Extended_UNIX_Code_Packed_Format_for_Japanese csEUCPkdFmtJapanese
11401 { Extended_UNIX_Code_Fixed_Width_for_Japanese csEUCFixWidJapanese }
11402 { ISO-10646-UCS-Basic csUnicodeASCII }
11403 { ISO-10646-Unicode-Latin1 csUnicodeLatin1 ISO-10646 }
11404 { ISO-Unicode-IBM-1261 csUnicodeIBM1261 }
11405 { ISO-Unicode-IBM-1268 csUnicodeIBM1268 }
11406 { ISO-Unicode-IBM-1276 csUnicodeIBM1276 }
11407 { ISO-Unicode-IBM-1264 csUnicodeIBM1264 }
11408 { ISO-Unicode-IBM-1265 csUnicodeIBM1265 }
11409 { ISO-8859-1-Windows-3.0-Latin-1 csWindows30Latin1 }
11410 { ISO-8859-1-Windows-3.1-Latin-1 csWindows31Latin1 }
11411 { ISO-8859-2-Windows-Latin-2 csWindows31Latin2 }
11412 { ISO-8859-9-Windows-Latin-5 csWindows31Latin5 }
11413 { Adobe-Standard-Encoding csAdobeStandardEncoding }
11414 { Ventura-US csVenturaUS }
11415 { Ventura-International csVenturaInternational }
11416 { PC8-Danish-Norwegian csPC8DanishNorwegian }
11417 { PC8-Turkish csPC8Turkish }
11418 { IBM-Symbols csIBMSymbols }
11419 { IBM-Thai csIBMThai }
11420 { HP-Legal csHPLegal }
11421 { HP-Pi-font csHPPiFont }
11422 { HP-Math8 csHPMath8 }
11423 { Adobe-Symbol-Encoding csHPPSMath }
11424 { HP-DeskTop csHPDesktop }
11425 { Ventura-Math csVenturaMath }
11426 { Microsoft-Publishing csMicrosoftPublishing }
11427 { Windows-31J csWindows31J }
11428 { GB2312 csGB2312 }
11432 proc tcl_encoding {enc} {
11433 global encoding_aliases tcl_encoding_cache
11434 if {[info exists tcl_encoding_cache($enc)]} {
11435 return $tcl_encoding_cache($enc)
11437 set names [encoding names]
11438 set lcnames [string tolower $names]
11439 set enc [string tolower $enc]
11440 set i [lsearch -exact $lcnames $enc]
11442 # look for "isonnn" instead of "iso-nnn" or "iso_nnn"
11443 if {[regsub {^(iso|cp|ibm|jis)[-_]} $enc {\1} encx]} {
11444 set i [lsearch -exact $lcnames $encx]
11448 foreach l $encoding_aliases {
11449 set ll [string tolower $l]
11450 if {[lsearch -exact $ll $enc] < 0} continue
11451 # look through the aliases for one that tcl knows about
11453 set i [lsearch -exact $lcnames $e]
11455 if {[regsub {^(iso|cp|ibm|jis)[-_]} $e {\1} ex]} {
11456 set i [lsearch -exact $lcnames $ex]
11466 set tclenc [lindex $names $i]
11468 set tcl_encoding_cache($enc) $tclenc
11472 proc gitattr {path attr default} {
11473 global path_attr_cache
11474 if {[info exists path_attr_cache($attr,$path)]} {
11475 set r $path_attr_cache($attr,$path)
11477 set r "unspecified"
11478 if {![catch {set line [exec git check-attr $attr -- $path]}]} {
11479 regexp "(.*): $attr: (.*)" $line m f r
11481 set path_attr_cache($attr,$path) $r
11483 if {$r eq "unspecified"} {
11489 proc cache_gitattr {attr pathlist} {
11490 global path_attr_cache
11492 foreach path $pathlist {
11493 if {![info exists path_attr_cache($attr,$path)]} {
11494 lappend newlist $path
11498 if {[tk windowingsystem] == "win32"} {
11499 # windows has a 32k limit on the arguments to a command...
11502 while {$newlist ne {}} {
11503 set head [lrange $newlist 0 [expr {$lim - 1}]]
11504 set newlist [lrange $newlist $lim end]
11505 if {![catch {set rlist [eval exec git check-attr $attr -- $head]}]} {
11506 foreach row [split $rlist "\n"] {
11507 if {[regexp "(.*): $attr: (.*)" $row m path value]} {
11508 if {[string index $path 0] eq "\""} {
11509 set path [encoding convertfrom [lindex $path 0]]
11511 set path_attr_cache($attr,$path) $value
11518 proc get_path_encoding {path} {
11519 global gui_encoding perfile_attrs
11520 set tcl_enc $gui_encoding
11521 if {$path ne {} && $perfile_attrs} {
11522 set enc2 [tcl_encoding [gitattr $path encoding $tcl_enc]]
11530 # First check that Tcl/Tk is recent enough
11531 if {[catch {package require Tk 8.4} err]} {
11532 show_error {} . "Sorry, gitk cannot run with this version of Tcl/Tk.\n\
11533 Gitk requires at least Tcl/Tk 8.4." list
11537 # Unset GIT_TRACE var if set
11538 if { [info exists ::env(GIT_TRACE)] } {
11539 unset ::env(GIT_TRACE)
11543 set wrcomcmd "git diff-tree --stdin -p --pretty"
11547 set gitencoding [exec git config --get i18n.commitencoding]
11550 set gitencoding [exec git config --get i18n.logoutputencoding]
11552 if {$gitencoding == ""} {
11553 set gitencoding "utf-8"
11555 set tclencoding [tcl_encoding $gitencoding]
11556 if {$tclencoding == {}} {
11557 puts stderr "Warning: encoding $gitencoding is not supported by Tcl/Tk"
11560 set gui_encoding [encoding system]
11562 set enc [exec git config --get gui.encoding]
11564 set tclenc [tcl_encoding $enc]
11565 if {$tclenc ne {}} {
11566 set gui_encoding $tclenc
11568 puts stderr "Warning: encoding $enc is not supported by Tcl/Tk"
11573 set log_showroot true
11575 set log_showroot [exec git config --bool --get log.showroot]
11578 if {[tk windowingsystem] eq "aqua"} {
11579 set mainfont {{Lucida Grande} 9}
11580 set textfont {Monaco 9}
11581 set uifont {{Lucida Grande} 9 bold}
11582 } elseif {![catch {::tk::pkgconfig get fontsystem} xft] && $xft eq "xft"} {
11584 set mainfont {sans 9}
11585 set textfont {monospace 9}
11586 set uifont {sans 9 bold}
11588 set mainfont {Helvetica 9}
11589 set textfont {Courier 9}
11590 set uifont {Helvetica 9 bold}
11593 set findmergefiles 0
11601 set cmitmode "patch"
11602 set wrapcomment "none"
11607 set showlocalchanges 1
11609 set datetimeformat "%Y-%m-%d %H:%M:%S"
11612 set perfile_attrs 0
11615 if {[tk windowingsystem] eq "aqua"} {
11616 set extdifftool "opendiff"
11618 set extdifftool "meld"
11621 set colors {green red blue magenta darkgrey brown orange}
11622 if {[tk windowingsystem] eq "win32"} {
11623 set uicolor SystemButtonFace
11624 set bgcolor SystemWindow
11625 set fgcolor SystemButtonText
11626 set selectbgcolor SystemHighlight
11631 set selectbgcolor gray85
11633 set diffcolors {red "#00a000" blue}
11637 set markbgcolor "#e0e0ff"
11639 set circlecolors {white blue gray blue blue}
11641 # button for popping up context menus
11642 if {[tk windowingsystem] eq "aqua"} {
11643 set ctxbut <Button-2>
11645 set ctxbut <Button-3>
11648 ## For msgcat loading, first locate the installation location.
11649 if { [info exists ::env(GITK_MSGSDIR)] } {
11650 ## Msgsdir was manually set in the environment.
11651 set gitk_msgsdir $::env(GITK_MSGSDIR)
11653 ## Let's guess the prefix from argv0.
11654 set gitk_prefix [file dirname [file dirname [file normalize $argv0]]]
11655 set gitk_libdir [file join $gitk_prefix share gitk lib]
11656 set gitk_msgsdir [file join $gitk_libdir msgs]
11660 ## Internationalization (i18n) through msgcat and gettext. See
11661 ## http://www.gnu.org/software/gettext/manual/html_node/Tcl.html
11662 package require msgcat
11663 namespace import ::msgcat::mc
11664 ## And eventually load the actual message catalog
11665 ::msgcat::mcload $gitk_msgsdir
11667 catch {source ~/.gitk}
11669 parsefont mainfont $mainfont
11670 eval font create mainfont [fontflags mainfont]
11671 eval font create mainfontbold [fontflags mainfont 1]
11673 parsefont textfont $textfont
11674 eval font create textfont [fontflags textfont]
11675 eval font create textfontbold [fontflags textfont 1]
11677 parsefont uifont $uifont
11678 eval font create uifont [fontflags uifont]
11684 # check that we can find a .git directory somewhere...
11685 if {[catch {set gitdir [exec git rev-parse --git-dir]}]} {
11686 show_error {} . [mc "Cannot find a git repository here."]
11691 set selectheadid {}
11694 set cmdline_files {}
11696 set revtreeargscmd {}
11697 foreach arg $argv {
11698 switch -glob -- $arg {
11701 set cmdline_files [lrange $argv [expr {$i + 1}] end]
11704 "--select-commit=*" {
11705 set selecthead [string range $arg 16 end]
11708 set revtreeargscmd [string range $arg 10 end]
11711 lappend revtreeargs $arg
11717 if {$selecthead eq "HEAD"} {
11721 if {$i >= [llength $argv] && $revtreeargs ne {}} {
11722 # no -- on command line, but some arguments (other than --argscmd)
11724 set f [eval exec git rev-parse --no-revs --no-flags $revtreeargs]
11725 set cmdline_files [split $f "\n"]
11726 set n [llength $cmdline_files]
11727 set revtreeargs [lrange $revtreeargs 0 end-$n]
11728 # Unfortunately git rev-parse doesn't produce an error when
11729 # something is both a revision and a filename. To be consistent
11730 # with git log and git rev-list, check revtreeargs for filenames.
11731 foreach arg $revtreeargs {
11732 if {[file exists $arg]} {
11733 show_error {} . [mc "Ambiguous argument '%s': both revision\
11734 and filename" $arg]
11739 # unfortunately we get both stdout and stderr in $err,
11740 # so look for "fatal:".
11741 set i [string first "fatal:" $err]
11743 set err [string range $err [expr {$i + 6}] end]
11745 show_error {} . "[mc "Bad arguments to gitk:"]\n$err"
11750 set nullid "0000000000000000000000000000000000000000"
11751 set nullid2 "0000000000000000000000000000000000000001"
11752 set nullfile "/dev/null"
11754 set have_tk85 [expr {[package vcompare $tk_version "8.5"] >= 0}]
11755 if {![info exists have_ttk]} {
11756 set have_ttk [llength [info commands ::ttk::style]]
11758 set use_ttk [expr {$have_ttk && $want_ttk}]
11759 set NS [expr {$use_ttk ? "ttk" : ""}]
11761 regexp {^git version ([\d.]*\d)} [exec git version] _ git_version
11764 if {[package vcompare $git_version "1.6.6.2"] >= 0} {
11765 set show_notes "--show-notes"
11775 set highlight_paths {}
11777 set searchdirn -forwards
11780 set diffelide {0 0}
11781 set markingmatches 0
11782 set linkentercount 0
11783 set need_redisplay 0
11790 set selectedhlview [mc "None"]
11791 set highlight_related [mc "None"]
11792 set highlight_files {}
11793 set viewfiles(0) {}
11796 set viewargscmd(0) {}
11798 set selectedline {}
11806 set hasworktree [hasworktree]
11808 if {[expr {[exec git rev-parse --is-inside-work-tree] == "true"}]} {
11809 set cdup [exec git rev-parse --show-cdup]
11811 set worktree [exec git rev-parse --show-toplevel]
11815 image create photo gitlogo -width 16 -height 16
11817 image create photo gitlogominus -width 4 -height 2
11818 gitlogominus put #C00000 -to 0 0 4 2
11819 gitlogo copy gitlogominus -to 1 5
11820 gitlogo copy gitlogominus -to 6 5
11821 gitlogo copy gitlogominus -to 11 5
11822 image delete gitlogominus
11824 image create photo gitlogoplus -width 4 -height 4
11825 gitlogoplus put #008000 -to 1 0 3 4
11826 gitlogoplus put #008000 -to 0 1 4 3
11827 gitlogo copy gitlogoplus -to 1 9
11828 gitlogo copy gitlogoplus -to 6 9
11829 gitlogo copy gitlogoplus -to 11 9
11830 image delete gitlogoplus
11832 image create photo gitlogo32 -width 32 -height 32
11833 gitlogo32 copy gitlogo -zoom 2 2
11835 wm iconphoto . -default gitlogo gitlogo32
11837 # wait for the window to become visible
11838 tkwait visibility .
11839 wm title . "$appname: [reponame]"
11843 if {$cmdline_files ne {} || $revtreeargs ne {} || $revtreeargscmd ne {}} {
11844 # create a view for the files/dirs specified on the command line
11848 set viewname(1) [mc "Command line"]
11849 set viewfiles(1) $cmdline_files
11850 set viewargs(1) $revtreeargs
11851 set viewargscmd(1) $revtreeargscmd
11855 .bar.view entryconf [mca "Edit view..."] -state normal
11856 .bar.view entryconf [mca "Delete view"] -state normal
11859 if {[info exists permviews]} {
11860 foreach v $permviews {
11863 set viewname($n) [lindex $v 0]
11864 set viewfiles($n) [lindex $v 1]
11865 set viewargs($n) [lindex $v 2]
11866 set viewargscmd($n) [lindex $v 3]
11872 if {[tk windowingsystem] eq "win32"} {
11880 # indent-tabs-mode: t