French translation: copy -> copie.
[git/dscho.git] / gitk-git / gitk
blob2bd62e220c80a4d69dabde6129f1ed4b8324a51a
1 #!/bin/sh
2 # Tcl ignores the next line -*- tcl -*- \
3 exec wish "$0" -- "$@"
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.
10 package require Tk
12 proc hasworktree {} {
13 return [expr {[exec git rev-parse --is-bare-repository] == "false" &&
14 [exec git rev-parse --is-inside-git-dir] == "false"}]
17 proc reponame {} {
18 global gitdir
19 set n [file normalize $gitdir]
20 if {[string match "*/.git" $n]} {
21 set n [string range $n 0 end-5]
23 return [file tail $n]
26 proc gitworktree {} {
27 variable _gitworktree
28 if {[info exists _gitworktree]} {
29 return $_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]]
43 return $_gitworktree
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.
51 proc run args {
52 global isonrunq runq currunq
54 set script $args
55 if {[info exists isonrunq($script)]} return
56 if {$runq eq {} && ![info exists currunq]} {
57 after idle dorunq
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} {
68 global runq currunq
70 fileevent $fd readable {}
71 if {$runq eq {} && ![info exists currunq]} {
72 after idle dorunq
74 lappend runq [list $fd $script]
77 proc nukefile {fd} {
78 global runq
80 for {set i 0} {$i < [llength $runq]} {} {
81 if {[lindex $runq $i 0] eq $fd} {
82 set runq [lreplace $runq $i $i]
83 } else {
84 incr i
89 proc dorunq {} {
90 global isonrunq runq currunq
92 set tstart [clock clicks -milliseconds]
93 set t0 $tstart
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]
100 unset currunq
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]
108 } else {
109 fileevent $fd readable [list filereadable $fd $script]
111 } elseif {$fd eq {}} {
112 unset isonrunq($script)
114 set t0 $t1
115 if {$t1 - $tstart >= 80} break
117 if {$runq ne {}} {
118 after idle dorunq
122 proc reg_instance {fd} {
123 global commfd leftover loginstance
125 set i [incr loginstance]
126 set commfd($i) $fd
127 set leftover($i) {}
128 return $i
131 proc unmerged_files {files} {
132 global nr_unmerged
134 # find the list of unmerged files
135 set mlist {}
136 set nr_unmerged 0
137 if {[catch {
138 set fd [open "| git ls-files -u" r]
139 } err]} {
140 show_error {} . "[mc "Couldn't get list of unmerged files:"] $err"
141 exit 1
143 while {[gets $fd line] >= 0} {
144 set i [string first "\t" $line]
145 if {$i < 0} continue
146 set fname [string range $line [expr {$i+1}] end]
147 if {[lsearch -exact $mlist $fname] >= 0} continue
148 incr nr_unmerged
149 if {$files eq {} || [path_filter $files $fname]} {
150 lappend mlist $fname
153 catch {close $fd}
154 return $mlist
157 proc parseviewargs {n arglist} {
158 global vdatemode vmergeonly vflags vdflags vrevs vfiltered vorigargs env
159 global worddiff git_version
161 set vdatemode($n) 0
162 set vmergeonly($n) 0
163 set glflags {}
164 set diffargs {}
165 set nextisval 0
166 set revargs {}
167 set origargs $arglist
168 set allknown 1
169 set filtered 0
170 set i -1
171 foreach arg $arglist {
172 incr i
173 if {$nextisval} {
174 lappend glflags $arg
175 set nextisval 0
176 continue
178 switch -glob -- $arg {
179 "-d" -
180 "--date-order" {
181 set vdatemode($n) 1
182 # remove from origargs in case we hit an unknown option
183 set origargs [lreplace $origargs $i $i]
184 incr i -1
186 "-[puabwcrRBMC]" -
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"]
213 "--word-diff*" {
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
223 lappend glflags $arg
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
233 set filtered 1
234 lappend glflags $arg
236 "-n" {
237 # This appears to be the only one that has a value as a
238 # separate word following it
239 set filtered 1
240 set nextisval 1
241 lappend glflags $arg
243 "--not" - "--all" {
244 lappend revargs $arg
246 "--merge" {
247 set vmergeonly($n) 1
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"
254 "-*" {
255 # Other flag arguments including -<n>
256 if {[string is digit -strict [string range $arg 1 end]]} {
257 set filtered 1
258 } else {
259 # a flag argument that we don't recognize;
260 # that means we can't optimize
261 set allknown 0
263 lappend glflags $arg
265 default {
266 # Non-flag arguments specify commits or ranges of commits
267 if {[string match "*...*" $arg]} {
268 lappend revargs --gitk-symmetric-diff-marker
270 lappend revargs $arg
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
279 return $allknown
282 proc parseviewrevs {view revs} {
283 global vposids vnegids
285 if {$revs eq {}} {
286 set revs HEAD
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"]
292 set badrev {}
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]
298 && $badrev ne {}} {
299 if {[llength $badrev] == 1} {
300 set err "unknown revision $badrev"
301 } else {
302 set err "unknown revisions: [join $badrev ", "]"
304 } else {
305 set err [join [lrange $errlines $l end] "\n"]
307 break
309 lappend badrev $line
312 error_popup "[mc "Error parsing revisions:"] $err"
313 return {}
315 set ret {}
316 set pos {}
317 set neg {}
318 set sdm 0
319 foreach id [split $ids "\n"] {
320 if {$id eq "--gitk-symmetric-diff-marker"} {
321 set sdm 4
322 } elseif {[string match "^*" $id]} {
323 if {$sdm != 1} {
324 lappend ret $id
325 if {$sdm == 3} {
326 set sdm 0
329 lappend neg [string range $id 1 end]
330 } else {
331 if {$sdm != 2} {
332 lappend ret $id
333 } else {
334 lset ret end $id...[lindex $ret end]
336 lappend pos $id
338 incr sdm -1
340 set vposids($view) $pos
341 set vnegids($view) $neg
342 return $ret
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
348 global tclencoding
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
354 global show_notes
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
361 varcinit $view
363 set args $viewargs($view)
364 if {$viewargscmd($view) ne {}} {
365 if {[catch {
366 set str [exec sh -c $viewargscmd($view)]
367 } err]} {
368 error_popup "[mc "Error executing --argscmd command:"] $err"
369 return 0
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]
378 if {$files eq {}} {
379 global nr_unmerged
380 if {$nr_unmerged == 0} {
381 error_popup [mc "No files selected: --merge specified but\
382 no files are unmerged."]
383 } else {
384 error_popup [mc "No files selected: --merge specified but\
385 no unmerged files are within file limit."]
387 return 0
390 set vfilelimit($view) $files
392 if {$vcanopt($view)} {
393 set revs [parseviewrevs $view $vrevs($view)]
394 if {$revs eq {}} {
395 return 0
397 set args [limit_arg_length [concat $vflags($view) $revs]]
398 } else {
399 set args $vorigargs($view)
402 if {[catch {
403 set fd [open [concat | git log --no-color -z --pretty=raw $show_notes \
404 --parents --boundary $args "--" $files] r]
405 } err]} {
406 error_popup "[mc "Error executing git log:"] $err"
407 return 0
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
427 return 1
430 proc stop_instance {inst} {
431 global commfd leftover
433 set fd $commfd($inst)
434 catch {
435 set pid [pid $fd]
437 if {$::tcl_platform(platform) eq {windows}} {
438 exec kill -f $pid
439 } else {
440 exec kill $pid
443 catch {close $fd}
444 nukefile $fd
445 unset commfd($inst)
446 unset leftover($inst)
449 proc stop_backends {} {
450 global commfd
452 foreach inst [array names commfd] {
453 stop_instance $inst
457 proc stop_rev_list {view} {
458 global viewinstances
460 foreach inst $viewinstances($view) {
461 stop_instance $inst
463 set viewinstances($view) {}
466 proc reset_pending_select {selid} {
467 global pending_select mainheadid selectheadid
469 if {$selid ne {}} {
470 set pending_select $selid
471 } elseif {$selectheadid ne {}} {
472 set pending_select $selectheadid
473 } else {
474 set pending_select $mainheadid
478 proc getcommits {selid} {
479 global canv curview need_redisplay viewactive
481 initlayout
482 if {[start_rev_list $curview]} {
483 reset_pending_select $selid
484 show_status [mc "Reading commits..."]
485 set need_redisplay 1
486 } else {
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
496 global hasworktree
497 global varcid vposids vnegids vflags vrevs
498 global show_notes
500 set hasworktree [hasworktree]
501 rereadrefs
502 set view $curview
503 if {$mainheadid ne $viewmainheadid_orig($view)} {
504 if {$showlocalchanges} {
505 dohidelocalchanges
507 set viewmainheadid($view) $mainheadid
508 set viewmainheadid_orig($view) $mainheadid
509 if {$vfilelimit($view) ne {}} {
510 get_viewmainhead $view
513 if {$showlocalchanges} {
514 doshowlocalchanges
516 if {$vcanopt($view)} {
517 set oldpos $vposids($view)
518 set oldneg $vnegids($view)
519 set revs [parseviewrevs $view $vrevs($view)]
520 if {$revs eq {}} {
521 return
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)} {
527 set newrevs {}
528 set npos 0
529 # take out positive refs that we asked for before or
530 # that we have already seen
531 foreach rev $revs {
532 if {[string length $rev] == 40} {
533 if {[lsearch -exact $oldpos $rev] < 0
534 && ![info exists varcid($view,$rev)]} {
535 lappend newrevs $rev
536 incr npos
538 } else {
539 lappend $newrevs $rev
542 if {$npos == 0} return
543 set revs $newrevs
544 set vposids($view) [lsort -unique [concat $oldpos $vposids($view)]]
546 set args [concat $vflags($view) $revs --not $oldpos]
547 } else {
548 set args $vorigargs($view)
550 if {[catch {
551 set fd [open [concat | git log --no-color -z --pretty=raw $show_notes \
552 --parents --boundary $args "--" $vfilelimit($view)] r]
553 } err]} {
554 error_popup "[mc "Error executing git log:"] $err"
555 return
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"]
571 if {$showneartags} {
572 getallcommits
576 proc reloadcommits {} {
577 global curview viewcomplete selectedline currentid thickerline
578 global showneartags treediffs commitinterest cached_commitrow
579 global targetid
581 set selid {}
582 if {$selectedline ne {}} {
583 set selid $currentid
586 if {!$viewcomplete($curview)} {
587 stop_rev_list $curview
589 resetvarcs $curview
590 set selectedline {}
591 catch {unset currentid}
592 catch {unset thickerline}
593 catch {unset treediffs}
594 readrefs
595 changedrefs
596 if {$showneartags} {
597 getallcommits
599 clear_display
600 catch {unset commitinterest}
601 catch {unset cached_commitrow}
602 catch {unset targetid}
603 setcanvscroll
604 getcommits $selid
605 return 0
608 # This makes a string representation of a positive integer which
609 # sorts as a string in numerical order
610 proc strrep {n} {
611 if {$n < 16} {
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) {}
636 set varcmod($view) 0
637 set vrowmod($view) 0
638 set varcix($view) {{}}
639 set vlastins($view) {0}
642 proc resetvarcs {view} {
643 global varcid varccommits parents children vseedcount ordertok
644 global vshortids
646 foreach vid [array names varcid $view,*] {
647 unset varcid($vid)
648 unset children($vid)
649 unset parents($vid)
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,*] {
656 unset children($vid)
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
668 proc seeds {v} {
669 global vdownptr vleftptr varcstart
671 set ret {}
672 set a [lindex $vdownptr($v) 0]
673 while {$a != 0} {
674 lappend ret [lindex $varcstart($v) $a]
675 set a [lindex $vleftptr($v) $a]
677 return $ret
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)]
686 set vid $view,$id
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]} {
693 set cdate 0
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]"
701 } else {
702 set tok {}
704 set ka 0
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} {
709 set ki $kid
710 set ka $k
711 set tok [lindex $varctok($view) $k]
714 if {$ka != 0} {
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} {
721 set c $ka
722 set b [lindex $vdownptr($view) $ka]
723 } else {
724 set b [lindex $vleftptr($view) $c]
726 while {$b != 0 && [string compare $tok [lindex $varctok($view) $b]] >= 0} {
727 set c $b
728 set b [lindex $vleftptr($view) $c]
730 if {$c == $ka} {
731 lset vdownptr($view) $ka $a
732 lappend vbackptr($view) 0
733 } else {
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
740 if {$b != 0} {
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
750 return $a
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]
761 if {$i <= 0} return
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} {
785 modify_arc $v $oa
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]
794 set todo {}
795 set isrelated($a) 1
796 set kidchanged($a) 1
797 set ntot 0
798 while {$a != 0} {
799 if {[info exists isrelated($a)]} {
800 lappend todo $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
808 incr ntot
809 set b [lindex $vdownptr($v) $a]
810 if {$b == 0} {
811 while {$a != 0} {
812 set b [lindex $vleftptr($v) $a]
813 if {$b != 0} break
814 set a [lindex $vupptr($v) $a]
817 set a $b
819 foreach a $todo {
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] \
824 $children($v,$id)]
826 set oldtok [lindex $varctok($v) $a]
827 if {!$vdatemode($v)} {
828 set tok {}
829 } else {
830 set tok $oldtok
832 set ka 0
833 set kid [last_real_child $v,$id]
834 if {$kid ne {}} {
835 set k $varcid($v,$kid)
836 if {[string compare [lindex $varctok($v) $k] $tok] > 0} {
837 set ki $kid
838 set ka $k
839 set tok [lindex $varctok($v) $k]
842 if {$ka != 0} {
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} {
848 continue
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
854 } else {
855 set sortkids($p) 1
858 lset varctok($v) $a $tok
859 set b [lindex $vupptr($v) $a]
860 if {$b != $ka} {
861 if {[string compare [lindex $varctok($v) $ka] $vtokmod($v)] < 0} {
862 modify_arc $v $ka
864 if {[string compare [lindex $varctok($v) $b] $vtokmod($v)] < 0} {
865 modify_arc $v $b
867 set c [lindex $vbackptr($v) $a]
868 set d [lindex $vleftptr($v) $a]
869 if {$c == 0} {
870 lset vdownptr($v) $b $d
871 } else {
872 lset vleftptr($v) $c $d
874 if {$d != 0} {
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]
882 if {$c == 0 || \
883 [string compare $tok [lindex $varctok($v) $c]] < 0} {
884 set c $ka
885 set b [lindex $vdownptr($v) $ka]
886 } else {
887 set b [lindex $vleftptr($v) $c]
889 while {$b != 0 && \
890 [string compare $tok [lindex $varctok($v) $b]] >= 0} {
891 set c $b
892 set b [lindex $vleftptr($v) $c]
894 if {$c == $ka} {
895 lset vdownptr($v) $ka $a
896 lset vbackptr($v) $a 0
897 } else {
898 lset vleftptr($v) $c $a
899 lset vbackptr($v) $a $c
901 lset vleftptr($v) $a $b
902 if {$b != 0} {
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] \
911 $children($v,$id)]
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]} {
926 splitvarc $p $v
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} {
933 renumbervarc $pa $v
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
942 readcommit $id
943 set vid $v,$id
944 set cmitlisted($vid) 1
945 set children($vid) {}
946 set parents($vid) [list $p]
947 set a [newvarc $v $id]
948 set varcid($vid) $a
949 lappend vshortids($v,[string range $id 0 3]) $id
950 if {[string compare [lindex $varctok($v) $a] $vtokmod($v)] < 0} {
951 modify_arc $v $a
953 lappend varccommits($v,$a) $id
954 set vp $v,$p
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
960 incr commitidx($v)
961 if {$v == $curview} {
962 set numcommits $commitidx($v)
963 setcanvscroll
964 if {[info exists targetid]} {
965 if {![comes_before $targetid $p]} {
966 incr targetrow
972 proc insertfakerow {id p} {
973 global varcid varccommits parents children cmitlisted
974 global commitidx varctok vtokmod targetid targetrow curview numcommits
976 set v $curview
977 set a $varcid($v,$p)
978 set i [lsearch -exact $varccommits($v,$a) $p]
979 if {$i < 0} {
980 puts "oops: insertfakerow can't find [shortids $p] on arc $a"
981 return
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]
991 modify_arc $v $a $i
992 if {[info exists targetid]} {
993 if {![comes_before $targetid $p]} {
994 incr targetrow
997 setcanvscroll
998 drawvisible
1001 proc removefakerow {id} {
1002 global varcid varccommits parents children commitidx
1003 global varctok vtokmod cmitlisted currentid selectedline
1004 global targetid curview numcommits
1006 set v $curview
1007 if {[llength $parents($v,$id)] != 1} {
1008 puts "oops: removefakerow [shortids $id] has [llength $parents($v,$id)] parents"
1009 return
1011 set p [lindex $parents($v,$id) 0]
1012 set a $varcid($v,$id)
1013 set i [lsearch -exact $varccommits($v,$a) $id]
1014 if {$i < 0} {
1015 puts "oops: removefakerow can't find [shortids $id] on arc $a"
1016 return
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]
1025 if {$j >= 0} {
1026 set children($v,$p) [lreplace $children($v,$p) $j $j]
1028 modify_arc $v $a $i
1029 if {[info exist currentid] && $id eq $currentid} {
1030 unset currentid
1031 set selectedline {}
1033 if {[info exists targetid] && $targetid eq $id} {
1034 set targetid $p
1036 setcanvscroll
1037 drawvisible
1040 proc real_children {vp} {
1041 global children nullid nullid2
1043 set kids {}
1044 foreach id $children($vp) {
1045 if {$id ne $nullid && $id ne $nullid2} {
1046 lappend kids $id
1049 return $kids
1052 proc first_real_child {vp} {
1053 global children nullid nullid2
1055 foreach id $children($vp) {
1056 if {$id ne $nullid && $id ne $nullid2} {
1057 return $id
1060 return {}
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} {
1070 return $id
1073 return {}
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
1088 if {$lim ne {}} {
1089 set c [string compare [lindex $varctok($v) $a] $vtokmod($v)]
1090 if {$c > 0} return
1091 if {$c == 0} {
1092 set r [lindex $varcrow($v) $a]
1093 if {$r ne {} && $vrowmod($v) <= $r + $lim} return
1096 set vtokmod($v) [lindex $varctok($v) $a]
1097 set varcmod($v) $a
1098 if {$v == $curview} {
1099 while {$a != 0 && [lindex $varcrow($v) $a] eq {}} {
1100 set a [lindex $vupptr($v) $a]
1101 set lim {}
1103 set r 0
1104 if {$a != 0} {
1105 if {$lim eq {}} {
1106 set lim [llength $varccommits($v,$a)]
1108 set r [expr {[lindex $varcrow($v) $a] + $lim}]
1110 set vrowmod($v) $r
1111 undolayout $r
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}]
1130 set a $varcmod($v)
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]
1136 if {$a == 0} {
1137 set a [lindex $vdownptr($v) 0]
1138 if {$a == 0} return
1139 set vrownum($v) {0}
1140 set varcorder($v) [list $a]
1141 lset varcix($v) $a 0
1142 lset varcrow($v) $a 0
1143 set arcn 0
1144 set row 0
1145 } else {
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]
1153 while {1} {
1154 set p $a
1155 incr row [llength $varccommits($v,$a)]
1156 # go down if possible
1157 set b [lindex $vdownptr($v) $a]
1158 if {$b == 0} {
1159 # if not, go left, or go up until we can go left
1160 while {$a != 0} {
1161 set b [lindex $vleftptr($v) $a]
1162 if {$b != 0} break
1163 set a [lindex $vupptr($v) $a]
1165 if {$a == 0} break
1167 set a $b
1168 incr arcn
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]
1175 set varcmod($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} {
1184 global varcid
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
1194 set v $curview
1195 if {![info exists varcid($v,$id)]} {
1196 puts "oops rowofcommit no arc for [shortids $id]"
1197 return {}
1199 set a $varcid($v,$id)
1200 if {[string compare [lindex $varctok($v) $a] $vtokmod($v)] >= 0} {
1201 update_arcrows $v
1203 if {[info exists cached_commitrow($id)]} {
1204 return $cached_commitrow($id)
1206 set i [lsearch -exact $varccommits($v,$a) $id]
1207 if {$i < 0} {
1208 puts "oops didn't find commit [shortids $id] in arc $a"
1209 return {}
1211 incr i [lindex $varcrow($v) $a]
1212 set cached_commitrow($id) $i
1213 return $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
1220 set v $curview
1221 if {$a eq $b || ![info exists varcid($v,$a)] || \
1222 ![info exists varcid($v,$b)]} {
1223 return 0
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]} {
1234 return 0
1236 set lo 0
1237 set hi [llength $l]
1238 while {$hi - $lo > 1} {
1239 set mid [expr {int(($lo + $hi) / 2)}]
1240 set t [lindex $l $mid]
1241 if {$elt < $t} {
1242 set hi $mid
1243 } elseif {$elt > $t} {
1244 set lo $mid
1245 } else {
1246 return $mid
1249 return $lo
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} {
1269 if {$l < $r} {
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 {}} {
1282 set i $r
1283 foreach id $varccommits($curview,$a) {
1284 lset displayorder $i $id
1285 lset parentlist $i $parents($curview,$id)
1286 incr i
1289 incr r $al
1293 proc commitonrow {row} {
1294 global displayorder
1296 set id [lindex $displayorder $row]
1297 if {$id eq {}} {
1298 make_disporder $row [expr {$row + 1}]
1299 set id [lindex $displayorder $row]
1301 return $id
1304 proc closevarcs {v} {
1305 global varctok varccommits varcid parents children
1306 global cmitlisted commitidx vtokmod
1308 set missing_parents 0
1309 set scripts {}
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} {
1321 set b $a
1322 } else {
1323 set b [newvarc $v $p]
1325 set varcid($v,$p) $b
1326 if {[string compare [lindex $varctok($v) $b] $vtokmod($v)] < 0} {
1327 modify_arc $v $b
1329 lappend varccommits($v,$b) $p
1330 incr commitidx($v)
1331 set scripts [check_interest $p $scripts]
1334 if {$missing_parents > 0} {
1335 foreach s $scripts {
1336 eval $s
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]
1349 if {$i < 0} {
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)]} {
1383 set newlist {}
1384 foreach {i script} $commitinterest($prefix) {
1385 if {[string match "$i*" $id]} {
1386 lappend scripts [string map [list "%I" $id "%P" $i] $script]
1387 } else {
1388 lappend newlist $i $script
1391 if {$newlist ne {}} {
1392 set commitinterest($prefix) $newlist
1393 } else {
1394 unset commitinterest($prefix)
1397 return $scripts
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]} {
1410 set stuff "\0"
1412 if {$stuff == {}} {
1413 if {![eof $fd]} {
1414 return 1
1416 global commfd viewcomplete viewactive viewname
1417 global viewinstances
1418 unset commfd($inst)
1419 set i [lsearch -exact $viewinstances($view) $inst]
1420 if {$i >= 0} {
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]} {
1426 set fv {}
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"} {
1434 append err \
1435 " (Note: arguments to gitk are passed to git log\
1436 to allow selection of commits to be displayed.)"
1438 } else {
1439 set err "Error reading commits$fv: $err"
1441 error_popup $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
1447 closevarcs $view
1448 notbusy $view
1450 if {$view == $curview} {
1451 run chewcommits
1453 return 0
1455 set start 0
1456 set gotsome 0
1457 set scripts {}
1458 while 1 {
1459 set i [string first "\0" $stuff $start]
1460 if {$i < 0} {
1461 append leftover($inst) [string range $stuff $start end]
1462 break
1464 if {$start == 0} {
1465 set cmit $leftover($inst)
1466 append cmit [string range $stuff 0 [expr {$i - 1}]]
1467 set leftover($inst) {}
1468 } else {
1469 set cmit [string range $stuff $start [expr {$i - 1}]]
1471 set start [expr {$i + 1}]
1472 set j [string first "\n" $cmit]
1473 set ok 0
1474 set listed 1
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] {
1479 "-" {set listed 0}
1480 "^" {set listed 2}
1481 "<" {set listed 3}
1482 ">" {set listed 4}
1484 set ids [string range $ids 1 end]
1486 set ok 1
1487 foreach id $ids {
1488 if {[string length $id] != 40} {
1489 set ok 0
1490 break
1494 if {!$ok} {
1495 set shortcmit $cmit
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}"
1500 exit 1
1502 set id [lindex $ids 0]
1503 set vid $view,$id
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.
1514 if {![catch {
1515 set rwid [exec git rev-list --first-parent --max-count=1 \
1516 $id -- $vfilelimit($view)]
1517 }]} {
1518 if {$rwid ne {} && [info exists varcid($view,$rwid)]} {
1519 # use $rwid in place of $id
1520 rewrite_commit $view $id $rwid
1521 continue
1526 set a 0
1527 if {[info exists varcid($vid)]} {
1528 if {$cmitlisted($vid) || !$listed} continue
1529 set a $varcid($vid)
1531 if {$listed} {
1532 set olds [lrange $ids 1 end]
1533 } else {
1534 set olds {}
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)
1549 if {$a == 0} {
1550 # new arc
1551 set a [newvarc $view $id]
1553 if {[string compare [lindex $varctok($view) $a] $vtokmod($view)] < 0} {
1554 modify_arc $view $a
1556 if {![info exists varcid($vid)]} {
1557 set varcid($vid) $a
1558 lappend varccommits($view,$a) $id
1559 incr commitidx($view)
1562 set i 0
1563 foreach p $olds {
1564 if {$i == 0 || [lsearch -exact $olds $p] >= $i} {
1565 set vp $view,$p
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] \
1569 $children($vp)]
1570 catch {unset ordertok}
1572 if {[info exists varcid($view,$p)]} {
1573 fix_reversal $p $a $view
1576 incr i
1579 set scripts [check_interest $id $scripts]
1580 set gotsome 1
1582 if {$gotsome} {
1583 global numcommits hlview
1585 if {$view == $curview} {
1586 set numcommits $commitidx($view)
1587 run chewcommits
1589 if {[info exists hlview] && $view == $hlview} {
1590 # we never actually get here...
1591 run vhighlightmore
1593 foreach s $scripts {
1594 eval $s
1597 return 2
1600 proc chewcommits {} {
1601 global curview hlview viewcomplete
1602 global pending_select
1604 layoutmore
1605 if {$viewcomplete($curview)} {
1606 global commitidx varctok
1607 global numcommits startmsecs
1609 if {[info exists pending_select]} {
1610 update
1611 reset_pending_select {}
1613 if {[commitinview $pending_select $curview]} {
1614 selectline [rowofcommit $pending_select] 1
1615 } else {
1616 set row [first_real_row]
1617 selectline $row 1
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"
1624 } else {
1625 show_status [mc "No commits selected"]
1627 notbusy layout
1629 return 0
1632 proc do_readcommit {id} {
1633 global tclencoding
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]
1643 close $fd
1644 # Remove the heading line
1645 regsub {^commit [0-9a-f]+\n} $contents {} contents
1647 return $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} {
1656 global commitinfo
1658 set inhdr 1
1659 set comment {}
1660 set headline {}
1661 set auname {}
1662 set audate {}
1663 set comname {}
1664 set comdate {}
1665 set hdrend [string first "\n\n" $contents]
1666 if {$hdrend < 0} {
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] " "]
1683 set headline {}
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]
1687 if {$i >= 0} {
1688 set headline [string range $headline 0 $i]
1690 set headline [string trimright $headline]
1691 set i [string first "\r" $headline]
1692 if {$i >= 0} {
1693 set headline [string trimright [string range $headline 0 $i]]
1695 if {!$listed} {
1696 # git log indents the comment by 4 spaces;
1697 # if we got this via git cat-file, add the indentation
1698 set newcomment {}
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
1716 } else {
1717 readcommit $id
1718 if {![info exists commitinfo($id)]} {
1719 set commitinfo($id) [list [mc "No commit information available"]]
1722 return 1
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
1731 set ids {}
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} {
1738 lappend ids $id
1739 if {[llength $ids] >= 2} break
1744 } else {
1745 foreach match [array names varcid "$curview,$prefix*"] {
1746 lappend ids [lindex [split $match ","] 1]
1747 if {[llength $ids] >= 2} break
1750 return $ids
1753 proc readrefs {} {
1754 global tagids idtags headids idheads tagobjid
1755 global otherrefids idotherrefs mainhead mainheadid
1756 global selecthead selectheadid
1757 global hideremotes
1759 foreach v {tagids idtags headids idheads otherrefids idotherrefs} {
1760 catch {unset $v}
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]
1784 } else {
1785 set tagobjid($name) $id
1787 set tagids($name) $id
1788 lappend idtags($id) $name
1789 } else {
1790 set otherrefids($name) $id
1791 lappend idotherrefs($id) $name
1794 catch {close $refd}
1795 set mainhead {}
1796 set mainheadid {}
1797 catch {
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]
1804 set selectheadid {}
1805 if {$selecthead ne {}} {
1806 catch {
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} {
1819 break
1822 return $row
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} {
1839 unset idheads($id)
1840 } else {
1841 set i [lsearch -exact $idheads($id) $name]
1842 if {$i >= 0} {
1843 set idheads($id) [lreplace $idheads($id) $i $i]
1846 unset headids($name)
1849 proc ttk_toplevel {w args} {
1850 global use_ttk
1851 eval [linsert $args 0 ::toplevel $w]
1852 if {$use_ttk} {
1853 place [ttk::frame $w._toplevel_background] -x 0 -y 0 -relwidth 1 -relheight 1
1855 return $w
1858 proc make_transient {window origin} {
1859 global have_tk85
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
1864 # the parent.
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}} {
1877 global NS
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"
1888 tkwait window $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
1895 } else {
1896 set w .error
1897 ttk_toplevel $w
1898 make_transient $w $owner
1899 show_error $w $w $msg
1903 proc confirm_popup {msg {owner .}} {
1904 global confirm_ok NS
1905 set confirm_ok 0
1906 set w .confirm
1907 ttk_toplevel $w
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
1920 tkwait window $w
1921 return $confirm_ok
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
1931 } else {
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} {
1956 menu $m
1957 if {[tk windowingsystem] eq {aqua}} {
1958 set Meta1 Cmd
1959 } else {
1960 set Meta1 Ctrl
1962 foreach i $items {
1963 set name [mc [lindex $i 1]]
1964 set type [lindex $i 2]
1965 set thing [lindex $i 3]
1966 set params [list $type]
1967 if {$name ne {}} {
1968 set u [string first "&" [string map {&& x} $name]]
1969 lappend params -label [string map {&& & & {}} $name]
1970 if {$u >= 0} {
1971 lappend params -underline $u
1974 switch -- $type {
1975 "cascade" {
1976 set submenu [string tolower [string map {& ""} [lindex $i 1]]]
1977 lappend params -menu $m.$submenu
1979 "command" {
1980 lappend params -command $thing
1982 "radiobutton" {
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
1997 proc mca {str} {
1998 return [string map {&& & & {}} [mc $str]]
2001 proc makedroplist {w varname args} {
2002 global use_ttk
2003 if {$use_ttk} {
2004 set width 0
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]
2011 } else {
2012 set gm [eval [linsert $args 0 tk_optionMenu $w $varname]]
2014 return $gm
2017 proc makewindow {} {
2018 global canv canv2 canv3 linespc charspc ctext cflist cscroll
2019 global tabstop
2020 global findtype findtypemenu findloc findstring fstring geometry
2021 global entries sha1entry sha1string sha1but
2022 global diffcontextstring diffcontext
2023 global ignorespace
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
2033 global git_version
2034 global worddiff
2036 # The "mc" arguments here are purely so that xgettext
2037 # sees the following string as needing to be translated
2038 set file {
2039 mc "File" cascade {
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}
2044 {xx "" separator}
2045 {mc "Start git gui" command {exec git gui &}}
2046 {xx "" separator}
2047 {mc "Quit" command doquit -accelerator Meta1-Q}
2049 set edit {
2050 mc "Edit" cascade {
2051 {mc "Preferences" command doprefs}
2053 set view {
2054 mc "View" cascade {
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}
2058 {xx "" separator}
2059 {mc "All files" radiobutton {selectedview 0} -command {showview 0}}
2061 if {[tk windowingsystem] ne "aqua"} {
2062 set help {
2063 mc "Help" cascade {
2064 {mc "About gitk" command about}
2065 {mc "Key bindings" command keys}
2067 set bar [list $file $edit $view $help]
2068 } else {
2069 proc ::tk::mac::ShowPreferences {} {doprefs}
2070 proc ::tk::mac::Quit {} {doquit}
2071 lset file end [lreplace [lindex $file end] end-1 end]
2072 set apple {
2073 xx "Apple" cascade {
2074 {mc "About gitk" command about}
2075 {xx "" separator}
2077 set help {
2078 mc "Help" cascade {
2079 {mc "Key bindings" command keys}
2081 set bar [list $apple $file $view $help]
2083 makemenu .bar $bar
2084 . configure -menu .bar
2086 if {$use_ttk} {
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
2108 if {!$use_ttk} {
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
2115 canvas $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
2121 canvas $canv2 \
2122 -selectbackground $selectbgcolor \
2123 -background $bgcolor -bd 0 -yscrollincr $linespc
2124 .tf.histframe.pwclist add $canv2
2125 set canv3 .tf.histframe.pwclist.canv3
2126 canvas $canv3 \
2127 -selectbackground $selectbgcolor \
2128 -background $bgcolor -bd 0 -yscrollincr $linespc
2129 .tf.histframe.pwclist add $canv3
2130 if {$use_ttk} {
2131 bind .tf.histframe.pwclist <Map> {
2132 bind %W <Map> {}
2133 .tf.histframe.pwclist sashpos 1 [lindex $::geometry(pwsash1) 0]
2134 .tf.histframe.pwclist sashpos 0 [lindex $::geometry(pwsash0) 0]
2136 } else {
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"]
2188 set rownumsel {}
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 \
2195 -side left
2196 if {!$use_ttk} {
2197 foreach w {rownum numcommits} {.tf.bar.$w configure -font textfont}
2199 global selectedline
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
2206 if {$use_ttk} {
2207 set progresscanv [ttk::progressbar .tf.bar.progress]
2208 } else {
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}
2218 set fprogcoord 0
2219 set rprogcoord 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 \
2230 -side left -fill y
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
2239 set findstring {}
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
2260 .ctop add .tf
2261 if {!$use_ttk} {
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)
2274 } else {
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
2284 set searchstring ""
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"
2322 if {$have_tk85} {
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
2360 set mergemax 16
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
2366 if {!$use_ttk} {
2367 .pwbottom paneconfigure .bleft -width $geometry(botwidth)
2370 # lower right
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"]
2381 text $cflist \
2382 -selectbackground $selectbgcolor \
2383 -background $bgcolor -foreground $fgcolor \
2384 -font mainfont \
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
2399 .ctop add .pwbottom
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}} {
2419 set M1B M1
2420 set ::BM "3"
2421 } else {
2422 set M1B Control
2423 set ::BM "2"
2426 if {$use_ttk} {
2427 bind .ctop <Map> {
2428 bind %W <Map> {}
2429 %W sashpos 0 $::geometry(topheight)
2431 bind .pwbottom <Map> {
2432 bind %W <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 }
2444 } else {
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"
2483 bindkey z "goback"
2484 bindkey x "goforw"
2485 bindkey k "selnextline -1"
2486 bindkey j "selnextline 1"
2487 bindkey h "goback"
2488 bindkey l "goforw"
2489 bindkey b prevfile
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}
2496 bindkey f nextfile
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}
2522 global ctxbut
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
2567 global flist_menu
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
2577 global diff_menu
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]
2592 if {$w ne ""} {
2593 set u [expr {$D < 0 ? 5 : -5}]
2594 if {$w == $canv || $w == $canv2 || $w == $canv3} {
2595 allcanvs yview scroll $u units
2596 } else {
2597 catch {
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 {}} {
2609 set rownumsel {}
2610 } else {
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] {
2620 if {$c == $w} {
2621 $c scan $op $x $y
2622 } else {
2623 $c scan $op 0 $y
2628 proc scrollcanv {cscroll f0 f1} {
2629 $cscroll set $f0 $f1
2630 drawvisible
2631 flushhighlights
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} {
2638 global entries
2639 bind . $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
2650 # the entry widgets
2651 proc click {w} {
2652 global ctext entries
2653 foreach e [concat $entries $ctext] {
2654 if {$w == $e} return
2656 focus .
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
2665 if {$use_ttk} {
2666 $progresscanv configure -value [expr {int($fprogcoord * 100)}]
2667 return
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
2680 update
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]
2693 update
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
2709 catch {
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]"
2747 if {$use_ttk} {
2748 puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sashpos 0] 1\""
2749 puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sashpos 1] 1\""
2750 } else {
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)]}"
2763 puts $f "}"
2764 close $f
2765 file rename -force "~/.gitk-new" "~/.gitk"
2767 set stuffsaved 1
2770 proc resizeclistpanes {win w} {
2771 global oldwidth use_ttk
2772 if {[info exists oldwidth($win)]} {
2773 if {$use_ttk} {
2774 set s0 [$win sashpos 0]
2775 set s1 [$win sashpos 1]
2776 } else {
2777 set s0 [$win sash coord 0]
2778 set s1 [$win sash coord 1]
2780 if {$w < 60} {
2781 set sash0 [expr {int($w/2 - 2)}]
2782 set sash1 [expr {int($w*5/6 - 2)}]
2783 } else {
2784 set factor [expr {1.0 * $w / $oldwidth($win)}]
2785 set sash0 [expr {int($factor * [lindex $s0 0])}]
2786 set sash1 [expr {int($factor * [lindex $s1 0])}]
2787 if {$sash0 < 30} {
2788 set sash0 30
2790 if {$sash1 < $sash0 + 20} {
2791 set sash1 [expr {$sash0 + 20}]
2793 if {$sash1 > $w - 10} {
2794 set sash1 [expr {$w - 10}]
2795 if {$sash0 > $sash1 - 20} {
2796 set sash0 [expr {$sash1 - 20}]
2800 if {$use_ttk} {
2801 $win sashpos 0 $sash0
2802 $win sashpos 1 $sash1
2803 } else {
2804 $win sash place 0 $sash0 [lindex $s0 1]
2805 $win sash place 1 $sash1 [lindex $s1 1]
2808 set oldwidth($win) $w
2811 proc resizecdetpanes {win w} {
2812 global oldwidth use_ttk
2813 if {[info exists oldwidth($win)]} {
2814 if {$use_ttk} {
2815 set s0 [$win sashpos 0]
2816 } else {
2817 set s0 [$win sash coord 0]
2819 if {$w < 60} {
2820 set sash0 [expr {int($w*3/4 - 2)}]
2821 } else {
2822 set factor [expr {1.0 * $w / $oldwidth($win)}]
2823 set sash0 [expr {int($factor * [lindex $s0 0])}]
2824 if {$sash0 < 45} {
2825 set sash0 45
2827 if {$sash0 > $w - 15} {
2828 set sash0 [expr {$w - 15}]
2831 if {$use_ttk} {
2832 $win sashpos 0 $sash0
2833 } else {
2834 $win sash place 0 $sash0 [lindex $s0 1]
2837 set oldwidth($win) $w
2840 proc allcanvs args {
2841 global canv canv2 canv3
2842 eval $canv $args
2843 eval $canv2 $args
2844 eval $canv3 $args
2847 proc bindall {event action} {
2848 global canv canv2 canv3
2849 bind $canv $event $action
2850 bind $canv2 $event $action
2851 bind $canv3 $event $action
2854 proc about {} {
2855 global uifont NS
2856 set w .about
2857 if {[winfo exists $w]} {
2858 raise $w
2859 return
2861 ttk_toplevel $w
2862 wm title $w [mc "About gitk"]
2863 make_transient $w .
2864 message $w.m -text [mc "
2865 Gitk - a commit viewer for git
2867 Copyright \u00a9 2005-2011 Paul Mackerras
2869 Use and redistribute under the terms of the GNU General Public License"] \
2870 -justify center -aspect 400 -border 2 -bg white -relief groove
2871 pack $w.m -side top -fill x -padx 2 -pady 2
2872 ${NS}::button $w.ok -text [mc "Close"] -command "destroy $w" -default active
2873 pack $w.ok -side bottom
2874 bind $w <Visibility> "focus $w.ok"
2875 bind $w <Key-Escape> "destroy $w"
2876 bind $w <Key-Return> "destroy $w"
2877 tk::PlaceWindow $w widget .
2880 proc keys {} {
2881 global NS
2882 set w .keys
2883 if {[winfo exists $w]} {
2884 raise $w
2885 return
2887 if {[tk windowingsystem] eq {aqua}} {
2888 set M1T Cmd
2889 } else {
2890 set M1T Ctrl
2892 ttk_toplevel $w
2893 wm title $w [mc "Gitk key bindings"]
2894 make_transient $w .
2895 message $w.m -text "
2896 [mc "Gitk key bindings:"]
2898 [mc "<%s-Q> Quit" $M1T]
2899 [mc "<%s-W> Close window" $M1T]
2900 [mc "<Home> Move to first commit"]
2901 [mc "<End> Move to last commit"]
2902 [mc "<Up>, p, k Move up one commit"]
2903 [mc "<Down>, n, j Move down one commit"]
2904 [mc "<Left>, z, h Go back in history list"]
2905 [mc "<Right>, x, l Go forward in history list"]
2906 [mc "<PageUp> Move up one page in commit list"]
2907 [mc "<PageDown> Move down one page in commit list"]
2908 [mc "<%s-Home> Scroll to top of commit list" $M1T]
2909 [mc "<%s-End> Scroll to bottom of commit list" $M1T]
2910 [mc "<%s-Up> Scroll commit list up one line" $M1T]
2911 [mc "<%s-Down> Scroll commit list down one line" $M1T]
2912 [mc "<%s-PageUp> Scroll commit list up one page" $M1T]
2913 [mc "<%s-PageDown> Scroll commit list down one page" $M1T]
2914 [mc "<Shift-Up> Find backwards (upwards, later commits)"]
2915 [mc "<Shift-Down> Find forwards (downwards, earlier commits)"]
2916 [mc "<Delete>, b Scroll diff view up one page"]
2917 [mc "<Backspace> Scroll diff view up one page"]
2918 [mc "<Space> Scroll diff view down one page"]
2919 [mc "u Scroll diff view up 18 lines"]
2920 [mc "d Scroll diff view down 18 lines"]
2921 [mc "<%s-F> Find" $M1T]
2922 [mc "<%s-G> Move to next find hit" $M1T]
2923 [mc "<Return> Move to next find hit"]
2924 [mc "/ Focus the search box"]
2925 [mc "? Move to previous find hit"]
2926 [mc "f Scroll diff view to next file"]
2927 [mc "<%s-S> Search for next hit in diff view" $M1T]
2928 [mc "<%s-R> Search for previous hit in diff view" $M1T]
2929 [mc "<%s-KP+> Increase font size" $M1T]
2930 [mc "<%s-plus> Increase font size" $M1T]
2931 [mc "<%s-KP-> Decrease font size" $M1T]
2932 [mc "<%s-minus> Decrease font size" $M1T]
2933 [mc "<F5> Update"]
2935 -justify left -bg white -border 2 -relief groove
2936 pack $w.m -side top -fill both -padx 2 -pady 2
2937 ${NS}::button $w.ok -text [mc "Close"] -command "destroy $w" -default active
2938 bind $w <Key-Escape> [list destroy $w]
2939 pack $w.ok -side bottom
2940 bind $w <Visibility> "focus $w.ok"
2941 bind $w <Key-Escape> "destroy $w"
2942 bind $w <Key-Return> "destroy $w"
2945 # Procedures for manipulating the file list window at the
2946 # bottom right of the overall window.
2948 proc treeview {w l openlevs} {
2949 global treecontents treediropen treeheight treeparent treeindex
2951 set ix 0
2952 set treeindex() 0
2953 set lev 0
2954 set prefix {}
2955 set prefixend -1
2956 set prefendstack {}
2957 set htstack {}
2958 set ht 0
2959 set treecontents() {}
2960 $w conf -state normal
2961 foreach f $l {
2962 while {[string range $f 0 $prefixend] ne $prefix} {
2963 if {$lev <= $openlevs} {
2964 $w mark set e:$treeindex($prefix) "end -1c"
2965 $w mark gravity e:$treeindex($prefix) left
2967 set treeheight($prefix) $ht
2968 incr ht [lindex $htstack end]
2969 set htstack [lreplace $htstack end end]
2970 set prefixend [lindex $prefendstack end]
2971 set prefendstack [lreplace $prefendstack end end]
2972 set prefix [string range $prefix 0 $prefixend]
2973 incr lev -1
2975 set tail [string range $f [expr {$prefixend+1}] end]
2976 while {[set slash [string first "/" $tail]] >= 0} {
2977 lappend htstack $ht
2978 set ht 0
2979 lappend prefendstack $prefixend
2980 incr prefixend [expr {$slash + 1}]
2981 set d [string range $tail 0 $slash]
2982 lappend treecontents($prefix) $d
2983 set oldprefix $prefix
2984 append prefix $d
2985 set treecontents($prefix) {}
2986 set treeindex($prefix) [incr ix]
2987 set treeparent($prefix) $oldprefix
2988 set tail [string range $tail [expr {$slash+1}] end]
2989 if {$lev <= $openlevs} {
2990 set ht 1
2991 set treediropen($prefix) [expr {$lev < $openlevs}]
2992 set bm [expr {$lev == $openlevs? "tri-rt": "tri-dn"}]
2993 $w mark set d:$ix "end -1c"
2994 $w mark gravity d:$ix left
2995 set str "\n"
2996 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
2997 $w insert end $str
2998 $w image create end -align center -image $bm -padx 1 \
2999 -name a:$ix
3000 $w insert end $d [highlight_tag $prefix]
3001 $w mark set s:$ix "end -1c"
3002 $w mark gravity s:$ix left
3004 incr lev
3006 if {$tail ne {}} {
3007 if {$lev <= $openlevs} {
3008 incr ht
3009 set str "\n"
3010 for {set i 0} {$i < $lev} {incr i} {append str "\t"}
3011 $w insert end $str
3012 $w insert end $tail [highlight_tag $f]
3014 lappend treecontents($prefix) $tail
3017 while {$htstack ne {}} {
3018 set treeheight($prefix) $ht
3019 incr ht [lindex $htstack end]
3020 set htstack [lreplace $htstack end end]
3021 set prefixend [lindex $prefendstack end]
3022 set prefendstack [lreplace $prefendstack end end]
3023 set prefix [string range $prefix 0 $prefixend]
3025 $w conf -state disabled
3028 proc linetoelt {l} {
3029 global treeheight treecontents
3031 set y 2
3032 set prefix {}
3033 while {1} {
3034 foreach e $treecontents($prefix) {
3035 if {$y == $l} {
3036 return "$prefix$e"
3038 set n 1
3039 if {[string index $e end] eq "/"} {
3040 set n $treeheight($prefix$e)
3041 if {$y + $n > $l} {
3042 append prefix $e
3043 incr y
3044 break
3047 incr y $n
3052 proc highlight_tree {y prefix} {
3053 global treeheight treecontents cflist
3055 foreach e $treecontents($prefix) {
3056 set path $prefix$e
3057 if {[highlight_tag $path] ne {}} {
3058 $cflist tag add bold $y.0 "$y.0 lineend"
3060 incr y
3061 if {[string index $e end] eq "/" && $treeheight($path) > 1} {
3062 set y [highlight_tree $y $path]
3065 return $y
3068 proc treeclosedir {w dir} {
3069 global treediropen treeheight treeparent treeindex
3071 set ix $treeindex($dir)
3072 $w conf -state normal
3073 $w delete s:$ix e:$ix
3074 set treediropen($dir) 0
3075 $w image configure a:$ix -image tri-rt
3076 $w conf -state disabled
3077 set n [expr {1 - $treeheight($dir)}]
3078 while {$dir ne {}} {
3079 incr treeheight($dir) $n
3080 set dir $treeparent($dir)
3084 proc treeopendir {w dir} {
3085 global treediropen treeheight treeparent treecontents treeindex
3087 set ix $treeindex($dir)
3088 $w conf -state normal
3089 $w image configure a:$ix -image tri-dn
3090 $w mark set e:$ix s:$ix
3091 $w mark gravity e:$ix right
3092 set lev 0
3093 set str "\n"
3094 set n [llength $treecontents($dir)]
3095 for {set x $dir} {$x ne {}} {set x $treeparent($x)} {
3096 incr lev
3097 append str "\t"
3098 incr treeheight($x) $n
3100 foreach e $treecontents($dir) {
3101 set de $dir$e
3102 if {[string index $e end] eq "/"} {
3103 set iy $treeindex($de)
3104 $w mark set d:$iy e:$ix
3105 $w mark gravity d:$iy left
3106 $w insert e:$ix $str
3107 set treediropen($de) 0
3108 $w image create e:$ix -align center -image tri-rt -padx 1 \
3109 -name a:$iy
3110 $w insert e:$ix $e [highlight_tag $de]
3111 $w mark set s:$iy e:$ix
3112 $w mark gravity s:$iy left
3113 set treeheight($de) 1
3114 } else {
3115 $w insert e:$ix $str
3116 $w insert e:$ix $e [highlight_tag $de]
3119 $w mark gravity e:$ix right
3120 $w conf -state disabled
3121 set treediropen($dir) 1
3122 set top [lindex [split [$w index @0,0] .] 0]
3123 set ht [$w cget -height]
3124 set l [lindex [split [$w index s:$ix] .] 0]
3125 if {$l < $top} {
3126 $w yview $l.0
3127 } elseif {$l + $n + 1 > $top + $ht} {
3128 set top [expr {$l + $n + 2 - $ht}]
3129 if {$l < $top} {
3130 set top $l
3132 $w yview $top.0
3136 proc treeclick {w x y} {
3137 global treediropen cmitmode ctext cflist cflist_top
3139 if {$cmitmode ne "tree"} return
3140 if {![info exists cflist_top]} return
3141 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3142 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
3143 $cflist tag add highlight $l.0 "$l.0 lineend"
3144 set cflist_top $l
3145 if {$l == 1} {
3146 $ctext yview 1.0
3147 return
3149 set e [linetoelt $l]
3150 if {[string index $e end] ne "/"} {
3151 showfile $e
3152 } elseif {$treediropen($e)} {
3153 treeclosedir $w $e
3154 } else {
3155 treeopendir $w $e
3159 proc setfilelist {id} {
3160 global treefilelist cflist jump_to_here
3162 treeview $cflist $treefilelist($id) 0
3163 if {$jump_to_here ne {}} {
3164 set f [lindex $jump_to_here 0]
3165 if {[lsearch -exact $treefilelist($id) $f] >= 0} {
3166 showfile $f
3171 image create bitmap tri-rt -background black -foreground blue -data {
3172 #define tri-rt_width 13
3173 #define tri-rt_height 13
3174 static unsigned char tri-rt_bits[] = {
3175 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00,
3176 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x30, 0x00, 0x10, 0x00, 0x00, 0x00,
3177 0x00, 0x00};
3178 } -maskdata {
3179 #define tri-rt-mask_width 13
3180 #define tri-rt-mask_height 13
3181 static unsigned char tri-rt-mask_bits[] = {
3182 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01,
3183 0xf8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0x38, 0x00, 0x18, 0x00,
3184 0x08, 0x00};
3186 image create bitmap tri-dn -background black -foreground blue -data {
3187 #define tri-dn_width 13
3188 #define tri-dn_height 13
3189 static unsigned char tri-dn_bits[] = {
3190 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xf8, 0x03,
3191 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3192 0x00, 0x00};
3193 } -maskdata {
3194 #define tri-dn-mask_width 13
3195 #define tri-dn-mask_height 13
3196 static unsigned char tri-dn-mask_bits[] = {
3197 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07,
3198 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
3199 0x00, 0x00};
3202 image create bitmap reficon-T -background black -foreground yellow -data {
3203 #define tagicon_width 13
3204 #define tagicon_height 9
3205 static unsigned char tagicon_bits[] = {
3206 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x07,
3207 0xfc, 0x07, 0xf8, 0x07, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00};
3208 } -maskdata {
3209 #define tagicon-mask_width 13
3210 #define tagicon-mask_height 9
3211 static unsigned char tagicon-mask_bits[] = {
3212 0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x0f, 0xfc, 0x0f,
3213 0xfe, 0x0f, 0xfc, 0x0f, 0xf8, 0x0f, 0xf0, 0x0f, 0x00, 0x00};
3215 set rectdata {
3216 #define headicon_width 13
3217 #define headicon_height 9
3218 static unsigned char headicon_bits[] = {
3219 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0xf8, 0x07,
3220 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00};
3222 set rectmask {
3223 #define headicon-mask_width 13
3224 #define headicon-mask_height 9
3225 static unsigned char headicon-mask_bits[] = {
3226 0x00, 0x00, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f,
3227 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0x00, 0x00};
3229 image create bitmap reficon-H -background black -foreground green \
3230 -data $rectdata -maskdata $rectmask
3231 image create bitmap reficon-o -background black -foreground "#ddddff" \
3232 -data $rectdata -maskdata $rectmask
3234 proc init_flist {first} {
3235 global cflist cflist_top difffilestart
3237 $cflist conf -state normal
3238 $cflist delete 0.0 end
3239 if {$first ne {}} {
3240 $cflist insert end $first
3241 set cflist_top 1
3242 $cflist tag add highlight 1.0 "1.0 lineend"
3243 } else {
3244 catch {unset cflist_top}
3246 $cflist conf -state disabled
3247 set difffilestart {}
3250 proc highlight_tag {f} {
3251 global highlight_paths
3253 foreach p $highlight_paths {
3254 if {[string match $p $f]} {
3255 return "bold"
3258 return {}
3261 proc highlight_filelist {} {
3262 global cmitmode cflist
3264 $cflist conf -state normal
3265 if {$cmitmode ne "tree"} {
3266 set end [lindex [split [$cflist index end] .] 0]
3267 for {set l 2} {$l < $end} {incr l} {
3268 set line [$cflist get $l.0 "$l.0 lineend"]
3269 if {[highlight_tag $line] ne {}} {
3270 $cflist tag add bold $l.0 "$l.0 lineend"
3273 } else {
3274 highlight_tree 2 {}
3276 $cflist conf -state disabled
3279 proc unhighlight_filelist {} {
3280 global cflist
3282 $cflist conf -state normal
3283 $cflist tag remove bold 1.0 end
3284 $cflist conf -state disabled
3287 proc add_flist {fl} {
3288 global cflist
3290 $cflist conf -state normal
3291 foreach f $fl {
3292 $cflist insert end "\n"
3293 $cflist insert end $f [highlight_tag $f]
3295 $cflist conf -state disabled
3298 proc sel_flist {w x y} {
3299 global ctext difffilestart cflist cflist_top cmitmode
3301 if {$cmitmode eq "tree"} return
3302 if {![info exists cflist_top]} return
3303 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3304 $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
3305 $cflist tag add highlight $l.0 "$l.0 lineend"
3306 set cflist_top $l
3307 if {$l == 1} {
3308 $ctext yview 1.0
3309 } else {
3310 catch {$ctext yview [lindex $difffilestart [expr {$l - 2}]]}
3314 proc pop_flist_menu {w X Y x y} {
3315 global ctext cflist cmitmode flist_menu flist_menu_file
3316 global treediffs diffids
3318 stopfinding
3319 set l [lindex [split [$w index "@$x,$y"] "."] 0]
3320 if {$l <= 1} return
3321 if {$cmitmode eq "tree"} {
3322 set e [linetoelt $l]
3323 if {[string index $e end] eq "/"} return
3324 } else {
3325 set e [lindex $treediffs($diffids) [expr {$l-2}]]
3327 set flist_menu_file $e
3328 set xdiffstate "normal"
3329 if {$cmitmode eq "tree"} {
3330 set xdiffstate "disabled"
3332 # Disable "External diff" item in tree mode
3333 $flist_menu entryconf 2 -state $xdiffstate
3334 tk_popup $flist_menu $X $Y
3337 proc find_ctext_fileinfo {line} {
3338 global ctext_file_names ctext_file_lines
3340 set ok [bsearch $ctext_file_lines $line]
3341 set tline [lindex $ctext_file_lines $ok]
3343 if {$ok >= [llength $ctext_file_lines] || $line < $tline} {
3344 return {}
3345 } else {
3346 return [list [lindex $ctext_file_names $ok] $tline]
3350 proc pop_diff_menu {w X Y x y} {
3351 global ctext diff_menu flist_menu_file
3352 global diff_menu_txtpos diff_menu_line
3353 global diff_menu_filebase
3355 set diff_menu_txtpos [split [$w index "@$x,$y"] "."]
3356 set diff_menu_line [lindex $diff_menu_txtpos 0]
3357 # don't pop up the menu on hunk-separator or file-separator lines
3358 if {[lsearch -glob [$ctext tag names $diff_menu_line.0] "*sep"] >= 0} {
3359 return
3361 stopfinding
3362 set f [find_ctext_fileinfo $diff_menu_line]
3363 if {$f eq {}} return
3364 set flist_menu_file [lindex $f 0]
3365 set diff_menu_filebase [lindex $f 1]
3366 tk_popup $diff_menu $X $Y
3369 proc flist_hl {only} {
3370 global flist_menu_file findstring gdttype
3372 set x [shellquote $flist_menu_file]
3373 if {$only || $findstring eq {} || $gdttype ne [mc "touching paths:"]} {
3374 set findstring $x
3375 } else {
3376 append findstring " " $x
3378 set gdttype [mc "touching paths:"]
3381 proc gitknewtmpdir {} {
3382 global diffnum gitktmpdir gitdir
3384 if {![info exists gitktmpdir]} {
3385 set gitktmpdir [file join $gitdir [format ".gitk-tmp.%s" [pid]]]
3386 if {[catch {file mkdir $gitktmpdir} err]} {
3387 error_popup "[mc "Error creating temporary directory %s:" $gitktmpdir] $err"
3388 unset gitktmpdir
3389 return {}
3391 set diffnum 0
3393 incr diffnum
3394 set diffdir [file join $gitktmpdir $diffnum]
3395 if {[catch {file mkdir $diffdir} err]} {
3396 error_popup "[mc "Error creating temporary directory %s:" $diffdir] $err"
3397 return {}
3399 return $diffdir
3402 proc save_file_from_commit {filename output what} {
3403 global nullfile
3405 if {[catch {exec git show $filename -- > $output} err]} {
3406 if {[string match "fatal: bad revision *" $err]} {
3407 return $nullfile
3409 error_popup "[mc "Error getting \"%s\" from %s:" $filename $what] $err"
3410 return {}
3412 return $output
3415 proc external_diff_get_one_file {diffid filename diffdir} {
3416 global nullid nullid2 nullfile
3417 global worktree
3419 if {$diffid == $nullid} {
3420 set difffile [file join $worktree $filename]
3421 if {[file exists $difffile]} {
3422 return $difffile
3424 return $nullfile
3426 if {$diffid == $nullid2} {
3427 set difffile [file join $diffdir "\[index\] [file tail $filename]"]
3428 return [save_file_from_commit :$filename $difffile index]
3430 set difffile [file join $diffdir "\[$diffid\] [file tail $filename]"]
3431 return [save_file_from_commit $diffid:$filename $difffile \
3432 "revision $diffid"]
3435 proc external_diff {} {
3436 global nullid nullid2
3437 global flist_menu_file
3438 global diffids
3439 global extdifftool
3441 if {[llength $diffids] == 1} {
3442 # no reference commit given
3443 set diffidto [lindex $diffids 0]
3444 if {$diffidto eq $nullid} {
3445 # diffing working copy with index
3446 set diffidfrom $nullid2
3447 } elseif {$diffidto eq $nullid2} {
3448 # diffing index with HEAD
3449 set diffidfrom "HEAD"
3450 } else {
3451 # use first parent commit
3452 global parentlist selectedline
3453 set diffidfrom [lindex $parentlist $selectedline 0]
3455 } else {
3456 set diffidfrom [lindex $diffids 0]
3457 set diffidto [lindex $diffids 1]
3460 # make sure that several diffs wont collide
3461 set diffdir [gitknewtmpdir]
3462 if {$diffdir eq {}} return
3464 # gather files to diff
3465 set difffromfile [external_diff_get_one_file $diffidfrom $flist_menu_file $diffdir]
3466 set difftofile [external_diff_get_one_file $diffidto $flist_menu_file $diffdir]
3468 if {$difffromfile ne {} && $difftofile ne {}} {
3469 set cmd [list [shellsplit $extdifftool] $difffromfile $difftofile]
3470 if {[catch {set fl [open |$cmd r]} err]} {
3471 file delete -force $diffdir
3472 error_popup "$extdifftool: [mc "command failed:"] $err"
3473 } else {
3474 fconfigure $fl -blocking 0
3475 filerun $fl [list delete_at_eof $fl $diffdir]
3480 proc find_hunk_blamespec {base line} {
3481 global ctext
3483 # Find and parse the hunk header
3484 set s_lix [$ctext search -backwards -regexp ^@@ "$line.0 lineend" $base.0]
3485 if {$s_lix eq {}} return
3487 set s_line [$ctext get $s_lix "$s_lix + 1 lines"]
3488 if {![regexp {^@@@*(( -\d+(,\d+)?)+) \+(\d+)(,\d+)? @@} $s_line \
3489 s_line old_specs osz osz1 new_line nsz]} {
3490 return
3493 # base lines for the parents
3494 set base_lines [list $new_line]
3495 foreach old_spec [lrange [split $old_specs " "] 1 end] {
3496 if {![regexp -- {-(\d+)(,\d+)?} $old_spec \
3497 old_spec old_line osz]} {
3498 return
3500 lappend base_lines $old_line
3503 # Now scan the lines to determine offset within the hunk
3504 set max_parent [expr {[llength $base_lines]-2}]
3505 set dline 0
3506 set s_lno [lindex [split $s_lix "."] 0]
3508 # Determine if the line is removed
3509 set chunk [$ctext get $line.0 "$line.1 + $max_parent chars"]
3510 if {[string match {[-+ ]*} $chunk]} {
3511 set removed_idx [string first "-" $chunk]
3512 # Choose a parent index
3513 if {$removed_idx >= 0} {
3514 set parent $removed_idx
3515 } else {
3516 set unchanged_idx [string first " " $chunk]
3517 if {$unchanged_idx >= 0} {
3518 set parent $unchanged_idx
3519 } else {
3520 # blame the current commit
3521 set parent -1
3524 # then count other lines that belong to it
3525 for {set i $line} {[incr i -1] > $s_lno} {} {
3526 set chunk [$ctext get $i.0 "$i.1 + $max_parent chars"]
3527 # Determine if the line is removed
3528 set removed_idx [string first "-" $chunk]
3529 if {$parent >= 0} {
3530 set code [string index $chunk $parent]
3531 if {$code eq "-" || ($removed_idx < 0 && $code ne "+")} {
3532 incr dline
3534 } else {
3535 if {$removed_idx < 0} {
3536 incr dline
3540 incr parent
3541 } else {
3542 set parent 0
3545 incr dline [lindex $base_lines $parent]
3546 return [list $parent $dline]
3549 proc external_blame_diff {} {
3550 global currentid cmitmode
3551 global diff_menu_txtpos diff_menu_line
3552 global diff_menu_filebase flist_menu_file
3554 if {$cmitmode eq "tree"} {
3555 set parent_idx 0
3556 set line [expr {$diff_menu_line - $diff_menu_filebase}]
3557 } else {
3558 set hinfo [find_hunk_blamespec $diff_menu_filebase $diff_menu_line]
3559 if {$hinfo ne {}} {
3560 set parent_idx [lindex $hinfo 0]
3561 set line [lindex $hinfo 1]
3562 } else {
3563 set parent_idx 0
3564 set line 0
3568 external_blame $parent_idx $line
3571 # Find the SHA1 ID of the blob for file $fname in the index
3572 # at stage 0 or 2
3573 proc index_sha1 {fname} {
3574 set f [open [list | git ls-files -s $fname] r]
3575 while {[gets $f line] >= 0} {
3576 set info [lindex [split $line "\t"] 0]
3577 set stage [lindex $info 2]
3578 if {$stage eq "0" || $stage eq "2"} {
3579 close $f
3580 return [lindex $info 1]
3583 close $f
3584 return {}
3587 # Turn an absolute path into one relative to the current directory
3588 proc make_relative {f} {
3589 if {[file pathtype $f] eq "relative"} {
3590 return $f
3592 set elts [file split $f]
3593 set here [file split [pwd]]
3594 set ei 0
3595 set hi 0
3596 set res {}
3597 foreach d $here {
3598 if {$ei < $hi || $ei >= [llength $elts] || [lindex $elts $ei] ne $d} {
3599 lappend res ".."
3600 } else {
3601 incr ei
3603 incr hi
3605 set elts [concat $res [lrange $elts $ei end]]
3606 return [eval file join $elts]
3609 proc external_blame {parent_idx {line {}}} {
3610 global flist_menu_file cdup
3611 global nullid nullid2
3612 global parentlist selectedline currentid
3614 if {$parent_idx > 0} {
3615 set base_commit [lindex $parentlist $selectedline [expr {$parent_idx-1}]]
3616 } else {
3617 set base_commit $currentid
3620 if {$base_commit eq {} || $base_commit eq $nullid || $base_commit eq $nullid2} {
3621 error_popup [mc "No such commit"]
3622 return
3625 set cmdline [list git gui blame]
3626 if {$line ne {} && $line > 1} {
3627 lappend cmdline "--line=$line"
3629 set f [file join $cdup $flist_menu_file]
3630 # Unfortunately it seems git gui blame doesn't like
3631 # being given an absolute path...
3632 set f [make_relative $f]
3633 lappend cmdline $base_commit $f
3634 if {[catch {eval exec $cmdline &} err]} {
3635 error_popup "[mc "git gui blame: command failed:"] $err"
3639 proc show_line_source {} {
3640 global cmitmode currentid parents curview blamestuff blameinst
3641 global diff_menu_line diff_menu_filebase flist_menu_file
3642 global nullid nullid2 gitdir cdup
3644 set from_index {}
3645 if {$cmitmode eq "tree"} {
3646 set id $currentid
3647 set line [expr {$diff_menu_line - $diff_menu_filebase}]
3648 } else {
3649 set h [find_hunk_blamespec $diff_menu_filebase $diff_menu_line]
3650 if {$h eq {}} return
3651 set pi [lindex $h 0]
3652 if {$pi == 0} {
3653 mark_ctext_line $diff_menu_line
3654 return
3656 incr pi -1
3657 if {$currentid eq $nullid} {
3658 if {$pi > 0} {
3659 # must be a merge in progress...
3660 if {[catch {
3661 # get the last line from .git/MERGE_HEAD
3662 set f [open [file join $gitdir MERGE_HEAD] r]
3663 set id [lindex [split [read $f] "\n"] end-1]
3664 close $f
3665 } err]} {
3666 error_popup [mc "Couldn't read merge head: %s" $err]
3667 return
3669 } elseif {$parents($curview,$currentid) eq $nullid2} {
3670 # need to do the blame from the index
3671 if {[catch {
3672 set from_index [index_sha1 $flist_menu_file]
3673 } err]} {
3674 error_popup [mc "Error reading index: %s" $err]
3675 return
3677 } else {
3678 set id $parents($curview,$currentid)
3680 } else {
3681 set id [lindex $parents($curview,$currentid) $pi]
3683 set line [lindex $h 1]
3685 set blameargs {}
3686 if {$from_index ne {}} {
3687 lappend blameargs | git cat-file blob $from_index
3689 lappend blameargs | git blame -p -L$line,+1
3690 if {$from_index ne {}} {
3691 lappend blameargs --contents -
3692 } else {
3693 lappend blameargs $id
3695 lappend blameargs -- [file join $cdup $flist_menu_file]
3696 if {[catch {
3697 set f [open $blameargs r]
3698 } err]} {
3699 error_popup [mc "Couldn't start git blame: %s" $err]
3700 return
3702 nowbusy blaming [mc "Searching"]
3703 fconfigure $f -blocking 0
3704 set i [reg_instance $f]
3705 set blamestuff($i) {}
3706 set blameinst $i
3707 filerun $f [list read_line_source $f $i]
3710 proc stopblaming {} {
3711 global blameinst
3713 if {[info exists blameinst]} {
3714 stop_instance $blameinst
3715 unset blameinst
3716 notbusy blaming
3720 proc read_line_source {fd inst} {
3721 global blamestuff curview commfd blameinst nullid nullid2
3723 while {[gets $fd line] >= 0} {
3724 lappend blamestuff($inst) $line
3726 if {![eof $fd]} {
3727 return 1
3729 unset commfd($inst)
3730 unset blameinst
3731 notbusy blaming
3732 fconfigure $fd -blocking 1
3733 if {[catch {close $fd} err]} {
3734 error_popup [mc "Error running git blame: %s" $err]
3735 return 0
3738 set fname {}
3739 set line [split [lindex $blamestuff($inst) 0] " "]
3740 set id [lindex $line 0]
3741 set lnum [lindex $line 1]
3742 if {[string length $id] == 40 && [string is xdigit $id] &&
3743 [string is digit -strict $lnum]} {
3744 # look for "filename" line
3745 foreach l $blamestuff($inst) {
3746 if {[string match "filename *" $l]} {
3747 set fname [string range $l 9 end]
3748 break
3752 if {$fname ne {}} {
3753 # all looks good, select it
3754 if {$id eq $nullid} {
3755 # blame uses all-zeroes to mean not committed,
3756 # which would mean a change in the index
3757 set id $nullid2
3759 if {[commitinview $id $curview]} {
3760 selectline [rowofcommit $id] 1 [list $fname $lnum]
3761 } else {
3762 error_popup [mc "That line comes from commit %s, \
3763 which is not in this view" [shortids $id]]
3765 } else {
3766 puts "oops couldn't parse git blame output"
3768 return 0
3771 # delete $dir when we see eof on $f (presumably because the child has exited)
3772 proc delete_at_eof {f dir} {
3773 while {[gets $f line] >= 0} {}
3774 if {[eof $f]} {
3775 if {[catch {close $f} err]} {
3776 error_popup "[mc "External diff viewer failed:"] $err"
3778 file delete -force $dir
3779 return 0
3781 return 1
3784 # Functions for adding and removing shell-type quoting
3786 proc shellquote {str} {
3787 if {![string match "*\['\"\\ \t]*" $str]} {
3788 return $str
3790 if {![string match "*\['\"\\]*" $str]} {
3791 return "\"$str\""
3793 if {![string match "*'*" $str]} {
3794 return "'$str'"
3796 return "\"[string map {\" \\\" \\ \\\\} $str]\""
3799 proc shellarglist {l} {
3800 set str {}
3801 foreach a $l {
3802 if {$str ne {}} {
3803 append str " "
3805 append str [shellquote $a]
3807 return $str
3810 proc shelldequote {str} {
3811 set ret {}
3812 set used -1
3813 while {1} {
3814 incr used
3815 if {![regexp -start $used -indices "\['\"\\\\ \t]" $str first]} {
3816 append ret [string range $str $used end]
3817 set used [string length $str]
3818 break
3820 set first [lindex $first 0]
3821 set ch [string index $str $first]
3822 if {$first > $used} {
3823 append ret [string range $str $used [expr {$first - 1}]]
3824 set used $first
3826 if {$ch eq " " || $ch eq "\t"} break
3827 incr used
3828 if {$ch eq "'"} {
3829 set first [string first "'" $str $used]
3830 if {$first < 0} {
3831 error "unmatched single-quote"
3833 append ret [string range $str $used [expr {$first - 1}]]
3834 set used $first
3835 continue
3837 if {$ch eq "\\"} {
3838 if {$used >= [string length $str]} {
3839 error "trailing backslash"
3841 append ret [string index $str $used]
3842 continue
3844 # here ch == "\""
3845 while {1} {
3846 if {![regexp -start $used -indices "\[\"\\\\]" $str first]} {
3847 error "unmatched double-quote"
3849 set first [lindex $first 0]
3850 set ch [string index $str $first]
3851 if {$first > $used} {
3852 append ret [string range $str $used [expr {$first - 1}]]
3853 set used $first
3855 if {$ch eq "\""} break
3856 incr used
3857 append ret [string index $str $used]
3858 incr used
3861 return [list $used $ret]
3864 proc shellsplit {str} {
3865 set l {}
3866 while {1} {
3867 set str [string trimleft $str]
3868 if {$str eq {}} break
3869 set dq [shelldequote $str]
3870 set n [lindex $dq 0]
3871 set word [lindex $dq 1]
3872 set str [string range $str $n end]
3873 lappend l $word
3875 return $l
3878 # Code to implement multiple views
3880 proc newview {ishighlight} {
3881 global nextviewnum newviewname newishighlight
3882 global revtreeargs viewargscmd newviewopts curview
3884 set newishighlight $ishighlight
3885 set top .gitkview
3886 if {[winfo exists $top]} {
3887 raise $top
3888 return
3890 decode_view_opts $nextviewnum $revtreeargs
3891 set newviewname($nextviewnum) "[mc "View"] $nextviewnum"
3892 set newviewopts($nextviewnum,perm) 0
3893 set newviewopts($nextviewnum,cmd) $viewargscmd($curview)
3894 vieweditor $top $nextviewnum [mc "Gitk view definition"]
3897 set known_view_options {
3898 {perm b . {} {mc "Remember this view"}}
3899 {reflabel l + {} {mc "References (space separated list):"}}
3900 {refs t15 .. {} {mc "Branches & tags:"}}
3901 {allrefs b *. "--all" {mc "All refs"}}
3902 {branches b . "--branches" {mc "All (local) branches"}}
3903 {tags b . "--tags" {mc "All tags"}}
3904 {remotes b . "--remotes" {mc "All remote-tracking branches"}}
3905 {commitlbl l + {} {mc "Commit Info (regular expressions):"}}
3906 {author t15 .. "--author=*" {mc "Author:"}}
3907 {committer t15 . "--committer=*" {mc "Committer:"}}
3908 {loginfo t15 .. "--grep=*" {mc "Commit Message:"}}
3909 {allmatch b .. "--all-match" {mc "Matches all Commit Info criteria"}}
3910 {changes_l l + {} {mc "Changes to Files:"}}
3911 {pickaxe_s r0 . {} {mc "Fixed String"}}
3912 {pickaxe_t r1 . "--pickaxe-regex" {mc "Regular Expression"}}
3913 {pickaxe t15 .. "-S*" {mc "Search string:"}}
3914 {datelabel l + {} {mc "Commit Dates (\"2 weeks ago\", \"2009-03-17 15:27:38\", \"March 17, 2009 15:27:38\"):"}}
3915 {since t15 .. {"--since=*" "--after=*"} {mc "Since:"}}
3916 {until t15 . {"--until=*" "--before=*"} {mc "Until:"}}
3917 {limit_lbl l + {} {mc "Limit and/or skip a number of revisions (positive integer):"}}
3918 {limit t10 *. "--max-count=*" {mc "Number to show:"}}
3919 {skip t10 . "--skip=*" {mc "Number to skip:"}}
3920 {misc_lbl l + {} {mc "Miscellaneous options:"}}
3921 {dorder b *. {"--date-order" "-d"} {mc "Strictly sort by date"}}
3922 {lright b . "--left-right" {mc "Mark branch sides"}}
3923 {first b . "--first-parent" {mc "Limit to first parent"}}
3924 {smplhst b . "--simplify-by-decoration" {mc "Simple history"}}
3925 {args t50 *. {} {mc "Additional arguments to git log:"}}
3926 {allpaths path + {} {mc "Enter files and directories to include, one per line:"}}
3927 {cmd t50= + {} {mc "Command to generate more commits to include:"}}
3930 # Convert $newviewopts($n, ...) into args for git log.
3931 proc encode_view_opts {n} {
3932 global known_view_options newviewopts
3934 set rargs [list]
3935 foreach opt $known_view_options {
3936 set patterns [lindex $opt 3]
3937 if {$patterns eq {}} continue
3938 set pattern [lindex $patterns 0]
3940 if {[lindex $opt 1] eq "b"} {
3941 set val $newviewopts($n,[lindex $opt 0])
3942 if {$val} {
3943 lappend rargs $pattern
3945 } elseif {[regexp {^r(\d+)$} [lindex $opt 1] type value]} {
3946 regexp {^(.*_)} [lindex $opt 0] uselessvar button_id
3947 set val $newviewopts($n,$button_id)
3948 if {$val eq $value} {
3949 lappend rargs $pattern
3951 } else {
3952 set val $newviewopts($n,[lindex $opt 0])
3953 set val [string trim $val]
3954 if {$val ne {}} {
3955 set pfix [string range $pattern 0 end-1]
3956 lappend rargs $pfix$val
3960 set rargs [concat $rargs [shellsplit $newviewopts($n,refs)]]
3961 return [concat $rargs [shellsplit $newviewopts($n,args)]]
3964 # Fill $newviewopts($n, ...) based on args for git log.
3965 proc decode_view_opts {n view_args} {
3966 global known_view_options newviewopts
3968 foreach opt $known_view_options {
3969 set id [lindex $opt 0]
3970 if {[lindex $opt 1] eq "b"} {
3971 # Checkboxes
3972 set val 0
3973 } elseif {[regexp {^r(\d+)$} [lindex $opt 1]]} {
3974 # Radiobuttons
3975 regexp {^(.*_)} $id uselessvar id
3976 set val 0
3977 } else {
3978 # Text fields
3979 set val {}
3981 set newviewopts($n,$id) $val
3983 set oargs [list]
3984 set refargs [list]
3985 foreach arg $view_args {
3986 if {[regexp -- {^-([0-9]+)$} $arg arg cnt]
3987 && ![info exists found(limit)]} {
3988 set newviewopts($n,limit) $cnt
3989 set found(limit) 1
3990 continue
3992 catch { unset val }
3993 foreach opt $known_view_options {
3994 set id [lindex $opt 0]
3995 if {[info exists found($id)]} continue
3996 foreach pattern [lindex $opt 3] {
3997 if {![string match $pattern $arg]} continue
3998 if {[lindex $opt 1] eq "b"} {
3999 # Check buttons
4000 set val 1
4001 } elseif {[regexp {^r(\d+)$} [lindex $opt 1] match num]} {
4002 # Radio buttons
4003 regexp {^(.*_)} $id uselessvar id
4004 set val $num
4005 } else {
4006 # Text input fields
4007 set size [string length $pattern]
4008 set val [string range $arg [expr {$size-1}] end]
4010 set newviewopts($n,$id) $val
4011 set found($id) 1
4012 break
4014 if {[info exists val]} break
4016 if {[info exists val]} continue
4017 if {[regexp {^-} $arg]} {
4018 lappend oargs $arg
4019 } else {
4020 lappend refargs $arg
4023 set newviewopts($n,refs) [shellarglist $refargs]
4024 set newviewopts($n,args) [shellarglist $oargs]
4027 proc edit_or_newview {} {
4028 global curview
4030 if {$curview > 0} {
4031 editview
4032 } else {
4033 newview 0
4037 proc editview {} {
4038 global curview
4039 global viewname viewperm newviewname newviewopts
4040 global viewargs viewargscmd
4042 set top .gitkvedit-$curview
4043 if {[winfo exists $top]} {
4044 raise $top
4045 return
4047 decode_view_opts $curview $viewargs($curview)
4048 set newviewname($curview) $viewname($curview)
4049 set newviewopts($curview,perm) $viewperm($curview)
4050 set newviewopts($curview,cmd) $viewargscmd($curview)
4051 vieweditor $top $curview "[mc "Gitk: edit view"] $viewname($curview)"
4054 proc vieweditor {top n title} {
4055 global newviewname newviewopts viewfiles bgcolor
4056 global known_view_options NS
4058 ttk_toplevel $top
4059 wm title $top [concat $title [mc "-- criteria for selecting revisions"]]
4060 make_transient $top .
4062 # View name
4063 ${NS}::frame $top.nfr
4064 ${NS}::label $top.nl -text [mc "View Name"]
4065 ${NS}::entry $top.name -width 20 -textvariable newviewname($n)
4066 pack $top.nfr -in $top -fill x -pady 5 -padx 3
4067 pack $top.nl -in $top.nfr -side left -padx {0 5}
4068 pack $top.name -in $top.nfr -side left -padx {0 25}
4070 # View options
4071 set cframe $top.nfr
4072 set cexpand 0
4073 set cnt 0
4074 foreach opt $known_view_options {
4075 set id [lindex $opt 0]
4076 set type [lindex $opt 1]
4077 set flags [lindex $opt 2]
4078 set title [eval [lindex $opt 4]]
4079 set lxpad 0
4081 if {$flags eq "+" || $flags eq "*"} {
4082 set cframe $top.fr$cnt
4083 incr cnt
4084 ${NS}::frame $cframe
4085 pack $cframe -in $top -fill x -pady 3 -padx 3
4086 set cexpand [expr {$flags eq "*"}]
4087 } elseif {$flags eq ".." || $flags eq "*."} {
4088 set cframe $top.fr$cnt
4089 incr cnt
4090 ${NS}::frame $cframe
4091 pack $cframe -in $top -fill x -pady 3 -padx [list 15 3]
4092 set cexpand [expr {$flags eq "*."}]
4093 } else {
4094 set lxpad 5
4097 if {$type eq "l"} {
4098 ${NS}::label $cframe.l_$id -text $title
4099 pack $cframe.l_$id -in $cframe -side left -pady [list 3 0] -anchor w
4100 } elseif {$type eq "b"} {
4101 ${NS}::checkbutton $cframe.c_$id -text $title -variable newviewopts($n,$id)
4102 pack $cframe.c_$id -in $cframe -side left \
4103 -padx [list $lxpad 0] -expand $cexpand -anchor w
4104 } elseif {[regexp {^r(\d+)$} $type type sz]} {
4105 regexp {^(.*_)} $id uselessvar button_id
4106 ${NS}::radiobutton $cframe.c_$id -text $title -variable newviewopts($n,$button_id) -value $sz
4107 pack $cframe.c_$id -in $cframe -side left \
4108 -padx [list $lxpad 0] -expand $cexpand -anchor w
4109 } elseif {[regexp {^t(\d+)$} $type type sz]} {
4110 ${NS}::label $cframe.l_$id -text $title
4111 ${NS}::entry $cframe.e_$id -width $sz -background $bgcolor \
4112 -textvariable newviewopts($n,$id)
4113 pack $cframe.l_$id -in $cframe -side left -padx [list $lxpad 0]
4114 pack $cframe.e_$id -in $cframe -side left -expand 1 -fill x
4115 } elseif {[regexp {^t(\d+)=$} $type type sz]} {
4116 ${NS}::label $cframe.l_$id -text $title
4117 ${NS}::entry $cframe.e_$id -width $sz -background $bgcolor \
4118 -textvariable newviewopts($n,$id)
4119 pack $cframe.l_$id -in $cframe -side top -pady [list 3 0] -anchor w
4120 pack $cframe.e_$id -in $cframe -side top -fill x
4121 } elseif {$type eq "path"} {
4122 ${NS}::label $top.l -text $title
4123 pack $top.l -in $top -side top -pady [list 3 0] -anchor w -padx 3
4124 text $top.t -width 40 -height 5 -background $bgcolor
4125 if {[info exists viewfiles($n)]} {
4126 foreach f $viewfiles($n) {
4127 $top.t insert end $f
4128 $top.t insert end "\n"
4130 $top.t delete {end - 1c} end
4131 $top.t mark set insert 0.0
4133 pack $top.t -in $top -side top -pady [list 0 5] -fill both -expand 1 -padx 3
4137 ${NS}::frame $top.buts
4138 ${NS}::button $top.buts.ok -text [mc "OK"] -command [list newviewok $top $n]
4139 ${NS}::button $top.buts.apply -text [mc "Apply (F5)"] -command [list newviewok $top $n 1]
4140 ${NS}::button $top.buts.can -text [mc "Cancel"] -command [list destroy $top]
4141 bind $top <Control-Return> [list newviewok $top $n]
4142 bind $top <F5> [list newviewok $top $n 1]
4143 bind $top <Escape> [list destroy $top]
4144 grid $top.buts.ok $top.buts.apply $top.buts.can
4145 grid columnconfigure $top.buts 0 -weight 1 -uniform a
4146 grid columnconfigure $top.buts 1 -weight 1 -uniform a
4147 grid columnconfigure $top.buts 2 -weight 1 -uniform a
4148 pack $top.buts -in $top -side top -fill x
4149 focus $top.t
4152 proc doviewmenu {m first cmd op argv} {
4153 set nmenu [$m index end]
4154 for {set i $first} {$i <= $nmenu} {incr i} {
4155 if {[$m entrycget $i -command] eq $cmd} {
4156 eval $m $op $i $argv
4157 break
4162 proc allviewmenus {n op args} {
4163 # global viewhlmenu
4165 doviewmenu .bar.view 5 [list showview $n] $op $args
4166 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] $op $args
4169 proc newviewok {top n {apply 0}} {
4170 global nextviewnum newviewperm newviewname newishighlight
4171 global viewname viewfiles viewperm selectedview curview
4172 global viewargs viewargscmd newviewopts viewhlmenu
4174 if {[catch {
4175 set newargs [encode_view_opts $n]
4176 } err]} {
4177 error_popup "[mc "Error in commit selection arguments:"] $err" $top
4178 return
4180 set files {}
4181 foreach f [split [$top.t get 0.0 end] "\n"] {
4182 set ft [string trim $f]
4183 if {$ft ne {}} {
4184 lappend files $ft
4187 if {![info exists viewfiles($n)]} {
4188 # creating a new view
4189 incr nextviewnum
4190 set viewname($n) $newviewname($n)
4191 set viewperm($n) $newviewopts($n,perm)
4192 set viewfiles($n) $files
4193 set viewargs($n) $newargs
4194 set viewargscmd($n) $newviewopts($n,cmd)
4195 addviewmenu $n
4196 if {!$newishighlight} {
4197 run showview $n
4198 } else {
4199 run addvhighlight $n
4201 } else {
4202 # editing an existing view
4203 set viewperm($n) $newviewopts($n,perm)
4204 if {$newviewname($n) ne $viewname($n)} {
4205 set viewname($n) $newviewname($n)
4206 doviewmenu .bar.view 5 [list showview $n] \
4207 entryconf [list -label $viewname($n)]
4208 # doviewmenu $viewhlmenu 1 [list addvhighlight $n] \
4209 # entryconf [list -label $viewname($n) -value $viewname($n)]
4211 if {$files ne $viewfiles($n) || $newargs ne $viewargs($n) || \
4212 $newviewopts($n,cmd) ne $viewargscmd($n)} {
4213 set viewfiles($n) $files
4214 set viewargs($n) $newargs
4215 set viewargscmd($n) $newviewopts($n,cmd)
4216 if {$curview == $n} {
4217 run reloadcommits
4221 if {$apply} return
4222 catch {destroy $top}
4225 proc delview {} {
4226 global curview viewperm hlview selectedhlview
4228 if {$curview == 0} return
4229 if {[info exists hlview] && $hlview == $curview} {
4230 set selectedhlview [mc "None"]
4231 unset hlview
4233 allviewmenus $curview delete
4234 set viewperm($curview) 0
4235 showview 0
4238 proc addviewmenu {n} {
4239 global viewname viewhlmenu
4241 .bar.view add radiobutton -label $viewname($n) \
4242 -command [list showview $n] -variable selectedview -value $n
4243 #$viewhlmenu add radiobutton -label $viewname($n) \
4244 # -command [list addvhighlight $n] -variable selectedhlview
4247 proc showview {n} {
4248 global curview cached_commitrow ordertok
4249 global displayorder parentlist rowidlist rowisopt rowfinal
4250 global colormap rowtextx nextcolor canvxmax
4251 global numcommits viewcomplete
4252 global selectedline currentid canv canvy0
4253 global treediffs
4254 global pending_select mainheadid
4255 global commitidx
4256 global selectedview
4257 global hlview selectedhlview commitinterest
4259 if {$n == $curview} return
4260 set selid {}
4261 set ymax [lindex [$canv cget -scrollregion] 3]
4262 set span [$canv yview]
4263 set ytop [expr {[lindex $span 0] * $ymax}]
4264 set ybot [expr {[lindex $span 1] * $ymax}]
4265 set yscreen [expr {($ybot - $ytop) / 2}]
4266 if {$selectedline ne {}} {
4267 set selid $currentid
4268 set y [yc $selectedline]
4269 if {$ytop < $y && $y < $ybot} {
4270 set yscreen [expr {$y - $ytop}]
4272 } elseif {[info exists pending_select]} {
4273 set selid $pending_select
4274 unset pending_select
4276 unselectline
4277 normalline
4278 catch {unset treediffs}
4279 clear_display
4280 if {[info exists hlview] && $hlview == $n} {
4281 unset hlview
4282 set selectedhlview [mc "None"]
4284 catch {unset commitinterest}
4285 catch {unset cached_commitrow}
4286 catch {unset ordertok}
4288 set curview $n
4289 set selectedview $n
4290 .bar.view entryconf [mca "Edit view..."] -state [expr {$n == 0? "disabled": "normal"}]
4291 .bar.view entryconf [mca "Delete view"] -state [expr {$n == 0? "disabled": "normal"}]
4293 run refill_reflist
4294 if {![info exists viewcomplete($n)]} {
4295 getcommits $selid
4296 return
4299 set displayorder {}
4300 set parentlist {}
4301 set rowidlist {}
4302 set rowisopt {}
4303 set rowfinal {}
4304 set numcommits $commitidx($n)
4306 catch {unset colormap}
4307 catch {unset rowtextx}
4308 set nextcolor 0
4309 set canvxmax [$canv cget -width]
4310 set curview $n
4311 set row 0
4312 setcanvscroll
4313 set yf 0
4314 set row {}
4315 if {$selid ne {} && [commitinview $selid $n]} {
4316 set row [rowofcommit $selid]
4317 # try to get the selected row in the same position on the screen
4318 set ymax [lindex [$canv cget -scrollregion] 3]
4319 set ytop [expr {[yc $row] - $yscreen}]
4320 if {$ytop < 0} {
4321 set ytop 0
4323 set yf [expr {$ytop * 1.0 / $ymax}]
4325 allcanvs yview moveto $yf
4326 drawvisible
4327 if {$row ne {}} {
4328 selectline $row 0
4329 } elseif {!$viewcomplete($n)} {
4330 reset_pending_select $selid
4331 } else {
4332 reset_pending_select {}
4334 if {[commitinview $pending_select $curview]} {
4335 selectline [rowofcommit $pending_select] 1
4336 } else {
4337 set row [first_real_row]
4338 if {$row < $numcommits} {
4339 selectline $row 0
4343 if {!$viewcomplete($n)} {
4344 if {$numcommits == 0} {
4345 show_status [mc "Reading commits..."]
4347 } elseif {$numcommits == 0} {
4348 show_status [mc "No commits selected"]
4352 # Stuff relating to the highlighting facility
4354 proc ishighlighted {id} {
4355 global vhighlights fhighlights nhighlights rhighlights
4357 if {[info exists nhighlights($id)] && $nhighlights($id) > 0} {
4358 return $nhighlights($id)
4360 if {[info exists vhighlights($id)] && $vhighlights($id) > 0} {
4361 return $vhighlights($id)
4363 if {[info exists fhighlights($id)] && $fhighlights($id) > 0} {
4364 return $fhighlights($id)
4366 if {[info exists rhighlights($id)] && $rhighlights($id) > 0} {
4367 return $rhighlights($id)
4369 return 0
4372 proc bolden {id font} {
4373 global canv linehtag currentid boldids need_redisplay markedid
4375 # need_redisplay = 1 means the display is stale and about to be redrawn
4376 if {$need_redisplay} return
4377 lappend boldids $id
4378 $canv itemconf $linehtag($id) -font $font
4379 if {[info exists currentid] && $id eq $currentid} {
4380 $canv delete secsel
4381 set t [eval $canv create rect [$canv bbox $linehtag($id)] \
4382 -outline {{}} -tags secsel \
4383 -fill [$canv cget -selectbackground]]
4384 $canv lower $t
4386 if {[info exists markedid] && $id eq $markedid} {
4387 make_idmark $id
4391 proc bolden_name {id font} {
4392 global canv2 linentag currentid boldnameids need_redisplay
4394 if {$need_redisplay} return
4395 lappend boldnameids $id
4396 $canv2 itemconf $linentag($id) -font $font
4397 if {[info exists currentid] && $id eq $currentid} {
4398 $canv2 delete secsel
4399 set t [eval $canv2 create rect [$canv2 bbox $linentag($id)] \
4400 -outline {{}} -tags secsel \
4401 -fill [$canv2 cget -selectbackground]]
4402 $canv2 lower $t
4406 proc unbolden {} {
4407 global boldids
4409 set stillbold {}
4410 foreach id $boldids {
4411 if {![ishighlighted $id]} {
4412 bolden $id mainfont
4413 } else {
4414 lappend stillbold $id
4417 set boldids $stillbold
4420 proc addvhighlight {n} {
4421 global hlview viewcomplete curview vhl_done commitidx
4423 if {[info exists hlview]} {
4424 delvhighlight
4426 set hlview $n
4427 if {$n != $curview && ![info exists viewcomplete($n)]} {
4428 start_rev_list $n
4430 set vhl_done $commitidx($hlview)
4431 if {$vhl_done > 0} {
4432 drawvisible
4436 proc delvhighlight {} {
4437 global hlview vhighlights
4439 if {![info exists hlview]} return
4440 unset hlview
4441 catch {unset vhighlights}
4442 unbolden
4445 proc vhighlightmore {} {
4446 global hlview vhl_done commitidx vhighlights curview
4448 set max $commitidx($hlview)
4449 set vr [visiblerows]
4450 set r0 [lindex $vr 0]
4451 set r1 [lindex $vr 1]
4452 for {set i $vhl_done} {$i < $max} {incr i} {
4453 set id [commitonrow $i $hlview]
4454 if {[commitinview $id $curview]} {
4455 set row [rowofcommit $id]
4456 if {$r0 <= $row && $row <= $r1} {
4457 if {![highlighted $row]} {
4458 bolden $id mainfontbold
4460 set vhighlights($id) 1
4464 set vhl_done $max
4465 return 0
4468 proc askvhighlight {row id} {
4469 global hlview vhighlights iddrawn
4471 if {[commitinview $id $hlview]} {
4472 if {[info exists iddrawn($id)] && ![ishighlighted $id]} {
4473 bolden $id mainfontbold
4475 set vhighlights($id) 1
4476 } else {
4477 set vhighlights($id) 0
4481 proc hfiles_change {} {
4482 global highlight_files filehighlight fhighlights fh_serial
4483 global highlight_paths
4485 if {[info exists filehighlight]} {
4486 # delete previous highlights
4487 catch {close $filehighlight}
4488 unset filehighlight
4489 catch {unset fhighlights}
4490 unbolden
4491 unhighlight_filelist
4493 set highlight_paths {}
4494 after cancel do_file_hl $fh_serial
4495 incr fh_serial
4496 if {$highlight_files ne {}} {
4497 after 300 do_file_hl $fh_serial
4501 proc gdttype_change {name ix op} {
4502 global gdttype highlight_files findstring findpattern
4504 stopfinding
4505 if {$findstring ne {}} {
4506 if {$gdttype eq [mc "containing:"]} {
4507 if {$highlight_files ne {}} {
4508 set highlight_files {}
4509 hfiles_change
4511 findcom_change
4512 } else {
4513 if {$findpattern ne {}} {
4514 set findpattern {}
4515 findcom_change
4517 set highlight_files $findstring
4518 hfiles_change
4520 drawvisible
4522 # enable/disable findtype/findloc menus too
4525 proc find_change {name ix op} {
4526 global gdttype findstring highlight_files
4528 stopfinding
4529 if {$gdttype eq [mc "containing:"]} {
4530 findcom_change
4531 } else {
4532 if {$highlight_files ne $findstring} {
4533 set highlight_files $findstring
4534 hfiles_change
4537 drawvisible
4540 proc findcom_change args {
4541 global nhighlights boldnameids
4542 global findpattern findtype findstring gdttype
4544 stopfinding
4545 # delete previous highlights, if any
4546 foreach id $boldnameids {
4547 bolden_name $id mainfont
4549 set boldnameids {}
4550 catch {unset nhighlights}
4551 unbolden
4552 unmarkmatches
4553 if {$gdttype ne [mc "containing:"] || $findstring eq {}} {
4554 set findpattern {}
4555 } elseif {$findtype eq [mc "Regexp"]} {
4556 set findpattern $findstring
4557 } else {
4558 set e [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} \
4559 $findstring]
4560 set findpattern "*$e*"
4564 proc makepatterns {l} {
4565 set ret {}
4566 foreach e $l {
4567 set ee [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} $e]
4568 if {[string index $ee end] eq "/"} {
4569 lappend ret "$ee*"
4570 } else {
4571 lappend ret $ee
4572 lappend ret "$ee/*"
4575 return $ret
4578 proc do_file_hl {serial} {
4579 global highlight_files filehighlight highlight_paths gdttype fhl_list
4580 global cdup findtype
4582 if {$gdttype eq [mc "touching paths:"]} {
4583 # If "exact" match then convert backslashes to forward slashes.
4584 # Most useful to support Windows-flavoured file paths.
4585 if {$findtype eq [mc "Exact"]} {
4586 set highlight_files [string map {"\\" "/"} $highlight_files]
4588 if {[catch {set paths [shellsplit $highlight_files]}]} return
4589 set highlight_paths [makepatterns $paths]
4590 highlight_filelist
4591 set relative_paths {}
4592 foreach path $paths {
4593 lappend relative_paths [file join $cdup $path]
4595 set gdtargs [concat -- $relative_paths]
4596 } elseif {$gdttype eq [mc "adding/removing string:"]} {
4597 set gdtargs [list "-S$highlight_files"]
4598 } else {
4599 # must be "containing:", i.e. we're searching commit info
4600 return
4602 set cmd [concat | git diff-tree -r -s --stdin $gdtargs]
4603 set filehighlight [open $cmd r+]
4604 fconfigure $filehighlight -blocking 0
4605 filerun $filehighlight readfhighlight
4606 set fhl_list {}
4607 drawvisible
4608 flushhighlights
4611 proc flushhighlights {} {
4612 global filehighlight fhl_list
4614 if {[info exists filehighlight]} {
4615 lappend fhl_list {}
4616 puts $filehighlight ""
4617 flush $filehighlight
4621 proc askfilehighlight {row id} {
4622 global filehighlight fhighlights fhl_list
4624 lappend fhl_list $id
4625 set fhighlights($id) -1
4626 puts $filehighlight $id
4629 proc readfhighlight {} {
4630 global filehighlight fhighlights curview iddrawn
4631 global fhl_list find_dirn
4633 if {![info exists filehighlight]} {
4634 return 0
4636 set nr 0
4637 while {[incr nr] <= 100 && [gets $filehighlight line] >= 0} {
4638 set line [string trim $line]
4639 set i [lsearch -exact $fhl_list $line]
4640 if {$i < 0} continue
4641 for {set j 0} {$j < $i} {incr j} {
4642 set id [lindex $fhl_list $j]
4643 set fhighlights($id) 0
4645 set fhl_list [lrange $fhl_list [expr {$i+1}] end]
4646 if {$line eq {}} continue
4647 if {![commitinview $line $curview]} continue
4648 if {[info exists iddrawn($line)] && ![ishighlighted $line]} {
4649 bolden $line mainfontbold
4651 set fhighlights($line) 1
4653 if {[eof $filehighlight]} {
4654 # strange...
4655 puts "oops, git diff-tree died"
4656 catch {close $filehighlight}
4657 unset filehighlight
4658 return 0
4660 if {[info exists find_dirn]} {
4661 run findmore
4663 return 1
4666 proc doesmatch {f} {
4667 global findtype findpattern
4669 if {$findtype eq [mc "Regexp"]} {
4670 return [regexp $findpattern $f]
4671 } elseif {$findtype eq [mc "IgnCase"]} {
4672 return [string match -nocase $findpattern $f]
4673 } else {
4674 return [string match $findpattern $f]
4678 proc askfindhighlight {row id} {
4679 global nhighlights commitinfo iddrawn
4680 global findloc
4681 global markingmatches
4683 if {![info exists commitinfo($id)]} {
4684 getcommit $id
4686 set info $commitinfo($id)
4687 set isbold 0
4688 set fldtypes [list [mc Headline] [mc Author] "" [mc Committer] "" [mc Comments]]
4689 foreach f $info ty $fldtypes {
4690 if {$ty eq ""} continue
4691 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
4692 [doesmatch $f]} {
4693 if {$ty eq [mc "Author"]} {
4694 set isbold 2
4695 break
4697 set isbold 1
4700 if {$isbold && [info exists iddrawn($id)]} {
4701 if {![ishighlighted $id]} {
4702 bolden $id mainfontbold
4703 if {$isbold > 1} {
4704 bolden_name $id mainfontbold
4707 if {$markingmatches} {
4708 markrowmatches $row $id
4711 set nhighlights($id) $isbold
4714 proc markrowmatches {row id} {
4715 global canv canv2 linehtag linentag commitinfo findloc
4717 set headline [lindex $commitinfo($id) 0]
4718 set author [lindex $commitinfo($id) 1]
4719 $canv delete match$row
4720 $canv2 delete match$row
4721 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Headline"]} {
4722 set m [findmatches $headline]
4723 if {$m ne {}} {
4724 markmatches $canv $row $headline $linehtag($id) $m \
4725 [$canv itemcget $linehtag($id) -font] $row
4728 if {$findloc eq [mc "All fields"] || $findloc eq [mc "Author"]} {
4729 set m [findmatches $author]
4730 if {$m ne {}} {
4731 markmatches $canv2 $row $author $linentag($id) $m \
4732 [$canv2 itemcget $linentag($id) -font] $row
4737 proc vrel_change {name ix op} {
4738 global highlight_related
4740 rhighlight_none
4741 if {$highlight_related ne [mc "None"]} {
4742 run drawvisible
4746 # prepare for testing whether commits are descendents or ancestors of a
4747 proc rhighlight_sel {a} {
4748 global descendent desc_todo ancestor anc_todo
4749 global highlight_related
4751 catch {unset descendent}
4752 set desc_todo [list $a]
4753 catch {unset ancestor}
4754 set anc_todo [list $a]
4755 if {$highlight_related ne [mc "None"]} {
4756 rhighlight_none
4757 run drawvisible
4761 proc rhighlight_none {} {
4762 global rhighlights
4764 catch {unset rhighlights}
4765 unbolden
4768 proc is_descendent {a} {
4769 global curview children descendent desc_todo
4771 set v $curview
4772 set la [rowofcommit $a]
4773 set todo $desc_todo
4774 set leftover {}
4775 set done 0
4776 for {set i 0} {$i < [llength $todo]} {incr i} {
4777 set do [lindex $todo $i]
4778 if {[rowofcommit $do] < $la} {
4779 lappend leftover $do
4780 continue
4782 foreach nk $children($v,$do) {
4783 if {![info exists descendent($nk)]} {
4784 set descendent($nk) 1
4785 lappend todo $nk
4786 if {$nk eq $a} {
4787 set done 1
4791 if {$done} {
4792 set desc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
4793 return
4796 set descendent($a) 0
4797 set desc_todo $leftover
4800 proc is_ancestor {a} {
4801 global curview parents ancestor anc_todo
4803 set v $curview
4804 set la [rowofcommit $a]
4805 set todo $anc_todo
4806 set leftover {}
4807 set done 0
4808 for {set i 0} {$i < [llength $todo]} {incr i} {
4809 set do [lindex $todo $i]
4810 if {![commitinview $do $v] || [rowofcommit $do] > $la} {
4811 lappend leftover $do
4812 continue
4814 foreach np $parents($v,$do) {
4815 if {![info exists ancestor($np)]} {
4816 set ancestor($np) 1
4817 lappend todo $np
4818 if {$np eq $a} {
4819 set done 1
4823 if {$done} {
4824 set anc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
4825 return
4828 set ancestor($a) 0
4829 set anc_todo $leftover
4832 proc askrelhighlight {row id} {
4833 global descendent highlight_related iddrawn rhighlights
4834 global selectedline ancestor
4836 if {$selectedline eq {}} return
4837 set isbold 0
4838 if {$highlight_related eq [mc "Descendant"] ||
4839 $highlight_related eq [mc "Not descendant"]} {
4840 if {![info exists descendent($id)]} {
4841 is_descendent $id
4843 if {$descendent($id) == ($highlight_related eq [mc "Descendant"])} {
4844 set isbold 1
4846 } elseif {$highlight_related eq [mc "Ancestor"] ||
4847 $highlight_related eq [mc "Not ancestor"]} {
4848 if {![info exists ancestor($id)]} {
4849 is_ancestor $id
4851 if {$ancestor($id) == ($highlight_related eq [mc "Ancestor"])} {
4852 set isbold 1
4855 if {[info exists iddrawn($id)]} {
4856 if {$isbold && ![ishighlighted $id]} {
4857 bolden $id mainfontbold
4860 set rhighlights($id) $isbold
4863 # Graph layout functions
4865 proc shortids {ids} {
4866 set res {}
4867 foreach id $ids {
4868 if {[llength $id] > 1} {
4869 lappend res [shortids $id]
4870 } elseif {[regexp {^[0-9a-f]{40}$} $id]} {
4871 lappend res [string range $id 0 7]
4872 } else {
4873 lappend res $id
4876 return $res
4879 proc ntimes {n o} {
4880 set ret {}
4881 set o [list $o]
4882 for {set mask 1} {$mask <= $n} {incr mask $mask} {
4883 if {($n & $mask) != 0} {
4884 set ret [concat $ret $o]
4886 set o [concat $o $o]
4888 return $ret
4891 proc ordertoken {id} {
4892 global ordertok curview varcid varcstart varctok curview parents children
4893 global nullid nullid2
4895 if {[info exists ordertok($id)]} {
4896 return $ordertok($id)
4898 set origid $id
4899 set todo {}
4900 while {1} {
4901 if {[info exists varcid($curview,$id)]} {
4902 set a $varcid($curview,$id)
4903 set p [lindex $varcstart($curview) $a]
4904 } else {
4905 set p [lindex $children($curview,$id) 0]
4907 if {[info exists ordertok($p)]} {
4908 set tok $ordertok($p)
4909 break
4911 set id [first_real_child $curview,$p]
4912 if {$id eq {}} {
4913 # it's a root
4914 set tok [lindex $varctok($curview) $varcid($curview,$p)]
4915 break
4917 if {[llength $parents($curview,$id)] == 1} {
4918 lappend todo [list $p {}]
4919 } else {
4920 set j [lsearch -exact $parents($curview,$id) $p]
4921 if {$j < 0} {
4922 puts "oops didn't find [shortids $p] in parents of [shortids $id]"
4924 lappend todo [list $p [strrep $j]]
4927 for {set i [llength $todo]} {[incr i -1] >= 0} {} {
4928 set p [lindex $todo $i 0]
4929 append tok [lindex $todo $i 1]
4930 set ordertok($p) $tok
4932 set ordertok($origid) $tok
4933 return $tok
4936 # Work out where id should go in idlist so that order-token
4937 # values increase from left to right
4938 proc idcol {idlist id {i 0}} {
4939 set t [ordertoken $id]
4940 if {$i < 0} {
4941 set i 0
4943 if {$i >= [llength $idlist] || $t < [ordertoken [lindex $idlist $i]]} {
4944 if {$i > [llength $idlist]} {
4945 set i [llength $idlist]
4947 while {[incr i -1] >= 0 && $t < [ordertoken [lindex $idlist $i]]} {}
4948 incr i
4949 } else {
4950 if {$t > [ordertoken [lindex $idlist $i]]} {
4951 while {[incr i] < [llength $idlist] &&
4952 $t >= [ordertoken [lindex $idlist $i]]} {}
4955 return $i
4958 proc initlayout {} {
4959 global rowidlist rowisopt rowfinal displayorder parentlist
4960 global numcommits canvxmax canv
4961 global nextcolor
4962 global colormap rowtextx
4964 set numcommits 0
4965 set displayorder {}
4966 set parentlist {}
4967 set nextcolor 0
4968 set rowidlist {}
4969 set rowisopt {}
4970 set rowfinal {}
4971 set canvxmax [$canv cget -width]
4972 catch {unset colormap}
4973 catch {unset rowtextx}
4974 setcanvscroll
4977 proc setcanvscroll {} {
4978 global canv canv2 canv3 numcommits linespc canvxmax canvy0
4979 global lastscrollset lastscrollrows
4981 set ymax [expr {$canvy0 + ($numcommits - 0.5) * $linespc + 2}]
4982 $canv conf -scrollregion [list 0 0 $canvxmax $ymax]
4983 $canv2 conf -scrollregion [list 0 0 0 $ymax]
4984 $canv3 conf -scrollregion [list 0 0 0 $ymax]
4985 set lastscrollset [clock clicks -milliseconds]
4986 set lastscrollrows $numcommits
4989 proc visiblerows {} {
4990 global canv numcommits linespc
4992 set ymax [lindex [$canv cget -scrollregion] 3]
4993 if {$ymax eq {} || $ymax == 0} return
4994 set f [$canv yview]
4995 set y0 [expr {int([lindex $f 0] * $ymax)}]
4996 set r0 [expr {int(($y0 - 3) / $linespc) - 1}]
4997 if {$r0 < 0} {
4998 set r0 0
5000 set y1 [expr {int([lindex $f 1] * $ymax)}]
5001 set r1 [expr {int(($y1 - 3) / $linespc) + 1}]
5002 if {$r1 >= $numcommits} {
5003 set r1 [expr {$numcommits - 1}]
5005 return [list $r0 $r1]
5008 proc layoutmore {} {
5009 global commitidx viewcomplete curview
5010 global numcommits pending_select curview
5011 global lastscrollset lastscrollrows
5013 if {$lastscrollrows < 100 || $viewcomplete($curview) ||
5014 [clock clicks -milliseconds] - $lastscrollset > 500} {
5015 setcanvscroll
5017 if {[info exists pending_select] &&
5018 [commitinview $pending_select $curview]} {
5019 update
5020 selectline [rowofcommit $pending_select] 1
5022 drawvisible
5025 # With path limiting, we mightn't get the actual HEAD commit,
5026 # so ask git rev-list what is the first ancestor of HEAD that
5027 # touches a file in the path limit.
5028 proc get_viewmainhead {view} {
5029 global viewmainheadid vfilelimit viewinstances mainheadid
5031 catch {
5032 set rfd [open [concat | git rev-list -1 $mainheadid \
5033 -- $vfilelimit($view)] r]
5034 set j [reg_instance $rfd]
5035 lappend viewinstances($view) $j
5036 fconfigure $rfd -blocking 0
5037 filerun $rfd [list getviewhead $rfd $j $view]
5038 set viewmainheadid($curview) {}
5042 # git rev-list should give us just 1 line to use as viewmainheadid($view)
5043 proc getviewhead {fd inst view} {
5044 global viewmainheadid commfd curview viewinstances showlocalchanges
5046 set id {}
5047 if {[gets $fd line] < 0} {
5048 if {![eof $fd]} {
5049 return 1
5051 } elseif {[string length $line] == 40 && [string is xdigit $line]} {
5052 set id $line
5054 set viewmainheadid($view) $id
5055 close $fd
5056 unset commfd($inst)
5057 set i [lsearch -exact $viewinstances($view) $inst]
5058 if {$i >= 0} {
5059 set viewinstances($view) [lreplace $viewinstances($view) $i $i]
5061 if {$showlocalchanges && $id ne {} && $view == $curview} {
5062 doshowlocalchanges
5064 return 0
5067 proc doshowlocalchanges {} {
5068 global curview viewmainheadid
5070 if {$viewmainheadid($curview) eq {}} return
5071 if {[commitinview $viewmainheadid($curview) $curview]} {
5072 dodiffindex
5073 } else {
5074 interestedin $viewmainheadid($curview) dodiffindex
5078 proc dohidelocalchanges {} {
5079 global nullid nullid2 lserial curview
5081 if {[commitinview $nullid $curview]} {
5082 removefakerow $nullid
5084 if {[commitinview $nullid2 $curview]} {
5085 removefakerow $nullid2
5087 incr lserial
5090 # spawn off a process to do git diff-index --cached HEAD
5091 proc dodiffindex {} {
5092 global lserial showlocalchanges vfilelimit curview
5093 global hasworktree
5095 if {!$showlocalchanges || !$hasworktree} return
5096 incr lserial
5097 set cmd "|git diff-index --cached HEAD"
5098 if {$vfilelimit($curview) ne {}} {
5099 set cmd [concat $cmd -- $vfilelimit($curview)]
5101 set fd [open $cmd r]
5102 fconfigure $fd -blocking 0
5103 set i [reg_instance $fd]
5104 filerun $fd [list readdiffindex $fd $lserial $i]
5107 proc readdiffindex {fd serial inst} {
5108 global viewmainheadid nullid nullid2 curview commitinfo commitdata lserial
5109 global vfilelimit
5111 set isdiff 1
5112 if {[gets $fd line] < 0} {
5113 if {![eof $fd]} {
5114 return 1
5116 set isdiff 0
5118 # we only need to see one line and we don't really care what it says...
5119 stop_instance $inst
5121 if {$serial != $lserial} {
5122 return 0
5125 # now see if there are any local changes not checked in to the index
5126 set cmd "|git diff-files"
5127 if {$vfilelimit($curview) ne {}} {
5128 set cmd [concat $cmd -- $vfilelimit($curview)]
5130 set fd [open $cmd r]
5131 fconfigure $fd -blocking 0
5132 set i [reg_instance $fd]
5133 filerun $fd [list readdifffiles $fd $serial $i]
5135 if {$isdiff && ![commitinview $nullid2 $curview]} {
5136 # add the line for the changes in the index to the graph
5137 set hl [mc "Local changes checked in to index but not committed"]
5138 set commitinfo($nullid2) [list $hl {} {} {} {} " $hl\n"]
5139 set commitdata($nullid2) "\n $hl\n"
5140 if {[commitinview $nullid $curview]} {
5141 removefakerow $nullid
5143 insertfakerow $nullid2 $viewmainheadid($curview)
5144 } elseif {!$isdiff && [commitinview $nullid2 $curview]} {
5145 if {[commitinview $nullid $curview]} {
5146 removefakerow $nullid
5148 removefakerow $nullid2
5150 return 0
5153 proc readdifffiles {fd serial inst} {
5154 global viewmainheadid nullid nullid2 curview
5155 global commitinfo commitdata lserial
5157 set isdiff 1
5158 if {[gets $fd line] < 0} {
5159 if {![eof $fd]} {
5160 return 1
5162 set isdiff 0
5164 # we only need to see one line and we don't really care what it says...
5165 stop_instance $inst
5167 if {$serial != $lserial} {
5168 return 0
5171 if {$isdiff && ![commitinview $nullid $curview]} {
5172 # add the line for the local diff to the graph
5173 set hl [mc "Local uncommitted changes, not checked in to index"]
5174 set commitinfo($nullid) [list $hl {} {} {} {} " $hl\n"]
5175 set commitdata($nullid) "\n $hl\n"
5176 if {[commitinview $nullid2 $curview]} {
5177 set p $nullid2
5178 } else {
5179 set p $viewmainheadid($curview)
5181 insertfakerow $nullid $p
5182 } elseif {!$isdiff && [commitinview $nullid $curview]} {
5183 removefakerow $nullid
5185 return 0
5188 proc nextuse {id row} {
5189 global curview children
5191 if {[info exists children($curview,$id)]} {
5192 foreach kid $children($curview,$id) {
5193 if {![commitinview $kid $curview]} {
5194 return -1
5196 if {[rowofcommit $kid] > $row} {
5197 return [rowofcommit $kid]
5201 if {[commitinview $id $curview]} {
5202 return [rowofcommit $id]
5204 return -1
5207 proc prevuse {id row} {
5208 global curview children
5210 set ret -1
5211 if {[info exists children($curview,$id)]} {
5212 foreach kid $children($curview,$id) {
5213 if {![commitinview $kid $curview]} break
5214 if {[rowofcommit $kid] < $row} {
5215 set ret [rowofcommit $kid]
5219 return $ret
5222 proc make_idlist {row} {
5223 global displayorder parentlist uparrowlen downarrowlen mingaplen
5224 global commitidx curview children
5226 set r [expr {$row - $mingaplen - $downarrowlen - 1}]
5227 if {$r < 0} {
5228 set r 0
5230 set ra [expr {$row - $downarrowlen}]
5231 if {$ra < 0} {
5232 set ra 0
5234 set rb [expr {$row + $uparrowlen}]
5235 if {$rb > $commitidx($curview)} {
5236 set rb $commitidx($curview)
5238 make_disporder $r [expr {$rb + 1}]
5239 set ids {}
5240 for {} {$r < $ra} {incr r} {
5241 set nextid [lindex $displayorder [expr {$r + 1}]]
5242 foreach p [lindex $parentlist $r] {
5243 if {$p eq $nextid} continue
5244 set rn [nextuse $p $r]
5245 if {$rn >= $row &&
5246 $rn <= $r + $downarrowlen + $mingaplen + $uparrowlen} {
5247 lappend ids [list [ordertoken $p] $p]
5251 for {} {$r < $row} {incr r} {
5252 set nextid [lindex $displayorder [expr {$r + 1}]]
5253 foreach p [lindex $parentlist $r] {
5254 if {$p eq $nextid} continue
5255 set rn [nextuse $p $r]
5256 if {$rn < 0 || $rn >= $row} {
5257 lappend ids [list [ordertoken $p] $p]
5261 set id [lindex $displayorder $row]
5262 lappend ids [list [ordertoken $id] $id]
5263 while {$r < $rb} {
5264 foreach p [lindex $parentlist $r] {
5265 set firstkid [lindex $children($curview,$p) 0]
5266 if {[rowofcommit $firstkid] < $row} {
5267 lappend ids [list [ordertoken $p] $p]
5270 incr r
5271 set id [lindex $displayorder $r]
5272 if {$id ne {}} {
5273 set firstkid [lindex $children($curview,$id) 0]
5274 if {$firstkid ne {} && [rowofcommit $firstkid] < $row} {
5275 lappend ids [list [ordertoken $id] $id]
5279 set idlist {}
5280 foreach idx [lsort -unique $ids] {
5281 lappend idlist [lindex $idx 1]
5283 return $idlist
5286 proc rowsequal {a b} {
5287 while {[set i [lsearch -exact $a {}]] >= 0} {
5288 set a [lreplace $a $i $i]
5290 while {[set i [lsearch -exact $b {}]] >= 0} {
5291 set b [lreplace $b $i $i]
5293 return [expr {$a eq $b}]
5296 proc makeupline {id row rend col} {
5297 global rowidlist uparrowlen downarrowlen mingaplen
5299 for {set r $rend} {1} {set r $rstart} {
5300 set rstart [prevuse $id $r]
5301 if {$rstart < 0} return
5302 if {$rstart < $row} break
5304 if {$rstart + $uparrowlen + $mingaplen + $downarrowlen < $rend} {
5305 set rstart [expr {$rend - $uparrowlen - 1}]
5307 for {set r $rstart} {[incr r] <= $row} {} {
5308 set idlist [lindex $rowidlist $r]
5309 if {$idlist ne {} && [lsearch -exact $idlist $id] < 0} {
5310 set col [idcol $idlist $id $col]
5311 lset rowidlist $r [linsert $idlist $col $id]
5312 changedrow $r
5317 proc layoutrows {row endrow} {
5318 global rowidlist rowisopt rowfinal displayorder
5319 global uparrowlen downarrowlen maxwidth mingaplen
5320 global children parentlist
5321 global commitidx viewcomplete curview
5323 make_disporder [expr {$row - 1}] [expr {$endrow + $uparrowlen}]
5324 set idlist {}
5325 if {$row > 0} {
5326 set rm1 [expr {$row - 1}]
5327 foreach id [lindex $rowidlist $rm1] {
5328 if {$id ne {}} {
5329 lappend idlist $id
5332 set final [lindex $rowfinal $rm1]
5334 for {} {$row < $endrow} {incr row} {
5335 set rm1 [expr {$row - 1}]
5336 if {$rm1 < 0 || $idlist eq {}} {
5337 set idlist [make_idlist $row]
5338 set final 1
5339 } else {
5340 set id [lindex $displayorder $rm1]
5341 set col [lsearch -exact $idlist $id]
5342 set idlist [lreplace $idlist $col $col]
5343 foreach p [lindex $parentlist $rm1] {
5344 if {[lsearch -exact $idlist $p] < 0} {
5345 set col [idcol $idlist $p $col]
5346 set idlist [linsert $idlist $col $p]
5347 # if not the first child, we have to insert a line going up
5348 if {$id ne [lindex $children($curview,$p) 0]} {
5349 makeupline $p $rm1 $row $col
5353 set id [lindex $displayorder $row]
5354 if {$row > $downarrowlen} {
5355 set termrow [expr {$row - $downarrowlen - 1}]
5356 foreach p [lindex $parentlist $termrow] {
5357 set i [lsearch -exact $idlist $p]
5358 if {$i < 0} continue
5359 set nr [nextuse $p $termrow]
5360 if {$nr < 0 || $nr >= $row + $mingaplen + $uparrowlen} {
5361 set idlist [lreplace $idlist $i $i]
5365 set col [lsearch -exact $idlist $id]
5366 if {$col < 0} {
5367 set col [idcol $idlist $id]
5368 set idlist [linsert $idlist $col $id]
5369 if {$children($curview,$id) ne {}} {
5370 makeupline $id $rm1 $row $col
5373 set r [expr {$row + $uparrowlen - 1}]
5374 if {$r < $commitidx($curview)} {
5375 set x $col
5376 foreach p [lindex $parentlist $r] {
5377 if {[lsearch -exact $idlist $p] >= 0} continue
5378 set fk [lindex $children($curview,$p) 0]
5379 if {[rowofcommit $fk] < $row} {
5380 set x [idcol $idlist $p $x]
5381 set idlist [linsert $idlist $x $p]
5384 if {[incr r] < $commitidx($curview)} {
5385 set p [lindex $displayorder $r]
5386 if {[lsearch -exact $idlist $p] < 0} {
5387 set fk [lindex $children($curview,$p) 0]
5388 if {$fk ne {} && [rowofcommit $fk] < $row} {
5389 set x [idcol $idlist $p $x]
5390 set idlist [linsert $idlist $x $p]
5396 if {$final && !$viewcomplete($curview) &&
5397 $row + $uparrowlen + $mingaplen + $downarrowlen
5398 >= $commitidx($curview)} {
5399 set final 0
5401 set l [llength $rowidlist]
5402 if {$row == $l} {
5403 lappend rowidlist $idlist
5404 lappend rowisopt 0
5405 lappend rowfinal $final
5406 } elseif {$row < $l} {
5407 if {![rowsequal $idlist [lindex $rowidlist $row]]} {
5408 lset rowidlist $row $idlist
5409 changedrow $row
5411 lset rowfinal $row $final
5412 } else {
5413 set pad [ntimes [expr {$row - $l}] {}]
5414 set rowidlist [concat $rowidlist $pad]
5415 lappend rowidlist $idlist
5416 set rowfinal [concat $rowfinal $pad]
5417 lappend rowfinal $final
5418 set rowisopt [concat $rowisopt [ntimes [expr {$row - $l + 1}] 0]]
5421 return $row
5424 proc changedrow {row} {
5425 global displayorder iddrawn rowisopt need_redisplay
5427 set l [llength $rowisopt]
5428 if {$row < $l} {
5429 lset rowisopt $row 0
5430 if {$row + 1 < $l} {
5431 lset rowisopt [expr {$row + 1}] 0
5432 if {$row + 2 < $l} {
5433 lset rowisopt [expr {$row + 2}] 0
5437 set id [lindex $displayorder $row]
5438 if {[info exists iddrawn($id)]} {
5439 set need_redisplay 1
5443 proc insert_pad {row col npad} {
5444 global rowidlist
5446 set pad [ntimes $npad {}]
5447 set idlist [lindex $rowidlist $row]
5448 set bef [lrange $idlist 0 [expr {$col - 1}]]
5449 set aft [lrange $idlist $col end]
5450 set i [lsearch -exact $aft {}]
5451 if {$i > 0} {
5452 set aft [lreplace $aft $i $i]
5454 lset rowidlist $row [concat $bef $pad $aft]
5455 changedrow $row
5458 proc optimize_rows {row col endrow} {
5459 global rowidlist rowisopt displayorder curview children
5461 if {$row < 1} {
5462 set row 1
5464 for {} {$row < $endrow} {incr row; set col 0} {
5465 if {[lindex $rowisopt $row]} continue
5466 set haspad 0
5467 set y0 [expr {$row - 1}]
5468 set ym [expr {$row - 2}]
5469 set idlist [lindex $rowidlist $row]
5470 set previdlist [lindex $rowidlist $y0]
5471 if {$idlist eq {} || $previdlist eq {}} continue
5472 if {$ym >= 0} {
5473 set pprevidlist [lindex $rowidlist $ym]
5474 if {$pprevidlist eq {}} continue
5475 } else {
5476 set pprevidlist {}
5478 set x0 -1
5479 set xm -1
5480 for {} {$col < [llength $idlist]} {incr col} {
5481 set id [lindex $idlist $col]
5482 if {[lindex $previdlist $col] eq $id} continue
5483 if {$id eq {}} {
5484 set haspad 1
5485 continue
5487 set x0 [lsearch -exact $previdlist $id]
5488 if {$x0 < 0} continue
5489 set z [expr {$x0 - $col}]
5490 set isarrow 0
5491 set z0 {}
5492 if {$ym >= 0} {
5493 set xm [lsearch -exact $pprevidlist $id]
5494 if {$xm >= 0} {
5495 set z0 [expr {$xm - $x0}]
5498 if {$z0 eq {}} {
5499 # if row y0 is the first child of $id then it's not an arrow
5500 if {[lindex $children($curview,$id) 0] ne
5501 [lindex $displayorder $y0]} {
5502 set isarrow 1
5505 if {!$isarrow && $id ne [lindex $displayorder $row] &&
5506 [lsearch -exact [lindex $rowidlist [expr {$row+1}]] $id] < 0} {
5507 set isarrow 1
5509 # Looking at lines from this row to the previous row,
5510 # make them go straight up if they end in an arrow on
5511 # the previous row; otherwise make them go straight up
5512 # or at 45 degrees.
5513 if {$z < -1 || ($z < 0 && $isarrow)} {
5514 # Line currently goes left too much;
5515 # insert pads in the previous row, then optimize it
5516 set npad [expr {-1 - $z + $isarrow}]
5517 insert_pad $y0 $x0 $npad
5518 if {$y0 > 0} {
5519 optimize_rows $y0 $x0 $row
5521 set previdlist [lindex $rowidlist $y0]
5522 set x0 [lsearch -exact $previdlist $id]
5523 set z [expr {$x0 - $col}]
5524 if {$z0 ne {}} {
5525 set pprevidlist [lindex $rowidlist $ym]
5526 set xm [lsearch -exact $pprevidlist $id]
5527 set z0 [expr {$xm - $x0}]
5529 } elseif {$z > 1 || ($z > 0 && $isarrow)} {
5530 # Line currently goes right too much;
5531 # insert pads in this line
5532 set npad [expr {$z - 1 + $isarrow}]
5533 insert_pad $row $col $npad
5534 set idlist [lindex $rowidlist $row]
5535 incr col $npad
5536 set z [expr {$x0 - $col}]
5537 set haspad 1
5539 if {$z0 eq {} && !$isarrow && $ym >= 0} {
5540 # this line links to its first child on row $row-2
5541 set id [lindex $displayorder $ym]
5542 set xc [lsearch -exact $pprevidlist $id]
5543 if {$xc >= 0} {
5544 set z0 [expr {$xc - $x0}]
5547 # avoid lines jigging left then immediately right
5548 if {$z0 ne {} && $z < 0 && $z0 > 0} {
5549 insert_pad $y0 $x0 1
5550 incr x0
5551 optimize_rows $y0 $x0 $row
5552 set previdlist [lindex $rowidlist $y0]
5555 if {!$haspad} {
5556 # Find the first column that doesn't have a line going right
5557 for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
5558 set id [lindex $idlist $col]
5559 if {$id eq {}} break
5560 set x0 [lsearch -exact $previdlist $id]
5561 if {$x0 < 0} {
5562 # check if this is the link to the first child
5563 set kid [lindex $displayorder $y0]
5564 if {[lindex $children($curview,$id) 0] eq $kid} {
5565 # it is, work out offset to child
5566 set x0 [lsearch -exact $previdlist $kid]
5569 if {$x0 <= $col} break
5571 # Insert a pad at that column as long as it has a line and
5572 # isn't the last column
5573 if {$x0 >= 0 && [incr col] < [llength $idlist]} {
5574 set idlist [linsert $idlist $col {}]
5575 lset rowidlist $row $idlist
5576 changedrow $row
5582 proc xc {row col} {
5583 global canvx0 linespc
5584 return [expr {$canvx0 + $col * $linespc}]
5587 proc yc {row} {
5588 global canvy0 linespc
5589 return [expr {$canvy0 + $row * $linespc}]
5592 proc linewidth {id} {
5593 global thickerline lthickness
5595 set wid $lthickness
5596 if {[info exists thickerline] && $id eq $thickerline} {
5597 set wid [expr {2 * $lthickness}]
5599 return $wid
5602 proc rowranges {id} {
5603 global curview children uparrowlen downarrowlen
5604 global rowidlist
5606 set kids $children($curview,$id)
5607 if {$kids eq {}} {
5608 return {}
5610 set ret {}
5611 lappend kids $id
5612 foreach child $kids {
5613 if {![commitinview $child $curview]} break
5614 set row [rowofcommit $child]
5615 if {![info exists prev]} {
5616 lappend ret [expr {$row + 1}]
5617 } else {
5618 if {$row <= $prevrow} {
5619 puts "oops children of [shortids $id] out of order [shortids $child] $row <= [shortids $prev] $prevrow"
5621 # see if the line extends the whole way from prevrow to row
5622 if {$row > $prevrow + $uparrowlen + $downarrowlen &&
5623 [lsearch -exact [lindex $rowidlist \
5624 [expr {int(($row + $prevrow) / 2)}]] $id] < 0} {
5625 # it doesn't, see where it ends
5626 set r [expr {$prevrow + $downarrowlen}]
5627 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
5628 while {[incr r -1] > $prevrow &&
5629 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
5630 } else {
5631 while {[incr r] <= $row &&
5632 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
5633 incr r -1
5635 lappend ret $r
5636 # see where it starts up again
5637 set r [expr {$row - $uparrowlen}]
5638 if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
5639 while {[incr r] < $row &&
5640 [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
5641 } else {
5642 while {[incr r -1] >= $prevrow &&
5643 [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
5644 incr r
5646 lappend ret $r
5649 if {$child eq $id} {
5650 lappend ret $row
5652 set prev $child
5653 set prevrow $row
5655 return $ret
5658 proc drawlineseg {id row endrow arrowlow} {
5659 global rowidlist displayorder iddrawn linesegs
5660 global canv colormap linespc curview maxlinelen parentlist
5662 set cols [list [lsearch -exact [lindex $rowidlist $row] $id]]
5663 set le [expr {$row + 1}]
5664 set arrowhigh 1
5665 while {1} {
5666 set c [lsearch -exact [lindex $rowidlist $le] $id]
5667 if {$c < 0} {
5668 incr le -1
5669 break
5671 lappend cols $c
5672 set x [lindex $displayorder $le]
5673 if {$x eq $id} {
5674 set arrowhigh 0
5675 break
5677 if {[info exists iddrawn($x)] || $le == $endrow} {
5678 set c [lsearch -exact [lindex $rowidlist [expr {$le+1}]] $id]
5679 if {$c >= 0} {
5680 lappend cols $c
5681 set arrowhigh 0
5683 break
5685 incr le
5687 if {$le <= $row} {
5688 return $row
5691 set lines {}
5692 set i 0
5693 set joinhigh 0
5694 if {[info exists linesegs($id)]} {
5695 set lines $linesegs($id)
5696 foreach li $lines {
5697 set r0 [lindex $li 0]
5698 if {$r0 > $row} {
5699 if {$r0 == $le && [lindex $li 1] - $row <= $maxlinelen} {
5700 set joinhigh 1
5702 break
5704 incr i
5707 set joinlow 0
5708 if {$i > 0} {
5709 set li [lindex $lines [expr {$i-1}]]
5710 set r1 [lindex $li 1]
5711 if {$r1 == $row && $le - [lindex $li 0] <= $maxlinelen} {
5712 set joinlow 1
5716 set x [lindex $cols [expr {$le - $row}]]
5717 set xp [lindex $cols [expr {$le - 1 - $row}]]
5718 set dir [expr {$xp - $x}]
5719 if {$joinhigh} {
5720 set ith [lindex $lines $i 2]
5721 set coords [$canv coords $ith]
5722 set ah [$canv itemcget $ith -arrow]
5723 set arrowhigh [expr {$ah eq "first" || $ah eq "both"}]
5724 set x2 [lindex $cols [expr {$le + 1 - $row}]]
5725 if {$x2 ne {} && $x - $x2 == $dir} {
5726 set coords [lrange $coords 0 end-2]
5728 } else {
5729 set coords [list [xc $le $x] [yc $le]]
5731 if {$joinlow} {
5732 set itl [lindex $lines [expr {$i-1}] 2]
5733 set al [$canv itemcget $itl -arrow]
5734 set arrowlow [expr {$al eq "last" || $al eq "both"}]
5735 } elseif {$arrowlow} {
5736 if {[lsearch -exact [lindex $rowidlist [expr {$row-1}]] $id] >= 0 ||
5737 [lsearch -exact [lindex $parentlist [expr {$row-1}]] $id] >= 0} {
5738 set arrowlow 0
5741 set arrow [lindex {none first last both} [expr {$arrowhigh + 2*$arrowlow}]]
5742 for {set y $le} {[incr y -1] > $row} {} {
5743 set x $xp
5744 set xp [lindex $cols [expr {$y - 1 - $row}]]
5745 set ndir [expr {$xp - $x}]
5746 if {$dir != $ndir || $xp < 0} {
5747 lappend coords [xc $y $x] [yc $y]
5749 set dir $ndir
5751 if {!$joinlow} {
5752 if {$xp < 0} {
5753 # join parent line to first child
5754 set ch [lindex $displayorder $row]
5755 set xc [lsearch -exact [lindex $rowidlist $row] $ch]
5756 if {$xc < 0} {
5757 puts "oops: drawlineseg: child $ch not on row $row"
5758 } elseif {$xc != $x} {
5759 if {($arrowhigh && $le == $row + 1) || $dir == 0} {
5760 set d [expr {int(0.5 * $linespc)}]
5761 set x1 [xc $row $x]
5762 if {$xc < $x} {
5763 set x2 [expr {$x1 - $d}]
5764 } else {
5765 set x2 [expr {$x1 + $d}]
5767 set y2 [yc $row]
5768 set y1 [expr {$y2 + $d}]
5769 lappend coords $x1 $y1 $x2 $y2
5770 } elseif {$xc < $x - 1} {
5771 lappend coords [xc $row [expr {$x-1}]] [yc $row]
5772 } elseif {$xc > $x + 1} {
5773 lappend coords [xc $row [expr {$x+1}]] [yc $row]
5775 set x $xc
5777 lappend coords [xc $row $x] [yc $row]
5778 } else {
5779 set xn [xc $row $xp]
5780 set yn [yc $row]
5781 lappend coords $xn $yn
5783 if {!$joinhigh} {
5784 assigncolor $id
5785 set t [$canv create line $coords -width [linewidth $id] \
5786 -fill $colormap($id) -tags lines.$id -arrow $arrow]
5787 $canv lower $t
5788 bindline $t $id
5789 set lines [linsert $lines $i [list $row $le $t]]
5790 } else {
5791 $canv coords $ith $coords
5792 if {$arrow ne $ah} {
5793 $canv itemconf $ith -arrow $arrow
5795 lset lines $i 0 $row
5797 } else {
5798 set xo [lsearch -exact [lindex $rowidlist [expr {$row - 1}]] $id]
5799 set ndir [expr {$xo - $xp}]
5800 set clow [$canv coords $itl]
5801 if {$dir == $ndir} {
5802 set clow [lrange $clow 2 end]
5804 set coords [concat $coords $clow]
5805 if {!$joinhigh} {
5806 lset lines [expr {$i-1}] 1 $le
5807 } else {
5808 # coalesce two pieces
5809 $canv delete $ith
5810 set b [lindex $lines [expr {$i-1}] 0]
5811 set e [lindex $lines $i 1]
5812 set lines [lreplace $lines [expr {$i-1}] $i [list $b $e $itl]]
5814 $canv coords $itl $coords
5815 if {$arrow ne $al} {
5816 $canv itemconf $itl -arrow $arrow
5820 set linesegs($id) $lines
5821 return $le
5824 proc drawparentlinks {id row} {
5825 global rowidlist canv colormap curview parentlist
5826 global idpos linespc
5828 set rowids [lindex $rowidlist $row]
5829 set col [lsearch -exact $rowids $id]
5830 if {$col < 0} return
5831 set olds [lindex $parentlist $row]
5832 set row2 [expr {$row + 1}]
5833 set x [xc $row $col]
5834 set y [yc $row]
5835 set y2 [yc $row2]
5836 set d [expr {int(0.5 * $linespc)}]
5837 set ymid [expr {$y + $d}]
5838 set ids [lindex $rowidlist $row2]
5839 # rmx = right-most X coord used
5840 set rmx 0
5841 foreach p $olds {
5842 set i [lsearch -exact $ids $p]
5843 if {$i < 0} {
5844 puts "oops, parent $p of $id not in list"
5845 continue
5847 set x2 [xc $row2 $i]
5848 if {$x2 > $rmx} {
5849 set rmx $x2
5851 set j [lsearch -exact $rowids $p]
5852 if {$j < 0} {
5853 # drawlineseg will do this one for us
5854 continue
5856 assigncolor $p
5857 # should handle duplicated parents here...
5858 set coords [list $x $y]
5859 if {$i != $col} {
5860 # if attaching to a vertical segment, draw a smaller
5861 # slant for visual distinctness
5862 if {$i == $j} {
5863 if {$i < $col} {
5864 lappend coords [expr {$x2 + $d}] $y $x2 $ymid
5865 } else {
5866 lappend coords [expr {$x2 - $d}] $y $x2 $ymid
5868 } elseif {$i < $col && $i < $j} {
5869 # segment slants towards us already
5870 lappend coords [xc $row $j] $y
5871 } else {
5872 if {$i < $col - 1} {
5873 lappend coords [expr {$x2 + $linespc}] $y
5874 } elseif {$i > $col + 1} {
5875 lappend coords [expr {$x2 - $linespc}] $y
5877 lappend coords $x2 $y2
5879 } else {
5880 lappend coords $x2 $y2
5882 set t [$canv create line $coords -width [linewidth $p] \
5883 -fill $colormap($p) -tags lines.$p]
5884 $canv lower $t
5885 bindline $t $p
5887 if {$rmx > [lindex $idpos($id) 1]} {
5888 lset idpos($id) 1 $rmx
5889 redrawtags $id
5893 proc drawlines {id} {
5894 global canv
5896 $canv itemconf lines.$id -width [linewidth $id]
5899 proc drawcmittext {id row col} {
5900 global linespc canv canv2 canv3 fgcolor curview
5901 global cmitlisted commitinfo rowidlist parentlist
5902 global rowtextx idpos idtags idheads idotherrefs
5903 global linehtag linentag linedtag selectedline
5904 global canvxmax boldids boldnameids fgcolor markedid
5905 global mainheadid nullid nullid2 circleitem circlecolors ctxbut
5907 # listed is 0 for boundary, 1 for normal, 2 for negative, 3 for left, 4 for right
5908 set listed $cmitlisted($curview,$id)
5909 if {$id eq $nullid} {
5910 set ofill red
5911 } elseif {$id eq $nullid2} {
5912 set ofill green
5913 } elseif {$id eq $mainheadid} {
5914 set ofill yellow
5915 } else {
5916 set ofill [lindex $circlecolors $listed]
5918 set x [xc $row $col]
5919 set y [yc $row]
5920 set orad [expr {$linespc / 3}]
5921 if {$listed <= 2} {
5922 set t [$canv create oval [expr {$x - $orad}] [expr {$y - $orad}] \
5923 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
5924 -fill $ofill -outline $fgcolor -width 1 -tags circle]
5925 } elseif {$listed == 3} {
5926 # triangle pointing left for left-side commits
5927 set t [$canv create polygon \
5928 [expr {$x - $orad}] $y \
5929 [expr {$x + $orad - 1}] [expr {$y - $orad}] \
5930 [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
5931 -fill $ofill -outline $fgcolor -width 1 -tags circle]
5932 } else {
5933 # triangle pointing right for right-side commits
5934 set t [$canv create polygon \
5935 [expr {$x + $orad - 1}] $y \
5936 [expr {$x - $orad}] [expr {$y - $orad}] \
5937 [expr {$x - $orad}] [expr {$y + $orad - 1}] \
5938 -fill $ofill -outline $fgcolor -width 1 -tags circle]
5940 set circleitem($row) $t
5941 $canv raise $t
5942 $canv bind $t <1> {selcanvline {} %x %y}
5943 set rmx [llength [lindex $rowidlist $row]]
5944 set olds [lindex $parentlist $row]
5945 if {$olds ne {}} {
5946 set nextids [lindex $rowidlist [expr {$row + 1}]]
5947 foreach p $olds {
5948 set i [lsearch -exact $nextids $p]
5949 if {$i > $rmx} {
5950 set rmx $i
5954 set xt [xc $row $rmx]
5955 set rowtextx($row) $xt
5956 set idpos($id) [list $x $xt $y]
5957 if {[info exists idtags($id)] || [info exists idheads($id)]
5958 || [info exists idotherrefs($id)]} {
5959 set xt [drawtags $id $x $xt $y]
5961 if {[lindex $commitinfo($id) 6] > 0} {
5962 set xt [drawnotesign $xt $y]
5964 set headline [lindex $commitinfo($id) 0]
5965 set name [lindex $commitinfo($id) 1]
5966 set date [lindex $commitinfo($id) 2]
5967 set date [formatdate $date]
5968 set font mainfont
5969 set nfont mainfont
5970 set isbold [ishighlighted $id]
5971 if {$isbold > 0} {
5972 lappend boldids $id
5973 set font mainfontbold
5974 if {$isbold > 1} {
5975 lappend boldnameids $id
5976 set nfont mainfontbold
5979 set linehtag($id) [$canv create text $xt $y -anchor w -fill $fgcolor \
5980 -text $headline -font $font -tags text]
5981 $canv bind $linehtag($id) $ctxbut "rowmenu %X %Y $id"
5982 set linentag($id) [$canv2 create text 3 $y -anchor w -fill $fgcolor \
5983 -text $name -font $nfont -tags text]
5984 set linedtag($id) [$canv3 create text 3 $y -anchor w -fill $fgcolor \
5985 -text $date -font mainfont -tags text]
5986 if {$selectedline == $row} {
5987 make_secsel $id
5989 if {[info exists markedid] && $markedid eq $id} {
5990 make_idmark $id
5992 set xr [expr {$xt + [font measure $font $headline]}]
5993 if {$xr > $canvxmax} {
5994 set canvxmax $xr
5995 setcanvscroll
5999 proc drawcmitrow {row} {
6000 global displayorder rowidlist nrows_drawn
6001 global iddrawn markingmatches
6002 global commitinfo numcommits
6003 global filehighlight fhighlights findpattern nhighlights
6004 global hlview vhighlights
6005 global highlight_related rhighlights
6007 if {$row >= $numcommits} return
6009 set id [lindex $displayorder $row]
6010 if {[info exists hlview] && ![info exists vhighlights($id)]} {
6011 askvhighlight $row $id
6013 if {[info exists filehighlight] && ![info exists fhighlights($id)]} {
6014 askfilehighlight $row $id
6016 if {$findpattern ne {} && ![info exists nhighlights($id)]} {
6017 askfindhighlight $row $id
6019 if {$highlight_related ne [mc "None"] && ![info exists rhighlights($id)]} {
6020 askrelhighlight $row $id
6022 if {![info exists iddrawn($id)]} {
6023 set col [lsearch -exact [lindex $rowidlist $row] $id]
6024 if {$col < 0} {
6025 puts "oops, row $row id $id not in list"
6026 return
6028 if {![info exists commitinfo($id)]} {
6029 getcommit $id
6031 assigncolor $id
6032 drawcmittext $id $row $col
6033 set iddrawn($id) 1
6034 incr nrows_drawn
6036 if {$markingmatches} {
6037 markrowmatches $row $id
6041 proc drawcommits {row {endrow {}}} {
6042 global numcommits iddrawn displayorder curview need_redisplay
6043 global parentlist rowidlist rowfinal uparrowlen downarrowlen nrows_drawn
6045 if {$row < 0} {
6046 set row 0
6048 if {$endrow eq {}} {
6049 set endrow $row
6051 if {$endrow >= $numcommits} {
6052 set endrow [expr {$numcommits - 1}]
6055 set rl1 [expr {$row - $downarrowlen - 3}]
6056 if {$rl1 < 0} {
6057 set rl1 0
6059 set ro1 [expr {$row - 3}]
6060 if {$ro1 < 0} {
6061 set ro1 0
6063 set r2 [expr {$endrow + $uparrowlen + 3}]
6064 if {$r2 > $numcommits} {
6065 set r2 $numcommits
6067 for {set r $rl1} {$r < $r2} {incr r} {
6068 if {[lindex $rowidlist $r] ne {} && [lindex $rowfinal $r]} {
6069 if {$rl1 < $r} {
6070 layoutrows $rl1 $r
6072 set rl1 [expr {$r + 1}]
6075 if {$rl1 < $r} {
6076 layoutrows $rl1 $r
6078 optimize_rows $ro1 0 $r2
6079 if {$need_redisplay || $nrows_drawn > 2000} {
6080 clear_display
6083 # make the lines join to already-drawn rows either side
6084 set r [expr {$row - 1}]
6085 if {$r < 0 || ![info exists iddrawn([lindex $displayorder $r])]} {
6086 set r $row
6088 set er [expr {$endrow + 1}]
6089 if {$er >= $numcommits ||
6090 ![info exists iddrawn([lindex $displayorder $er])]} {
6091 set er $endrow
6093 for {} {$r <= $er} {incr r} {
6094 set id [lindex $displayorder $r]
6095 set wasdrawn [info exists iddrawn($id)]
6096 drawcmitrow $r
6097 if {$r == $er} break
6098 set nextid [lindex $displayorder [expr {$r + 1}]]
6099 if {$wasdrawn && [info exists iddrawn($nextid)]} continue
6100 drawparentlinks $id $r
6102 set rowids [lindex $rowidlist $r]
6103 foreach lid $rowids {
6104 if {$lid eq {}} continue
6105 if {[info exists lineend($lid)] && $lineend($lid) > $r} continue
6106 if {$lid eq $id} {
6107 # see if this is the first child of any of its parents
6108 foreach p [lindex $parentlist $r] {
6109 if {[lsearch -exact $rowids $p] < 0} {
6110 # make this line extend up to the child
6111 set lineend($p) [drawlineseg $p $r $er 0]
6114 } else {
6115 set lineend($lid) [drawlineseg $lid $r $er 1]
6121 proc undolayout {row} {
6122 global uparrowlen mingaplen downarrowlen
6123 global rowidlist rowisopt rowfinal need_redisplay
6125 set r [expr {$row - ($uparrowlen + $mingaplen + $downarrowlen)}]
6126 if {$r < 0} {
6127 set r 0
6129 if {[llength $rowidlist] > $r} {
6130 incr r -1
6131 set rowidlist [lrange $rowidlist 0 $r]
6132 set rowfinal [lrange $rowfinal 0 $r]
6133 set rowisopt [lrange $rowisopt 0 $r]
6134 set need_redisplay 1
6135 run drawvisible
6139 proc drawvisible {} {
6140 global canv linespc curview vrowmod selectedline targetrow targetid
6141 global need_redisplay cscroll numcommits
6143 set fs [$canv yview]
6144 set ymax [lindex [$canv cget -scrollregion] 3]
6145 if {$ymax eq {} || $ymax == 0 || $numcommits == 0} return
6146 set f0 [lindex $fs 0]
6147 set f1 [lindex $fs 1]
6148 set y0 [expr {int($f0 * $ymax)}]
6149 set y1 [expr {int($f1 * $ymax)}]
6151 if {[info exists targetid]} {
6152 if {[commitinview $targetid $curview]} {
6153 set r [rowofcommit $targetid]
6154 if {$r != $targetrow} {
6155 # Fix up the scrollregion and change the scrolling position
6156 # now that our target row has moved.
6157 set diff [expr {($r - $targetrow) * $linespc}]
6158 set targetrow $r
6159 setcanvscroll
6160 set ymax [lindex [$canv cget -scrollregion] 3]
6161 incr y0 $diff
6162 incr y1 $diff
6163 set f0 [expr {$y0 / $ymax}]
6164 set f1 [expr {$y1 / $ymax}]
6165 allcanvs yview moveto $f0
6166 $cscroll set $f0 $f1
6167 set need_redisplay 1
6169 } else {
6170 unset targetid
6174 set row [expr {int(($y0 - 3) / $linespc) - 1}]
6175 set endrow [expr {int(($y1 - 3) / $linespc) + 1}]
6176 if {$endrow >= $vrowmod($curview)} {
6177 update_arcrows $curview
6179 if {$selectedline ne {} &&
6180 $row <= $selectedline && $selectedline <= $endrow} {
6181 set targetrow $selectedline
6182 } elseif {[info exists targetid]} {
6183 set targetrow [expr {int(($row + $endrow) / 2)}]
6185 if {[info exists targetrow]} {
6186 if {$targetrow >= $numcommits} {
6187 set targetrow [expr {$numcommits - 1}]
6189 set targetid [commitonrow $targetrow]
6191 drawcommits $row $endrow
6194 proc clear_display {} {
6195 global iddrawn linesegs need_redisplay nrows_drawn
6196 global vhighlights fhighlights nhighlights rhighlights
6197 global linehtag linentag linedtag boldids boldnameids
6199 allcanvs delete all
6200 catch {unset iddrawn}
6201 catch {unset linesegs}
6202 catch {unset linehtag}
6203 catch {unset linentag}
6204 catch {unset linedtag}
6205 set boldids {}
6206 set boldnameids {}
6207 catch {unset vhighlights}
6208 catch {unset fhighlights}
6209 catch {unset nhighlights}
6210 catch {unset rhighlights}
6211 set need_redisplay 0
6212 set nrows_drawn 0
6215 proc findcrossings {id} {
6216 global rowidlist parentlist numcommits displayorder
6218 set cross {}
6219 set ccross {}
6220 foreach {s e} [rowranges $id] {
6221 if {$e >= $numcommits} {
6222 set e [expr {$numcommits - 1}]
6224 if {$e <= $s} continue
6225 for {set row $e} {[incr row -1] >= $s} {} {
6226 set x [lsearch -exact [lindex $rowidlist $row] $id]
6227 if {$x < 0} break
6228 set olds [lindex $parentlist $row]
6229 set kid [lindex $displayorder $row]
6230 set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
6231 if {$kidx < 0} continue
6232 set nextrow [lindex $rowidlist [expr {$row + 1}]]
6233 foreach p $olds {
6234 set px [lsearch -exact $nextrow $p]
6235 if {$px < 0} continue
6236 if {($kidx < $x && $x < $px) || ($px < $x && $x < $kidx)} {
6237 if {[lsearch -exact $ccross $p] >= 0} continue
6238 if {$x == $px + ($kidx < $px? -1: 1)} {
6239 lappend ccross $p
6240 } elseif {[lsearch -exact $cross $p] < 0} {
6241 lappend cross $p
6247 return [concat $ccross {{}} $cross]
6250 proc assigncolor {id} {
6251 global colormap colors nextcolor
6252 global parents children children curview
6254 if {[info exists colormap($id)]} return
6255 set ncolors [llength $colors]
6256 if {[info exists children($curview,$id)]} {
6257 set kids $children($curview,$id)
6258 } else {
6259 set kids {}
6261 if {[llength $kids] == 1} {
6262 set child [lindex $kids 0]
6263 if {[info exists colormap($child)]
6264 && [llength $parents($curview,$child)] == 1} {
6265 set colormap($id) $colormap($child)
6266 return
6269 set badcolors {}
6270 set origbad {}
6271 foreach x [findcrossings $id] {
6272 if {$x eq {}} {
6273 # delimiter between corner crossings and other crossings
6274 if {[llength $badcolors] >= $ncolors - 1} break
6275 set origbad $badcolors
6277 if {[info exists colormap($x)]
6278 && [lsearch -exact $badcolors $colormap($x)] < 0} {
6279 lappend badcolors $colormap($x)
6282 if {[llength $badcolors] >= $ncolors} {
6283 set badcolors $origbad
6285 set origbad $badcolors
6286 if {[llength $badcolors] < $ncolors - 1} {
6287 foreach child $kids {
6288 if {[info exists colormap($child)]
6289 && [lsearch -exact $badcolors $colormap($child)] < 0} {
6290 lappend badcolors $colormap($child)
6292 foreach p $parents($curview,$child) {
6293 if {[info exists colormap($p)]
6294 && [lsearch -exact $badcolors $colormap($p)] < 0} {
6295 lappend badcolors $colormap($p)
6299 if {[llength $badcolors] >= $ncolors} {
6300 set badcolors $origbad
6303 for {set i 0} {$i <= $ncolors} {incr i} {
6304 set c [lindex $colors $nextcolor]
6305 if {[incr nextcolor] >= $ncolors} {
6306 set nextcolor 0
6308 if {[lsearch -exact $badcolors $c]} break
6310 set colormap($id) $c
6313 proc bindline {t id} {
6314 global canv
6316 $canv bind $t <Enter> "lineenter %x %y $id"
6317 $canv bind $t <Motion> "linemotion %x %y $id"
6318 $canv bind $t <Leave> "lineleave $id"
6319 $canv bind $t <Button-1> "lineclick %x %y $id 1"
6322 proc drawtags {id x xt y1} {
6323 global idtags idheads idotherrefs mainhead
6324 global linespc lthickness
6325 global canv rowtextx curview fgcolor bgcolor ctxbut
6327 set marks {}
6328 set ntags 0
6329 set nheads 0
6330 if {[info exists idtags($id)]} {
6331 set marks $idtags($id)
6332 set ntags [llength $marks]
6334 if {[info exists idheads($id)]} {
6335 set marks [concat $marks $idheads($id)]
6336 set nheads [llength $idheads($id)]
6338 if {[info exists idotherrefs($id)]} {
6339 set marks [concat $marks $idotherrefs($id)]
6341 if {$marks eq {}} {
6342 return $xt
6345 set delta [expr {int(0.5 * ($linespc - $lthickness))}]
6346 set yt [expr {$y1 - 0.5 * $linespc}]
6347 set yb [expr {$yt + $linespc - 1}]
6348 set xvals {}
6349 set wvals {}
6350 set i -1
6351 foreach tag $marks {
6352 incr i
6353 if {$i >= $ntags && $i < $ntags + $nheads && $tag eq $mainhead} {
6354 set wid [font measure mainfontbold $tag]
6355 } else {
6356 set wid [font measure mainfont $tag]
6358 lappend xvals $xt
6359 lappend wvals $wid
6360 set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
6362 set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
6363 -width $lthickness -fill black -tags tag.$id]
6364 $canv lower $t
6365 foreach tag $marks x $xvals wid $wvals {
6366 set tag_quoted [string map {% %%} $tag]
6367 set xl [expr {$x + $delta}]
6368 set xr [expr {$x + $delta + $wid + $lthickness}]
6369 set font mainfont
6370 if {[incr ntags -1] >= 0} {
6371 # draw a tag
6372 set t [$canv create polygon $x [expr {$yt + $delta}] $xl $yt \
6373 $xr $yt $xr $yb $xl $yb $x [expr {$yb - $delta}] \
6374 -width 1 -outline black -fill yellow -tags tag.$id]
6375 $canv bind $t <1> [list showtag $tag_quoted 1]
6376 set rowtextx([rowofcommit $id]) [expr {$xr + $linespc}]
6377 } else {
6378 # draw a head or other ref
6379 if {[incr nheads -1] >= 0} {
6380 set col green
6381 if {$tag eq $mainhead} {
6382 set font mainfontbold
6384 } else {
6385 set col "#ddddff"
6387 set xl [expr {$xl - $delta/2}]
6388 $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
6389 -width 1 -outline black -fill $col -tags tag.$id
6390 if {[regexp {^(remotes/.*/|remotes/)} $tag match remoteprefix]} {
6391 set rwid [font measure mainfont $remoteprefix]
6392 set xi [expr {$x + 1}]
6393 set yti [expr {$yt + 1}]
6394 set xri [expr {$x + $rwid}]
6395 $canv create polygon $xi $yti $xri $yti $xri $yb $xi $yb \
6396 -width 0 -fill "#ffddaa" -tags tag.$id
6399 set t [$canv create text $xl $y1 -anchor w -text $tag -fill $fgcolor \
6400 -font $font -tags [list tag.$id text]]
6401 if {$ntags >= 0} {
6402 $canv bind $t <1> [list showtag $tag_quoted 1]
6403 } elseif {$nheads >= 0} {
6404 $canv bind $t $ctxbut [list headmenu %X %Y $id $tag_quoted]
6407 return $xt
6410 proc drawnotesign {xt y} {
6411 global linespc canv fgcolor
6413 set orad [expr {$linespc / 3}]
6414 set t [$canv create rectangle [expr {$xt - $orad}] [expr {$y - $orad}] \
6415 [expr {$xt + $orad - 1}] [expr {$y + $orad - 1}] \
6416 -fill yellow -outline $fgcolor -width 1 -tags circle]
6417 set xt [expr {$xt + $orad * 3}]
6418 return $xt
6421 proc xcoord {i level ln} {
6422 global canvx0 xspc1 xspc2
6424 set x [expr {$canvx0 + $i * $xspc1($ln)}]
6425 if {$i > 0 && $i == $level} {
6426 set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
6427 } elseif {$i > $level} {
6428 set x [expr {$x + $xspc2 - $xspc1($ln)}]
6430 return $x
6433 proc show_status {msg} {
6434 global canv fgcolor
6436 clear_display
6437 $canv create text 3 3 -anchor nw -text $msg -font mainfont \
6438 -tags text -fill $fgcolor
6441 # Don't change the text pane cursor if it is currently the hand cursor,
6442 # showing that we are over a sha1 ID link.
6443 proc settextcursor {c} {
6444 global ctext curtextcursor
6446 if {[$ctext cget -cursor] == $curtextcursor} {
6447 $ctext config -cursor $c
6449 set curtextcursor $c
6452 proc nowbusy {what {name {}}} {
6453 global isbusy busyname statusw
6455 if {[array names isbusy] eq {}} {
6456 . config -cursor watch
6457 settextcursor watch
6459 set isbusy($what) 1
6460 set busyname($what) $name
6461 if {$name ne {}} {
6462 $statusw conf -text $name
6466 proc notbusy {what} {
6467 global isbusy maincursor textcursor busyname statusw
6469 catch {
6470 unset isbusy($what)
6471 if {$busyname($what) ne {} &&
6472 [$statusw cget -text] eq $busyname($what)} {
6473 $statusw conf -text {}
6476 if {[array names isbusy] eq {}} {
6477 . config -cursor $maincursor
6478 settextcursor $textcursor
6482 proc findmatches {f} {
6483 global findtype findstring
6484 if {$findtype == [mc "Regexp"]} {
6485 set matches [regexp -indices -all -inline $findstring $f]
6486 } else {
6487 set fs $findstring
6488 if {$findtype == [mc "IgnCase"]} {
6489 set f [string tolower $f]
6490 set fs [string tolower $fs]
6492 set matches {}
6493 set i 0
6494 set l [string length $fs]
6495 while {[set j [string first $fs $f $i]] >= 0} {
6496 lappend matches [list $j [expr {$j+$l-1}]]
6497 set i [expr {$j + $l}]
6500 return $matches
6503 proc dofind {{dirn 1} {wrap 1}} {
6504 global findstring findstartline findcurline selectedline numcommits
6505 global gdttype filehighlight fh_serial find_dirn findallowwrap
6507 if {[info exists find_dirn]} {
6508 if {$find_dirn == $dirn} return
6509 stopfinding
6511 focus .
6512 if {$findstring eq {} || $numcommits == 0} return
6513 if {$selectedline eq {}} {
6514 set findstartline [lindex [visiblerows] [expr {$dirn < 0}]]
6515 } else {
6516 set findstartline $selectedline
6518 set findcurline $findstartline
6519 nowbusy finding [mc "Searching"]
6520 if {$gdttype ne [mc "containing:"] && ![info exists filehighlight]} {
6521 after cancel do_file_hl $fh_serial
6522 do_file_hl $fh_serial
6524 set find_dirn $dirn
6525 set findallowwrap $wrap
6526 run findmore
6529 proc stopfinding {} {
6530 global find_dirn findcurline fprogcoord
6532 if {[info exists find_dirn]} {
6533 unset find_dirn
6534 unset findcurline
6535 notbusy finding
6536 set fprogcoord 0
6537 adjustprogress
6539 stopblaming
6542 proc findmore {} {
6543 global commitdata commitinfo numcommits findpattern findloc
6544 global findstartline findcurline findallowwrap
6545 global find_dirn gdttype fhighlights fprogcoord
6546 global curview varcorder vrownum varccommits vrowmod
6548 if {![info exists find_dirn]} {
6549 return 0
6551 set fldtypes [list [mc "Headline"] [mc "Author"] "" [mc "Committer"] "" [mc "Comments"]]
6552 set l $findcurline
6553 set moretodo 0
6554 if {$find_dirn > 0} {
6555 incr l
6556 if {$l >= $numcommits} {
6557 set l 0
6559 if {$l <= $findstartline} {
6560 set lim [expr {$findstartline + 1}]
6561 } else {
6562 set lim $numcommits
6563 set moretodo $findallowwrap
6565 } else {
6566 if {$l == 0} {
6567 set l $numcommits
6569 incr l -1
6570 if {$l >= $findstartline} {
6571 set lim [expr {$findstartline - 1}]
6572 } else {
6573 set lim -1
6574 set moretodo $findallowwrap
6577 set n [expr {($lim - $l) * $find_dirn}]
6578 if {$n > 500} {
6579 set n 500
6580 set moretodo 1
6582 if {$l + ($find_dirn > 0? $n: 1) > $vrowmod($curview)} {
6583 update_arcrows $curview
6585 set found 0
6586 set domore 1
6587 set ai [bsearch $vrownum($curview) $l]
6588 set a [lindex $varcorder($curview) $ai]
6589 set arow [lindex $vrownum($curview) $ai]
6590 set ids [lindex $varccommits($curview,$a)]
6591 set arowend [expr {$arow + [llength $ids]}]
6592 if {$gdttype eq [mc "containing:"]} {
6593 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
6594 if {$l < $arow || $l >= $arowend} {
6595 incr ai $find_dirn
6596 set a [lindex $varcorder($curview) $ai]
6597 set arow [lindex $vrownum($curview) $ai]
6598 set ids [lindex $varccommits($curview,$a)]
6599 set arowend [expr {$arow + [llength $ids]}]
6601 set id [lindex $ids [expr {$l - $arow}]]
6602 # shouldn't happen unless git log doesn't give all the commits...
6603 if {![info exists commitdata($id)] ||
6604 ![doesmatch $commitdata($id)]} {
6605 continue
6607 if {![info exists commitinfo($id)]} {
6608 getcommit $id
6610 set info $commitinfo($id)
6611 foreach f $info ty $fldtypes {
6612 if {$ty eq ""} continue
6613 if {($findloc eq [mc "All fields"] || $findloc eq $ty) &&
6614 [doesmatch $f]} {
6615 set found 1
6616 break
6619 if {$found} break
6621 } else {
6622 for {} {$n > 0} {incr n -1; incr l $find_dirn} {
6623 if {$l < $arow || $l >= $arowend} {
6624 incr ai $find_dirn
6625 set a [lindex $varcorder($curview) $ai]
6626 set arow [lindex $vrownum($curview) $ai]
6627 set ids [lindex $varccommits($curview,$a)]
6628 set arowend [expr {$arow + [llength $ids]}]
6630 set id [lindex $ids [expr {$l - $arow}]]
6631 if {![info exists fhighlights($id)]} {
6632 # this sets fhighlights($id) to -1
6633 askfilehighlight $l $id
6635 if {$fhighlights($id) > 0} {
6636 set found $domore
6637 break
6639 if {$fhighlights($id) < 0} {
6640 if {$domore} {
6641 set domore 0
6642 set findcurline [expr {$l - $find_dirn}]
6647 if {$found || ($domore && !$moretodo)} {
6648 unset findcurline
6649 unset find_dirn
6650 notbusy finding
6651 set fprogcoord 0
6652 adjustprogress
6653 if {$found} {
6654 findselectline $l
6655 } else {
6656 bell
6658 return 0
6660 if {!$domore} {
6661 flushhighlights
6662 } else {
6663 set findcurline [expr {$l - $find_dirn}]
6665 set n [expr {($findcurline - $findstartline) * $find_dirn - 1}]
6666 if {$n < 0} {
6667 incr n $numcommits
6669 set fprogcoord [expr {$n * 1.0 / $numcommits}]
6670 adjustprogress
6671 return $domore
6674 proc findselectline {l} {
6675 global findloc commentend ctext findcurline markingmatches gdttype
6677 set markingmatches [expr {$gdttype eq [mc "containing:"]}]
6678 set findcurline $l
6679 selectline $l 1
6680 if {$markingmatches &&
6681 ($findloc eq [mc "All fields"] || $findloc eq [mc "Comments"])} {
6682 # highlight the matches in the comments
6683 set f [$ctext get 1.0 $commentend]
6684 set matches [findmatches $f]
6685 foreach match $matches {
6686 set start [lindex $match 0]
6687 set end [expr {[lindex $match 1] + 1}]
6688 $ctext tag add found "1.0 + $start c" "1.0 + $end c"
6691 drawvisible
6694 # mark the bits of a headline or author that match a find string
6695 proc markmatches {canv l str tag matches font row} {
6696 global selectedline
6698 set bbox [$canv bbox $tag]
6699 set x0 [lindex $bbox 0]
6700 set y0 [lindex $bbox 1]
6701 set y1 [lindex $bbox 3]
6702 foreach match $matches {
6703 set start [lindex $match 0]
6704 set end [lindex $match 1]
6705 if {$start > $end} continue
6706 set xoff [font measure $font [string range $str 0 [expr {$start-1}]]]
6707 set xlen [font measure $font [string range $str 0 [expr {$end}]]]
6708 set t [$canv create rect [expr {$x0+$xoff}] $y0 \
6709 [expr {$x0+$xlen+2}] $y1 \
6710 -outline {} -tags [list match$l matches] -fill yellow]
6711 $canv lower $t
6712 if {$row == $selectedline} {
6713 $canv raise $t secsel
6718 proc unmarkmatches {} {
6719 global markingmatches
6721 allcanvs delete matches
6722 set markingmatches 0
6723 stopfinding
6726 proc selcanvline {w x y} {
6727 global canv canvy0 ctext linespc
6728 global rowtextx
6729 set ymax [lindex [$canv cget -scrollregion] 3]
6730 if {$ymax == {}} return
6731 set yfrac [lindex [$canv yview] 0]
6732 set y [expr {$y + $yfrac * $ymax}]
6733 set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
6734 if {$l < 0} {
6735 set l 0
6737 if {$w eq $canv} {
6738 set xmax [lindex [$canv cget -scrollregion] 2]
6739 set xleft [expr {[lindex [$canv xview] 0] * $xmax}]
6740 if {![info exists rowtextx($l)] || $xleft + $x < $rowtextx($l)} return
6742 unmarkmatches
6743 selectline $l 1
6746 proc commit_descriptor {p} {
6747 global commitinfo
6748 if {![info exists commitinfo($p)]} {
6749 getcommit $p
6751 set l "..."
6752 if {[llength $commitinfo($p)] > 1} {
6753 set l [lindex $commitinfo($p) 0]
6755 return "$p ($l)\n"
6758 # append some text to the ctext widget, and make any SHA1 ID
6759 # that we know about be a clickable link.
6760 proc appendwithlinks {text tags} {
6761 global ctext linknum curview
6763 set start [$ctext index "end - 1c"]
6764 $ctext insert end $text $tags
6765 set links [regexp -indices -all -inline {(?:\m|-g)[0-9a-f]{6,40}\M} $text]
6766 foreach l $links {
6767 set s [lindex $l 0]
6768 set e [lindex $l 1]
6769 set linkid [string range $text $s $e]
6770 incr e
6771 $ctext tag delete link$linknum
6772 $ctext tag add link$linknum "$start + $s c" "$start + $e c"
6773 setlink $linkid link$linknum
6774 incr linknum
6778 proc setlink {id lk} {
6779 global curview ctext pendinglinks
6781 if {[string range $id 0 1] eq "-g"} {
6782 set id [string range $id 2 end]
6785 set known 0
6786 if {[string length $id] < 40} {
6787 set matches [longid $id]
6788 if {[llength $matches] > 0} {
6789 if {[llength $matches] > 1} return
6790 set known 1
6791 set id [lindex $matches 0]
6793 } else {
6794 set known [commitinview $id $curview]
6796 if {$known} {
6797 $ctext tag conf $lk -foreground blue -underline 1
6798 $ctext tag bind $lk <1> [list selbyid $id]
6799 $ctext tag bind $lk <Enter> {linkcursor %W 1}
6800 $ctext tag bind $lk <Leave> {linkcursor %W -1}
6801 } else {
6802 lappend pendinglinks($id) $lk
6803 interestedin $id {makelink %P}
6807 proc appendshortlink {id {pre {}} {post {}}} {
6808 global ctext linknum
6810 $ctext insert end $pre
6811 $ctext tag delete link$linknum
6812 $ctext insert end [string range $id 0 7] link$linknum
6813 $ctext insert end $post
6814 setlink $id link$linknum
6815 incr linknum
6818 proc makelink {id} {
6819 global pendinglinks
6821 if {![info exists pendinglinks($id)]} return
6822 foreach lk $pendinglinks($id) {
6823 setlink $id $lk
6825 unset pendinglinks($id)
6828 proc linkcursor {w inc} {
6829 global linkentercount curtextcursor
6831 if {[incr linkentercount $inc] > 0} {
6832 $w configure -cursor hand2
6833 } else {
6834 $w configure -cursor $curtextcursor
6835 if {$linkentercount < 0} {
6836 set linkentercount 0
6841 proc viewnextline {dir} {
6842 global canv linespc
6844 $canv delete hover
6845 set ymax [lindex [$canv cget -scrollregion] 3]
6846 set wnow [$canv yview]
6847 set wtop [expr {[lindex $wnow 0] * $ymax}]
6848 set newtop [expr {$wtop + $dir * $linespc}]
6849 if {$newtop < 0} {
6850 set newtop 0
6851 } elseif {$newtop > $ymax} {
6852 set newtop $ymax
6854 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
6857 # add a list of tag or branch names at position pos
6858 # returns the number of names inserted
6859 proc appendrefs {pos ids var} {
6860 global ctext linknum curview $var maxrefs
6862 if {[catch {$ctext index $pos}]} {
6863 return 0
6865 $ctext conf -state normal
6866 $ctext delete $pos "$pos lineend"
6867 set tags {}
6868 foreach id $ids {
6869 foreach tag [set $var\($id\)] {
6870 lappend tags [list $tag $id]
6873 if {[llength $tags] > $maxrefs} {
6874 $ctext insert $pos "[mc "many"] ([llength $tags])"
6875 } else {
6876 set tags [lsort -index 0 -decreasing $tags]
6877 set sep {}
6878 foreach ti $tags {
6879 set id [lindex $ti 1]
6880 set lk link$linknum
6881 incr linknum
6882 $ctext tag delete $lk
6883 $ctext insert $pos $sep
6884 $ctext insert $pos [lindex $ti 0] $lk
6885 setlink $id $lk
6886 set sep ", "
6889 $ctext conf -state disabled
6890 return [llength $tags]
6893 # called when we have finished computing the nearby tags
6894 proc dispneartags {delay} {
6895 global selectedline currentid showneartags tagphase
6897 if {$selectedline eq {} || !$showneartags} return
6898 after cancel dispnexttag
6899 if {$delay} {
6900 after 200 dispnexttag
6901 set tagphase -1
6902 } else {
6903 after idle dispnexttag
6904 set tagphase 0
6908 proc dispnexttag {} {
6909 global selectedline currentid showneartags tagphase ctext
6911 if {$selectedline eq {} || !$showneartags} return
6912 switch -- $tagphase {
6914 set dtags [desctags $currentid]
6915 if {$dtags ne {}} {
6916 appendrefs precedes $dtags idtags
6920 set atags [anctags $currentid]
6921 if {$atags ne {}} {
6922 appendrefs follows $atags idtags
6926 set dheads [descheads $currentid]
6927 if {$dheads ne {}} {
6928 if {[appendrefs branch $dheads idheads] > 1
6929 && [$ctext get "branch -3c"] eq "h"} {
6930 # turn "Branch" into "Branches"
6931 $ctext conf -state normal
6932 $ctext insert "branch -2c" "es"
6933 $ctext conf -state disabled
6938 if {[incr tagphase] <= 2} {
6939 after idle dispnexttag
6943 proc make_secsel {id} {
6944 global linehtag linentag linedtag canv canv2 canv3
6946 if {![info exists linehtag($id)]} return
6947 $canv delete secsel
6948 set t [eval $canv create rect [$canv bbox $linehtag($id)] -outline {{}} \
6949 -tags secsel -fill [$canv cget -selectbackground]]
6950 $canv lower $t
6951 $canv2 delete secsel
6952 set t [eval $canv2 create rect [$canv2 bbox $linentag($id)] -outline {{}} \
6953 -tags secsel -fill [$canv2 cget -selectbackground]]
6954 $canv2 lower $t
6955 $canv3 delete secsel
6956 set t [eval $canv3 create rect [$canv3 bbox $linedtag($id)] -outline {{}} \
6957 -tags secsel -fill [$canv3 cget -selectbackground]]
6958 $canv3 lower $t
6961 proc make_idmark {id} {
6962 global linehtag canv fgcolor
6964 if {![info exists linehtag($id)]} return
6965 $canv delete markid
6966 set t [eval $canv create rect [$canv bbox $linehtag($id)] \
6967 -tags markid -outline $fgcolor]
6968 $canv raise $t
6971 proc selectline {l isnew {desired_loc {}}} {
6972 global canv ctext commitinfo selectedline
6973 global canvy0 linespc parents children curview
6974 global currentid sha1entry
6975 global commentend idtags linknum
6976 global mergemax numcommits pending_select
6977 global cmitmode showneartags allcommits
6978 global targetrow targetid lastscrollrows
6979 global autoselect autosellen jump_to_here
6981 catch {unset pending_select}
6982 $canv delete hover
6983 normalline
6984 unsel_reflist
6985 stopfinding
6986 if {$l < 0 || $l >= $numcommits} return
6987 set id [commitonrow $l]
6988 set targetid $id
6989 set targetrow $l
6990 set selectedline $l
6991 set currentid $id
6992 if {$lastscrollrows < $numcommits} {
6993 setcanvscroll
6996 set y [expr {$canvy0 + $l * $linespc}]
6997 set ymax [lindex [$canv cget -scrollregion] 3]
6998 set ytop [expr {$y - $linespc - 1}]
6999 set ybot [expr {$y + $linespc + 1}]
7000 set wnow [$canv yview]
7001 set wtop [expr {[lindex $wnow 0] * $ymax}]
7002 set wbot [expr {[lindex $wnow 1] * $ymax}]
7003 set wh [expr {$wbot - $wtop}]
7004 set newtop $wtop
7005 if {$ytop < $wtop} {
7006 if {$ybot < $wtop} {
7007 set newtop [expr {$y - $wh / 2.0}]
7008 } else {
7009 set newtop $ytop
7010 if {$newtop > $wtop - $linespc} {
7011 set newtop [expr {$wtop - $linespc}]
7014 } elseif {$ybot > $wbot} {
7015 if {$ytop > $wbot} {
7016 set newtop [expr {$y - $wh / 2.0}]
7017 } else {
7018 set newtop [expr {$ybot - $wh}]
7019 if {$newtop < $wtop + $linespc} {
7020 set newtop [expr {$wtop + $linespc}]
7024 if {$newtop != $wtop} {
7025 if {$newtop < 0} {
7026 set newtop 0
7028 allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
7029 drawvisible
7032 make_secsel $id
7034 if {$isnew} {
7035 addtohistory [list selbyid $id 0] savecmitpos
7038 $sha1entry delete 0 end
7039 $sha1entry insert 0 $id
7040 if {$autoselect} {
7041 $sha1entry selection range 0 $autosellen
7043 rhighlight_sel $id
7045 $ctext conf -state normal
7046 clear_ctext
7047 set linknum 0
7048 if {![info exists commitinfo($id)]} {
7049 getcommit $id
7051 set info $commitinfo($id)
7052 set date [formatdate [lindex $info 2]]
7053 $ctext insert end "[mc "Author"]: [lindex $info 1] $date\n"
7054 set date [formatdate [lindex $info 4]]
7055 $ctext insert end "[mc "Committer"]: [lindex $info 3] $date\n"
7056 if {[info exists idtags($id)]} {
7057 $ctext insert end [mc "Tags:"]
7058 foreach tag $idtags($id) {
7059 $ctext insert end " $tag"
7061 $ctext insert end "\n"
7064 set headers {}
7065 set olds $parents($curview,$id)
7066 if {[llength $olds] > 1} {
7067 set np 0
7068 foreach p $olds {
7069 if {$np >= $mergemax} {
7070 set tag mmax
7071 } else {
7072 set tag m$np
7074 $ctext insert end "[mc "Parent"]: " $tag
7075 appendwithlinks [commit_descriptor $p] {}
7076 incr np
7078 } else {
7079 foreach p $olds {
7080 append headers "[mc "Parent"]: [commit_descriptor $p]"
7084 foreach c $children($curview,$id) {
7085 append headers "[mc "Child"]: [commit_descriptor $c]"
7088 # make anything that looks like a SHA1 ID be a clickable link
7089 appendwithlinks $headers {}
7090 if {$showneartags} {
7091 if {![info exists allcommits]} {
7092 getallcommits
7094 $ctext insert end "[mc "Branch"]: "
7095 $ctext mark set branch "end -1c"
7096 $ctext mark gravity branch left
7097 $ctext insert end "\n[mc "Follows"]: "
7098 $ctext mark set follows "end -1c"
7099 $ctext mark gravity follows left
7100 $ctext insert end "\n[mc "Precedes"]: "
7101 $ctext mark set precedes "end -1c"
7102 $ctext mark gravity precedes left
7103 $ctext insert end "\n"
7104 dispneartags 1
7106 $ctext insert end "\n"
7107 set comment [lindex $info 5]
7108 if {[string first "\r" $comment] >= 0} {
7109 set comment [string map {"\r" "\n "} $comment]
7111 appendwithlinks $comment {comment}
7113 $ctext tag remove found 1.0 end
7114 $ctext conf -state disabled
7115 set commentend [$ctext index "end - 1c"]
7117 set jump_to_here $desired_loc
7118 init_flist [mc "Comments"]
7119 if {$cmitmode eq "tree"} {
7120 gettree $id
7121 } elseif {[llength $olds] <= 1} {
7122 startdiff $id
7123 } else {
7124 mergediff $id
7128 proc selfirstline {} {
7129 unmarkmatches
7130 selectline 0 1
7133 proc sellastline {} {
7134 global numcommits
7135 unmarkmatches
7136 set l [expr {$numcommits - 1}]
7137 selectline $l 1
7140 proc selnextline {dir} {
7141 global selectedline
7142 focus .
7143 if {$selectedline eq {}} return
7144 set l [expr {$selectedline + $dir}]
7145 unmarkmatches
7146 selectline $l 1
7149 proc selnextpage {dir} {
7150 global canv linespc selectedline numcommits
7152 set lpp [expr {([winfo height $canv] - 2) / $linespc}]
7153 if {$lpp < 1} {
7154 set lpp 1
7156 allcanvs yview scroll [expr {$dir * $lpp}] units
7157 drawvisible
7158 if {$selectedline eq {}} return
7159 set l [expr {$selectedline + $dir * $lpp}]
7160 if {$l < 0} {
7161 set l 0
7162 } elseif {$l >= $numcommits} {
7163 set l [expr $numcommits - 1]
7165 unmarkmatches
7166 selectline $l 1
7169 proc unselectline {} {
7170 global selectedline currentid
7172 set selectedline {}
7173 catch {unset currentid}
7174 allcanvs delete secsel
7175 rhighlight_none
7178 proc reselectline {} {
7179 global selectedline
7181 if {$selectedline ne {}} {
7182 selectline $selectedline 0
7186 proc addtohistory {cmd {saveproc {}}} {
7187 global history historyindex curview
7189 unset_posvars
7190 save_position
7191 set elt [list $curview $cmd $saveproc {}]
7192 if {$historyindex > 0
7193 && [lindex $history [expr {$historyindex - 1}]] == $elt} {
7194 return
7197 if {$historyindex < [llength $history]} {
7198 set history [lreplace $history $historyindex end $elt]
7199 } else {
7200 lappend history $elt
7202 incr historyindex
7203 if {$historyindex > 1} {
7204 .tf.bar.leftbut conf -state normal
7205 } else {
7206 .tf.bar.leftbut conf -state disabled
7208 .tf.bar.rightbut conf -state disabled
7211 # save the scrolling position of the diff display pane
7212 proc save_position {} {
7213 global historyindex history
7215 if {$historyindex < 1} return
7216 set hi [expr {$historyindex - 1}]
7217 set fn [lindex $history $hi 2]
7218 if {$fn ne {}} {
7219 lset history $hi 3 [eval $fn]
7223 proc unset_posvars {} {
7224 global last_posvars
7226 if {[info exists last_posvars]} {
7227 foreach {var val} $last_posvars {
7228 global $var
7229 catch {unset $var}
7231 unset last_posvars
7235 proc godo {elt} {
7236 global curview last_posvars
7238 set view [lindex $elt 0]
7239 set cmd [lindex $elt 1]
7240 set pv [lindex $elt 3]
7241 if {$curview != $view} {
7242 showview $view
7244 unset_posvars
7245 foreach {var val} $pv {
7246 global $var
7247 set $var $val
7249 set last_posvars $pv
7250 eval $cmd
7253 proc goback {} {
7254 global history historyindex
7255 focus .
7257 if {$historyindex > 1} {
7258 save_position
7259 incr historyindex -1
7260 godo [lindex $history [expr {$historyindex - 1}]]
7261 .tf.bar.rightbut conf -state normal
7263 if {$historyindex <= 1} {
7264 .tf.bar.leftbut conf -state disabled
7268 proc goforw {} {
7269 global history historyindex
7270 focus .
7272 if {$historyindex < [llength $history]} {
7273 save_position
7274 set cmd [lindex $history $historyindex]
7275 incr historyindex
7276 godo $cmd
7277 .tf.bar.leftbut conf -state normal
7279 if {$historyindex >= [llength $history]} {
7280 .tf.bar.rightbut conf -state disabled
7284 proc gettree {id} {
7285 global treefilelist treeidlist diffids diffmergeid treepending
7286 global nullid nullid2
7288 set diffids $id
7289 catch {unset diffmergeid}
7290 if {![info exists treefilelist($id)]} {
7291 if {![info exists treepending]} {
7292 if {$id eq $nullid} {
7293 set cmd [list | git ls-files]
7294 } elseif {$id eq $nullid2} {
7295 set cmd [list | git ls-files --stage -t]
7296 } else {
7297 set cmd [list | git ls-tree -r $id]
7299 if {[catch {set gtf [open $cmd r]}]} {
7300 return
7302 set treepending $id
7303 set treefilelist($id) {}
7304 set treeidlist($id) {}
7305 fconfigure $gtf -blocking 0 -encoding binary
7306 filerun $gtf [list gettreeline $gtf $id]
7308 } else {
7309 setfilelist $id
7313 proc gettreeline {gtf id} {
7314 global treefilelist treeidlist treepending cmitmode diffids nullid nullid2
7316 set nl 0
7317 while {[incr nl] <= 1000 && [gets $gtf line] >= 0} {
7318 if {$diffids eq $nullid} {
7319 set fname $line
7320 } else {
7321 set i [string first "\t" $line]
7322 if {$i < 0} continue
7323 set fname [string range $line [expr {$i+1}] end]
7324 set line [string range $line 0 [expr {$i-1}]]
7325 if {$diffids ne $nullid2 && [lindex $line 1] ne "blob"} continue
7326 set sha1 [lindex $line 2]
7327 lappend treeidlist($id) $sha1
7329 if {[string index $fname 0] eq "\""} {
7330 set fname [lindex $fname 0]
7332 set fname [encoding convertfrom utf-8 $fname]
7333 lappend treefilelist($id) $fname
7335 if {![eof $gtf]} {
7336 return [expr {$nl >= 1000? 2: 1}]
7338 close $gtf
7339 unset treepending
7340 if {$cmitmode ne "tree"} {
7341 if {![info exists diffmergeid]} {
7342 gettreediffs $diffids
7344 } elseif {$id ne $diffids} {
7345 gettree $diffids
7346 } else {
7347 setfilelist $id
7349 return 0
7352 proc showfile {f} {
7353 global treefilelist treeidlist diffids nullid nullid2
7354 global ctext_file_names ctext_file_lines
7355 global ctext commentend
7357 set i [lsearch -exact $treefilelist($diffids) $f]
7358 if {$i < 0} {
7359 puts "oops, $f not in list for id $diffids"
7360 return
7362 if {$diffids eq $nullid} {
7363 if {[catch {set bf [open $f r]} err]} {
7364 puts "oops, can't read $f: $err"
7365 return
7367 } else {
7368 set blob [lindex $treeidlist($diffids) $i]
7369 if {[catch {set bf [open [concat | git cat-file blob $blob] r]} err]} {
7370 puts "oops, error reading blob $blob: $err"
7371 return
7374 fconfigure $bf -blocking 0 -encoding [get_path_encoding $f]
7375 filerun $bf [list getblobline $bf $diffids]
7376 $ctext config -state normal
7377 clear_ctext $commentend
7378 lappend ctext_file_names $f
7379 lappend ctext_file_lines [lindex [split $commentend "."] 0]
7380 $ctext insert end "\n"
7381 $ctext insert end "$f\n" filesep
7382 $ctext config -state disabled
7383 $ctext yview $commentend
7384 settabs 0
7387 proc getblobline {bf id} {
7388 global diffids cmitmode ctext
7390 if {$id ne $diffids || $cmitmode ne "tree"} {
7391 catch {close $bf}
7392 return 0
7394 $ctext config -state normal
7395 set nl 0
7396 while {[incr nl] <= 1000 && [gets $bf line] >= 0} {
7397 $ctext insert end "$line\n"
7399 if {[eof $bf]} {
7400 global jump_to_here ctext_file_names commentend
7402 # delete last newline
7403 $ctext delete "end - 2c" "end - 1c"
7404 close $bf
7405 if {$jump_to_here ne {} &&
7406 [lindex $jump_to_here 0] eq [lindex $ctext_file_names 0]} {
7407 set lnum [expr {[lindex $jump_to_here 1] +
7408 [lindex [split $commentend .] 0]}]
7409 mark_ctext_line $lnum
7411 $ctext config -state disabled
7412 return 0
7414 $ctext config -state disabled
7415 return [expr {$nl >= 1000? 2: 1}]
7418 proc mark_ctext_line {lnum} {
7419 global ctext markbgcolor
7421 $ctext tag delete omark
7422 $ctext tag add omark $lnum.0 "$lnum.0 + 1 line"
7423 $ctext tag conf omark -background $markbgcolor
7424 $ctext see $lnum.0
7427 proc mergediff {id} {
7428 global diffmergeid
7429 global diffids treediffs
7430 global parents curview
7432 set diffmergeid $id
7433 set diffids $id
7434 set treediffs($id) {}
7435 set np [llength $parents($curview,$id)]
7436 settabs $np
7437 getblobdiffs $id
7440 proc startdiff {ids} {
7441 global treediffs diffids treepending diffmergeid nullid nullid2
7443 settabs 1
7444 set diffids $ids
7445 catch {unset diffmergeid}
7446 if {![info exists treediffs($ids)] ||
7447 [lsearch -exact $ids $nullid] >= 0 ||
7448 [lsearch -exact $ids $nullid2] >= 0} {
7449 if {![info exists treepending]} {
7450 gettreediffs $ids
7452 } else {
7453 addtocflist $ids
7457 # If the filename (name) is under any of the passed filter paths
7458 # then return true to include the file in the listing.
7459 proc path_filter {filter name} {
7460 set worktree [gitworktree]
7461 foreach p $filter {
7462 set fq_p [file normalize $p]
7463 set fq_n [file normalize [file join $worktree $name]]
7464 if {[string match [file normalize $fq_p]* $fq_n]} {
7465 return 1
7468 return 0
7471 proc addtocflist {ids} {
7472 global treediffs
7474 add_flist $treediffs($ids)
7475 getblobdiffs $ids
7478 proc diffcmd {ids flags} {
7479 global log_showroot nullid nullid2
7481 set i [lsearch -exact $ids $nullid]
7482 set j [lsearch -exact $ids $nullid2]
7483 if {$i >= 0} {
7484 if {[llength $ids] > 1 && $j < 0} {
7485 # comparing working directory with some specific revision
7486 set cmd [concat | git diff-index $flags]
7487 if {$i == 0} {
7488 lappend cmd -R [lindex $ids 1]
7489 } else {
7490 lappend cmd [lindex $ids 0]
7492 } else {
7493 # comparing working directory with index
7494 set cmd [concat | git diff-files $flags]
7495 if {$j == 1} {
7496 lappend cmd -R
7499 } elseif {$j >= 0} {
7500 set cmd [concat | git diff-index --cached $flags]
7501 if {[llength $ids] > 1} {
7502 # comparing index with specific revision
7503 if {$j == 0} {
7504 lappend cmd -R [lindex $ids 1]
7505 } else {
7506 lappend cmd [lindex $ids 0]
7508 } else {
7509 # comparing index with HEAD
7510 lappend cmd HEAD
7512 } else {
7513 if {$log_showroot} {
7514 lappend flags --root
7516 set cmd [concat | git diff-tree -r $flags $ids]
7518 return $cmd
7521 proc gettreediffs {ids} {
7522 global treediff treepending
7524 if {[catch {set gdtf [open [diffcmd $ids {--no-commit-id}] r]}]} return
7526 set treepending $ids
7527 set treediff {}
7528 fconfigure $gdtf -blocking 0 -encoding binary
7529 filerun $gdtf [list gettreediffline $gdtf $ids]
7532 proc gettreediffline {gdtf ids} {
7533 global treediff treediffs treepending diffids diffmergeid
7534 global cmitmode vfilelimit curview limitdiffs perfile_attrs
7536 set nr 0
7537 set sublist {}
7538 set max 1000
7539 if {$perfile_attrs} {
7540 # cache_gitattr is slow, and even slower on win32 where we
7541 # have to invoke it for only about 30 paths at a time
7542 set max 500
7543 if {[tk windowingsystem] == "win32"} {
7544 set max 120
7547 while {[incr nr] <= $max && [gets $gdtf line] >= 0} {
7548 set i [string first "\t" $line]
7549 if {$i >= 0} {
7550 set file [string range $line [expr {$i+1}] end]
7551 if {[string index $file 0] eq "\""} {
7552 set file [lindex $file 0]
7554 set file [encoding convertfrom utf-8 $file]
7555 if {$file ne [lindex $treediff end]} {
7556 lappend treediff $file
7557 lappend sublist $file
7561 if {$perfile_attrs} {
7562 cache_gitattr encoding $sublist
7564 if {![eof $gdtf]} {
7565 return [expr {$nr >= $max? 2: 1}]
7567 close $gdtf
7568 if {$limitdiffs && $vfilelimit($curview) ne {}} {
7569 set flist {}
7570 foreach f $treediff {
7571 if {[path_filter $vfilelimit($curview) $f]} {
7572 lappend flist $f
7575 set treediffs($ids) $flist
7576 } else {
7577 set treediffs($ids) $treediff
7579 unset treepending
7580 if {$cmitmode eq "tree" && [llength $diffids] == 1} {
7581 gettree $diffids
7582 } elseif {$ids != $diffids} {
7583 if {![info exists diffmergeid]} {
7584 gettreediffs $diffids
7586 } else {
7587 addtocflist $ids
7589 return 0
7592 # empty string or positive integer
7593 proc diffcontextvalidate {v} {
7594 return [regexp {^(|[1-9][0-9]*)$} $v]
7597 proc diffcontextchange {n1 n2 op} {
7598 global diffcontextstring diffcontext
7600 if {[string is integer -strict $diffcontextstring]} {
7601 if {$diffcontextstring >= 0} {
7602 set diffcontext $diffcontextstring
7603 reselectline
7608 proc changeignorespace {} {
7609 reselectline
7612 proc changeworddiff {name ix op} {
7613 reselectline
7616 proc getblobdiffs {ids} {
7617 global blobdifffd diffids env
7618 global diffinhdr treediffs
7619 global diffcontext
7620 global ignorespace
7621 global worddiff
7622 global limitdiffs vfilelimit curview
7623 global diffencoding targetline diffnparents
7624 global git_version currdiffsubmod
7626 set textconv {}
7627 if {[package vcompare $git_version "1.6.1"] >= 0} {
7628 set textconv "--textconv"
7630 set submodule {}
7631 if {[package vcompare $git_version "1.6.6"] >= 0} {
7632 set submodule "--submodule"
7634 set cmd [diffcmd $ids "-p $textconv $submodule -C --cc --no-commit-id -U$diffcontext"]
7635 if {$ignorespace} {
7636 append cmd " -w"
7638 if {$worddiff ne [mc "Line diff"]} {
7639 append cmd " --word-diff=porcelain"
7641 if {$limitdiffs && $vfilelimit($curview) ne {}} {
7642 set cmd [concat $cmd -- $vfilelimit($curview)]
7644 if {[catch {set bdf [open $cmd r]} err]} {
7645 error_popup [mc "Error getting diffs: %s" $err]
7646 return
7648 set targetline {}
7649 set diffnparents 0
7650 set diffinhdr 0
7651 set diffencoding [get_path_encoding {}]
7652 fconfigure $bdf -blocking 0 -encoding binary -eofchar {}
7653 set blobdifffd($ids) $bdf
7654 set currdiffsubmod ""
7655 filerun $bdf [list getblobdiffline $bdf $diffids]
7658 proc savecmitpos {} {
7659 global ctext cmitmode
7661 if {$cmitmode eq "tree"} {
7662 return {}
7664 return [list target_scrollpos [$ctext index @0,0]]
7667 proc savectextpos {} {
7668 global ctext
7670 return [list target_scrollpos [$ctext index @0,0]]
7673 proc maybe_scroll_ctext {ateof} {
7674 global ctext target_scrollpos
7676 if {![info exists target_scrollpos]} return
7677 if {!$ateof} {
7678 set nlines [expr {[winfo height $ctext]
7679 / [font metrics textfont -linespace]}]
7680 if {[$ctext compare "$target_scrollpos + $nlines lines" <= end]} return
7682 $ctext yview $target_scrollpos
7683 unset target_scrollpos
7686 proc setinlist {var i val} {
7687 global $var
7689 while {[llength [set $var]] < $i} {
7690 lappend $var {}
7692 if {[llength [set $var]] == $i} {
7693 lappend $var $val
7694 } else {
7695 lset $var $i $val
7699 proc makediffhdr {fname ids} {
7700 global ctext curdiffstart treediffs diffencoding
7701 global ctext_file_names jump_to_here targetline diffline
7703 set fname [encoding convertfrom utf-8 $fname]
7704 set diffencoding [get_path_encoding $fname]
7705 set i [lsearch -exact $treediffs($ids) $fname]
7706 if {$i >= 0} {
7707 setinlist difffilestart $i $curdiffstart
7709 lset ctext_file_names end $fname
7710 set l [expr {(78 - [string length $fname]) / 2}]
7711 set pad [string range "----------------------------------------" 1 $l]
7712 $ctext insert $curdiffstart "$pad $fname $pad" filesep
7713 set targetline {}
7714 if {$jump_to_here ne {} && [lindex $jump_to_here 0] eq $fname} {
7715 set targetline [lindex $jump_to_here 1]
7717 set diffline 0
7720 proc getblobdiffline {bdf ids} {
7721 global diffids blobdifffd ctext curdiffstart
7722 global diffnexthead diffnextnote difffilestart
7723 global ctext_file_names ctext_file_lines
7724 global diffinhdr treediffs mergemax diffnparents
7725 global diffencoding jump_to_here targetline diffline currdiffsubmod
7726 global worddiff
7728 set nr 0
7729 $ctext conf -state normal
7730 while {[incr nr] <= 1000 && [gets $bdf line] >= 0} {
7731 if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
7732 catch {close $bdf}
7733 return 0
7735 if {![string compare -length 5 "diff " $line]} {
7736 if {![regexp {^diff (--cc|--git) } $line m type]} {
7737 set line [encoding convertfrom utf-8 $line]
7738 $ctext insert end "$line\n" hunksep
7739 continue
7741 # start of a new file
7742 set diffinhdr 1
7743 $ctext insert end "\n"
7744 set curdiffstart [$ctext index "end - 1c"]
7745 lappend ctext_file_names ""
7746 lappend ctext_file_lines [lindex [split $curdiffstart "."] 0]
7747 $ctext insert end "\n" filesep
7749 if {$type eq "--cc"} {
7750 # start of a new file in a merge diff
7751 set fname [string range $line 10 end]
7752 if {[lsearch -exact $treediffs($ids) $fname] < 0} {
7753 lappend treediffs($ids) $fname
7754 add_flist [list $fname]
7757 } else {
7758 set line [string range $line 11 end]
7759 # If the name hasn't changed the length will be odd,
7760 # the middle char will be a space, and the two bits either
7761 # side will be a/name and b/name, or "a/name" and "b/name".
7762 # If the name has changed we'll get "rename from" and
7763 # "rename to" or "copy from" and "copy to" lines following
7764 # this, and we'll use them to get the filenames.
7765 # This complexity is necessary because spaces in the
7766 # filename(s) don't get escaped.
7767 set l [string length $line]
7768 set i [expr {$l / 2}]
7769 if {!(($l & 1) && [string index $line $i] eq " " &&
7770 [string range $line 2 [expr {$i - 1}]] eq \
7771 [string range $line [expr {$i + 3}] end])} {
7772 continue
7774 # unescape if quoted and chop off the a/ from the front
7775 if {[string index $line 0] eq "\""} {
7776 set fname [string range [lindex $line 0] 2 end]
7777 } else {
7778 set fname [string range $line 2 [expr {$i - 1}]]
7781 makediffhdr $fname $ids
7783 } elseif {![string compare -length 16 "* Unmerged path " $line]} {
7784 set fname [encoding convertfrom utf-8 [string range $line 16 end]]
7785 $ctext insert end "\n"
7786 set curdiffstart [$ctext index "end - 1c"]
7787 lappend ctext_file_names $fname
7788 lappend ctext_file_lines [lindex [split $curdiffstart "."] 0]
7789 $ctext insert end "$line\n" filesep
7790 set i [lsearch -exact $treediffs($ids) $fname]
7791 if {$i >= 0} {
7792 setinlist difffilestart $i $curdiffstart
7795 } elseif {![string compare -length 2 "@@" $line]} {
7796 regexp {^@@+} $line ats
7797 set line [encoding convertfrom $diffencoding $line]
7798 $ctext insert end "$line\n" hunksep
7799 if {[regexp { \+(\d+),\d+ @@} $line m nl]} {
7800 set diffline $nl
7802 set diffnparents [expr {[string length $ats] - 1}]
7803 set diffinhdr 0
7805 } elseif {![string compare -length 10 "Submodule " $line]} {
7806 # start of a new submodule
7807 if {[regexp -indices "\[0-9a-f\]+\\.\\." $line nameend]} {
7808 set fname [string range $line 10 [expr [lindex $nameend 0] - 2]]
7809 } else {
7810 set fname [string range $line 10 [expr [string first "contains " $line] - 2]]
7812 if {$currdiffsubmod != $fname} {
7813 $ctext insert end "\n"; # Add newline after commit message
7815 set curdiffstart [$ctext index "end - 1c"]
7816 lappend ctext_file_names ""
7817 if {$currdiffsubmod != $fname} {
7818 lappend ctext_file_lines $fname
7819 makediffhdr $fname $ids
7820 set currdiffsubmod $fname
7821 $ctext insert end "\n$line\n" filesep
7822 } else {
7823 $ctext insert end "$line\n" filesep
7825 } elseif {![string compare -length 3 " >" $line]} {
7826 set $currdiffsubmod ""
7827 set line [encoding convertfrom $diffencoding $line]
7828 $ctext insert end "$line\n" dresult
7829 } elseif {![string compare -length 3 " <" $line]} {
7830 set $currdiffsubmod ""
7831 set line [encoding convertfrom $diffencoding $line]
7832 $ctext insert end "$line\n" d0
7833 } elseif {$diffinhdr} {
7834 if {![string compare -length 12 "rename from " $line]} {
7835 set fname [string range $line [expr 6 + [string first " from " $line] ] end]
7836 if {[string index $fname 0] eq "\""} {
7837 set fname [lindex $fname 0]
7839 set fname [encoding convertfrom utf-8 $fname]
7840 set i [lsearch -exact $treediffs($ids) $fname]
7841 if {$i >= 0} {
7842 setinlist difffilestart $i $curdiffstart
7844 } elseif {![string compare -length 10 $line "rename to "] ||
7845 ![string compare -length 8 $line "copy to "]} {
7846 set fname [string range $line [expr 4 + [string first " to " $line] ] end]
7847 if {[string index $fname 0] eq "\""} {
7848 set fname [lindex $fname 0]
7850 makediffhdr $fname $ids
7851 } elseif {[string compare -length 3 $line "---"] == 0} {
7852 # do nothing
7853 continue
7854 } elseif {[string compare -length 3 $line "+++"] == 0} {
7855 set diffinhdr 0
7856 continue
7858 set line [encoding convertfrom utf-8 $line]
7859 $ctext insert end "$line\n" filesep
7861 } else {
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]
7873 if {$dowords} {
7874 set line [string range $line 1 end]
7876 if {$num >= 0} {
7877 # removed line, first parent with line is $num
7878 if {$num >= $mergemax} {
7879 set num "max"
7881 if {$dowords && $worddiff eq [mc "Markup words"]} {
7882 $ctext insert end "\[-$line-\]" $tag$num
7883 } else {
7884 $ctext insert end "$line" $tag$num
7886 if {!$dowords} {
7887 $ctext insert end "\n" $tag$num
7889 } else {
7890 set tags {}
7891 if {[string first "+" $prefix] >= 0} {
7892 # added line
7893 lappend tags ${tag}result
7894 if {$diffnparents > 1} {
7895 set num [string first " " $prefix]
7896 if {$num >= 0} {
7897 if {$num >= $mergemax} {
7898 set num "max"
7900 lappend tags m$num
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"]
7909 set targetline {}
7910 } else {
7911 incr diffline
7914 if {$dowords && $worddiff eq [mc "Markup words"]} {
7915 $ctext insert end "$words_pre_markup$line$words_post_markup" $tags
7916 } else {
7917 $ctext insert end "$line" $tags
7919 if {!$dowords} {
7920 $ctext insert end "\n" $tags
7923 } elseif {$dowords && $prefix eq "~"} {
7924 $ctext insert end "\n" {}
7925 } else {
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
7937 if {[eof $bdf]} {
7938 catch {close $bdf}
7939 return 0
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
7954 $ctext yview $loc
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
7961 proc prevfile {} {
7962 global difffilestart ctext cmitmode
7964 if {$cmitmode eq "tree"} return
7965 set prev 0.0
7966 set prevline 1
7967 set here [$ctext index @0,0]
7968 foreach loc $difffilestart {
7969 if {[$ctext compare $loc >= $here]} {
7970 highlightfile $prev $prevline
7971 return
7973 set prev $loc
7974 incr prevline
7976 highlightfile $prev $prevline
7979 proc nextfile {} {
7980 global difffilestart ctext cmitmode
7982 if {$cmitmode eq "tree"} return
7983 set here [$ctext index @0,0]
7984 set line 1
7985 foreach loc $difffilestart {
7986 incr line
7987 if {[$ctext compare $loc > $here]} {
7988 highlightfile $loc $line
7989 return
7994 proc clear_ctext {{first 1.0}} {
7995 global ctext smarktop smarkbot
7996 global ctext_file_names ctext_file_lines
7997 global pendinglinks
7999 set l [lindex [split $first .] 0]
8000 if {![info exists smarktop] || [$ctext compare $first < $smarktop.0]} {
8001 set smarktop $l
8003 if {![info exists smarkbot] || [$ctext compare $first < $smarkbot.0]} {
8004 set smarkbot $l
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}]
8026 } else {
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]
8038 if {$sel ne {}} {
8039 $ctext mark set anchor [lindex $sel 0]
8040 } elseif {$searchdirn eq "-forwards"} {
8041 $ctext mark set anchor @0,0
8042 } else {
8043 $ctext mark set anchor @0,[winfo height $ctext]
8046 if {$searchstring ne {}} {
8047 set here [$ctext search $searchdirn -- $searchstring anchor]
8048 if {$here ne {}} {
8049 $ctext see $here
8051 searchmarkvisible 1
8055 proc dosearch {} {
8056 global sstring ctext searchstring searchdirn
8058 focus $sstring
8059 $sstring icursor end
8060 set searchdirn -forwards
8061 if {$searchstring ne {}} {
8062 set sel [$ctext tag ranges sel]
8063 if {$sel ne {}} {
8064 set start "[lindex $sel 0] + 1c"
8065 } elseif {[catch {set start [$ctext index anchor]}]} {
8066 set start "@0,0"
8068 set match [$ctext search -count mlen -- $searchstring $start]
8069 $ctext tag remove sel 1.0 end
8070 if {$match eq {}} {
8071 bell
8072 return
8074 $ctext see $match
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
8084 focus $sstring
8085 $sstring icursor end
8086 set searchdirn -backwards
8087 if {$searchstring ne {}} {
8088 set sel [$ctext tag ranges sel]
8089 if {$sel ne {}} {
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
8096 if {$match eq {}} {
8097 bell
8098 return
8100 $ctext see $match
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
8110 set mend $first.0
8111 while {1} {
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
8129 } else {
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} {
8142 global searchstring
8144 .bleft.bottom.sb set $f0 $f1
8145 if {$searchstring ne {}} {
8146 searchmarkvisible 0
8150 proc setcoords {} {
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
8160 set xspc2 $linespc
8163 proc redisplay {} {
8164 global canv
8165 global selectedline
8167 set ymax [lindex [$canv cget -scrollregion] 3]
8168 if {$ymax eq {} || $ymax == 0} return
8169 set span [$canv yview]
8170 clear_display
8171 setcanvscroll
8172 allcanvs yview moveto [lindex $span 0]
8173 drawvisible
8174 if {$selectedline ne {}} {
8175 selectline $selectedline 0
8176 allcanvs yview moveto [lindex $span 0]
8180 proc parsefont {f n} {
8181 global fontattr
8183 set fontattr($f,family) [lindex $n 0]
8184 set s [lindex $n 1]
8185 if {$s eq {} || $s == 0} {
8186 set s 10
8187 } elseif {$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] {
8194 switch -- $style {
8195 "normal" -
8196 "bold" {set fontattr($f,weight) $style}
8197 "roman" -
8198 "italic" {set fontattr($f,slant) $style}
8203 proc fontflags {f {isbold 0}} {
8204 global fontattr
8206 return [list -family $fontattr($f,family) -size $fontattr($f,size) \
8207 -weight [expr {$isbold? "bold": $fontattr($f,weight)}] \
8208 -slant $fontattr($f,slant)]
8211 proc fontname {f} {
8212 global fontattr
8214 set n [list $fontattr($f,family) $fontattr($f,size)]
8215 if {$fontattr($f,weight) eq "bold"} {
8216 lappend n "bold"
8218 if {$fontattr($f,slant) eq "italic"} {
8219 lappend n "italic"
8221 return $n
8224 proc incrfont {inc} {
8225 global mainfont textfont ctext canv cflist showrefstop
8226 global stopped entries fontattr
8228 unmarkmatches
8229 set s $fontattr(mainfont,size)
8230 incr s $inc
8231 if {$s < 1} {
8232 set s 1
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)
8239 incr s $inc
8240 if {$s < 1} {
8241 set s 1
8243 set fontattr(textfont,size) $s
8244 font config textfont -size $s
8245 font config textfontbold -size $s
8246 set textfont [fontname textfont]
8247 setcoords
8248 settabs
8249 redisplay
8252 proc clearsha1 {} {
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)} {
8263 set state disabled
8264 } else {
8265 set state normal
8267 if {[$sha1but cget -state] == $state} return
8268 if {$state == "normal"} {
8269 $sha1but conf -state normal -relief raised -text "[mc "Goto:"] "
8270 } else {
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)
8284 } else {
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]
8291 return
8293 set id [lindex $matches 0]
8295 } else {
8296 if {[catch {set id [exec git rev-parse --verify $sha1string]}]} {
8297 error_popup [mc "Revision %s is not known" $sha1string]
8298 return
8302 if {[commitinview $id $curview]} {
8303 selectline [rowofcommit $id] 1
8304 return
8306 if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
8307 set msg [mc "SHA1 id %s is not known" $sha1string]
8308 } else {
8309 set msg [mc "Revision %s is not in the current view" $sha1string]
8311 error_popup $msg
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
8319 set hoverx $x
8320 set hovery $y
8321 set hoverid $id
8322 if {[info exists hovertimer]} {
8323 after cancel $hovertimer
8325 set hovertimer [after 500 linehover]
8326 $canv delete hover
8329 proc linemotion {x y id} {
8330 global hoverx hovery hoverid hovertimer
8332 if {[info exists hoverid] && $id == $hoverid} {
8333 set hoverx $x
8334 set hovery $y
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} {
8346 $canv delete hover
8347 if {[info exists hovertimer]} {
8348 after cancel $hovertimer
8349 unset hovertimer
8351 unset hoverid
8355 proc linehover {} {
8356 global hoverx hovery hoverid hovertimer
8357 global canv linespc lthickness
8358 global commitinfo
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]
8372 $canv raise $t
8373 set t [$canv create text $x $y -anchor nw -text $text -tags hover \
8374 -font mainfont]
8375 $canv raise $t
8378 proc clickisonarrow {id y} {
8379 global lthickness
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} {
8387 return $i
8390 return {}
8393 proc arrowjump {id n y} {
8394 global canv
8396 # 1 <-> 2, 3 <-> 4, etc...
8397 set n [expr {(($n - 1) ^ 1) + 1}]
8398 set row [lindex [rowranges $id] $n]
8399 set yt [yc $row]
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}]
8405 if {$yfrac < 0} {
8406 set yfrac 0
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
8415 unmarkmatches
8416 unselectline
8417 normalline
8418 $canv delete hover
8419 # draw this line thicker than normal
8420 set thickerline $id
8421 drawlines $id
8422 if {$isnew} {
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]
8429 if {$dirn ne {}} {
8430 arrowjump $id $dirn $y
8431 return
8434 if {$isnew} {
8435 addtohistory [list lineclick $x $y $id 0] savectextpos
8437 # fill the details pane with info about this line
8438 $ctext conf -state normal
8439 clear_ctext
8440 settabs 0
8441 $ctext insert end "[mc "Parent"]:\t"
8442 $ctext insert end $id link0
8443 setlink $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)
8450 if {$kids ne {}} {
8451 $ctext insert end "\n[mc "Children"]:"
8452 set i 0
8453 foreach child $kids {
8454 incr i
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
8468 init_flist {}
8471 proc normalline {} {
8472 global thickerline
8473 if {[info exists thickerline]} {
8474 set id $thickerline
8475 unset thickerline
8476 drawlines $id
8480 proc selbyid {id {isnew 1}} {
8481 global curview
8482 if {[commitinview $id $curview]} {
8483 selectline [rowofcommit $id] $isnew
8487 proc mstime {} {
8488 global startmstime
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
8499 stopfinding
8500 set rowmenuid $id
8501 if {$selectedline eq {} || [rowofcommit $id] eq $selectedline} {
8502 set state disabled
8503 } else {
8504 set state normal
8506 if {[info exists markedid] && $markedid ne $id} {
8507 set mstate normal
8508 } else {
8509 set mstate disabled
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
8515 } else {
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
8521 } else {
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
8532 proc markhere {} {
8533 global rowmenuid markedid canv
8535 set markedid $rowmenuid
8536 make_idmark $markedid
8539 proc gotomark {} {
8540 global markedid
8542 if {[info exists markedid]} {
8543 selbyid $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]]
8567 while 1 {
8568 set r1 [lindex $l1 0]
8569 set r2 [lindex $l2 0]
8570 if {$r1 eq {} || $r2 eq {}} break
8571 if {$r1 == $r2} {
8572 selectline $r1 1
8573 break
8575 if {$r1 > $r2} {
8576 set l1 [replace_by_kids $l1 $r1]
8577 } else {
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} {
8595 global patchids
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]
8601 if {[catch {
8602 set x [eval exec $cmd | git patch-id]
8603 set patchids($id) [lindex $x 0]
8604 }]} {
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
8615 clear_ctext
8616 init_flist {}
8617 for {set i 0} {$i < 100} {incr i} {
8618 set skipa 0
8619 set skipb 0
8620 if {[llength $parents($curview,$a)] > 1} {
8621 appendshortlink $a [mc "Skipping merge commit "] "\n"
8622 set skipa 1
8623 } else {
8624 set patcha [getpatchid $a]
8626 if {[llength $parents($curview,$b)] > 1} {
8627 appendshortlink $b [mc "Skipping merge commit "] "\n"
8628 set skipb 1
8629 } else {
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"]
8638 break
8640 if {$patchb eq "error"} {
8641 appendshortlink $b [mc "Error getting patch ID for "] \
8642 [mc " - stopping\n"]
8643 break
8645 if {$patcha eq $patchb} {
8646 if {$heada eq $headb} {
8647 appendshortlink $a [mc "Commit "]
8648 appendshortlink $b " == " " $heada\n"
8649 } else {
8650 appendshortlink $a [mc "Commit "] " $heada\n"
8651 appendshortlink $b [mc " is the same patch as\n "] \
8652 " $headb\n"
8654 set skipa 1
8655 set skipb 1
8656 } else {
8657 $ctext insert end "\n"
8658 appendshortlink $a [mc "Commit "] " $heada\n"
8659 appendshortlink $b [mc " differs from\n "] \
8660 " $headb\n"
8661 $ctext insert end [mc "Diff of commits:\n\n"]
8662 $ctext conf -state disabled
8663 update
8664 diffcommits $a $b
8665 return
8668 if {$skipa} {
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]]
8674 break
8676 set a [lindex $kids 0]
8678 if {$skipb} {
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]]
8683 break
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]"]
8697 if {[catch {
8698 exec git diff-tree -p --pretty $a >$fna
8699 exec git diff-tree -p --pretty $b >$fnb
8700 } err]} {
8701 error_popup [mc "Error writing commit to file: %s" $err]
8702 return
8704 if {[catch {
8705 set fd [open "| diff -U$diffcontext $fna $fnb" r]
8706 } err]} {
8707 error_popup [mc "Error diffing commits: %s" $err]
8708 return
8710 set diffids [list commits $a $b]
8711 set blobdifffd($diffids) $fd
8712 set diffinhdr 0
8713 set currdiffsubmod ""
8714 filerun $fd [list getblobdiffline $fd $diffids]
8717 proc diffvssel {dirn} {
8718 global rowmenuid selectedline
8720 if {$selectedline eq {}} return
8721 if {$dirn} {
8722 set oldid [commitonrow $selectedline]
8723 set newid $rowmenuid
8724 } else {
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
8736 if {$dirn} {
8737 set oldid $markedid
8738 set newid $rowmenuid
8739 } else {
8740 set oldid $rowmenuid
8741 set newid $markedid
8743 addtohistory [list doseldiff $oldid $newid] savectextpos
8744 doseldiff $oldid $newid
8747 proc doseldiff {oldid newid} {
8748 global ctext
8749 global commitinfo
8751 $ctext conf -state normal
8752 clear_ctext
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]
8770 proc mkpatch {} {
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]
8778 set top .patch
8779 set patchtop $top
8780 catch {destroy $top}
8781 ttk_toplevel $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"]
8808 incr patchnum
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
8819 focus $top.fname
8822 proc mkpatchrev {} {
8823 global patchtop
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
8838 proc mkpatchgo {} {
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}
8852 unset patchtop
8855 proc mkpatchcan {} {
8856 global patchtop
8858 catch {destroy $patchtop}
8859 unset patchtop
8862 proc mktag {} {
8863 global rowmenuid mktagtop commitinfo NS
8865 set top .maketag
8866 set mktagtop $top
8867 catch {destroy $top}
8868 ttk_toplevel $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
8898 focus $top.tag
8901 proc domktag {} {
8902 global mktagtop env tagids idtags
8904 set id [$mktagtop.sha1 get]
8905 set tag [$mktagtop.tag get]
8906 set msg [$mktagtop.msg get]
8907 if {$tag == {}} {
8908 error_popup [mc "No tag name specified"] $mktagtop
8909 return 0
8911 if {[info exists tagids($tag)]} {
8912 error_popup [mc "Tag \"%s\" already exists" $tag] $mktagtop
8913 return 0
8915 if {[catch {
8916 if {$msg != {}} {
8917 exec git tag -a -m $msg $tag $id
8918 } else {
8919 exec git tag $tag $id
8921 } err]} {
8922 error_popup "[mc "Error creating tag:"] $err" $mktagtop
8923 return 0
8926 set tagids($tag) $id
8927 lappend idtags($id) $tag
8928 redrawtags $id
8929 addedtag $id
8930 dispneartags 0
8931 run refill_reflist
8932 return 1
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} {
8943 set ofill yellow
8944 } else {
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} {
8955 set canvxmax $xr
8956 setcanvscroll
8958 if {[info exists currentid] && $currentid == $id} {
8959 make_secsel $id
8961 if {[info exists markedid] && $markedid eq $id} {
8962 make_idmark $id
8966 proc mktagcan {} {
8967 global mktagtop
8969 catch {destroy $mktagtop}
8970 unset mktagtop
8973 proc mktaggo {} {
8974 if {![domktag]} return
8975 mktagcan
8978 proc writecommit {} {
8979 global rowmenuid wrcomtop commitinfo wrcomcmd NS
8981 set top .writecommit
8982 set wrcomtop $top
8983 catch {destroy $top}
8984 ttk_toplevel $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
9013 focus $top.fname
9016 proc wrcomgo {} {
9017 global wrcomtop
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}
9026 unset wrcomtop
9029 proc wrcomcan {} {
9030 global wrcomtop
9032 catch {destroy $wrcomtop}
9033 unset wrcomtop
9036 proc mkbranch {} {
9037 global rowmenuid mkbrtop NS
9039 set top .makebranch
9040 catch {destroy $top}
9041 ttk_toplevel $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
9062 focus $top.name
9065 proc mkbrgo {top} {
9066 global headids idheads
9068 set name [$top.name get]
9069 set id [$top.sha1 get]
9070 set cmdargs {}
9071 set old_id {}
9072 if {$name eq {}} {
9073 error_popup [mc "Please specify a name for the new branch"] $top
9074 return
9076 if {[info exists headids($name)]} {
9077 if {![confirm_popup [mc \
9078 "Branch '%s' already exists. Overwrite?" $name] $top]} {
9079 return
9081 set old_id $headids($name)
9082 lappend cmdargs -f
9084 catch {destroy $top}
9085 lappend cmdargs $name $id
9086 nowbusy newbranch
9087 update
9088 if {[catch {
9089 eval exec git branch $cmdargs
9090 } err]} {
9091 notbusy newbranch
9092 error_popup $err
9093 } else {
9094 notbusy newbranch
9095 if {$old_id ne {}} {
9096 movehead $id $name
9097 movedhead $id $name
9098 redrawtags $old_id
9099 redrawtags $id
9100 } else {
9101 set headids($name) $id
9102 lappend idheads($id) $name
9103 addedhead $id $name
9104 redrawtags $id
9106 dispneartags 0
9107 run refill_reflist
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)]} {
9118 getcommit $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]
9124 && $date ne {}} {
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
9140 global gitdir
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]]
9148 if {!$ok} return
9150 nowbusy cherrypick [mc "Cherry-picking"]
9151 update
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]} {
9155 notbusy cherrypick
9156 if {[regexp -line \
9157 {Entry '(.*)' (would be overwritten by merge|not uptodate)} \
9158 $err msg fname]} {
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)} \
9164 $err]} {
9165 if {[confirm_popup [mc "Cherry-pick failed because of merge\
9166 conflict.\nDo you wish to run git citool to\
9167 resolve it?"]]} {
9168 # Force citool to read MERGE_MSG
9169 file delete [file join $gitdir "GITGUI_MSG"]
9170 exec_citool {} $rowmenuid
9172 } else {
9173 error_popup $err
9175 run updatecommits
9176 return
9178 set newhead [exec git rev-parse HEAD]
9179 if {$newhead eq $oldhead} {
9180 notbusy cherrypick
9181 error_popup [mc "No changes committed"]
9182 return
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
9193 redrawtags $oldhead
9194 redrawtags $newhead
9195 selbyid $newhead
9197 notbusy cherrypick
9200 proc resethead {} {
9201 global mainhead rowmenuid confirm_ok resettype NS
9203 set confirm_ok 0
9204 set w ".confirmreset"
9205 ttk_toplevel $w
9206 make_transient $w .
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:"]
9212 set resettype mixed
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"
9229 tkwait window $w
9230 if {!$confirm_ok} return
9231 if {[catch {set fd [open \
9232 [list | git reset --$resettype $rowmenuid 2>@1] r]} err]} {
9233 error_popup $err
9234 } else {
9235 dohidelocalchanges
9236 filerun $fd [list readresetstat $fd]
9237 nowbusy reset [mc "Resetting"]
9238 selbyid $rowmenuid
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}]
9248 adjustprogress
9250 return 1
9252 set rprogcoord 0
9253 adjustprogress
9254 notbusy reset
9255 if {[catch {close $fd} err]} {
9256 error_popup $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
9264 redrawtags $oldhead
9265 redrawtags $newhead
9267 if {$showlocalchanges} {
9268 doshowlocalchanges
9270 return 0
9273 # context menu for a head
9274 proc headmenu {x y id head} {
9275 global headmenuid headmenuhead headctxmenu mainhead
9277 stopfinding
9278 set headmenuid $id
9279 set headmenuhead $head
9280 set state normal
9281 if {[string match "remotes/*" $head]} {
9282 set state disabled
9284 if {$head eq $mainhead} {
9285 set state disabled
9287 $headctxmenu entryconfigure 0 -state $state
9288 $headctxmenu entryconfigure 1 -state $state
9289 tk_popup $headctxmenu $x $y
9292 proc cobranch {} {
9293 global headmenuid headmenuhead headids
9294 global showlocalchanges
9296 # check the tree is clean first??
9297 nowbusy checkout [mc "Checking out"]
9298 update
9299 dohidelocalchanges
9300 if {[catch {
9301 set fd [open [list | git checkout $headmenuhead 2>@1] r]
9302 } err]} {
9303 notbusy checkout
9304 error_popup $err
9305 if {$showlocalchanges} {
9306 dodiffindex
9308 } else {
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}]]
9320 adjustprogress
9322 return 1
9324 set progresscoords {0 0}
9325 adjustprogress
9326 notbusy checkout
9327 if {[catch {close $fd} err]} {
9328 error_popup $err
9330 set oldmainid $mainheadid
9331 set mainhead $newhead
9332 set mainheadid $newheadid
9333 set viewmainheadid($curview) $newheadid
9334 redrawtags $oldmainid
9335 redrawtags $newheadid
9336 selbyid $newheadid
9337 if {$showlocalchanges} {
9338 dodiffindex
9342 proc rmbranch {} {
9343 global headmenuid headmenuhead mainhead
9344 global idheads
9346 set head $headmenuhead
9347 set id $headmenuid
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"]
9351 return
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
9359 nowbusy rmbranch
9360 update
9361 if {[catch {exec git branch -D $head} err]} {
9362 notbusy rmbranch
9363 error_popup $err
9364 return
9366 removehead $id $head
9367 removedhead $id $head
9368 redrawtags $id
9369 notbusy rmbranch
9370 dispneartags 0
9371 run refill_reflist
9374 # Display a list of tags and heads
9375 proc showrefs {} {
9376 global showrefstop bgcolor fgcolor selectbgcolor NS
9377 global bglist fglist reflistfilter reflist maincursor
9379 set top .showrefs
9380 set showrefstop $top
9381 if {[winfo exists $top]} {
9382 raise $top
9383 refill_reflist
9384 return
9386 ttk_toplevel $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
9401 ${NS}::frame $top.f
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]
9411 grid $top.close -
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}
9417 set reflist {}
9418 refill_reflist
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 {} {
9437 global showrefstop
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
9452 global curview
9454 if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
9455 set refs {}
9456 foreach n [array names headids] {
9457 if {[string match $reflistfilter $n]} {
9458 if {[commitinview $headids($n) $curview]} {
9459 lappend refs [list $n H]
9460 } else {
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]
9469 } else {
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]
9478 } else {
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"
9490 set i 0
9491 set j 0
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]]
9497 if {$cmp == 0} {
9498 set cmp [string compare [lindex $reflist $i 1] \
9499 [lindex $refs $j 1]]
9501 } else {
9502 set cmp -1
9504 } else {
9505 set cmp 1
9507 switch -- $cmp {
9508 -1 {
9509 $showrefstop.list delete "[expr {$j+1}].0" "[expr {$j+2}].0"
9510 incr i
9513 incr i
9514 incr j
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"
9521 incr j
9525 set reflist $refs
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
9535 global gitdir
9537 if {![info exists allcommits]} {
9538 set nextarc 0
9539 set allcommits 0
9540 set seeds {}
9541 set allcwait 0
9542 set cachedarcs 0
9543 set allccache [file join $gitdir "gitk.cache"]
9544 if {![catch {
9545 set f [open $allccache r]
9546 set allcwait 1
9547 getcache $f
9548 }]} return
9551 if {$allcwait} {
9552 return
9554 set cmd [list | git rev-list --parents]
9555 set allcupdate [expr {$seeds ne {}}]
9556 if {!$allcupdate} {
9557 set ids "--all"
9558 } else {
9559 set refs [concat [array names idheads] [array names idtags] \
9560 [array names idotherrefs]]
9561 set ids {}
9562 set tagobjs {}
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} {
9569 lappend ids $id
9572 if {$ids ne {}} {
9573 foreach id $seeds {
9574 lappend ids "^$id"
9578 if {$ids ne {}} {
9579 set cmd [limit_arg_length [concat $cmd $ids]]
9580 set fd [open $cmd r]
9581 fconfigure $fd -blocking 0
9582 incr allcommits
9583 nowbusy allcommits
9584 filerun $fd [list getallclines $fd]
9585 } else {
9586 dispneartags 0
9590 # The maximum command line length for the CreateProcess function is 32767 characters, see
9591 # http://blogs.msdn.com/oldnewthing/archive/2003/12/10/56028.aspx
9592 # Be a little conservative in case Tcl adds some more stuff to the command line we do not
9593 # know about and truncate the command line at a SHA1-boundary below 32000 characters.
9594 proc limit_arg_length {cmd} {
9595 if {[tk windowingsystem] == "win32" &&
9596 [string length $cmd] > 32000} {
9597 set ndx [string last " " $cmd 32000]
9598 if {$ndx != -1} {
9599 return [string range $cmd 0 $ndx]
9602 return $cmd
9605 # Since most commits have 1 parent and 1 child, we group strings of
9606 # such commits into "arcs" joining branch/merge points (BMPs), which
9607 # are commits that either don't have 1 parent or don't have 1 child.
9609 # arcnos(id) - incoming arcs for BMP, arc we're on for other nodes
9610 # arcout(id) - outgoing arcs for BMP
9611 # arcids(a) - list of IDs on arc including end but not start
9612 # arcstart(a) - BMP ID at start of arc
9613 # arcend(a) - BMP ID at end of arc
9614 # growing(a) - arc a is still growing
9615 # arctags(a) - IDs out of arcids (excluding end) that have tags
9616 # archeads(a) - IDs out of arcids (excluding end) that have heads
9617 # The start of an arc is at the descendent end, so "incoming" means
9618 # coming from descendents, and "outgoing" means going towards ancestors.
9620 proc getallclines {fd} {
9621 global allparents allchildren idtags idheads nextarc
9622 global arcnos arcids arctags arcout arcend arcstart archeads growing
9623 global seeds allcommits cachedarcs allcupdate
9625 set nid 0
9626 while {[incr nid] <= 1000 && [gets $fd line] >= 0} {
9627 set id [lindex $line 0]
9628 if {[info exists allparents($id)]} {
9629 # seen it already
9630 continue
9632 set cachedarcs 0
9633 set olds [lrange $line 1 end]
9634 set allparents($id) $olds
9635 if {![info exists allchildren($id)]} {
9636 set allchildren($id) {}
9637 set arcnos($id) {}
9638 lappend seeds $id
9639 } else {
9640 set a $arcnos($id)
9641 if {[llength $olds] == 1 && [llength $a] == 1} {
9642 lappend arcids($a) $id
9643 if {[info exists idtags($id)]} {
9644 lappend arctags($a) $id
9646 if {[info exists idheads($id)]} {
9647 lappend archeads($a) $id
9649 if {[info exists allparents($olds)]} {
9650 # seen parent already
9651 if {![info exists arcout($olds)]} {
9652 splitarc $olds
9654 lappend arcids($a) $olds
9655 set arcend($a) $olds
9656 unset growing($a)
9658 lappend allchildren($olds) $id
9659 lappend arcnos($olds) $a
9660 continue
9663 foreach a $arcnos($id) {
9664 lappend arcids($a) $id
9665 set arcend($a) $id
9666 unset growing($a)
9669 set ao {}
9670 foreach p $olds {
9671 lappend allchildren($p) $id
9672 set a [incr nextarc]
9673 set arcstart($a) $id
9674 set archeads($a) {}
9675 set arctags($a) {}
9676 set archeads($a) {}
9677 set arcids($a) {}
9678 lappend ao $a
9679 set growing($a) 1
9680 if {[info exists allparents($p)]} {
9681 # seen it already, may need to make a new branch
9682 if {![info exists arcout($p)]} {
9683 splitarc $p
9685 lappend arcids($a) $p
9686 set arcend($a) $p
9687 unset growing($a)
9689 lappend arcnos($p) $a
9691 set arcout($id) $ao
9693 if {$nid > 0} {
9694 global cached_dheads cached_dtags cached_atags
9695 catch {unset cached_dheads}
9696 catch {unset cached_dtags}
9697 catch {unset cached_atags}
9699 if {![eof $fd]} {
9700 return [expr {$nid >= 1000? 2: 1}]
9702 set cacheok 1
9703 if {[catch {
9704 fconfigure $fd -blocking 1
9705 close $fd
9706 } err]} {
9707 # got an error reading the list of commits
9708 # if we were updating, try rereading the whole thing again
9709 if {$allcupdate} {
9710 incr allcommits -1
9711 dropcache $err
9712 return
9714 error_popup "[mc "Error reading commit topology information;\
9715 branch and preceding/following tag information\
9716 will be incomplete."]\n($err)"
9717 set cacheok 0
9719 if {[incr allcommits -1] == 0} {
9720 notbusy allcommits
9721 if {$cacheok} {
9722 run savecache
9725 dispneartags 0
9726 return 0
9729 proc recalcarc {a} {
9730 global arctags archeads arcids idtags idheads
9732 set at {}
9733 set ah {}
9734 foreach id [lrange $arcids($a) 0 end-1] {
9735 if {[info exists idtags($id)]} {
9736 lappend at $id
9738 if {[info exists idheads($id)]} {
9739 lappend ah $id
9742 set arctags($a) $at
9743 set archeads($a) $ah
9746 proc splitarc {p} {
9747 global arcnos arcids nextarc arctags archeads idtags idheads
9748 global arcstart arcend arcout allparents growing
9750 set a $arcnos($p)
9751 if {[llength $a] != 1} {
9752 puts "oops splitarc called but [llength $a] arcs already"
9753 return
9755 set a [lindex $a 0]
9756 set i [lsearch -exact $arcids($a) $p]
9757 if {$i < 0} {
9758 puts "oops splitarc $p not in arc $a"
9759 return
9761 set na [incr nextarc]
9762 if {[info exists arcend($a)]} {
9763 set arcend($na) $arcend($a)
9764 } else {
9765 set l [lindex $allparents([lindex $arcids($a) end]) 0]
9766 set j [lsearch -exact $arcnos($l) $a]
9767 set arcnos($l) [lreplace $arcnos($l) $j $j $na]
9769 set tail [lrange $arcids($a) [expr {$i+1}] end]
9770 set arcids($a) [lrange $arcids($a) 0 $i]
9771 set arcend($a) $p
9772 set arcstart($na) $p
9773 set arcout($p) $na
9774 set arcids($na) $tail
9775 if {[info exists growing($a)]} {
9776 set growing($na) 1
9777 unset growing($a)
9780 foreach id $tail {
9781 if {[llength $arcnos($id)] == 1} {
9782 set arcnos($id) $na
9783 } else {
9784 set j [lsearch -exact $arcnos($id) $a]
9785 set arcnos($id) [lreplace $arcnos($id) $j $j $na]
9789 # reconstruct tags and heads lists
9790 if {$arctags($a) ne {} || $archeads($a) ne {}} {
9791 recalcarc $a
9792 recalcarc $na
9793 } else {
9794 set arctags($na) {}
9795 set archeads($na) {}
9799 # Update things for a new commit added that is a child of one
9800 # existing commit. Used when cherry-picking.
9801 proc addnewchild {id p} {
9802 global allparents allchildren idtags nextarc
9803 global arcnos arcids arctags arcout arcend arcstart archeads growing
9804 global seeds allcommits
9806 if {![info exists allcommits] || ![info exists arcnos($p)]} return
9807 set allparents($id) [list $p]
9808 set allchildren($id) {}
9809 set arcnos($id) {}
9810 lappend seeds $id
9811 lappend allchildren($p) $id
9812 set a [incr nextarc]
9813 set arcstart($a) $id
9814 set archeads($a) {}
9815 set arctags($a) {}
9816 set arcids($a) [list $p]
9817 set arcend($a) $p
9818 if {![info exists arcout($p)]} {
9819 splitarc $p
9821 lappend arcnos($p) $a
9822 set arcout($id) [list $a]
9825 # This implements a cache for the topology information.
9826 # The cache saves, for each arc, the start and end of the arc,
9827 # the ids on the arc, and the outgoing arcs from the end.
9828 proc readcache {f} {
9829 global arcnos arcids arcout arcstart arcend arctags archeads nextarc
9830 global idtags idheads allparents cachedarcs possible_seeds seeds growing
9831 global allcwait
9833 set a $nextarc
9834 set lim $cachedarcs
9835 if {$lim - $a > 500} {
9836 set lim [expr {$a + 500}]
9838 if {[catch {
9839 if {$a == $lim} {
9840 # finish reading the cache and setting up arctags, etc.
9841 set line [gets $f]
9842 if {$line ne "1"} {error "bad final version"}
9843 close $f
9844 foreach id [array names idtags] {
9845 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
9846 [llength $allparents($id)] == 1} {
9847 set a [lindex $arcnos($id) 0]
9848 if {$arctags($a) eq {}} {
9849 recalcarc $a
9853 foreach id [array names idheads] {
9854 if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
9855 [llength $allparents($id)] == 1} {
9856 set a [lindex $arcnos($id) 0]
9857 if {$archeads($a) eq {}} {
9858 recalcarc $a
9862 foreach id [lsort -unique $possible_seeds] {
9863 if {$arcnos($id) eq {}} {
9864 lappend seeds $id
9867 set allcwait 0
9868 } else {
9869 while {[incr a] <= $lim} {
9870 set line [gets $f]
9871 if {[llength $line] != 3} {error "bad line"}
9872 set s [lindex $line 0]
9873 set arcstart($a) $s
9874 lappend arcout($s) $a
9875 if {![info exists arcnos($s)]} {
9876 lappend possible_seeds $s
9877 set arcnos($s) {}
9879 set e [lindex $line 1]
9880 if {$e eq {}} {
9881 set growing($a) 1
9882 } else {
9883 set arcend($a) $e
9884 if {![info exists arcout($e)]} {
9885 set arcout($e) {}
9888 set arcids($a) [lindex $line 2]
9889 foreach id $arcids($a) {
9890 lappend allparents($s) $id
9891 set s $id
9892 lappend arcnos($id) $a
9894 if {![info exists allparents($s)]} {
9895 set allparents($s) {}
9897 set arctags($a) {}
9898 set archeads($a) {}
9900 set nextarc [expr {$a - 1}]
9902 } err]} {
9903 dropcache $err
9904 return 0
9906 if {!$allcwait} {
9907 getallcommits
9909 return $allcwait
9912 proc getcache {f} {
9913 global nextarc cachedarcs possible_seeds
9915 if {[catch {
9916 set line [gets $f]
9917 if {[llength $line] != 2 || [lindex $line 0] ne "1"} {error "bad version"}
9918 # make sure it's an integer
9919 set cachedarcs [expr {int([lindex $line 1])}]
9920 if {$cachedarcs < 0} {error "bad number of arcs"}
9921 set nextarc 0
9922 set possible_seeds {}
9923 run readcache $f
9924 } err]} {
9925 dropcache $err
9927 return 0
9930 proc dropcache {err} {
9931 global allcwait nextarc cachedarcs seeds
9933 #puts "dropping cache ($err)"
9934 foreach v {arcnos arcout arcids arcstart arcend growing \
9935 arctags archeads allparents allchildren} {
9936 global $v
9937 catch {unset $v}
9939 set allcwait 0
9940 set nextarc 0
9941 set cachedarcs 0
9942 set seeds {}
9943 getallcommits
9946 proc writecache {f} {
9947 global cachearc cachedarcs allccache
9948 global arcstart arcend arcnos arcids arcout
9950 set a $cachearc
9951 set lim $cachedarcs
9952 if {$lim - $a > 1000} {
9953 set lim [expr {$a + 1000}]
9955 if {[catch {
9956 while {[incr a] <= $lim} {
9957 if {[info exists arcend($a)]} {
9958 puts $f [list $arcstart($a) $arcend($a) $arcids($a)]
9959 } else {
9960 puts $f [list $arcstart($a) {} $arcids($a)]
9963 } err]} {
9964 catch {close $f}
9965 catch {file delete $allccache}
9966 #puts "writing cache failed ($err)"
9967 return 0
9969 set cachearc [expr {$a - 1}]
9970 if {$a > $cachedarcs} {
9971 puts $f "1"
9972 close $f
9973 return 0
9975 return 1
9978 proc savecache {} {
9979 global nextarc cachedarcs cachearc allccache
9981 if {$nextarc == $cachedarcs} return
9982 set cachearc 0
9983 set cachedarcs $nextarc
9984 catch {
9985 set f [open $allccache w]
9986 puts $f [list 1 $cachedarcs]
9987 run writecache $f
9991 # Returns 1 if a is an ancestor of b, -1 if b is an ancestor of a,
9992 # or 0 if neither is true.
9993 proc anc_or_desc {a b} {
9994 global arcout arcstart arcend arcnos cached_isanc
9996 if {$arcnos($a) eq $arcnos($b)} {
9997 # Both are on the same arc(s); either both are the same BMP,
9998 # or if one is not a BMP, the other is also not a BMP or is
9999 # the BMP at end of the arc (and it only has 1 incoming arc).
10000 # Or both can be BMPs with no incoming arcs.
10001 if {$a eq $b || $arcnos($a) eq {}} {
10002 return 0
10004 # assert {[llength $arcnos($a)] == 1}
10005 set arc [lindex $arcnos($a) 0]
10006 set i [lsearch -exact $arcids($arc) $a]
10007 set j [lsearch -exact $arcids($arc) $b]
10008 if {$i < 0 || $i > $j} {
10009 return 1
10010 } else {
10011 return -1
10015 if {![info exists arcout($a)]} {
10016 set arc [lindex $arcnos($a) 0]
10017 if {[info exists arcend($arc)]} {
10018 set aend $arcend($arc)
10019 } else {
10020 set aend {}
10022 set a $arcstart($arc)
10023 } else {
10024 set aend $a
10026 if {![info exists arcout($b)]} {
10027 set arc [lindex $arcnos($b) 0]
10028 if {[info exists arcend($arc)]} {
10029 set bend $arcend($arc)
10030 } else {
10031 set bend {}
10033 set b $arcstart($arc)
10034 } else {
10035 set bend $b
10037 if {$a eq $bend} {
10038 return 1
10040 if {$b eq $aend} {
10041 return -1
10043 if {[info exists cached_isanc($a,$bend)]} {
10044 if {$cached_isanc($a,$bend)} {
10045 return 1
10048 if {[info exists cached_isanc($b,$aend)]} {
10049 if {$cached_isanc($b,$aend)} {
10050 return -1
10052 if {[info exists cached_isanc($a,$bend)]} {
10053 return 0
10057 set todo [list $a $b]
10058 set anc($a) a
10059 set anc($b) b
10060 for {set i 0} {$i < [llength $todo]} {incr i} {
10061 set x [lindex $todo $i]
10062 if {$anc($x) eq {}} {
10063 continue
10065 foreach arc $arcnos($x) {
10066 set xd $arcstart($arc)
10067 if {$xd eq $bend} {
10068 set cached_isanc($a,$bend) 1
10069 set cached_isanc($b,$aend) 0
10070 return 1
10071 } elseif {$xd eq $aend} {
10072 set cached_isanc($b,$aend) 1
10073 set cached_isanc($a,$bend) 0
10074 return -1
10076 if {![info exists anc($xd)]} {
10077 set anc($xd) $anc($x)
10078 lappend todo $xd
10079 } elseif {$anc($xd) ne $anc($x)} {
10080 set anc($xd) {}
10084 set cached_isanc($a,$bend) 0
10085 set cached_isanc($b,$aend) 0
10086 return 0
10089 # This identifies whether $desc has an ancestor that is
10090 # a growing tip of the graph and which is not an ancestor of $anc
10091 # and returns 0 if so and 1 if not.
10092 # If we subsequently discover a tag on such a growing tip, and that
10093 # turns out to be a descendent of $anc (which it could, since we
10094 # don't necessarily see children before parents), then $desc
10095 # isn't a good choice to display as a descendent tag of
10096 # $anc (since it is the descendent of another tag which is
10097 # a descendent of $anc). Similarly, $anc isn't a good choice to
10098 # display as a ancestor tag of $desc.
10100 proc is_certain {desc anc} {
10101 global arcnos arcout arcstart arcend growing problems
10103 set certain {}
10104 if {[llength $arcnos($anc)] == 1} {
10105 # tags on the same arc are certain
10106 if {$arcnos($desc) eq $arcnos($anc)} {
10107 return 1
10109 if {![info exists arcout($anc)]} {
10110 # if $anc is partway along an arc, use the start of the arc instead
10111 set a [lindex $arcnos($anc) 0]
10112 set anc $arcstart($a)
10115 if {[llength $arcnos($desc)] > 1 || [info exists arcout($desc)]} {
10116 set x $desc
10117 } else {
10118 set a [lindex $arcnos($desc) 0]
10119 set x $arcend($a)
10121 if {$x == $anc} {
10122 return 1
10124 set anclist [list $x]
10125 set dl($x) 1
10126 set nnh 1
10127 set ngrowanc 0
10128 for {set i 0} {$i < [llength $anclist] && ($nnh > 0 || $ngrowanc > 0)} {incr i} {
10129 set x [lindex $anclist $i]
10130 if {$dl($x)} {
10131 incr nnh -1
10133 set done($x) 1
10134 foreach a $arcout($x) {
10135 if {[info exists growing($a)]} {
10136 if {![info exists growanc($x)] && $dl($x)} {
10137 set growanc($x) 1
10138 incr ngrowanc
10140 } else {
10141 set y $arcend($a)
10142 if {[info exists dl($y)]} {
10143 if {$dl($y)} {
10144 if {!$dl($x)} {
10145 set dl($y) 0
10146 if {![info exists done($y)]} {
10147 incr nnh -1
10149 if {[info exists growanc($x)]} {
10150 incr ngrowanc -1
10152 set xl [list $y]
10153 for {set k 0} {$k < [llength $xl]} {incr k} {
10154 set z [lindex $xl $k]
10155 foreach c $arcout($z) {
10156 if {[info exists arcend($c)]} {
10157 set v $arcend($c)
10158 if {[info exists dl($v)] && $dl($v)} {
10159 set dl($v) 0
10160 if {![info exists done($v)]} {
10161 incr nnh -1
10163 if {[info exists growanc($v)]} {
10164 incr ngrowanc -1
10166 lappend xl $v
10173 } elseif {$y eq $anc || !$dl($x)} {
10174 set dl($y) 0
10175 lappend anclist $y
10176 } else {
10177 set dl($y) 1
10178 lappend anclist $y
10179 incr nnh
10184 foreach x [array names growanc] {
10185 if {$dl($x)} {
10186 return 0
10188 return 0
10190 return 1
10193 proc validate_arctags {a} {
10194 global arctags idtags
10196 set i -1
10197 set na $arctags($a)
10198 foreach id $arctags($a) {
10199 incr i
10200 if {![info exists idtags($id)]} {
10201 set na [lreplace $na $i $i]
10202 incr i -1
10205 set arctags($a) $na
10208 proc validate_archeads {a} {
10209 global archeads idheads
10211 set i -1
10212 set na $archeads($a)
10213 foreach id $archeads($a) {
10214 incr i
10215 if {![info exists idheads($id)]} {
10216 set na [lreplace $na $i $i]
10217 incr i -1
10220 set archeads($a) $na
10223 # Return the list of IDs that have tags that are descendents of id,
10224 # ignoring IDs that are descendents of IDs already reported.
10225 proc desctags {id} {
10226 global arcnos arcstart arcids arctags idtags allparents
10227 global growing cached_dtags
10229 if {![info exists allparents($id)]} {
10230 return {}
10232 set t1 [clock clicks -milliseconds]
10233 set argid $id
10234 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10235 # part-way along an arc; check that arc first
10236 set a [lindex $arcnos($id) 0]
10237 if {$arctags($a) ne {}} {
10238 validate_arctags $a
10239 set i [lsearch -exact $arcids($a) $id]
10240 set tid {}
10241 foreach t $arctags($a) {
10242 set j [lsearch -exact $arcids($a) $t]
10243 if {$j >= $i} break
10244 set tid $t
10246 if {$tid ne {}} {
10247 return $tid
10250 set id $arcstart($a)
10251 if {[info exists idtags($id)]} {
10252 return $id
10255 if {[info exists cached_dtags($id)]} {
10256 return $cached_dtags($id)
10259 set origid $id
10260 set todo [list $id]
10261 set queued($id) 1
10262 set nc 1
10263 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
10264 set id [lindex $todo $i]
10265 set done($id) 1
10266 set ta [info exists hastaggedancestor($id)]
10267 if {!$ta} {
10268 incr nc -1
10270 # ignore tags on starting node
10271 if {!$ta && $i > 0} {
10272 if {[info exists idtags($id)]} {
10273 set tagloc($id) $id
10274 set ta 1
10275 } elseif {[info exists cached_dtags($id)]} {
10276 set tagloc($id) $cached_dtags($id)
10277 set ta 1
10280 foreach a $arcnos($id) {
10281 set d $arcstart($a)
10282 if {!$ta && $arctags($a) ne {}} {
10283 validate_arctags $a
10284 if {$arctags($a) ne {}} {
10285 lappend tagloc($id) [lindex $arctags($a) end]
10288 if {$ta || $arctags($a) ne {}} {
10289 set tomark [list $d]
10290 for {set j 0} {$j < [llength $tomark]} {incr j} {
10291 set dd [lindex $tomark $j]
10292 if {![info exists hastaggedancestor($dd)]} {
10293 if {[info exists done($dd)]} {
10294 foreach b $arcnos($dd) {
10295 lappend tomark $arcstart($b)
10297 if {[info exists tagloc($dd)]} {
10298 unset tagloc($dd)
10300 } elseif {[info exists queued($dd)]} {
10301 incr nc -1
10303 set hastaggedancestor($dd) 1
10307 if {![info exists queued($d)]} {
10308 lappend todo $d
10309 set queued($d) 1
10310 if {![info exists hastaggedancestor($d)]} {
10311 incr nc
10316 set tags {}
10317 foreach id [array names tagloc] {
10318 if {![info exists hastaggedancestor($id)]} {
10319 foreach t $tagloc($id) {
10320 if {[lsearch -exact $tags $t] < 0} {
10321 lappend tags $t
10326 set t2 [clock clicks -milliseconds]
10327 set loopix $i
10329 # remove tags that are descendents of other tags
10330 for {set i 0} {$i < [llength $tags]} {incr i} {
10331 set a [lindex $tags $i]
10332 for {set j 0} {$j < $i} {incr j} {
10333 set b [lindex $tags $j]
10334 set r [anc_or_desc $a $b]
10335 if {$r == 1} {
10336 set tags [lreplace $tags $j $j]
10337 incr j -1
10338 incr i -1
10339 } elseif {$r == -1} {
10340 set tags [lreplace $tags $i $i]
10341 incr i -1
10342 break
10347 if {[array names growing] ne {}} {
10348 # graph isn't finished, need to check if any tag could get
10349 # eclipsed by another tag coming later. Simply ignore any
10350 # tags that could later get eclipsed.
10351 set ctags {}
10352 foreach t $tags {
10353 if {[is_certain $t $origid]} {
10354 lappend ctags $t
10357 if {$tags eq $ctags} {
10358 set cached_dtags($origid) $tags
10359 } else {
10360 set tags $ctags
10362 } else {
10363 set cached_dtags($origid) $tags
10365 set t3 [clock clicks -milliseconds]
10366 if {0 && $t3 - $t1 >= 100} {
10367 puts "iterating descendents ($loopix/[llength $todo] nodes) took\
10368 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
10370 return $tags
10373 proc anctags {id} {
10374 global arcnos arcids arcout arcend arctags idtags allparents
10375 global growing cached_atags
10377 if {![info exists allparents($id)]} {
10378 return {}
10380 set t1 [clock clicks -milliseconds]
10381 set argid $id
10382 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10383 # part-way along an arc; check that arc first
10384 set a [lindex $arcnos($id) 0]
10385 if {$arctags($a) ne {}} {
10386 validate_arctags $a
10387 set i [lsearch -exact $arcids($a) $id]
10388 foreach t $arctags($a) {
10389 set j [lsearch -exact $arcids($a) $t]
10390 if {$j > $i} {
10391 return $t
10395 if {![info exists arcend($a)]} {
10396 return {}
10398 set id $arcend($a)
10399 if {[info exists idtags($id)]} {
10400 return $id
10403 if {[info exists cached_atags($id)]} {
10404 return $cached_atags($id)
10407 set origid $id
10408 set todo [list $id]
10409 set queued($id) 1
10410 set taglist {}
10411 set nc 1
10412 for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
10413 set id [lindex $todo $i]
10414 set done($id) 1
10415 set td [info exists hastaggeddescendent($id)]
10416 if {!$td} {
10417 incr nc -1
10419 # ignore tags on starting node
10420 if {!$td && $i > 0} {
10421 if {[info exists idtags($id)]} {
10422 set tagloc($id) $id
10423 set td 1
10424 } elseif {[info exists cached_atags($id)]} {
10425 set tagloc($id) $cached_atags($id)
10426 set td 1
10429 foreach a $arcout($id) {
10430 if {!$td && $arctags($a) ne {}} {
10431 validate_arctags $a
10432 if {$arctags($a) ne {}} {
10433 lappend tagloc($id) [lindex $arctags($a) 0]
10436 if {![info exists arcend($a)]} continue
10437 set d $arcend($a)
10438 if {$td || $arctags($a) ne {}} {
10439 set tomark [list $d]
10440 for {set j 0} {$j < [llength $tomark]} {incr j} {
10441 set dd [lindex $tomark $j]
10442 if {![info exists hastaggeddescendent($dd)]} {
10443 if {[info exists done($dd)]} {
10444 foreach b $arcout($dd) {
10445 if {[info exists arcend($b)]} {
10446 lappend tomark $arcend($b)
10449 if {[info exists tagloc($dd)]} {
10450 unset tagloc($dd)
10452 } elseif {[info exists queued($dd)]} {
10453 incr nc -1
10455 set hastaggeddescendent($dd) 1
10459 if {![info exists queued($d)]} {
10460 lappend todo $d
10461 set queued($d) 1
10462 if {![info exists hastaggeddescendent($d)]} {
10463 incr nc
10468 set t2 [clock clicks -milliseconds]
10469 set loopix $i
10470 set tags {}
10471 foreach id [array names tagloc] {
10472 if {![info exists hastaggeddescendent($id)]} {
10473 foreach t $tagloc($id) {
10474 if {[lsearch -exact $tags $t] < 0} {
10475 lappend tags $t
10481 # remove tags that are ancestors of other tags
10482 for {set i 0} {$i < [llength $tags]} {incr i} {
10483 set a [lindex $tags $i]
10484 for {set j 0} {$j < $i} {incr j} {
10485 set b [lindex $tags $j]
10486 set r [anc_or_desc $a $b]
10487 if {$r == -1} {
10488 set tags [lreplace $tags $j $j]
10489 incr j -1
10490 incr i -1
10491 } elseif {$r == 1} {
10492 set tags [lreplace $tags $i $i]
10493 incr i -1
10494 break
10499 if {[array names growing] ne {}} {
10500 # graph isn't finished, need to check if any tag could get
10501 # eclipsed by another tag coming later. Simply ignore any
10502 # tags that could later get eclipsed.
10503 set ctags {}
10504 foreach t $tags {
10505 if {[is_certain $origid $t]} {
10506 lappend ctags $t
10509 if {$tags eq $ctags} {
10510 set cached_atags($origid) $tags
10511 } else {
10512 set tags $ctags
10514 } else {
10515 set cached_atags($origid) $tags
10517 set t3 [clock clicks -milliseconds]
10518 if {0 && $t3 - $t1 >= 100} {
10519 puts "iterating ancestors ($loopix/[llength $todo] nodes) took\
10520 [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
10522 return $tags
10525 # Return the list of IDs that have heads that are descendents of id,
10526 # including id itself if it has a head.
10527 proc descheads {id} {
10528 global arcnos arcstart arcids archeads idheads cached_dheads
10529 global allparents
10531 if {![info exists allparents($id)]} {
10532 return {}
10534 set aret {}
10535 if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
10536 # part-way along an arc; check it first
10537 set a [lindex $arcnos($id) 0]
10538 if {$archeads($a) ne {}} {
10539 validate_archeads $a
10540 set i [lsearch -exact $arcids($a) $id]
10541 foreach t $archeads($a) {
10542 set j [lsearch -exact $arcids($a) $t]
10543 if {$j > $i} break
10544 lappend aret $t
10547 set id $arcstart($a)
10549 set origid $id
10550 set todo [list $id]
10551 set seen($id) 1
10552 set ret {}
10553 for {set i 0} {$i < [llength $todo]} {incr i} {
10554 set id [lindex $todo $i]
10555 if {[info exists cached_dheads($id)]} {
10556 set ret [concat $ret $cached_dheads($id)]
10557 } else {
10558 if {[info exists idheads($id)]} {
10559 lappend ret $id
10561 foreach a $arcnos($id) {
10562 if {$archeads($a) ne {}} {
10563 validate_archeads $a
10564 if {$archeads($a) ne {}} {
10565 set ret [concat $ret $archeads($a)]
10568 set d $arcstart($a)
10569 if {![info exists seen($d)]} {
10570 lappend todo $d
10571 set seen($d) 1
10576 set ret [lsort -unique $ret]
10577 set cached_dheads($origid) $ret
10578 return [concat $ret $aret]
10581 proc addedtag {id} {
10582 global arcnos arcout cached_dtags cached_atags
10584 if {![info exists arcnos($id)]} return
10585 if {![info exists arcout($id)]} {
10586 recalcarc [lindex $arcnos($id) 0]
10588 catch {unset cached_dtags}
10589 catch {unset cached_atags}
10592 proc addedhead {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 removedhead {hid head} {
10603 global cached_dheads
10605 catch {unset cached_dheads}
10608 proc movedhead {hid head} {
10609 global arcnos arcout cached_dheads
10611 if {![info exists arcnos($hid)]} return
10612 if {![info exists arcout($hid)]} {
10613 recalcarc [lindex $arcnos($hid) 0]
10615 catch {unset cached_dheads}
10618 proc changedrefs {} {
10619 global cached_dheads cached_dtags cached_atags cached_tagcontent
10620 global arctags archeads arcnos arcout idheads idtags
10622 foreach id [concat [array names idheads] [array names idtags]] {
10623 if {[info exists arcnos($id)] && ![info exists arcout($id)]} {
10624 set a [lindex $arcnos($id) 0]
10625 if {![info exists donearc($a)]} {
10626 recalcarc $a
10627 set donearc($a) 1
10631 catch {unset cached_tagcontent}
10632 catch {unset cached_dtags}
10633 catch {unset cached_atags}
10634 catch {unset cached_dheads}
10637 proc rereadrefs {} {
10638 global idtags idheads idotherrefs mainheadid
10640 set refids [concat [array names idtags] \
10641 [array names idheads] [array names idotherrefs]]
10642 foreach id $refids {
10643 if {![info exists ref($id)]} {
10644 set ref($id) [listrefs $id]
10647 set oldmainhead $mainheadid
10648 readrefs
10649 changedrefs
10650 set refids [lsort -unique [concat $refids [array names idtags] \
10651 [array names idheads] [array names idotherrefs]]]
10652 foreach id $refids {
10653 set v [listrefs $id]
10654 if {![info exists ref($id)] || $ref($id) != $v} {
10655 redrawtags $id
10658 if {$oldmainhead ne $mainheadid} {
10659 redrawtags $oldmainhead
10660 redrawtags $mainheadid
10662 run refill_reflist
10665 proc listrefs {id} {
10666 global idtags idheads idotherrefs
10668 set x {}
10669 if {[info exists idtags($id)]} {
10670 set x $idtags($id)
10672 set y {}
10673 if {[info exists idheads($id)]} {
10674 set y $idheads($id)
10676 set z {}
10677 if {[info exists idotherrefs($id)]} {
10678 set z $idotherrefs($id)
10680 return [list $x $y $z]
10683 proc showtag {tag isnew} {
10684 global ctext cached_tagcontent tagids linknum tagobjid
10686 if {$isnew} {
10687 addtohistory [list showtag $tag 0] savectextpos
10689 $ctext conf -state normal
10690 clear_ctext
10691 settabs 0
10692 set linknum 0
10693 if {![info exists cached_tagcontent($tag)]} {
10694 catch {
10695 set cached_tagcontent($tag) [exec git cat-file tag $tag]
10698 if {[info exists cached_tagcontent($tag)]} {
10699 set text $cached_tagcontent($tag)
10700 } else {
10701 set text "[mc "Tag"]: $tag\n[mc "Id"]: $tagids($tag)"
10703 appendwithlinks $text {}
10704 maybe_scroll_ctext 1
10705 $ctext conf -state disabled
10706 init_flist {}
10709 proc doquit {} {
10710 global stopped
10711 global gitktmpdir
10713 set stopped 100
10714 savestuff .
10715 destroy .
10717 if {[info exists gitktmpdir]} {
10718 catch {file delete -force $gitktmpdir}
10722 proc mkfontdisp {font top which} {
10723 global fontattr fontpref $font NS use_ttk
10725 set fontpref($font) [set $font]
10726 ${NS}::button $top.${font}but -text $which \
10727 -command [list choosefont $font $which]
10728 ${NS}::label $top.$font -relief flat -font $font \
10729 -text $fontattr($font,family) -justify left
10730 grid x $top.${font}but $top.$font -sticky w
10733 proc choosefont {font which} {
10734 global fontparam fontlist fonttop fontattr
10735 global prefstop NS
10737 set fontparam(which) $which
10738 set fontparam(font) $font
10739 set fontparam(family) [font actual $font -family]
10740 set fontparam(size) $fontattr($font,size)
10741 set fontparam(weight) $fontattr($font,weight)
10742 set fontparam(slant) $fontattr($font,slant)
10743 set top .gitkfont
10744 set fonttop $top
10745 if {![winfo exists $top]} {
10746 font create sample
10747 eval font config sample [font actual $font]
10748 ttk_toplevel $top
10749 make_transient $top $prefstop
10750 wm title $top [mc "Gitk font chooser"]
10751 ${NS}::label $top.l -textvariable fontparam(which)
10752 pack $top.l -side top
10753 set fontlist [lsort [font families]]
10754 ${NS}::frame $top.f
10755 listbox $top.f.fam -listvariable fontlist \
10756 -yscrollcommand [list $top.f.sb set]
10757 bind $top.f.fam <<ListboxSelect>> selfontfam
10758 ${NS}::scrollbar $top.f.sb -command [list $top.f.fam yview]
10759 pack $top.f.sb -side right -fill y
10760 pack $top.f.fam -side left -fill both -expand 1
10761 pack $top.f -side top -fill both -expand 1
10762 ${NS}::frame $top.g
10763 spinbox $top.g.size -from 4 -to 40 -width 4 \
10764 -textvariable fontparam(size) \
10765 -validatecommand {string is integer -strict %s}
10766 checkbutton $top.g.bold -padx 5 \
10767 -font {{Times New Roman} 12 bold} -text [mc "B"] -indicatoron 0 \
10768 -variable fontparam(weight) -onvalue bold -offvalue normal
10769 checkbutton $top.g.ital -padx 5 \
10770 -font {{Times New Roman} 12 italic} -text [mc "I"] -indicatoron 0 \
10771 -variable fontparam(slant) -onvalue italic -offvalue roman
10772 pack $top.g.size $top.g.bold $top.g.ital -side left
10773 pack $top.g -side top
10774 canvas $top.c -width 150 -height 50 -border 2 -relief sunk \
10775 -background white
10776 $top.c create text 100 25 -anchor center -text $which -font sample \
10777 -fill black -tags text
10778 bind $top.c <Configure> [list centertext $top.c]
10779 pack $top.c -side top -fill x
10780 ${NS}::frame $top.buts
10781 ${NS}::button $top.buts.ok -text [mc "OK"] -command fontok -default active
10782 ${NS}::button $top.buts.can -text [mc "Cancel"] -command fontcan -default normal
10783 bind $top <Key-Return> fontok
10784 bind $top <Key-Escape> fontcan
10785 grid $top.buts.ok $top.buts.can
10786 grid columnconfigure $top.buts 0 -weight 1 -uniform a
10787 grid columnconfigure $top.buts 1 -weight 1 -uniform a
10788 pack $top.buts -side bottom -fill x
10789 trace add variable fontparam write chg_fontparam
10790 } else {
10791 raise $top
10792 $top.c itemconf text -text $which
10794 set i [lsearch -exact $fontlist $fontparam(family)]
10795 if {$i >= 0} {
10796 $top.f.fam selection set $i
10797 $top.f.fam see $i
10801 proc centertext {w} {
10802 $w coords text [expr {[winfo width $w] / 2}] [expr {[winfo height $w] / 2}]
10805 proc fontok {} {
10806 global fontparam fontpref prefstop
10808 set f $fontparam(font)
10809 set fontpref($f) [list $fontparam(family) $fontparam(size)]
10810 if {$fontparam(weight) eq "bold"} {
10811 lappend fontpref($f) "bold"
10813 if {$fontparam(slant) eq "italic"} {
10814 lappend fontpref($f) "italic"
10816 set w $prefstop.notebook.fonts.$f
10817 $w conf -text $fontparam(family) -font $fontpref($f)
10819 fontcan
10822 proc fontcan {} {
10823 global fonttop fontparam
10825 if {[info exists fonttop]} {
10826 catch {destroy $fonttop}
10827 catch {font delete sample}
10828 unset fonttop
10829 unset fontparam
10833 if {[package vsatisfies [package provide Tk] 8.6]} {
10834 # In Tk 8.6 we have a native font chooser dialog. Overwrite the above
10835 # function to make use of it.
10836 proc choosefont {font which} {
10837 tk fontchooser configure -title $which -font $font \
10838 -command [list on_choosefont $font $which]
10839 tk fontchooser show
10841 proc on_choosefont {font which newfont} {
10842 global fontparam
10843 puts stderr "$font $newfont"
10844 array set f [font actual $newfont]
10845 set fontparam(which) $which
10846 set fontparam(font) $font
10847 set fontparam(family) $f(-family)
10848 set fontparam(size) $f(-size)
10849 set fontparam(weight) $f(-weight)
10850 set fontparam(slant) $f(-slant)
10851 fontok
10855 proc selfontfam {} {
10856 global fonttop fontparam
10858 set i [$fonttop.f.fam curselection]
10859 if {$i ne {}} {
10860 set fontparam(family) [$fonttop.f.fam get $i]
10864 proc chg_fontparam {v sub op} {
10865 global fontparam
10867 font config sample -$sub $fontparam($sub)
10870 # Create a property sheet tab page
10871 proc create_prefs_page {w} {
10872 global NS
10873 set parent [join [lrange [split $w .] 0 end-1] .]
10874 if {[winfo class $parent] eq "TNotebook"} {
10875 ${NS}::frame $w
10876 } else {
10877 ${NS}::labelframe $w
10881 proc prefspage_general {notebook} {
10882 global NS maxwidth maxgraphpct showneartags showlocalchanges
10883 global tabstop limitdiffs autoselect autosellen extdifftool perfile_attrs
10884 global hideremotes want_ttk have_ttk
10886 set page [create_prefs_page $notebook.general]
10888 ${NS}::label $page.ldisp -text [mc "Commit list display options"]
10889 grid $page.ldisp - -sticky w -pady 10
10890 ${NS}::label $page.spacer -text " "
10891 ${NS}::label $page.maxwidthl -text [mc "Maximum graph width (lines)"]
10892 spinbox $page.maxwidth -from 0 -to 100 -width 4 -textvariable maxwidth
10893 grid $page.spacer $page.maxwidthl $page.maxwidth -sticky w
10894 ${NS}::label $page.maxpctl -text [mc "Maximum graph width (% of pane)"]
10895 spinbox $page.maxpct -from 1 -to 100 -width 4 -textvariable maxgraphpct
10896 grid x $page.maxpctl $page.maxpct -sticky w
10897 ${NS}::checkbutton $page.showlocal -text [mc "Show local changes"] \
10898 -variable showlocalchanges
10899 grid x $page.showlocal -sticky w
10900 ${NS}::checkbutton $page.autoselect -text [mc "Auto-select SHA1 (length)"] \
10901 -variable autoselect
10902 spinbox $page.autosellen -from 1 -to 40 -width 4 -textvariable autosellen
10903 grid x $page.autoselect $page.autosellen -sticky w
10904 ${NS}::checkbutton $page.hideremotes -text [mc "Hide remote refs"] \
10905 -variable hideremotes
10906 grid x $page.hideremotes -sticky w
10908 ${NS}::label $page.ddisp -text [mc "Diff display options"]
10909 grid $page.ddisp - -sticky w -pady 10
10910 ${NS}::label $page.tabstopl -text [mc "Tab spacing"]
10911 spinbox $page.tabstop -from 1 -to 20 -width 4 -textvariable tabstop
10912 grid x $page.tabstopl $page.tabstop -sticky w
10913 ${NS}::checkbutton $page.ntag -text [mc "Display nearby tags"] \
10914 -variable showneartags
10915 grid x $page.ntag -sticky w
10916 ${NS}::checkbutton $page.ldiff -text [mc "Limit diffs to listed paths"] \
10917 -variable limitdiffs
10918 grid x $page.ldiff -sticky w
10919 ${NS}::checkbutton $page.lattr -text [mc "Support per-file encodings"] \
10920 -variable perfile_attrs
10921 grid x $page.lattr -sticky w
10923 ${NS}::entry $page.extdifft -textvariable extdifftool
10924 ${NS}::frame $page.extdifff
10925 ${NS}::label $page.extdifff.l -text [mc "External diff tool" ]
10926 ${NS}::button $page.extdifff.b -text [mc "Choose..."] -command choose_extdiff
10927 pack $page.extdifff.l $page.extdifff.b -side left
10928 pack configure $page.extdifff.l -padx 10
10929 grid x $page.extdifff $page.extdifft -sticky ew
10931 ${NS}::label $page.lgen -text [mc "General options"]
10932 grid $page.lgen - -sticky w -pady 10
10933 ${NS}::checkbutton $page.want_ttk -variable want_ttk \
10934 -text [mc "Use themed widgets"]
10935 if {$have_ttk} {
10936 ${NS}::label $page.ttk_note -text [mc "(change requires restart)"]
10937 } else {
10938 ${NS}::label $page.ttk_note -text [mc "(currently unavailable)"]
10940 grid x $page.want_ttk $page.ttk_note -sticky w
10941 return $page
10944 proc prefspage_colors {notebook} {
10945 global NS uicolor bgcolor fgcolor ctext diffcolors selectbgcolor markbgcolor
10947 set page [create_prefs_page $notebook.colors]
10949 ${NS}::label $page.cdisp -text [mc "Colors: press to choose"]
10950 grid $page.cdisp - -sticky w -pady 10
10951 label $page.ui -padx 40 -relief sunk -background $uicolor
10952 ${NS}::button $page.uibut -text [mc "Interface"] \
10953 -command [list choosecolor uicolor {} $page.ui [mc "interface"] setui]
10954 grid x $page.uibut $page.ui -sticky w
10955 label $page.bg -padx 40 -relief sunk -background $bgcolor
10956 ${NS}::button $page.bgbut -text [mc "Background"] \
10957 -command [list choosecolor bgcolor {} $page.bg [mc "background"] setbg]
10958 grid x $page.bgbut $page.bg -sticky w
10959 label $page.fg -padx 40 -relief sunk -background $fgcolor
10960 ${NS}::button $page.fgbut -text [mc "Foreground"] \
10961 -command [list choosecolor fgcolor {} $page.fg [mc "foreground"] setfg]
10962 grid x $page.fgbut $page.fg -sticky w
10963 label $page.diffold -padx 40 -relief sunk -background [lindex $diffcolors 0]
10964 ${NS}::button $page.diffoldbut -text [mc "Diff: old lines"] \
10965 -command [list choosecolor diffcolors 0 $page.diffold [mc "diff old lines"] \
10966 [list $ctext tag conf d0 -foreground]]
10967 grid x $page.diffoldbut $page.diffold -sticky w
10968 label $page.diffnew -padx 40 -relief sunk -background [lindex $diffcolors 1]
10969 ${NS}::button $page.diffnewbut -text [mc "Diff: new lines"] \
10970 -command [list choosecolor diffcolors 1 $page.diffnew [mc "diff new lines"] \
10971 [list $ctext tag conf dresult -foreground]]
10972 grid x $page.diffnewbut $page.diffnew -sticky w
10973 label $page.hunksep -padx 40 -relief sunk -background [lindex $diffcolors 2]
10974 ${NS}::button $page.hunksepbut -text [mc "Diff: hunk header"] \
10975 -command [list choosecolor diffcolors 2 $page.hunksep \
10976 [mc "diff hunk header"] \
10977 [list $ctext tag conf hunksep -foreground]]
10978 grid x $page.hunksepbut $page.hunksep -sticky w
10979 label $page.markbgsep -padx 40 -relief sunk -background $markbgcolor
10980 ${NS}::button $page.markbgbut -text [mc "Marked line bg"] \
10981 -command [list choosecolor markbgcolor {} $page.markbgsep \
10982 [mc "marked line background"] \
10983 [list $ctext tag conf omark -background]]
10984 grid x $page.markbgbut $page.markbgsep -sticky w
10985 label $page.selbgsep -padx 40 -relief sunk -background $selectbgcolor
10986 ${NS}::button $page.selbgbut -text [mc "Select bg"] \
10987 -command [list choosecolor selectbgcolor {} $page.selbgsep [mc "background"] setselbg]
10988 grid x $page.selbgbut $page.selbgsep -sticky w
10989 return $page
10992 proc prefspage_fonts {notebook} {
10993 global NS
10994 set page [create_prefs_page $notebook.fonts]
10995 ${NS}::label $page.cfont -text [mc "Fonts: press to choose"]
10996 grid $page.cfont - -sticky w -pady 10
10997 mkfontdisp mainfont $page [mc "Main font"]
10998 mkfontdisp textfont $page [mc "Diff display font"]
10999 mkfontdisp uifont $page [mc "User interface font"]
11000 return $page
11003 proc doprefs {} {
11004 global maxwidth maxgraphpct use_ttk NS
11005 global oldprefs prefstop showneartags showlocalchanges
11006 global uicolor bgcolor fgcolor ctext diffcolors selectbgcolor markbgcolor
11007 global tabstop limitdiffs autoselect autosellen extdifftool perfile_attrs
11008 global hideremotes want_ttk have_ttk
11010 set top .gitkprefs
11011 set prefstop $top
11012 if {[winfo exists $top]} {
11013 raise $top
11014 return
11016 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
11017 limitdiffs tabstop perfile_attrs hideremotes want_ttk} {
11018 set oldprefs($v) [set $v]
11020 ttk_toplevel $top
11021 wm title $top [mc "Gitk preferences"]
11022 make_transient $top .
11024 if {[set use_notebook [expr {$use_ttk && [info command ::ttk::notebook] ne ""}]]} {
11025 set notebook [ttk::notebook $top.notebook]
11026 } else {
11027 set notebook [${NS}::frame $top.notebook -borderwidth 0 -relief flat]
11030 lappend pages [prefspage_general $notebook] [mc "General"]
11031 lappend pages [prefspage_colors $notebook] [mc "Colors"]
11032 lappend pages [prefspage_fonts $notebook] [mc "Fonts"]
11033 set col 0
11034 foreach {page title} $pages {
11035 if {$use_notebook} {
11036 $notebook add $page -text $title
11037 } else {
11038 set btn [${NS}::button $notebook.b_[string map {. X} $page] \
11039 -text $title -command [list raise $page]]
11040 $page configure -text $title
11041 grid $btn -row 0 -column [incr col] -sticky w
11042 grid $page -row 1 -column 0 -sticky news -columnspan 100
11046 if {!$use_notebook} {
11047 grid columnconfigure $notebook 0 -weight 1
11048 grid rowconfigure $notebook 1 -weight 1
11049 raise [lindex $pages 0]
11052 grid $notebook -sticky news -padx 2 -pady 2
11053 grid rowconfigure $top 0 -weight 1
11054 grid columnconfigure $top 0 -weight 1
11056 ${NS}::frame $top.buts
11057 ${NS}::button $top.buts.ok -text [mc "OK"] -command prefsok -default active
11058 ${NS}::button $top.buts.can -text [mc "Cancel"] -command prefscan -default normal
11059 bind $top <Key-Return> prefsok
11060 bind $top <Key-Escape> prefscan
11061 grid $top.buts.ok $top.buts.can
11062 grid columnconfigure $top.buts 0 -weight 1 -uniform a
11063 grid columnconfigure $top.buts 1 -weight 1 -uniform a
11064 grid $top.buts - - -pady 10 -sticky ew
11065 grid columnconfigure $top 2 -weight 1
11066 bind $top <Visibility> [list focus $top.buts.ok]
11069 proc choose_extdiff {} {
11070 global extdifftool
11072 set prog [tk_getOpenFile -title [mc "External diff tool"] -multiple false]
11073 if {$prog ne {}} {
11074 set extdifftool $prog
11078 proc choosecolor {v vi w x cmd} {
11079 global $v
11081 set c [tk_chooseColor -initialcolor [lindex [set $v] $vi] \
11082 -title [mc "Gitk: choose color for %s" $x]]
11083 if {$c eq {}} return
11084 $w conf -background $c
11085 lset $v $vi $c
11086 eval $cmd $c
11089 proc setselbg {c} {
11090 global bglist cflist
11091 foreach w $bglist {
11092 $w configure -selectbackground $c
11094 $cflist tag configure highlight \
11095 -background [$cflist cget -selectbackground]
11096 allcanvs itemconf secsel -fill $c
11099 # This sets the background color and the color scheme for the whole UI.
11100 # For some reason, tk_setPalette chooses a nasty dark red for selectColor
11101 # if we don't specify one ourselves, which makes the checkbuttons and
11102 # radiobuttons look bad. This chooses white for selectColor if the
11103 # background color is light, or black if it is dark.
11104 proc setui {c} {
11105 if {[tk windowingsystem] eq "win32"} { return }
11106 set bg [winfo rgb . $c]
11107 set selc black
11108 if {[lindex $bg 0] + 1.5 * [lindex $bg 1] + 0.5 * [lindex $bg 2] > 100000} {
11109 set selc white
11111 tk_setPalette background $c selectColor $selc
11114 proc setbg {c} {
11115 global bglist
11117 foreach w $bglist {
11118 $w conf -background $c
11122 proc setfg {c} {
11123 global fglist canv
11125 foreach w $fglist {
11126 $w conf -foreground $c
11128 allcanvs itemconf text -fill $c
11129 $canv itemconf circle -outline $c
11130 $canv itemconf markid -outline $c
11133 proc prefscan {} {
11134 global oldprefs prefstop
11136 foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
11137 limitdiffs tabstop perfile_attrs hideremotes want_ttk} {
11138 global $v
11139 set $v $oldprefs($v)
11141 catch {destroy $prefstop}
11142 unset prefstop
11143 fontcan
11146 proc prefsok {} {
11147 global maxwidth maxgraphpct
11148 global oldprefs prefstop showneartags showlocalchanges
11149 global fontpref mainfont textfont uifont
11150 global limitdiffs treediffs perfile_attrs
11151 global hideremotes
11153 catch {destroy $prefstop}
11154 unset prefstop
11155 fontcan
11156 set fontchanged 0
11157 if {$mainfont ne $fontpref(mainfont)} {
11158 set mainfont $fontpref(mainfont)
11159 parsefont mainfont $mainfont
11160 eval font configure mainfont [fontflags mainfont]
11161 eval font configure mainfontbold [fontflags mainfont 1]
11162 setcoords
11163 set fontchanged 1
11165 if {$textfont ne $fontpref(textfont)} {
11166 set textfont $fontpref(textfont)
11167 parsefont textfont $textfont
11168 eval font configure textfont [fontflags textfont]
11169 eval font configure textfontbold [fontflags textfont 1]
11171 if {$uifont ne $fontpref(uifont)} {
11172 set uifont $fontpref(uifont)
11173 parsefont uifont $uifont
11174 eval font configure uifont [fontflags uifont]
11176 settabs
11177 if {$showlocalchanges != $oldprefs(showlocalchanges)} {
11178 if {$showlocalchanges} {
11179 doshowlocalchanges
11180 } else {
11181 dohidelocalchanges
11184 if {$limitdiffs != $oldprefs(limitdiffs) ||
11185 ($perfile_attrs && !$oldprefs(perfile_attrs))} {
11186 # treediffs elements are limited by path;
11187 # won't have encodings cached if perfile_attrs was just turned on
11188 catch {unset treediffs}
11190 if {$fontchanged || $maxwidth != $oldprefs(maxwidth)
11191 || $maxgraphpct != $oldprefs(maxgraphpct)} {
11192 redisplay
11193 } elseif {$showneartags != $oldprefs(showneartags) ||
11194 $limitdiffs != $oldprefs(limitdiffs)} {
11195 reselectline
11197 if {$hideremotes != $oldprefs(hideremotes)} {
11198 rereadrefs
11202 proc formatdate {d} {
11203 global datetimeformat
11204 if {$d ne {}} {
11205 set d [clock format [lindex $d 0] -format $datetimeformat]
11207 return $d
11210 # This list of encoding names and aliases is distilled from
11211 # http://www.iana.org/assignments/character-sets.
11212 # Not all of them are supported by Tcl.
11213 set encoding_aliases {
11214 { ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991 ASCII
11215 ISO646-US US-ASCII us IBM367 cp367 csASCII }
11216 { ISO-10646-UTF-1 csISO10646UTF1 }
11217 { ISO_646.basic:1983 ref csISO646basic1983 }
11218 { INVARIANT csINVARIANT }
11219 { ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion }
11220 { BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom }
11221 { NATS-SEFI iso-ir-8-1 csNATSSEFI }
11222 { NATS-SEFI-ADD iso-ir-8-2 csNATSSEFIADD }
11223 { NATS-DANO iso-ir-9-1 csNATSDANO }
11224 { NATS-DANO-ADD iso-ir-9-2 csNATSDANOADD }
11225 { SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE se csISO10Swedish }
11226 { SEN_850200_C iso-ir-11 ISO646-SE2 se2 csISO11SwedishForNames }
11227 { KS_C_5601-1987 iso-ir-149 KS_C_5601-1989 KSC_5601 korean csKSC56011987 }
11228 { ISO-2022-KR csISO2022KR }
11229 { EUC-KR csEUCKR }
11230 { ISO-2022-JP csISO2022JP }
11231 { ISO-2022-JP-2 csISO2022JP2 }
11232 { JIS_C6220-1969-jp JIS_C6220-1969 iso-ir-13 katakana x0201-7
11233 csISO13JISC6220jp }
11234 { JIS_C6220-1969-ro iso-ir-14 jp ISO646-JP csISO14JISC6220ro }
11235 { IT iso-ir-15 ISO646-IT csISO15Italian }
11236 { PT iso-ir-16 ISO646-PT csISO16Portuguese }
11237 { ES iso-ir-17 ISO646-ES csISO17Spanish }
11238 { greek7-old iso-ir-18 csISO18Greek7Old }
11239 { latin-greek iso-ir-19 csISO19LatinGreek }
11240 { DIN_66003 iso-ir-21 de ISO646-DE csISO21German }
11241 { NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French }
11242 { Latin-greek-1 iso-ir-27 csISO27LatinGreek1 }
11243 { ISO_5427 iso-ir-37 csISO5427Cyrillic }
11244 { JIS_C6226-1978 iso-ir-42 csISO42JISC62261978 }
11245 { BS_viewdata iso-ir-47 csISO47BSViewdata }
11246 { INIS iso-ir-49 csISO49INIS }
11247 { INIS-8 iso-ir-50 csISO50INIS8 }
11248 { INIS-cyrillic iso-ir-51 csISO51INISCyrillic }
11249 { ISO_5427:1981 iso-ir-54 ISO5427Cyrillic1981 }
11250 { ISO_5428:1980 iso-ir-55 csISO5428Greek }
11251 { GB_1988-80 iso-ir-57 cn ISO646-CN csISO57GB1988 }
11252 { GB_2312-80 iso-ir-58 chinese csISO58GB231280 }
11253 { NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
11254 csISO60Norwegian1 }
11255 { NS_4551-2 ISO646-NO2 iso-ir-61 no2 csISO61Norwegian2 }
11256 { NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French }
11257 { videotex-suppl iso-ir-70 csISO70VideotexSupp1 }
11258 { PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2 }
11259 { ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2 }
11260 { MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian }
11261 { JIS_C6226-1983 iso-ir-87 x0208 JIS_X0208-1983 csISO87JISX0208 }
11262 { greek7 iso-ir-88 csISO88Greek7 }
11263 { ASMO_449 ISO_9036 arabic7 iso-ir-89 csISO89ASMO449 }
11264 { iso-ir-90 csISO90 }
11265 { JIS_C6229-1984-a iso-ir-91 jp-ocr-a csISO91JISC62291984a }
11266 { JIS_C6229-1984-b iso-ir-92 ISO646-JP-OCR-B jp-ocr-b
11267 csISO92JISC62991984b }
11268 { JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add csISO93JIS62291984badd }
11269 { JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand csISO94JIS62291984hand }
11270 { JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
11271 csISO95JIS62291984handadd }
11272 { JIS_C6229-1984-kana iso-ir-96 csISO96JISC62291984kana }
11273 { ISO_2033-1983 iso-ir-98 e13b csISO2033 }
11274 { ANSI_X3.110-1983 iso-ir-99 CSA_T500-1983 NAPLPS csISO99NAPLPS }
11275 { ISO_8859-1:1987 iso-ir-100 ISO_8859-1 ISO-8859-1 latin1 l1 IBM819
11276 CP819 csISOLatin1 }
11277 { ISO_8859-2:1987 iso-ir-101 ISO_8859-2 ISO-8859-2 latin2 l2 csISOLatin2 }
11278 { T.61-7bit iso-ir-102 csISO102T617bit }
11279 { T.61-8bit T.61 iso-ir-103 csISO103T618bit }
11280 { ISO_8859-3:1988 iso-ir-109 ISO_8859-3 ISO-8859-3 latin3 l3 csISOLatin3 }
11281 { ISO_8859-4:1988 iso-ir-110 ISO_8859-4 ISO-8859-4 latin4 l4 csISOLatin4 }
11282 { ECMA-cyrillic iso-ir-111 KOI8-E csISO111ECMACyrillic }
11283 { CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca csISO121Canadian1 }
11284 { CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2 csISO122Canadian2 }
11285 { CSA_Z243.4-1985-gr iso-ir-123 csISO123CSAZ24341985gr }
11286 { ISO_8859-6:1987 iso-ir-127 ISO_8859-6 ISO-8859-6 ECMA-114 ASMO-708
11287 arabic csISOLatinArabic }
11288 { ISO_8859-6-E csISO88596E ISO-8859-6-E }
11289 { ISO_8859-6-I csISO88596I ISO-8859-6-I }
11290 { ISO_8859-7:1987 iso-ir-126 ISO_8859-7 ISO-8859-7 ELOT_928 ECMA-118
11291 greek greek8 csISOLatinGreek }
11292 { T.101-G2 iso-ir-128 csISO128T101G2 }
11293 { ISO_8859-8:1988 iso-ir-138 ISO_8859-8 ISO-8859-8 hebrew
11294 csISOLatinHebrew }
11295 { ISO_8859-8-E csISO88598E ISO-8859-8-E }
11296 { ISO_8859-8-I csISO88598I ISO-8859-8-I }
11297 { CSN_369103 iso-ir-139 csISO139CSN369103 }
11298 { JUS_I.B1.002 iso-ir-141 ISO646-YU js yu csISO141JUSIB1002 }
11299 { ISO_6937-2-add iso-ir-142 csISOTextComm }
11300 { IEC_P27-1 iso-ir-143 csISO143IECP271 }
11301 { ISO_8859-5:1988 iso-ir-144 ISO_8859-5 ISO-8859-5 cyrillic
11302 csISOLatinCyrillic }
11303 { JUS_I.B1.003-serb iso-ir-146 serbian csISO146Serbian }
11304 { JUS_I.B1.003-mac macedonian iso-ir-147 csISO147Macedonian }
11305 { ISO_8859-9:1989 iso-ir-148 ISO_8859-9 ISO-8859-9 latin5 l5 csISOLatin5 }
11306 { greek-ccitt iso-ir-150 csISO150 csISO150GreekCCITT }
11307 { NC_NC00-10:81 cuba iso-ir-151 ISO646-CU csISO151Cuba }
11308 { ISO_6937-2-25 iso-ir-152 csISO6937Add }
11309 { GOST_19768-74 ST_SEV_358-88 iso-ir-153 csISO153GOST1976874 }
11310 { ISO_8859-supp iso-ir-154 latin1-2-5 csISO8859Supp }
11311 { ISO_10367-box iso-ir-155 csISO10367Box }
11312 { ISO-8859-10 iso-ir-157 l6 ISO_8859-10:1992 csISOLatin6 latin6 }
11313 { latin-lap lap iso-ir-158 csISO158Lap }
11314 { JIS_X0212-1990 x0212 iso-ir-159 csISO159JISX02121990 }
11315 { DS_2089 DS2089 ISO646-DK dk csISO646Danish }
11316 { us-dk csUSDK }
11317 { dk-us csDKUS }
11318 { JIS_X0201 X0201 csHalfWidthKatakana }
11319 { KSC5636 ISO646-KR csKSC5636 }
11320 { ISO-10646-UCS-2 csUnicode }
11321 { ISO-10646-UCS-4 csUCS4 }
11322 { DEC-MCS dec csDECMCS }
11323 { hp-roman8 roman8 r8 csHPRoman8 }
11324 { macintosh mac csMacintosh }
11325 { IBM037 cp037 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl
11326 csIBM037 }
11327 { IBM038 EBCDIC-INT cp038 csIBM038 }
11328 { IBM273 CP273 csIBM273 }
11329 { IBM274 EBCDIC-BE CP274 csIBM274 }
11330 { IBM275 EBCDIC-BR cp275 csIBM275 }
11331 { IBM277 EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 }
11332 { IBM278 CP278 ebcdic-cp-fi ebcdic-cp-se csIBM278 }
11333 { IBM280 CP280 ebcdic-cp-it csIBM280 }
11334 { IBM281 EBCDIC-JP-E cp281 csIBM281 }
11335 { IBM284 CP284 ebcdic-cp-es csIBM284 }
11336 { IBM285 CP285 ebcdic-cp-gb csIBM285 }
11337 { IBM290 cp290 EBCDIC-JP-kana csIBM290 }
11338 { IBM297 cp297 ebcdic-cp-fr csIBM297 }
11339 { IBM420 cp420 ebcdic-cp-ar1 csIBM420 }
11340 { IBM423 cp423 ebcdic-cp-gr csIBM423 }
11341 { IBM424 cp424 ebcdic-cp-he csIBM424 }
11342 { IBM437 cp437 437 csPC8CodePage437 }
11343 { IBM500 CP500 ebcdic-cp-be ebcdic-cp-ch csIBM500 }
11344 { IBM775 cp775 csPC775Baltic }
11345 { IBM850 cp850 850 csPC850Multilingual }
11346 { IBM851 cp851 851 csIBM851 }
11347 { IBM852 cp852 852 csPCp852 }
11348 { IBM855 cp855 855 csIBM855 }
11349 { IBM857 cp857 857 csIBM857 }
11350 { IBM860 cp860 860 csIBM860 }
11351 { IBM861 cp861 861 cp-is csIBM861 }
11352 { IBM862 cp862 862 csPC862LatinHebrew }
11353 { IBM863 cp863 863 csIBM863 }
11354 { IBM864 cp864 csIBM864 }
11355 { IBM865 cp865 865 csIBM865 }
11356 { IBM866 cp866 866 csIBM866 }
11357 { IBM868 CP868 cp-ar csIBM868 }
11358 { IBM869 cp869 869 cp-gr csIBM869 }
11359 { IBM870 CP870 ebcdic-cp-roece ebcdic-cp-yu csIBM870 }
11360 { IBM871 CP871 ebcdic-cp-is csIBM871 }
11361 { IBM880 cp880 EBCDIC-Cyrillic csIBM880 }
11362 { IBM891 cp891 csIBM891 }
11363 { IBM903 cp903 csIBM903 }
11364 { IBM904 cp904 904 csIBBM904 }
11365 { IBM905 CP905 ebcdic-cp-tr csIBM905 }
11366 { IBM918 CP918 ebcdic-cp-ar2 csIBM918 }
11367 { IBM1026 CP1026 csIBM1026 }
11368 { EBCDIC-AT-DE csIBMEBCDICATDE }
11369 { EBCDIC-AT-DE-A csEBCDICATDEA }
11370 { EBCDIC-CA-FR csEBCDICCAFR }
11371 { EBCDIC-DK-NO csEBCDICDKNO }
11372 { EBCDIC-DK-NO-A csEBCDICDKNOA }
11373 { EBCDIC-FI-SE csEBCDICFISE }
11374 { EBCDIC-FI-SE-A csEBCDICFISEA }
11375 { EBCDIC-FR csEBCDICFR }
11376 { EBCDIC-IT csEBCDICIT }
11377 { EBCDIC-PT csEBCDICPT }
11378 { EBCDIC-ES csEBCDICES }
11379 { EBCDIC-ES-A csEBCDICESA }
11380 { EBCDIC-ES-S csEBCDICESS }
11381 { EBCDIC-UK csEBCDICUK }
11382 { EBCDIC-US csEBCDICUS }
11383 { UNKNOWN-8BIT csUnknown8BiT }
11384 { MNEMONIC csMnemonic }
11385 { MNEM csMnem }
11386 { VISCII csVISCII }
11387 { VIQR csVIQR }
11388 { KOI8-R csKOI8R }
11389 { IBM00858 CCSID00858 CP00858 PC-Multilingual-850+euro }
11390 { IBM00924 CCSID00924 CP00924 ebcdic-Latin9--euro }
11391 { IBM01140 CCSID01140 CP01140 ebcdic-us-37+euro }
11392 { IBM01141 CCSID01141 CP01141 ebcdic-de-273+euro }
11393 { IBM01142 CCSID01142 CP01142 ebcdic-dk-277+euro ebcdic-no-277+euro }
11394 { IBM01143 CCSID01143 CP01143 ebcdic-fi-278+euro ebcdic-se-278+euro }
11395 { IBM01144 CCSID01144 CP01144 ebcdic-it-280+euro }
11396 { IBM01145 CCSID01145 CP01145 ebcdic-es-284+euro }
11397 { IBM01146 CCSID01146 CP01146 ebcdic-gb-285+euro }
11398 { IBM01147 CCSID01147 CP01147 ebcdic-fr-297+euro }
11399 { IBM01148 CCSID01148 CP01148 ebcdic-international-500+euro }
11400 { IBM01149 CCSID01149 CP01149 ebcdic-is-871+euro }
11401 { IBM1047 IBM-1047 }
11402 { PTCP154 csPTCP154 PT154 CP154 Cyrillic-Asian }
11403 { Amiga-1251 Ami1251 Amiga1251 Ami-1251 }
11404 { UNICODE-1-1 csUnicode11 }
11405 { CESU-8 csCESU-8 }
11406 { BOCU-1 csBOCU-1 }
11407 { UNICODE-1-1-UTF-7 csUnicode11UTF7 }
11408 { ISO-8859-14 iso-ir-199 ISO_8859-14:1998 ISO_8859-14 latin8 iso-celtic
11409 l8 }
11410 { ISO-8859-15 ISO_8859-15 Latin-9 }
11411 { ISO-8859-16 iso-ir-226 ISO_8859-16:2001 ISO_8859-16 latin10 l10 }
11412 { GBK CP936 MS936 windows-936 }
11413 { JIS_Encoding csJISEncoding }
11414 { Shift_JIS MS_Kanji csShiftJIS ShiftJIS Shift-JIS }
11415 { Extended_UNIX_Code_Packed_Format_for_Japanese csEUCPkdFmtJapanese
11416 EUC-JP }
11417 { Extended_UNIX_Code_Fixed_Width_for_Japanese csEUCFixWidJapanese }
11418 { ISO-10646-UCS-Basic csUnicodeASCII }
11419 { ISO-10646-Unicode-Latin1 csUnicodeLatin1 ISO-10646 }
11420 { ISO-Unicode-IBM-1261 csUnicodeIBM1261 }
11421 { ISO-Unicode-IBM-1268 csUnicodeIBM1268 }
11422 { ISO-Unicode-IBM-1276 csUnicodeIBM1276 }
11423 { ISO-Unicode-IBM-1264 csUnicodeIBM1264 }
11424 { ISO-Unicode-IBM-1265 csUnicodeIBM1265 }
11425 { ISO-8859-1-Windows-3.0-Latin-1 csWindows30Latin1 }
11426 { ISO-8859-1-Windows-3.1-Latin-1 csWindows31Latin1 }
11427 { ISO-8859-2-Windows-Latin-2 csWindows31Latin2 }
11428 { ISO-8859-9-Windows-Latin-5 csWindows31Latin5 }
11429 { Adobe-Standard-Encoding csAdobeStandardEncoding }
11430 { Ventura-US csVenturaUS }
11431 { Ventura-International csVenturaInternational }
11432 { PC8-Danish-Norwegian csPC8DanishNorwegian }
11433 { PC8-Turkish csPC8Turkish }
11434 { IBM-Symbols csIBMSymbols }
11435 { IBM-Thai csIBMThai }
11436 { HP-Legal csHPLegal }
11437 { HP-Pi-font csHPPiFont }
11438 { HP-Math8 csHPMath8 }
11439 { Adobe-Symbol-Encoding csHPPSMath }
11440 { HP-DeskTop csHPDesktop }
11441 { Ventura-Math csVenturaMath }
11442 { Microsoft-Publishing csMicrosoftPublishing }
11443 { Windows-31J csWindows31J }
11444 { GB2312 csGB2312 }
11445 { Big5 csBig5 }
11448 proc tcl_encoding {enc} {
11449 global encoding_aliases tcl_encoding_cache
11450 if {[info exists tcl_encoding_cache($enc)]} {
11451 return $tcl_encoding_cache($enc)
11453 set names [encoding names]
11454 set lcnames [string tolower $names]
11455 set enc [string tolower $enc]
11456 set i [lsearch -exact $lcnames $enc]
11457 if {$i < 0} {
11458 # look for "isonnn" instead of "iso-nnn" or "iso_nnn"
11459 if {[regsub {^(iso|cp|ibm|jis)[-_]} $enc {\1} encx]} {
11460 set i [lsearch -exact $lcnames $encx]
11463 if {$i < 0} {
11464 foreach l $encoding_aliases {
11465 set ll [string tolower $l]
11466 if {[lsearch -exact $ll $enc] < 0} continue
11467 # look through the aliases for one that tcl knows about
11468 foreach e $ll {
11469 set i [lsearch -exact $lcnames $e]
11470 if {$i < 0} {
11471 if {[regsub {^(iso|cp|ibm|jis)[-_]} $e {\1} ex]} {
11472 set i [lsearch -exact $lcnames $ex]
11475 if {$i >= 0} break
11477 break
11480 set tclenc {}
11481 if {$i >= 0} {
11482 set tclenc [lindex $names $i]
11484 set tcl_encoding_cache($enc) $tclenc
11485 return $tclenc
11488 proc gitattr {path attr default} {
11489 global path_attr_cache
11490 if {[info exists path_attr_cache($attr,$path)]} {
11491 set r $path_attr_cache($attr,$path)
11492 } else {
11493 set r "unspecified"
11494 if {![catch {set line [exec git check-attr $attr -- $path]}]} {
11495 regexp "(.*): $attr: (.*)" $line m f r
11497 set path_attr_cache($attr,$path) $r
11499 if {$r eq "unspecified"} {
11500 return $default
11502 return $r
11505 proc cache_gitattr {attr pathlist} {
11506 global path_attr_cache
11507 set newlist {}
11508 foreach path $pathlist {
11509 if {![info exists path_attr_cache($attr,$path)]} {
11510 lappend newlist $path
11513 set lim 1000
11514 if {[tk windowingsystem] == "win32"} {
11515 # windows has a 32k limit on the arguments to a command...
11516 set lim 30
11518 while {$newlist ne {}} {
11519 set head [lrange $newlist 0 [expr {$lim - 1}]]
11520 set newlist [lrange $newlist $lim end]
11521 if {![catch {set rlist [eval exec git check-attr $attr -- $head]}]} {
11522 foreach row [split $rlist "\n"] {
11523 if {[regexp "(.*): $attr: (.*)" $row m path value]} {
11524 if {[string index $path 0] eq "\""} {
11525 set path [encoding convertfrom utf-8 [lindex $path 0]]
11527 set path_attr_cache($attr,$path) $value
11534 proc get_path_encoding {path} {
11535 global gui_encoding perfile_attrs
11536 set tcl_enc $gui_encoding
11537 if {$path ne {} && $perfile_attrs} {
11538 set enc2 [tcl_encoding [gitattr $path encoding $tcl_enc]]
11539 if {$enc2 ne {}} {
11540 set tcl_enc $enc2
11543 return $tcl_enc
11546 # First check that Tcl/Tk is recent enough
11547 if {[catch {package require Tk 8.4} err]} {
11548 show_error {} . "Sorry, gitk cannot run with this version of Tcl/Tk.\n\
11549 Gitk requires at least Tcl/Tk 8.4." list
11550 exit 1
11553 # Unset GIT_TRACE var if set
11554 if { [info exists ::env(GIT_TRACE)] } {
11555 unset ::env(GIT_TRACE)
11558 # defaults...
11559 set wrcomcmd "git diff-tree --stdin -p --pretty"
11561 set gitencoding {}
11562 catch {
11563 set gitencoding [exec git config --get i18n.commitencoding]
11565 catch {
11566 set gitencoding [exec git config --get i18n.logoutputencoding]
11568 if {$gitencoding == ""} {
11569 set gitencoding "utf-8"
11571 set tclencoding [tcl_encoding $gitencoding]
11572 if {$tclencoding == {}} {
11573 puts stderr "Warning: encoding $gitencoding is not supported by Tcl/Tk"
11576 set gui_encoding [encoding system]
11577 catch {
11578 set enc [exec git config --get gui.encoding]
11579 if {$enc ne {}} {
11580 set tclenc [tcl_encoding $enc]
11581 if {$tclenc ne {}} {
11582 set gui_encoding $tclenc
11583 } else {
11584 puts stderr "Warning: encoding $enc is not supported by Tcl/Tk"
11589 set log_showroot true
11590 catch {
11591 set log_showroot [exec git config --bool --get log.showroot]
11594 if {[tk windowingsystem] eq "aqua"} {
11595 set mainfont {{Lucida Grande} 9}
11596 set textfont {Monaco 9}
11597 set uifont {{Lucida Grande} 9 bold}
11598 } elseif {![catch {::tk::pkgconfig get fontsystem} xft] && $xft eq "xft"} {
11599 # fontconfig!
11600 set mainfont {sans 9}
11601 set textfont {monospace 9}
11602 set uifont {sans 9 bold}
11603 } else {
11604 set mainfont {Helvetica 9}
11605 set textfont {Courier 9}
11606 set uifont {Helvetica 9 bold}
11608 set tabstop 8
11609 set findmergefiles 0
11610 set maxgraphpct 50
11611 set maxwidth 16
11612 set revlistorder 0
11613 set fastdate 0
11614 set uparrowlen 5
11615 set downarrowlen 5
11616 set mingaplen 100
11617 set cmitmode "patch"
11618 set wrapcomment "none"
11619 set showneartags 1
11620 set hideremotes 0
11621 set maxrefs 20
11622 set maxlinelen 200
11623 set showlocalchanges 1
11624 set limitdiffs 1
11625 set datetimeformat "%Y-%m-%d %H:%M:%S"
11626 set autoselect 1
11627 set autosellen 40
11628 set perfile_attrs 0
11629 set want_ttk 1
11631 if {[tk windowingsystem] eq "aqua"} {
11632 set extdifftool "opendiff"
11633 } else {
11634 set extdifftool "meld"
11637 set colors {green red blue magenta darkgrey brown orange}
11638 if {[tk windowingsystem] eq "win32"} {
11639 set uicolor SystemButtonFace
11640 set bgcolor SystemWindow
11641 set fgcolor SystemButtonText
11642 set selectbgcolor SystemHighlight
11643 } else {
11644 set uicolor grey85
11645 set bgcolor white
11646 set fgcolor black
11647 set selectbgcolor gray85
11649 set diffcolors {red "#00a000" blue}
11650 set diffcontext 3
11651 set ignorespace 0
11652 set worddiff ""
11653 set markbgcolor "#e0e0ff"
11655 set circlecolors {white blue gray blue blue}
11657 # button for popping up context menus
11658 if {[tk windowingsystem] eq "aqua"} {
11659 set ctxbut <Button-2>
11660 } else {
11661 set ctxbut <Button-3>
11664 ## For msgcat loading, first locate the installation location.
11665 if { [info exists ::env(GITK_MSGSDIR)] } {
11666 ## Msgsdir was manually set in the environment.
11667 set gitk_msgsdir $::env(GITK_MSGSDIR)
11668 } else {
11669 ## Let's guess the prefix from argv0.
11670 set gitk_prefix [file dirname [file dirname [file normalize $argv0]]]
11671 set gitk_libdir [file join $gitk_prefix share gitk lib]
11672 set gitk_msgsdir [file join $gitk_libdir msgs]
11675 ## Internationalization (i18n) through msgcat and gettext. See
11676 ## http://www.gnu.org/software/gettext/manual/html_node/Tcl.html
11677 package require msgcat
11678 namespace import ::msgcat::mc
11679 ## And eventually load the actual message catalog
11680 ::msgcat::mcload $gitk_msgsdir
11682 catch {source ~/.gitk}
11684 parsefont mainfont $mainfont
11685 eval font create mainfont [fontflags mainfont]
11686 eval font create mainfontbold [fontflags mainfont 1]
11688 parsefont textfont $textfont
11689 eval font create textfont [fontflags textfont]
11690 eval font create textfontbold [fontflags textfont 1]
11692 parsefont uifont $uifont
11693 eval font create uifont [fontflags uifont]
11695 setui $uicolor
11697 setoptions
11699 # check that we can find a .git directory somewhere...
11700 if {[catch {set gitdir [exec git rev-parse --git-dir]}]} {
11701 show_error {} . [mc "Cannot find a git repository here."]
11702 exit 1
11705 set selecthead {}
11706 set selectheadid {}
11708 set revtreeargs {}
11709 set cmdline_files {}
11710 set i 0
11711 set revtreeargscmd {}
11712 foreach arg $argv {
11713 switch -glob -- $arg {
11714 "" { }
11715 "--" {
11716 set cmdline_files [lrange $argv [expr {$i + 1}] end]
11717 break
11719 "--select-commit=*" {
11720 set selecthead [string range $arg 16 end]
11722 "--argscmd=*" {
11723 set revtreeargscmd [string range $arg 10 end]
11725 default {
11726 lappend revtreeargs $arg
11729 incr i
11732 if {$selecthead eq "HEAD"} {
11733 set selecthead {}
11736 if {$i >= [llength $argv] && $revtreeargs ne {}} {
11737 # no -- on command line, but some arguments (other than --argscmd)
11738 if {[catch {
11739 set f [eval exec git rev-parse --no-revs --no-flags $revtreeargs]
11740 set cmdline_files [split $f "\n"]
11741 set n [llength $cmdline_files]
11742 set revtreeargs [lrange $revtreeargs 0 end-$n]
11743 # Unfortunately git rev-parse doesn't produce an error when
11744 # something is both a revision and a filename. To be consistent
11745 # with git log and git rev-list, check revtreeargs for filenames.
11746 foreach arg $revtreeargs {
11747 if {[file exists $arg]} {
11748 show_error {} . [mc "Ambiguous argument '%s': both revision\
11749 and filename" $arg]
11750 exit 1
11753 } err]} {
11754 # unfortunately we get both stdout and stderr in $err,
11755 # so look for "fatal:".
11756 set i [string first "fatal:" $err]
11757 if {$i > 0} {
11758 set err [string range $err [expr {$i + 6}] end]
11760 show_error {} . "[mc "Bad arguments to gitk:"]\n$err"
11761 exit 1
11765 set nullid "0000000000000000000000000000000000000000"
11766 set nullid2 "0000000000000000000000000000000000000001"
11767 set nullfile "/dev/null"
11769 set have_tk85 [expr {[package vcompare $tk_version "8.5"] >= 0}]
11770 if {![info exists have_ttk]} {
11771 set have_ttk [llength [info commands ::ttk::style]]
11773 set use_ttk [expr {$have_ttk && $want_ttk}]
11774 set NS [expr {$use_ttk ? "ttk" : ""}]
11776 regexp {^git version ([\d.]*\d)} [exec git version] _ git_version
11778 set show_notes {}
11779 if {[package vcompare $git_version "1.6.6.2"] >= 0} {
11780 set show_notes "--show-notes"
11783 set appname "gitk"
11785 set runq {}
11786 set history {}
11787 set historyindex 0
11788 set fh_serial 0
11789 set nhl_names {}
11790 set highlight_paths {}
11791 set findpattern {}
11792 set searchdirn -forwards
11793 set boldids {}
11794 set boldnameids {}
11795 set diffelide {0 0}
11796 set markingmatches 0
11797 set linkentercount 0
11798 set need_redisplay 0
11799 set nrows_drawn 0
11800 set firsttabstop 0
11802 set nextviewnum 1
11803 set curview 0
11804 set selectedview 0
11805 set selectedhlview [mc "None"]
11806 set highlight_related [mc "None"]
11807 set highlight_files {}
11808 set viewfiles(0) {}
11809 set viewperm(0) 0
11810 set viewargs(0) {}
11811 set viewargscmd(0) {}
11813 set selectedline {}
11814 set numcommits 0
11815 set loginstance 0
11816 set cmdlineok 0
11817 set stopped 0
11818 set stuffsaved 0
11819 set patchnum 0
11820 set lserial 0
11821 set hasworktree [hasworktree]
11822 set cdup {}
11823 if {[expr {[exec git rev-parse --is-inside-work-tree] == "true"}]} {
11824 set cdup [exec git rev-parse --show-cdup]
11826 set worktree [exec git rev-parse --show-toplevel]
11827 setcoords
11828 makewindow
11829 if {$::tcl_platform(platform) eq {windows} && [file exists $gitk_prefix/etc/git.ico]} {
11830 wm iconbitmap . -default $gitk_prefix/etc/git.ico
11831 } else {
11832 catch {
11833 image create photo gitlogo -width 16 -height 16
11835 image create photo gitlogominus -width 4 -height 2
11836 gitlogominus put #C00000 -to 0 0 4 2
11837 gitlogo copy gitlogominus -to 1 5
11838 gitlogo copy gitlogominus -to 6 5
11839 gitlogo copy gitlogominus -to 11 5
11840 image delete gitlogominus
11842 image create photo gitlogoplus -width 4 -height 4
11843 gitlogoplus put #008000 -to 1 0 3 4
11844 gitlogoplus put #008000 -to 0 1 4 3
11845 gitlogo copy gitlogoplus -to 1 9
11846 gitlogo copy gitlogoplus -to 6 9
11847 gitlogo copy gitlogoplus -to 11 9
11848 image delete gitlogoplus
11850 image create photo gitlogo32 -width 32 -height 32
11851 gitlogo32 copy gitlogo -zoom 2 2
11853 wm iconphoto . -default gitlogo gitlogo32
11856 # wait for the window to become visible
11857 tkwait visibility .
11858 wm title . "$appname: [reponame]"
11859 update
11860 readrefs
11862 if {$cmdline_files ne {} || $revtreeargs ne {} || $revtreeargscmd ne {}} {
11863 # create a view for the files/dirs specified on the command line
11864 set curview 1
11865 set selectedview 1
11866 set nextviewnum 2
11867 set viewname(1) [mc "Command line"]
11868 set viewfiles(1) $cmdline_files
11869 set viewargs(1) $revtreeargs
11870 set viewargscmd(1) $revtreeargscmd
11871 set viewperm(1) 0
11872 set vdatemode(1) 0
11873 addviewmenu 1
11874 .bar.view entryconf [mca "Edit view..."] -state normal
11875 .bar.view entryconf [mca "Delete view"] -state normal
11878 if {[info exists permviews]} {
11879 foreach v $permviews {
11880 set n $nextviewnum
11881 incr nextviewnum
11882 set viewname($n) [lindex $v 0]
11883 set viewfiles($n) [lindex $v 1]
11884 set viewargs($n) [lindex $v 2]
11885 set viewargscmd($n) [lindex $v 3]
11886 set viewperm($n) 1
11887 addviewmenu $n
11891 if {[tk windowingsystem] eq "win32"} {
11892 focus -force .
11895 getcommits {}
11897 # Local variables:
11898 # mode: tcl
11899 # indent-tabs-mode: t
11900 # tab-width: 8
11901 # End: