kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1802 Commits
6 Branches
36 Tags
131 MiB
Tree: 34143b2639
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '34143b2639'
${ noResults }
git/gitk

3690 lines
96 KiB
Raw Normal View History Unescape

Add initial version of gitk to the CVS repository
20 years ago
#!/bin/sh
# Tcl ignores the next line -*- tcl -*- \
exec wish "$0" -- "${1+$@}"
# Copyright (C) 2005 Paul Mackerras. All rights reserved.
# This program is free software; it may be used, copied, modified
# and distributed under the terms of the GNU General Public Licence,
# either version 2, or (at your option) any later version.
[PATCH] gitk: Use GIT_DIR where appropriate. Some places assumed .git is the GIT_DIR, resulting heads and tags not showing when it was run like "GIT_DIR=. gitk --all". This is not a contrived example --- I rely on it to verify my private copy of git.git repository before pushing it out. Define a single procedure "gitdir" and use it. Signed-off-by: Junio C Hamano <junkio@cox.net> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
proc gitdir {} {
global env
if {[info exists env(GIT_DIR)]} {
return $env(GIT_DIR)
} else {
return ".git"
}
}
Add initial version of gitk to the CVS repository
20 years ago
proc getcommits {rargs} {
Check for the existence of the git directory on startup. Check that $GIT_DIR (or .git, if GIT_DIR is not set) is a directory. This means we can give a more informative error message if the user runs gitk somewhere that isn't a git repository.
20 years ago
global commits commfd phase canv mainfont env
Only do an update every 100 commits when drawing the graph. On a large repository with > 60,000 commits, each call to the Tk update primitive (which gives Tk a chance to respond to events and redraw the screen) was taking up to 0.2 seconds. Because the logic was to call update after drawing a commit if 0.1 seconds had passed since the last update call, we were calling it for every commit, which was slowing us down enormously. Now we also require that we have drawn 100 commits since the last update (as well as it being at least 0.1 seconds since the last update). Drawing 100 commits takes around 0.1 - 0.2 seconds (even in this large repo) on my G5.
20 years ago
global startmsecs nextupdate ncmupdate
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
global ctext maincursor textcursor leftover
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
Check for the existence of the git directory on startup. Check that $GIT_DIR (or .git, if GIT_DIR is not set) is a directory. This means we can give a more informative error message if the user runs gitk somewhere that isn't a git repository.
20 years ago
# check that we can find a .git directory somewhere...
[PATCH] gitk: Use GIT_DIR where appropriate. Some places assumed .git is the GIT_DIR, resulting heads and tags not showing when it was run like "GIT_DIR=. gitk --all". This is not a contrived example --- I rely on it to verify my private copy of git.git repository before pushing it out. Define a single procedure "gitdir" and use it. Signed-off-by: Junio C Hamano <junkio@cox.net> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
set gitdir [gitdir]
Check for the existence of the git directory on startup. Check that $GIT_DIR (or .git, if GIT_DIR is not set) is a directory. This means we can give a more informative error message if the user runs gitk somewhere that isn't a git repository.
20 years ago
if {![file isdirectory $gitdir]} {
error_popup "Cannot find the git directory \"$gitdir\"."
exit 1
}
Add initial version of gitk to the CVS repository
20 years ago
set commits {}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set phase getcommits
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set startmsecs [clock clicks -milliseconds]
set nextupdate [expr $startmsecs + 100]
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
set ncmupdate 1
Pass arguments through git-rev-parse. This allows the user to specify ranges more flexibly; for instance the user can now do "gitk v2.6.12.." and see all the changes since 2.6.12.
20 years ago
if [catch {
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set parse_args [concat --default HEAD $rargs]
Pass arguments through git-rev-parse. This allows the user to specify ranges more flexibly; for instance the user can now do "gitk v2.6.12.." and see all the changes since 2.6.12.
20 years ago
set parsed_args [split [eval exec git-rev-parse $parse_args] "\n"]
}] {
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
# if git-rev-parse failed for some reason...
Pass arguments through git-rev-parse. This allows the user to specify ranges more flexibly; for instance the user can now do "gitk v2.6.12.." and see all the changes since 2.6.12.
20 years ago
if {$rargs == {}} {
set rargs HEAD
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set parsed_args $rargs
Pass arguments through git-rev-parse. This allows the user to specify ranges more flexibly; for instance the user can now do "gitk v2.6.12.." and see all the changes since 2.6.12.
20 years ago
}
if [catch {
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
set commfd [open "|git-rev-list --header --topo-order --parents $parsed_args" r]
Pass arguments through git-rev-parse. This allows the user to specify ranges more flexibly; for instance the user can now do "gitk v2.6.12.." and see all the changes since 2.6.12.
20 years ago
} err] {
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
puts stderr "Error executing git-rev-list: $err"
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
exit 1
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set leftover {}
Use lf translation rather than binary when reading commit data. The effect of this is that it allows Tcl to do the locale-specific conversion of the input data to its internal unicode representation. That means that commit messages in Russian or other languages should be displayed correctly now (according to the locale that is in effect.)
20 years ago
fconfigure $commfd -blocking 0 -translation lf
Only do an update every 100 commits when drawing the graph. On a large repository with > 60,000 commits, each call to the Tk update primitive (which gives Tk a chance to respond to events and redraw the screen) was taking up to 0.2 seconds. Because the logic was to call update after drawing a commit if 0.1 seconds had passed since the last update call, we were calling it for every commit, which was slowing us down enormously. Now we also require that we have drawn 100 commits since the last update (as well as it being at least 0.1 seconds since the last update). Drawing 100 commits takes around 0.1 - 0.2 seconds (even in this large repo) on my G5.
20 years ago
fileevent $commfd readable [list getcommitlines $commfd]
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
$canv delete all
$canv create text 3 3 -anchor nw -text "Reading commits..." \
-font $mainfont -tags textitems
Fix operation without libreadobj.so.0.0 Display a watch cursor when reading the commits initially
20 years ago
. config -cursor watch
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
settextcursor watch
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
proc getcommitlines {commfd} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global commits parents cdate children
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global commitlisted phase commitinfo nextupdate
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
global stopped redisplaying leftover
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set stuff [read $commfd]
if {$stuff == {}} {
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
if {![eof $commfd]} return
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
# set it blocking so we wait for the process to terminate
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
fconfigure $commfd -blocking 1
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
if {![catch {close $commfd} err]} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
after idle finishcommits
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
return
}
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
if {[string range $err 0 4] == "usage"} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set err \
{Gitk: error reading commits: bad arguments to git-rev-list.
(Note: arguments to gitk are passed to git-rev-list
to allow selection of commits to be displayed.)}
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
} else {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set err "Error reading commits: $err"
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
error_popup $err
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
exit 1
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set start 0
while 1 {
set i [string first "\0" $stuff $start]
if {$i < 0} {
Fix a bug where we would corrupt the stuff read from git-rev-list. If we have a very long commit message, and we end up getting a bufferfull of data from git-rev-list that all belongs to one commit, we ended up throwing away the data from a previous read that should have been included. The result was a error message about not being able to parse the output of git-rev-list. Also, if the git-rev-list output that we can't parse is long, only put the first 80 chars in the error message. Otherwise we end up with an enormous error window.
20 years ago
append leftover [string range $stuff $start end]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
return
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set cmit [string range $stuff $start [expr {$i - 1}]]
if {$start == 0} {
set cmit "$leftover$cmit"
Fix a bug where we would corrupt the stuff read from git-rev-list. If we have a very long commit message, and we end up getting a bufferfull of data from git-rev-list that all belongs to one commit, we ended up throwing away the data from a previous read that should have been included. The result was a error message about not being able to parse the output of git-rev-list. Also, if the git-rev-list output that we can't parse is long, only put the first 80 chars in the error message. Otherwise we end up with an enormous error window.
20 years ago
set leftover {}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
}
set start [expr {$i + 1}]
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
set j [string first "\n" $cmit]
set ok 0
if {$j >= 0} {
set ids [string range $cmit 0 [expr {$j - 1}]]
set ok 1
foreach id $ids {
if {![regexp {^[0-9a-f]{40}$} $id]} {
set ok 0
break
}
}
}
if {!$ok} {
Fix a bug where we would corrupt the stuff read from git-rev-list. If we have a very long commit message, and we end up getting a bufferfull of data from git-rev-list that all belongs to one commit, we ended up throwing away the data from a previous read that should have been included. The result was a error message about not being able to parse the output of git-rev-list. Also, if the git-rev-list output that we can't parse is long, only put the first 80 chars in the error message. Otherwise we end up with an enormous error window.
20 years ago
set shortcmit $cmit
if {[string length $shortcmit] > 80} {
set shortcmit "[string range $shortcmit 0 80]..."
}
error_popup "Can't parse git-rev-list output: {$shortcmit}"
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
exit 1
}
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
set id [lindex $ids 0]
set olds [lrange $ids 1 end]
set cmit [string range $cmit [expr {$j + 1}] end]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
lappend commits $id
set commitlisted($id) 1
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
parsecommit $id $cmit 1 [lrange $ids 1 end]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
drawcommit $id
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
if {[clock clicks -milliseconds] >= $nextupdate} {
doupdate 1
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
}
while {$redisplaying} {
set redisplaying 0
if {$stopped == 1} {
set stopped 0
set phase "getcommits"
foreach id $commits {
drawcommit $id
if {$stopped} break
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
if {[clock clicks -milliseconds] >= $nextupdate} {
doupdate 1
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
}
}
}
}
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
proc doupdate {reading} {
global commfd nextupdate numcommits ncmupdate
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
if {$reading} {
fileevent $commfd readable {}
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
update
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
set nextupdate [expr {[clock clicks -milliseconds] + 100}]
if {$numcommits < 100} {
set ncmupdate [expr {$numcommits + 1}]
} elseif {$numcommits < 10000} {
set ncmupdate [expr {$numcommits + 10}]
} else {
set ncmupdate [expr {$numcommits + 100}]
}
if {$reading} {
fileevent $commfd readable [list getcommitlines $commfd]
}
Add initial version of gitk to the CVS repository
20 years ago
}
proc readcommit {id} {
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
if [catch {set contents [exec git-cat-file commit $id]}] return
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
parsecommit $id $contents 0 {}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
}
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
proc parsecommit {id contents listed olds} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global commitinfo children nchildren parents nparents cdate ncleft
Add initial version of gitk to the CVS repository
20 years ago
set inhdr 1
set comment {}
set headline {}
set auname {}
set audate {}
set comname {}
set comdate {}
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
if {![info exists nchildren($id)]} {
set children($id) {}
set nchildren($id) 0
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set ncleft($id) 0
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
}
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
set parents($id) $olds
set nparents($id) [llength $olds]
foreach p $olds {
if {![info exists nchildren($p)]} {
set children($p) [list $id]
set nchildren($p) 1
set ncleft($p) 1
} elseif {[lsearch -exact $children($p) $id] < 0} {
lappend children($p) $id
incr nchildren($p)
incr ncleft($p)
Add graft support. We read .git/info/grafts and use the information in there to override the list of parents we get from git-rev-list or git-cat-file.
20 years ago
}
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
foreach line [split $contents "\n"] {
Add initial version of gitk to the CVS repository
20 years ago
if {$inhdr} {
if {$line == {}} {
set inhdr 0
} else {
set tag [lindex $line 0]
Use the --parents flag to git-rev-list. With --parents, git-rev-list gives us the list of parents on the first line of each commit. We use that rather than looking for the parent: lines in the commit body, since this way we get to know about the grafts for free.
20 years ago
if {$tag == "author"} {
Add initial version of gitk to the CVS repository
20 years ago
set x [expr {[llength $line] - 2}]
set audate [lindex $line $x]
set auname [lrange $line 1 [expr {$x - 1}]]
} elseif {$tag == "committer"} {
set x [expr {[llength $line] - 2}]
set comdate [lindex $line $x]
set comname [lrange $line 1 [expr {$x - 1}]]
}
}
} else {
if {$comment == {}} {
Account for indentation of the checkin comments by git-rev-list This involves adding indentation when we read a commit with git-cat-file and trimming the whitespace from the headline.
20 years ago
set headline [string trim $line]
Add initial version of gitk to the CVS repository
20 years ago
} else {
append comment "\n"
}
Account for indentation of the checkin comments by git-rev-list This involves adding indentation when we read a commit with git-cat-file and trimming the whitespace from the headline.
20 years ago
if {!$listed} {
# git-rev-list indents the comment by 4 spaces;
# if we got this via git-cat-file, add the indentation
append comment " "
}
Add initial version of gitk to the CVS repository
20 years ago
append comment $line
}
}
if {$audate != {}} {
set audate [clock format $audate -format "%Y-%m-%d %H:%M:%S"]
}
if {$comdate != {}} {
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
set cdate($id) $comdate
Add initial version of gitk to the CVS repository
20 years ago
set comdate [clock format $comdate -format "%Y-%m-%d %H:%M:%S"]
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
set commitinfo($id) [list $headline $auname $audate \
$comname $comdate $comment]
Add initial version of gitk to the CVS repository
20 years ago
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
proc readrefs {} {
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
global tagids idtags headids idheads tagcontents
[PATCH] gitk: Use GIT_DIR where appropriate. Some places assumed .git is the GIT_DIR, resulting heads and tags not showing when it was run like "GIT_DIR=. gitk --all". This is not a contrived example --- I rely on it to verify my private copy of git.git repository before pushing it out. Define a single procedure "gitdir" and use it. Signed-off-by: Junio C Hamano <junkio@cox.net> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
set tags [glob -nocomplain -types f [gitdir]/refs/tags/*]
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
foreach f $tags {
catch {
set fd [open $f r]
set line [read $fd]
if {[regexp {^[0-9a-f]{40}} $line id]} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set direct [file tail $f]
set tagids($direct) $id
lappend idtags($id) $direct
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
set tagblob [exec git-cat-file tag $id]
set contents [split $tagblob "\n"]
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
set obj {}
set type {}
set tag {}
foreach l $contents {
if {$l == {}} break
switch -- [lindex $l 0] {
"object" {set obj [lindex $l 1]}
"type" {set type [lindex $l 1]}
"tag" {set tag [string range $l 4 end]}
}
}
if {$obj != {} && $type == "commit" && $tag != {}} {
set tagids($tag) $obj
lappend idtags($obj) $tag
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
set tagcontents($tag) $tagblob
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
}
}
Show heads as well as tags
20 years ago
close $fd
}
}
[PATCH] gitk: Use GIT_DIR where appropriate. Some places assumed .git is the GIT_DIR, resulting heads and tags not showing when it was run like "GIT_DIR=. gitk --all". This is not a contrived example --- I rely on it to verify my private copy of git.git repository before pushing it out. Define a single procedure "gitdir" and use it. Signed-off-by: Junio C Hamano <junkio@cox.net> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
set heads [glob -nocomplain -types f [gitdir]/refs/heads/*]
Show heads as well as tags
20 years ago
foreach f $heads {
catch {
set fd [open $f r]
set line [read $fd 40]
if {[regexp {^[0-9a-f]{40}} $line id]} {
set head [file tail $f]
set headids($head) $line
lappend idheads($line) $head
}
close $fd
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
}
}
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
readotherrefs refs {} {tags heads}
}
proc readotherrefs {base dname excl} {
global otherrefids idotherrefs
set git [gitdir]
set files [glob -nocomplain -types f [file join $git $base *]]
foreach f $files {
catch {
set fd [open $f r]
set line [read $fd 40]
if {[regexp {^[0-9a-f]{40}} $line id]} {
set name "$dname[file tail $f]"
set otherrefids($name) $id
lappend idotherrefs($id) $name
}
close $fd
}
}
set dirs [glob -nocomplain -types d [file join $git $base *]]
foreach d $dirs {
set dir [file tail $d]
if {[lsearch -exact $excl $dir] >= 0} continue
readotherrefs [file join $base $dir] "$dname$dir/" {}
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
proc error_popup msg {
set w .error
toplevel $w
wm transient $w .
message $w.m -text $msg -justify center -aspect 400
pack $w.m -side top -fill x -padx 20 -pady 20
button $w.ok -text OK -command "destroy $w"
pack $w.ok -side bottom -fill x
bind $w <Visibility> "grab $w; focus $w"
tkwait window $w
}
Add initial version of gitk to the CVS repository
20 years ago
proc makewindow {} {
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
global canv canv2 canv3 linespc charspc ctext cflist textfont
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
global findtype findtypemenu findloc findstring fstring geometry
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
global entries sha1entry sha1string sha1but
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
global maincursor textcursor curtextcursor
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
global rowctxmenu gaudydiff mergemax
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
menu .bar
.bar add cascade -label "File" -menu .bar.file
menu .bar.file
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
.bar.file add command -label "Reread references" -command rereadrefs
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
.bar.file add command -label "Quit" -command doquit
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
menu .bar.help
.bar add cascade -label "Help" -menu .bar.help
.bar.help add command -label "About gitk" -command about
. configure -menu .bar
save window geometry on exit, and restore it on startup
20 years ago
if {![info exists geometry(canv1)]} {
set geometry(canv1) [expr 45 * $charspc]
set geometry(canv2) [expr 30 * $charspc]
set geometry(canv3) [expr 15 * $charspc]
set geometry(canvh) [expr 25 * $linespc + 4]
set geometry(ctextw) 80
set geometry(ctexth) 30
set geometry(cflistw) 30
}
Use a panedwindow Make it cope with commits having parents that aren't listed.
20 years ago
panedwindow .ctop -orient vertical
save window geometry on exit, and restore it on startup
20 years ago
if {[info exists geometry(width)]} {
.ctop conf -width $geometry(width) -height $geometry(height)
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
set texth [expr {$geometry(height) - $geometry(canvh) - 56}]
set geometry(ctexth) [expr {($texth - 8) /
[font metrics $textfont -linespace]}]
save window geometry on exit, and restore it on startup
20 years ago
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
frame .ctop.top
frame .ctop.top.bar
pack .ctop.top.bar -side bottom -fill x
set cscroll .ctop.top.csb
scrollbar $cscroll -command {allcanvs yview} -highlightthickness 0
pack $cscroll -side right -fill y
panedwindow .ctop.top.clist -orient horizontal -sashpad 0 -handlesize 4
pack .ctop.top.clist -side top -fill both -expand 1
.ctop add .ctop.top
set canv .ctop.top.clist.canv
save window geometry on exit, and restore it on startup
20 years ago
canvas $canv -height $geometry(canvh) -width $geometry(canv1) \
source ~/.gitk for user-specific option settings use a panedwindow for the main list with three panes, and make them scroll together
20 years ago
-bg white -bd 0 \
-yscrollincr $linespc -yscrollcommand "$cscroll set"
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
.ctop.top.clist add $canv
set canv2 .ctop.top.clist.canv2
save window geometry on exit, and restore it on startup
20 years ago
canvas $canv2 -height $geometry(canvh) -width $geometry(canv2) \
source ~/.gitk for user-specific option settings use a panedwindow for the main list with three panes, and make them scroll together
20 years ago
-bg white -bd 0 -yscrollincr $linespc
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
.ctop.top.clist add $canv2
set canv3 .ctop.top.clist.canv3
save window geometry on exit, and restore it on startup
20 years ago
canvas $canv3 -height $geometry(canvh) -width $geometry(canv3) \
source ~/.gitk for user-specific option settings use a panedwindow for the main list with three panes, and make them scroll together
20 years ago
-bg white -bd 0 -yscrollincr $linespc
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
.ctop.top.clist add $canv3
Resize the panes in the paned windows (commit list and details) to keep the proportionality of the pane widths as the overall window is resized.
20 years ago
bind .ctop.top.clist <Configure> {resizeclistpanes %W %w}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
set sha1entry .ctop.top.bar.sha1
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
set entries $sha1entry
set sha1but .ctop.top.bar.sha1label
button $sha1but -text "SHA1 ID: " -state disabled -relief flat \
-command gotocommit -width 8
$sha1but conf -disabledforeground [$sha1but cget -foreground]
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
pack .ctop.top.bar.sha1label -side left
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
entry $sha1entry -width 40 -font $textfont -textvariable sha1string
trace add variable sha1string write sha1change
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
pack $sha1entry -side left -pady 2
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
image create bitmap bm-left -data {
#define left_width 16
#define left_height 16
static unsigned char left_bits[] = {
0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
}
image create bitmap bm-right -data {
#define right_width 16
#define right_height 16
static unsigned char right_bits[] = {
0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
}
button .ctop.top.bar.leftbut -image bm-left -command goback \
-state disabled -width 26
pack .ctop.top.bar.leftbut -side left -fill y
button .ctop.top.bar.rightbut -image bm-right -command goforw \
-state disabled -width 26
pack .ctop.top.bar.rightbut -side left -fill y
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
button .ctop.top.bar.findbut -text "Find" -command dofind
pack .ctop.top.bar.findbut -side left
set findstring {}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set fstring .ctop.top.bar.findstring
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
lappend entries $fstring
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
entry $fstring -width 30 -font $textfont -textvariable findstring
pack $fstring -side left -expand 1 -fill x
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
set findtype Exact
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set findtypemenu [tk_optionMenu .ctop.top.bar.findtype \
findtype Exact IgnCase Regexp]
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
set findloc "All fields"
tk_optionMenu .ctop.top.bar.findloc findloc "All fields" Headline \
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
Comments Author Committer Files Pickaxe
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
pack .ctop.top.bar.findloc -side right
pack .ctop.top.bar.findtype -side right
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
# for making sure type==Exact whenever loc==Pickaxe
trace add variable findloc write findlocchange
source ~/.gitk for user-specific option settings use a panedwindow for the main list with three panes, and make them scroll together
20 years ago
Display the list of changed files in a listbox pane.
20 years ago
panedwindow .ctop.cdet -orient horizontal
.ctop add .ctop.cdet
Make getting file lists asynchronous Add some scrollbars
20 years ago
frame .ctop.cdet.left
set ctext .ctop.cdet.left.ctext
save window geometry on exit, and restore it on startup
20 years ago
text $ctext -bg white -state disabled -font $textfont \
-width $geometry(ctextw) -height $geometry(ctexth) \
[PATCH] "Child" information in commit window - and cleanups This adds "Child: " lines to the commit window, which tells what children a commit has. It also cleans things up: it marks the text widget as no-wrap, which means that it doesn't need to truncate the commit description arbitrarily by hand. Also, the description itself is now done by a common helper routine that handles both the parent and the children. Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
-yscrollcommand ".ctop.cdet.left.sb set" -wrap none
Make getting file lists asynchronous Add some scrollbars
20 years ago
scrollbar .ctop.cdet.left.sb -command "$ctext yview"
pack .ctop.cdet.left.sb -side right -fill y
pack $ctext -side left -fill both -expand 1
.ctop.cdet add .ctop.cdet.left
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
$ctext tag conf filesep -font [concat $textfont bold] -back "#aaaaaa"
if {$gaudydiff} {
$ctext tag conf hunksep -back blue -fore white
$ctext tag conf d0 -back "#ff8080"
$ctext tag conf d1 -back green
} else {
$ctext tag conf hunksep -fore blue
$ctext tag conf d0 -fore red
$ctext tag conf d1 -fore "#00a000"
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
$ctext tag conf m0 -fore red
$ctext tag conf m1 -fore blue
$ctext tag conf m2 -fore green
$ctext tag conf m3 -fore purple
$ctext tag conf m4 -fore brown
$ctext tag conf mmax -fore darkgrey
set mergemax 5
$ctext tag conf mresult -font [concat $textfont bold]
$ctext tag conf msep -font [concat $textfont bold]
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
$ctext tag conf found -back yellow
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
Make getting file lists asynchronous Add some scrollbars
20 years ago
frame .ctop.cdet.right
set cflist .ctop.cdet.right.cfiles
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
listbox $cflist -bg white -selectmode extended -width $geometry(cflistw) \
Make getting file lists asynchronous Add some scrollbars
20 years ago
-yscrollcommand ".ctop.cdet.right.sb set"
scrollbar .ctop.cdet.right.sb -command "$cflist yview"
pack .ctop.cdet.right.sb -side right -fill y
pack $cflist -side left -fill both -expand 1
.ctop.cdet add .ctop.cdet.right
save window geometry on exit, and restore it on startup
20 years ago
bind .ctop.cdet <Configure> {resizecdetpanes %W %w}
Make getting file lists asynchronous Add some scrollbars
20 years ago
Use a panedwindow Make it cope with commits having parents that aren't listed.
20 years ago
pack .ctop -side top -fill both -expand 1
Add initial version of gitk to the CVS repository
20 years ago
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
bindall <1> {selcanvline %W %x %y}
#bindall <B1-Motion> {selcanvline %W %x %y}
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
bindall <ButtonRelease-4> "allcanvs yview scroll -5 units"
bindall <ButtonRelease-5> "allcanvs yview scroll 5 units"
source ~/.gitk for user-specific option settings use a panedwindow for the main list with three panes, and make them scroll together
20 years ago
bindall <2> "allcanvs scan mark 0 %y"
bindall <B2-Motion> "allcanvs scan dragto 0 %y"
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
bind . <Key-Up> "selnextline -1"
bind . <Key-Down> "selnextline 1"
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
bind . <Key-Prior> "allcanvs yview scroll -1 pages"
bind . <Key-Next> "allcanvs yview scroll 1 pages"
bindkey <Key-Delete> "$ctext yview scroll -1 pages"
bindkey <Key-BackSpace> "$ctext yview scroll -1 pages"
bindkey <Key-space> "$ctext yview scroll 1 pages"
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
bindkey p "selnextline -1"
bindkey n "selnextline 1"
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
bindkey b "$ctext yview scroll -1 pages"
bindkey d "$ctext yview scroll 18 units"
bindkey u "$ctext yview scroll -18 units"
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
bindkey / {findnext 1}
bindkey <Key-Return> {findnext 0}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
bindkey ? findprev
Accommodate new git-diff-tree output format Add 'f' key for moving to next file
20 years ago
bindkey f nextfile
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
bind . <Control-q> doquit
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
bind . <Control-f> dofind
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
bind . <Control-g> {findnext 0}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
bind . <Control-r> findprev
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
bind . <Control-equal> {incrfont 1}
bind . <Control-KP_Add> {incrfont 1}
bind . <Control-minus> {incrfont -1}
bind . <Control-KP_Subtract> {incrfont -1}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
bind $cflist <<ListboxSelect>> listboxsel
save window geometry on exit, and restore it on startup
20 years ago
bind . <Destroy> {savestuff %W}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
bind . <Button-1> "click %W"
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
bind $fstring <Key-Return> dofind
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
bind $sha1entry <Key-Return> gotocommit
Clear the SHA1 entry field when we go to paste something into it If the user pastes in the selection (with the middle mouse button) and it already has 40 characters in it, clear it before pasting.
20 years ago
bind $sha1entry <<PasteSelection>> clearsha1
Fix operation without libreadobj.so.0.0 Display a watch cursor when reading the commits initially
20 years ago
set maincursor [. cget -cursor]
set textcursor [$ctext cget -cursor]
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
set curtextcursor $textcursor
Draw graph lines as one continuous line where possible Added context menu on lines Added headline display when the mouse hovers over a line Removed some debug messages
20 years ago
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set rowctxmenu .rowctxmenu
menu $rowctxmenu -tearoff 0
$rowctxmenu add command -label "Diff this -> selected" \
-command {diffvssel 0}
$rowctxmenu add command -label "Diff selected -> this" \
-command {diffvssel 1}
Add a menu entry for generating a patch between any two commits.
20 years ago
$rowctxmenu add command -label "Make patch" -command mkpatch
Add a menu item for creating tags.
20 years ago
$rowctxmenu add command -label "Create tag" -command mktag
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
$rowctxmenu add command -label "Write commit to file" -command writecommit
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
}
# when we make a key binding for the toplevel, make sure
# it doesn't get triggered when that key is pressed in the
# find string entry widget.
proc bindkey {ev script} {
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
global entries
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
bind . $ev $script
set escript [bind Entry $ev]
if {$escript == {}} {
set escript [bind Entry <Key>]
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
foreach e $entries {
bind $e $ev "$escript; break"
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
}
# set the focus back to the toplevel for any click outside
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
# the entry widgets
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
proc click {w} {
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
global entries
foreach e $entries {
if {$w == $e} return
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
focus .
save window geometry on exit, and restore it on startup
20 years ago
}
proc savestuff {w} {
global canv canv2 canv3 ctext cflist mainfont textfont
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
global stuffsaved findmergefiles gaudydiff maxgraphpct
Save the maxwidth setting in the ~/.gitk file.
20 years ago
global maxwidth
Import the --topo-order change and fix the writing of ~/.gitk.
20 years ago
save window geometry on exit, and restore it on startup
20 years ago
if {$stuffsaved} return
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
if {![winfo viewable .]} return
save window geometry on exit, and restore it on startup
20 years ago
catch {
set f [open "~/.gitk-new" w]
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
puts $f [list set mainfont $mainfont]
puts $f [list set textfont $textfont]
puts $f [list set findmergefiles $findmergefiles]
puts $f [list set gaudydiff $gaudydiff]
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
puts $f [list set maxgraphpct $maxgraphpct]
Save the maxwidth setting in the ~/.gitk file.
20 years ago
puts $f [list set maxwidth $maxwidth]
save window geometry on exit, and restore it on startup
20 years ago
puts $f "set geometry(width) [winfo width .ctop]"
puts $f "set geometry(height) [winfo height .ctop]"
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
puts $f "set geometry(canv1) [expr [winfo width $canv]-2]"
puts $f "set geometry(canv2) [expr [winfo width $canv2]-2]"
puts $f "set geometry(canv3) [expr [winfo width $canv3]-2]"
puts $f "set geometry(canvh) [expr [winfo height $canv]-2]"
save window geometry on exit, and restore it on startup
20 years ago
set wid [expr {([winfo width $ctext] - 8) \
/ [font measure $textfont "0"]}]
puts $f "set geometry(ctextw) $wid"
set wid [expr {([winfo width $cflist] - 11) \
/ [font measure [$cflist cget -font] "0"]}]
puts $f "set geometry(cflistw) $wid"
close $f
file rename -force "~/.gitk-new" "~/.gitk"
}
set stuffsaved 1
Add initial version of gitk to the CVS repository
20 years ago
}
Resize the panes in the paned windows (commit list and details) to keep the proportionality of the pane widths as the overall window is resized.
20 years ago
proc resizeclistpanes {win w} {
global oldwidth
if [info exists oldwidth($win)] {
set s0 [$win sash coord 0]
set s1 [$win sash coord 1]
if {$w < 60} {
set sash0 [expr {int($w/2 - 2)}]
set sash1 [expr {int($w*5/6 - 2)}]
} else {
set factor [expr {1.0 * $w / $oldwidth($win)}]
set sash0 [expr {int($factor * [lindex $s0 0])}]
set sash1 [expr {int($factor * [lindex $s1 0])}]
if {$sash0 < 30} {
set sash0 30
}
if {$sash1 < $sash0 + 20} {
set sash1 [expr $sash0 + 20]
}
if {$sash1 > $w - 10} {
set sash1 [expr $w - 10]
if {$sash0 > $sash1 - 20} {
set sash0 [expr $sash1 - 20]
}
}
}
$win sash place 0 $sash0 [lindex $s0 1]
$win sash place 1 $sash1 [lindex $s1 1]
}
set oldwidth($win) $w
}
proc resizecdetpanes {win w} {
global oldwidth
if [info exists oldwidth($win)] {
set s0 [$win sash coord 0]
if {$w < 60} {
set sash0 [expr {int($w*3/4 - 2)}]
} else {
set factor [expr {1.0 * $w / $oldwidth($win)}]
set sash0 [expr {int($factor * [lindex $s0 0])}]
if {$sash0 < 45} {
set sash0 45
}
if {$sash0 > $w - 15} {
set sash0 [expr $w - 15]
}
}
$win sash place 0 $sash0 [lindex $s0 1]
}
set oldwidth($win) $w
}
source ~/.gitk for user-specific option settings use a panedwindow for the main list with three panes, and make them scroll together
20 years ago
proc allcanvs args {
global canv canv2 canv3
eval $canv $args
eval $canv2 $args
eval $canv3 $args
}
proc bindall {event action} {
global canv canv2 canv3
bind $canv $event $action
bind $canv2 $event $action
bind $canv3 $event $action
}
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
proc about {} {
set w .about
if {[winfo exists $w]} {
raise $w
return
}
toplevel $w
wm title $w "About gitk"
message $w.m -text {
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
Gitk version 1.2
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
Copyright <EFBFBD> 2005 Paul Mackerras
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
Use and redistribute under the terms of the GNU General Public License} \
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
-justify center -aspect 400
pack $w.m -side top -fill x -padx 20 -pady 20
button $w.ok -text Close -command "destroy $w"
pack $w.ok -side bottom
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
proc assigncolor {id} {
global commitinfo colormap commcolors colors nextcolor
global parents nparents children nchildren
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
global cornercrossings crossings
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
if [info exists colormap($id)] return
set ncolors [llength $colors]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
if {$nparents($id) <= 1 && $nchildren($id) == 1} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set child [lindex $children($id) 0]
if {[info exists colormap($child)]
&& $nparents($child) == 1} {
set colormap($id) $colormap($child)
return
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
set badcolors {}
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
if {[info exists cornercrossings($id)]} {
foreach x $cornercrossings($id) {
if {[info exists colormap($x)]
&& [lsearch -exact $badcolors $colormap($x)] < 0} {
lappend badcolors $colormap($x)
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
if {[llength $badcolors] >= $ncolors} {
set badcolors {}
}
}
set origbad $badcolors
if {[llength $badcolors] < $ncolors - 1} {
if {[info exists crossings($id)]} {
foreach x $crossings($id) {
if {[info exists colormap($x)]
&& [lsearch -exact $badcolors $colormap($x)] < 0} {
lappend badcolors $colormap($x)
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
}
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
if {[llength $badcolors] >= $ncolors} {
set badcolors $origbad
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
set origbad $badcolors
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
if {[llength $badcolors] < $ncolors - 1} {
foreach child $children($id) {
if {[info exists colormap($child)]
&& [lsearch -exact $badcolors $colormap($child)] < 0} {
lappend badcolors $colormap($child)
}
if {[info exists parents($child)]} {
foreach p $parents($child) {
if {[info exists colormap($p)]
&& [lsearch -exact $badcolors $colormap($p)] < 0} {
lappend badcolors $colormap($p)
}
}
}
}
if {[llength $badcolors] >= $ncolors} {
set badcolors $origbad
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
for {set i 0} {$i <= $ncolors} {incr i} {
set c [lindex $colors $nextcolor]
if {[incr nextcolor] >= $ncolors} {
set nextcolor 0
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
if {[lsearch -exact $badcolors $c]} break
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set colormap($id) $c
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
proc initgraph {} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global canvy canvy0 lineno numcommits nextcolor linespc
global mainline mainlinearrow sidelines
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global nchildren ncleft
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global displist nhyperspace
Add initial version of gitk to the CVS repository
20 years ago
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
allcanvs delete all
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set nextcolor 0
set canvy $canvy0
set lineno -1
set numcommits 0
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
catch {unset mainline}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
catch {unset mainlinearrow}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
catch {unset sidelines}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
foreach id [array names nchildren] {
Add initial version of gitk to the CVS repository
20 years ago
set ncleft($id) $nchildren($id)
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set displist {}
set nhyperspace 0
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
proc bindline {t id} {
global canv
$canv bind $t <Enter> "lineenter %x %y $id"
$canv bind $t <Motion> "linemotion %x %y $id"
$canv bind $t <Leave> "lineleave $id"
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
$canv bind $t <Button-1> "lineclick %x %y $id 1"
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
}
Draw selected graph line thicker and make arrowheads active.
20 years ago
proc drawlines {id xtra} {
global mainline mainlinearrow sidelines lthickness colormap canv
$canv delete lines.$id
if {[info exists mainline($id)]} {
set t [$canv create line $mainline($id) \
-width [expr {($xtra + 1) * $lthickness}] \
-fill $colormap($id) -tags lines.$id \
-arrow $mainlinearrow($id)]
$canv lower $t
bindline $t $id
}
if {[info exists sidelines($id)]} {
foreach ls $sidelines($id) {
set coords [lindex $ls 0]
set thick [lindex $ls 1]
set arrow [lindex $ls 2]
set t [$canv create line $coords -fill $colormap($id) \
-width [expr {($thick + $xtra) * $lthickness}] \
-arrow $arrow -tags lines.$id]
$canv lower $t
bindline $t $id
}
}
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
# level here is an index in displist
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
proc drawcommitline {level} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global parents children nparents displist
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
global canv canv2 canv3 mainfont namefont canvy linespc
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global lineid linehtag linentag linedtag commitinfo
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
global colormap numcommits currentparents dupparents
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
global idtags idline idheads idotherrefs
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global lineno lthickness mainline mainlinearrow sidelines
global commitlisted rowtextx idpos lastuse displist
global oldnlines olddlevel olddisplist
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
incr numcommits
incr lineno
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set id [lindex $displist $level]
set lastuse($id) $lineno
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set lineid($lineno) $id
set idline($id) $lineno
set ofill [expr {[info exists commitlisted($id)]? "blue": "white"}]
if {![info exists commitinfo($id)]} {
readcommit $id
if {![info exists commitinfo($id)]} {
set commitinfo($id) {"No commit information available"}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set nparents($id) 0
}
Add initial version of gitk to the CVS repository
20 years ago
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
assigncolor $id
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set currentparents {}
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
set dupparents {}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
if {[info exists commitlisted($id)] && [info exists parents($id)]} {
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
foreach p $parents($id) {
if {[lsearch -exact $currentparents $p] < 0} {
lappend currentparents $p
} else {
# remember that this parent was listed twice
lappend dupparents $p
}
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
}
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
set x [xcoord $level $level $lineno]
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set y1 $canvy
set canvy [expr $canvy + $linespc]
allcanvs conf -scrollregion \
[list 0 0 0 [expr $y1 + 0.5 * $linespc + 2]]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
if {[info exists mainline($id)]} {
lappend mainline($id) $x $y1
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
if {$mainlinearrow($id) ne "none"} {
set mainline($id) [trimdiagstart $mainline($id)]
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
}
Draw selected graph line thicker and make arrowheads active.
20 years ago
drawlines $id 0
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set orad [expr {$linespc / 3}]
set t [$canv create oval [expr $x - $orad] [expr $y1 - $orad] \
[expr $x + $orad - 1] [expr $y1 + $orad - 1] \
-fill $ofill -outline black -width 1]
$canv raise $t
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$canv bind $t <1> {selcanvline {} %x %y}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set xt [xcoord [llength $displist] $level $lineno]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
if {[llength $currentparents] > 2} {
set xt [expr {$xt + ([llength $currentparents] - 2) * $linespc}]
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set rowtextx($lineno) $xt
Add a menu item for creating tags.
20 years ago
set idpos($id) [list $x $xt $y1]
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
if {[info exists idtags($id)] || [info exists idheads($id)]
|| [info exists idotherrefs($id)]} {
Add a menu item for creating tags.
20 years ago
set xt [drawtags $id $x $xt $y1]
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
set headline [lindex $commitinfo($id) 0]
set name [lindex $commitinfo($id) 1]
set date [lindex $commitinfo($id) 2]
set linehtag($lineno) [$canv create text $xt $y1 -anchor w \
-text $headline -font $mainfont ]
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$canv bind $linehtag($lineno) <Button-3> "rowmenu %X %Y $id"
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set linentag($lineno) [$canv2 create text 3 $y1 -anchor w \
-text $name -font $namefont]
set linedtag($lineno) [$canv3 create text 3 $y1 -anchor w \
-text $date -font $mainfont]
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set olddlevel $level
set olddisplist $displist
set oldnlines [llength $displist]
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Add a menu item for creating tags.
20 years ago
proc drawtags {id x xt y1} {
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
global idtags idheads idotherrefs
Add a menu item for creating tags.
20 years ago
global linespc lthickness
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
global canv mainfont idline rowtextx
Add a menu item for creating tags.
20 years ago
set marks {}
set ntags 0
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
set nheads 0
Add a menu item for creating tags.
20 years ago
if {[info exists idtags($id)]} {
set marks $idtags($id)
set ntags [llength $marks]
}
if {[info exists idheads($id)]} {
set marks [concat $marks $idheads($id)]
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
set nheads [llength $idheads($id)]
}
if {[info exists idotherrefs($id)]} {
set marks [concat $marks $idotherrefs($id)]
Add a menu item for creating tags.
20 years ago
}
if {$marks eq {}} {
return $xt
}
set delta [expr {int(0.5 * ($linespc - $lthickness))}]
set yt [expr $y1 - 0.5 * $linespc]
set yb [expr $yt + $linespc - 1]
set xvals {}
set wvals {}
foreach tag $marks {
set wid [font measure $mainfont $tag]
lappend xvals $xt
lappend wvals $wid
set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
}
set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
-width $lthickness -fill black -tags tag.$id]
$canv lower $t
foreach tag $marks x $xvals wid $wvals {
set xl [expr $x + $delta]
set xr [expr $x + $delta + $wid + $lthickness]
if {[incr ntags -1] >= 0} {
# draw a tag
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
set t [$canv create polygon $x [expr $yt + $delta] $xl $yt \
$xr $yt $xr $yb $xl $yb $x [expr $yb - $delta] \
-width 1 -outline black -fill yellow -tags tag.$id]
$canv bind $t <1> [list showtag $tag 1]
set rowtextx($idline($id)) [expr {$xr + $linespc}]
Add a menu item for creating tags.
20 years ago
} else {
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
# draw a head or other ref
if {[incr nheads -1] >= 0} {
set col green
} else {
set col "#ddddff"
}
Add a menu item for creating tags.
20 years ago
set xl [expr $xl - $delta/2]
$canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
-width 1 -outline black -fill $col -tags tag.$id
Add a menu item for creating tags.
20 years ago
}
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
set t [$canv create text $xl $y1 -anchor w -text $tag \
-font $mainfont -tags tag.$id]
if {$ntags >= 0} {
$canv bind $t <1> [list showtag $tag 1]
}
Add a menu item for creating tags.
20 years ago
}
return $xt
}
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
proc notecrossings {id lo hi corner} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global olddisplist crossings cornercrossings
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
for {set i $lo} {[incr i] < $hi} {} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set p [lindex $olddisplist $i]
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
if {$p == {}} continue
if {$i == $corner} {
if {![info exists cornercrossings($id)]
|| [lsearch -exact $cornercrossings($id) $p] < 0} {
lappend cornercrossings($id) $p
}
if {![info exists cornercrossings($p)]
|| [lsearch -exact $cornercrossings($p) $id] < 0} {
lappend cornercrossings($p) $id
}
} else {
if {![info exists crossings($id)]
|| [lsearch -exact $crossings($id) $p] < 0} {
lappend crossings($id) $p
}
if {![info exists crossings($p)]
|| [lsearch -exact $crossings($p) $id] < 0} {
lappend crossings($p) $id
}
}
}
}
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
proc xcoord {i level ln} {
global canvx0 xspc1 xspc2
set x [expr {$canvx0 + $i * $xspc1($ln)}]
if {$i > 0 && $i == $level} {
set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
} elseif {$i > $level} {
set x [expr {$x + $xspc2 - $xspc1($ln)}]
}
return $x
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
# it seems Tk can't draw arrows on the end of diagonal line segments...
proc trimdiagend {line} {
while {[llength $line] > 4} {
set x1 [lindex $line end-3]
set y1 [lindex $line end-2]
set x2 [lindex $line end-1]
set y2 [lindex $line end]
if {($x1 == $x2) != ($y1 == $y2)} break
set line [lreplace $line end-1 end]
}
return $line
}
proc trimdiagstart {line} {
while {[llength $line] > 4} {
set x1 [lindex $line 0]
set y1 [lindex $line 1]
set x2 [lindex $line 2]
set y2 [lindex $line 3]
if {($x1 == $x2) != ($y1 == $y2)} break
set line [lreplace $line 0 1]
}
return $line
}
proc drawslants {id needonscreen nohs} {
global canv mainline mainlinearrow sidelines
global canvx0 canvy xspc1 xspc2 lthickness
global currentparents dupparents
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
global lthickness linespc canvy colormap lineno geometry
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global maxgraphpct maxwidth
global displist onscreen lastuse
global parents commitlisted
global oldnlines olddlevel olddisplist
global nhyperspace numcommits nnewparents
if {$lineno < 0} {
lappend displist $id
set onscreen($id) 1
return 0
}
set y1 [expr {$canvy - $linespc}]
set y2 $canvy
# work out what we need to get back on screen
set reins {}
if {$onscreen($id) < 0} {
# next to do isn't displayed, better get it on screen...
lappend reins [list $id 0]
}
# make sure all the previous commits's parents are on the screen
foreach p $currentparents {
if {$onscreen($p) < 0} {
lappend reins [list $p 0]
}
}
# bring back anything requested by caller
if {$needonscreen ne {}} {
lappend reins $needonscreen
}
# try the shortcut
if {$currentparents == $id && $onscreen($id) == 0 && $reins eq {}} {
set dlevel $olddlevel
set x [xcoord $dlevel $dlevel $lineno]
set mainline($id) [list $x $y1]
set mainlinearrow($id) none
set lastuse($id) $lineno
set displist [lreplace $displist $dlevel $dlevel $id]
set onscreen($id) 1
set xspc1([expr {$lineno + 1}]) $xspc1($lineno)
return $dlevel
}
# update displist
set displist [lreplace $displist $olddlevel $olddlevel]
set j $olddlevel
foreach p $currentparents {
set lastuse($p) $lineno
if {$onscreen($p) == 0} {
set displist [linsert $displist $j $p]
set onscreen($p) 1
incr j
}
}
if {$onscreen($id) == 0} {
lappend displist $id
Fix a bug where commits with no children weren't marked as on-screen. This problem was revealed by running gitk --all on Wolfgang Denk's u-boot repository.
20 years ago
set onscreen($id) 1
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
}
# remove the null entry if present
set nullentry [lsearch -exact $displist {}]
if {$nullentry >= 0} {
set displist [lreplace $displist $nullentry $nullentry]
}
# bring back the ones we need now (if we did it earlier
# it would change displist and invalidate olddlevel)
foreach pi $reins {
# test again in case of duplicates in reins
set p [lindex $pi 0]
if {$onscreen($p) < 0} {
set onscreen($p) 1
set lastuse($p) $lineno
set displist [linsert $displist [lindex $pi 1] $p]
incr nhyperspace -1
}
}
set lastuse($id) $lineno
# see if we need to make any lines jump off into hyperspace
set displ [llength $displist]
if {$displ > $maxwidth} {
set ages {}
foreach x $displist {
lappend ages [list $lastuse($x) $x]
}
set ages [lsort -integer -index 0 $ages]
set k 0
while {$displ > $maxwidth} {
set use [lindex $ages $k 0]
set victim [lindex $ages $k 1]
if {$use >= $lineno - 5} break
incr k
if {[lsearch -exact $nohs $victim] >= 0} continue
set i [lsearch -exact $displist $victim]
set displist [lreplace $displist $i $i]
set onscreen($victim) -1
incr nhyperspace
incr displ -1
if {$i < $nullentry} {
incr nullentry -1
}
set x [lindex $mainline($victim) end-1]
lappend mainline($victim) $x $y1
set line [trimdiagend $mainline($victim)]
set arrow "last"
if {$mainlinearrow($victim) ne "none"} {
set line [trimdiagstart $line]
set arrow "both"
}
lappend sidelines($victim) [list $line 1 $arrow]
unset mainline($victim)
}
}
set dlevel [lsearch -exact $displist $id]
# If we are reducing, put in a null entry
if {$displ < $oldnlines} {
# does the next line look like a merge?
# i.e. does it have > 1 new parent?
if {$nnewparents($id) > 1} {
set i [expr {$dlevel + 1}]
} elseif {$nnewparents([lindex $olddisplist $olddlevel]) == 0} {
set i $olddlevel
if {$nullentry >= 0 && $nullentry < $i} {
incr i -1
}
} elseif {$nullentry >= 0} {
set i $nullentry
while {$i < $displ
&& [lindex $olddisplist $i] == [lindex $displist $i]} {
incr i
}
} else {
set i $olddlevel
if {$dlevel >= $i} {
incr i
}
}
if {$i < $displ} {
set displist [linsert $displist $i {}]
incr displ
if {$dlevel >= $i} {
incr dlevel
}
}
}
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
# decide on the line spacing for the next line
set lj [expr {$lineno + 1}]
set maxw [expr {$maxgraphpct * $geometry(canv1) / 100}]
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
if {$displ <= 1 || $canvx0 + $displ * $xspc2 <= $maxw} {
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
set xspc1($lj) $xspc2
} else {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set xspc1($lj) [expr {($maxw - $canvx0 - $xspc2) / ($displ - 1)}]
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
if {$xspc1($lj) < $lthickness} {
set xspc1($lj) $lthickness
}
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
foreach idi $reins {
set id [lindex $idi 0]
set j [lsearch -exact $displist $id]
set xj [xcoord $j $dlevel $lj]
set mainline($id) [list $xj $y2]
set mainlinearrow($id) first
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set i -1
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
foreach id $olddisplist {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
incr i
if {$id == {}} continue
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
if {$onscreen($id) <= 0} continue
set xi [xcoord $i $olddlevel $lineno]
if {$i == $olddlevel} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
foreach p $currentparents {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set j [lsearch -exact $displist $p]
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
set coords [list $xi $y1]
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set xj [xcoord $j $dlevel $lj]
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
if {$xj < $xi - $linespc} {
lappend coords [expr {$xj + $linespc}] $y1
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
notecrossings $p $j $i [expr {$j + 1}]
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
} elseif {$xj > $xi + $linespc} {
lappend coords [expr {$xj - $linespc}] $y1
Try to assign colors so crossing lines have different colors In particular try hard to give different colors to lines that cross at a corner in one of the lines.
20 years ago
notecrossings $p $i $j [expr {$j - 1}]
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
}
if {[lsearch -exact $dupparents $p] >= 0} {
# draw a double-width line to indicate the doubled parent
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
lappend coords $xj $y2
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
lappend sidelines($p) [list $coords 2 none]
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
if {![info exists mainline($p)]} {
set mainline($p) [list $xj $y2]
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set mainlinearrow($p) none
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
}
} else {
# normal case, no parent duplicated
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
set yb $y2
set dx [expr {abs($xi - $xj)}]
if {0 && $dx < $linespc} {
set yb [expr {$y1 + $dx}]
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
if {![info exists mainline($p)]} {
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
if {$xi != $xj} {
lappend coords $xj $yb
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
}
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
set mainline($p) $coords
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set mainlinearrow($p) none
Draw graph lines as one continuous line where possible Added context menu on lines Added headline display when the mouse hovers over a line Removed some debug messages
20 years ago
} else {
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
lappend coords $xj $yb
if {$yb < $y2} {
lappend coords $xj $y2
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
lappend sidelines($p) [list $coords 1 none]
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Show heads as well as tags
20 years ago
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
}
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
} else {
set j $i
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
if {[lindex $displist $i] != $id} {
set j [lsearch -exact $displist $id]
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
}
if {$j != $i || $xspc1($lineno) != $xspc1($lj)
Fix a bug where commits with no children weren't marked as on-screen. This problem was revealed by running gitk --all on Wolfgang Denk's u-boot repository.
20 years ago
|| ($olddlevel < $i && $i < $dlevel)
|| ($dlevel < $i && $i < $olddlevel)} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set xj [xcoord $j $dlevel $lj]
Fix a bug where commits with no children weren't marked as on-screen. This problem was revealed by running gitk --all on Wolfgang Denk's u-boot repository.
20 years ago
lappend mainline($id) $xi $y1 $xj $y2
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
}
Add initial version of gitk to the CVS repository
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
return $dlevel
}
# search for x in a list of lists
proc llsearch {llist x} {
set i 0
foreach l $llist {
if {$l == $x || [lsearch -exact $l $x] >= 0} {
return $i
}
incr i
}
return -1
}
proc drawmore {reading} {
global displayorder numcommits ncmupdate nextupdate
global stopped nhyperspace parents commitlisted
global maxwidth onscreen displist currentparents olddlevel
set n [llength $displayorder]
while {$numcommits < $n} {
set id [lindex $displayorder $numcommits]
set ctxend [expr {$numcommits + 10}]
if {!$reading && $ctxend > $n} {
set ctxend $n
}
set dlist {}
if {$numcommits > 0} {
set dlist [lreplace $displist $olddlevel $olddlevel]
set i $olddlevel
foreach p $currentparents {
if {$onscreen($p) == 0} {
set dlist [linsert $dlist $i $p]
incr i
}
}
}
set nohs {}
set reins {}
set isfat [expr {[llength $dlist] > $maxwidth}]
if {$nhyperspace > 0 || $isfat} {
if {$ctxend > $n} break
# work out what to bring back and
# what we want to don't want to send into hyperspace
set room 1
for {set k $numcommits} {$k < $ctxend} {incr k} {
set x [lindex $displayorder $k]
set i [llsearch $dlist $x]
if {$i < 0} {
set i [llength $dlist]
lappend dlist $x
}
if {[lsearch -exact $nohs $x] < 0} {
lappend nohs $x
}
if {$reins eq {} && $onscreen($x) < 0 && $room} {
set reins [list $x $i]
}
set newp {}
if {[info exists commitlisted($x)]} {
set right 0
foreach p $parents($x) {
if {[llsearch $dlist $p] < 0} {
lappend newp $p
if {[lsearch -exact $nohs $p] < 0} {
lappend nohs $p
}
if {$reins eq {} && $onscreen($p) < 0 && $room} {
set reins [list $p [expr {$i + $right}]]
}
}
set right 1
}
}
set l [lindex $dlist $i]
if {[llength $l] == 1} {
set l $newp
} else {
set j [lsearch -exact $l $x]
set l [concat [lreplace $l $j $j] $newp]
}
set dlist [lreplace $dlist $i $i $l]
if {$room && $isfat && [llength $newp] <= 1} {
set room 0
}
}
}
set dlevel [drawslants $id $reins $nohs]
drawcommitline $dlevel
if {[clock clicks -milliseconds] >= $nextupdate
&& $numcommits >= $ncmupdate} {
doupdate $reading
if {$stopped} break
}
}
}
# level here is an index in todo
proc updatetodo {level noshortcut} {
global ncleft todo nnewparents
global commitlisted parents onscreen
set id [lindex $todo $level]
set olds {}
if {[info exists commitlisted($id)]} {
foreach p $parents($id) {
if {[lsearch -exact $olds $p] < 0} {
lappend olds $p
}
}
}
if {!$noshortcut && [llength $olds] == 1} {
set p [lindex $olds 0]
if {$ncleft($p) == 1 && [lsearch -exact $todo $p] < 0} {
set ncleft($p) 0
set todo [lreplace $todo $level $level $p]
set onscreen($p) 0
set nnewparents($id) 1
return 0
}
}
set todo [lreplace $todo $level $level]
set i $level
set n 0
foreach p $olds {
incr ncleft($p) -1
set k [lsearch -exact $todo $p]
if {$k < 0} {
set todo [linsert $todo $i $p]
set onscreen($p) 0
incr i
incr n
}
}
set nnewparents($id) $n
return 1
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Add initial version of gitk to the CVS repository
20 years ago
Fix behaviour in the case where we have no commits to display. I had code in there to put "No commits selected" on the canvas but it needed some globals.
20 years ago
proc decidenext {{noread 0}} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global ncleft todo
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global datemode cdate
Fix behaviour in the case where we have no commits to display. I had code in there to put "No commits selected" on the canvas but it needed some globals.
20 years ago
global commitinfo
Add initial version of gitk to the CVS repository
20 years ago
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
# choose which one to do next time around
set todol [llength $todo]
set level -1
set latest {}
for {set k $todol} {[incr k -1] >= 0} {} {
set p [lindex $todo $k]
if {$ncleft($p) == 0} {
if {$datemode} {
Fix behaviour in the case where we have no commits to display. I had code in there to put "No commits selected" on the canvas but it needed some globals.
20 years ago
if {![info exists commitinfo($p)]} {
if {$noread} {
return {}
}
readcommit $p
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
if {$latest == {} || $cdate($p) > $latest} {
Add initial version of gitk to the CVS repository
20 years ago
set level $k
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set latest $cdate($p)
Add initial version of gitk to the CVS repository
20 years ago
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
} else {
set level $k
break
Add initial version of gitk to the CVS repository
20 years ago
}
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
if {$level < 0} {
if {$todo != {}} {
puts "ERROR: none of the pending commits can be done yet:"
foreach p $todo {
Use git-rev-list --header. With --header, git-rev-list gives us the contents of the commit in-line, so we don't need to exec a git-cat-file to get it, and we don't need the readobj command either. Also fixed a residual problem with handling the commit that has a parent listed twice.
20 years ago
puts " $p ($ncleft($p))"
Add initial version of gitk to the CVS repository
20 years ago
}
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
return -1
}
Add initial version of gitk to the CVS repository
20 years ago
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
return $level
}
Add initial version of gitk to the CVS repository
20 years ago
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
proc drawcommit {id} {
global phase todo nchildren datemode nextupdate
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global numcommits ncmupdate displayorder todo onscreen
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
if {$phase != "incrdraw"} {
set phase incrdraw
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set displayorder {}
set todo {}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
initgraph
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
}
if {$nchildren($id) == 0} {
lappend todo $id
set onscreen($id) 0
}
set level [decidenext 1]
if {$level == {} || $id != [lindex $todo $level]} {
return
}
while 1 {
lappend displayorder [lindex $todo $level]
if {[updatetodo $level $datemode]} {
set level [decidenext 1]
if {$level == {}} break
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set id [lindex $todo $level]
if {![info exists commitlisted($id)]} {
break
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
drawmore 1
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
proc finishcommits {} {
global phase
Fix behaviour in the case where we have no commits to display. I had code in there to put "No commits selected" on the canvas but it needed some globals.
20 years ago
global canv mainfont ctext maincursor textcursor
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
if {$phase != "incrdraw"} {
$canv delete all
$canv create text 3 3 -anchor nw -text "No commits selected" \
-font $mainfont -tags textitems
set phase {}
Fix behaviour in the case where we have no commits to display. I had code in there to put "No commits selected" on the canvas but it needed some globals.
20 years ago
} else {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
drawrest
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Fix operation without libreadobj.so.0.0 Display a watch cursor when reading the commits initially
20 years ago
. config -cursor $maincursor
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
settextcursor $textcursor
}
# Don't change the text pane cursor if it is currently the hand cursor,
# showing that we are over a sha1 ID link.
proc settextcursor {c} {
global ctext curtextcursor
if {[$ctext cget -cursor] == $curtextcursor} {
$ctext config -cursor $c
}
set curtextcursor $c
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
proc drawgraph {} {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global nextupdate startmsecs ncmupdate
global displayorder onscreen
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
if {$displayorder == {}} return
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set startmsecs [clock clicks -milliseconds]
set nextupdate [expr $startmsecs + 100]
Refine the update heuristic to improve responsiveness a bit. The previous commit improved performance a lot but also meant that we waited longer to see something drawn. This refines the heuristics for when to call update so that (1) when we have finished processing a bufferfull of information from git-rev-list, we call update if enough time has elapsed, regardless of how many commits we've drawn, and (2) the number of commits drawn between updates scales with the total number of commits drawn: 1 for 1-99 commits, 10 for 100-9999 commits, or 100 for >= 10000 commits.
20 years ago
set ncmupdate 1
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
initgraph
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
foreach id $displayorder {
set onscreen($id) 0
}
drawmore 0
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
proc drawrest {} {
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global phase stopped redisplaying selectedline
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global datemode todo displayorder
Only do an update every 100 commits when drawing the graph. On a large repository with > 60,000 commits, each call to the Tk update primitive (which gives Tk a chance to respond to events and redraw the screen) was taking up to 0.2 seconds. Because the logic was to call update after drawing a commit if 0.1 seconds had passed since the last update call, we were calling it for every commit, which was slowing us down enormously. Now we also require that we have drawn 100 commits since the last update (as well as it being at least 0.1 seconds since the last update). Drawing 100 commits takes around 0.1 - 0.2 seconds (even in this large repo) on my G5.
20 years ago
global numcommits ncmupdate
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
global nextupdate startmsecs
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set level [decidenext]
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
if {$level >= 0} {
set phase drawgraph
while 1 {
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
lappend displayorder [lindex $todo $level]
Handle the case of a parent being listed twice in a merge. This happens in the linux-2.6 tree. We draw the graph line double-thick to show that this happened. Also fix a bug where we got a bogus "No commit information available" line at the end on simple repositories like this one.
20 years ago
set hard [updatetodo $level $datemode]
if {$hard} {
set level [decidenext]
if {$level < 0} break
}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
}
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
drawmore 0
Add initial version of gitk to the CVS repository
20 years ago
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set phase {}
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
set drawmsecs [expr [clock clicks -milliseconds] - $startmsecs]
Draw graph lines as one continuous line where possible Added context menu on lines Added headline display when the mouse hovers over a line Removed some debug messages
20 years ago
#puts "overall $drawmsecs ms for $numcommits commits"
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
if {$redisplaying} {
if {$stopped == 0 && [info exists selectedline]} {
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $selectedline 0
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
}
if {$stopped == 1} {
set stopped 0
after idle drawgraph
} else {
set redisplaying 0
}
}
Add initial version of gitk to the CVS repository
20 years ago
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
proc findmatches {f} {
global findtype foundstring foundstrlen
if {$findtype == "Regexp"} {
set matches [regexp -indices -all -inline $foundstring $f]
} else {
if {$findtype == "IgnCase"} {
set str [string tolower $f]
} else {
set str $f
}
set matches {}
set i 0
while {[set j [string first $foundstring $str $i]] >= 0} {
lappend matches [list $j [expr $j+$foundstrlen-1]]
set i [expr $j + $foundstrlen]
}
}
return $matches
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
proc dofind {} {
global findtype findloc findstring markedmatches commitinfo
global numcommits lineid linehtag linentag linedtag
global mainfont namefont canv canv2 canv3 selectedline
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
global matchinglines foundstring foundstrlen
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
stopfindproc
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
unmarkmatches
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
focus .
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
set matchinglines {}
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
if {$findloc == "Pickaxe"} {
findpatches
return
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
if {$findtype == "IgnCase"} {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set foundstring [string tolower $findstring]
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
} else {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set foundstring $findstring
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set foundstrlen [string length $findstring]
if {$foundstrlen == 0} return
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
if {$findloc == "Files"} {
findfiles
return
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
if {![info exists selectedline]} {
set oldsel -1
} else {
set oldsel $selectedline
}
set didsel 0
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set fldtypes {Headline Author Date Committer CDate Comment}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
for {set l 0} {$l < $numcommits} {incr l} {
set id $lineid($l)
set info $commitinfo($id)
set doesmatch 0
foreach f $info ty $fldtypes {
if {$findloc != "All fields" && $findloc != $ty} {
continue
}
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set matches [findmatches $f]
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
if {$matches == {}} continue
set doesmatch 1
if {$ty == "Headline"} {
markmatches $canv $l $f $linehtag($l) $matches $mainfont
} elseif {$ty == "Author"} {
markmatches $canv2 $l $f $linentag($l) $matches $namefont
} elseif {$ty == "Date"} {
markmatches $canv3 $l $f $linedtag($l) $matches $mainfont
}
}
if {$doesmatch} {
lappend matchinglines $l
if {!$didsel && $l > $oldsel} {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
findselectline $l
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
set didsel 1
}
}
}
if {$matchinglines == {}} {
bell
} elseif {!$didsel} {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
findselectline [lindex $matchinglines 0]
}
}
proc findselectline {l} {
global findloc commentend ctext
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $l 1
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
if {$findloc == "All fields" || $findloc == "Comments"} {
# highlight the matches in the comments
set f [$ctext get 1.0 $commentend]
set matches [findmatches $f]
foreach match $matches {
set start [lindex $match 0]
set end [expr [lindex $match 1] + 1]
$ctext tag add found "1.0 + $start c" "1.0 + $end c"
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
}
}
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
proc findnext {restart} {
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
global matchinglines selectedline
if {![info exists matchinglines]} {
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
if {$restart} {
dofind
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
return
}
if {![info exists selectedline]} return
foreach l $matchinglines {
if {$l > $selectedline} {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
findselectline $l
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
return
}
}
bell
}
proc findprev {} {
global matchinglines selectedline
if {![info exists matchinglines]} {
dofind
return
}
if {![info exists selectedline]} return
set prev {}
foreach l $matchinglines {
if {$l >= $selectedline} break
set prev $l
}
if {$prev != {}} {
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
findselectline $prev
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
} else {
bell
}
}
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
proc findlocchange {name ix op} {
global findloc findtype findtypemenu
if {$findloc == "Pickaxe"} {
set findtype Exact
set state disabled
} else {
set state normal
}
$findtypemenu entryconf 1 -state $state
$findtypemenu entryconf 2 -state $state
}
proc stopfindproc {{done 0}} {
global findprocpid findprocfile findids
global ctext findoldcursor phase maincursor textcursor
global findinprogress
catch {unset findids}
if {[info exists findprocpid]} {
if {!$done} {
catch {exec kill $findprocpid}
}
catch {close $findprocfile}
unset findprocpid
}
if {[info exists findinprogress]} {
unset findinprogress
if {$phase != "incrdraw"} {
. config -cursor $maincursor
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
settextcursor $textcursor
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
}
}
}
proc findpatches {} {
global findstring selectedline numcommits
global findprocpid findprocfile
global finddidsel ctext lineid findinprogress
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
global findinsertpos
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
if {$numcommits == 0} return
# make a list of all the ids to search, starting at the one
# after the selected line (if any)
if {[info exists selectedline]} {
set l $selectedline
} else {
set l -1
}
set inputids {}
for {set i 0} {$i < $numcommits} {incr i} {
if {[incr l] >= $numcommits} {
set l 0
}
append inputids $lineid($l) "\n"
}
if {[catch {
set f [open [list | git-diff-tree --stdin -s -r -S$findstring \
<< $inputids] r]
} err]} {
error_popup "Error starting search process: $err"
return
}
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
set findinsertpos end
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set findprocfile $f
set findprocpid [pid $f]
fconfigure $f -blocking 0
fileevent $f readable readfindproc
set finddidsel 0
. config -cursor watch
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
settextcursor watch
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set findinprogress 1
}
proc readfindproc {} {
global findprocfile finddidsel
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
global idline matchinglines findinsertpos
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set n [gets $findprocfile line]
if {$n < 0} {
if {[eof $findprocfile]} {
stopfindproc 1
if {!$finddidsel} {
bell
}
}
return
}
if {![regexp {^[0-9a-f]{40}} $line id]} {
error_popup "Can't parse git-diff-tree output: $line"
stopfindproc
return
}
if {![info exists idline($id)]} {
puts stderr "spurious id: $id"
return
}
set l $idline($id)
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
insertmatch $l $id
}
proc insertmatch {l id} {
global matchinglines findinsertpos finddidsel
if {$findinsertpos == "end"} {
if {$matchinglines != {} && $l < [lindex $matchinglines 0]} {
set matchinglines [linsert $matchinglines 0 $l]
set findinsertpos 1
} else {
lappend matchinglines $l
}
} else {
set matchinglines [linsert $matchinglines $findinsertpos $l]
incr findinsertpos
}
markheadline $l $id
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
if {!$finddidsel} {
findselectline $l
set finddidsel 1
}
}
proc findfiles {} {
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
global selectedline numcommits lineid ctext
global ffileline finddidsel parents nparents
global findinprogress findstartline findinsertpos
global treediffs fdiffids fdiffsneeded fdiffpos
global findmergefiles
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
if {$numcommits == 0} return
if {[info exists selectedline]} {
set l [expr {$selectedline + 1}]
} else {
set l 0
}
set ffileline $l
set findstartline $l
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
set diffsneeded {}
set fdiffsneeded {}
while 1 {
set id $lineid($l)
if {$findmergefiles || $nparents($id) == 1} {
foreach p $parents($id) {
if {![info exists treediffs([list $id $p])]} {
append diffsneeded "$id $p\n"
lappend fdiffsneeded [list $id $p]
}
}
}
if {[incr l] >= $numcommits} {
set l 0
}
if {$l == $findstartline} break
}
# start off a git-diff-tree process if needed
if {$diffsneeded ne {}} {
if {[catch {
set df [open [list | git-diff-tree -r --stdin << $diffsneeded] r]
} err ]} {
error_popup "Error starting search process: $err"
return
}
catch {unset fdiffids}
set fdiffpos 0
fconfigure $df -blocking 0
fileevent $df readable [list readfilediffs $df]
}
set finddidsel 0
set findinsertpos end
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set id $lineid($l)
set p [lindex $parents($id) 0]
. config -cursor watch
Change cursor to a hand cursor when over a SHA1 ID link. This is based on suggestions by Jeff Epler and Linus Torvalds, but extended so that we do the switching between the watch cursor and the normal cursor correctly as well. Also fixed a bug pointed out by Junio Hamano - I wasn't incrementing the link number (duh!).
20 years ago
settextcursor watch
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set findinprogress 1
findcont [list $id $p]
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
update
}
proc readfilediffs {df} {
global findids fdiffids fdiffs
set n [gets $df line]
if {$n < 0} {
if {[eof $df]} {
donefilediff
if {[catch {close $df} err]} {
stopfindproc
bell
error_popup "Error in git-diff-tree: $err"
} elseif {[info exists findids]} {
set ids $findids
stopfindproc
bell
error_popup "Couldn't find diffs for {$ids}"
}
}
return
}
if {[regexp {^([0-9a-f]{40}) \(from ([0-9a-f]{40})\)} $line match id p]} {
# start of a new string of diffs
donefilediff
set fdiffids [list $id $p]
set fdiffs {}
} elseif {[string match ":*" $line]} {
lappend fdiffs [lindex $line 5]
}
}
proc donefilediff {} {
global fdiffids fdiffs treediffs findids
global fdiffsneeded fdiffpos
if {[info exists fdiffids]} {
while {[lindex $fdiffsneeded $fdiffpos] ne $fdiffids
&& $fdiffpos < [llength $fdiffsneeded]} {
# git-diff-tree doesn't output anything for a commit
# which doesn't change anything
set nullids [lindex $fdiffsneeded $fdiffpos]
set treediffs($nullids) {}
if {[info exists findids] && $nullids eq $findids} {
unset findids
findcont $nullids
}
incr fdiffpos
}
incr fdiffpos
if {![info exists treediffs($fdiffids)]} {
set treediffs($fdiffids) $fdiffs
}
if {[info exists findids] && $fdiffids eq $findids} {
unset findids
findcont $fdiffids
}
}
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
}
proc findcont {ids} {
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
global findids treediffs parents nparents
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
global ffileline findstartline finddidsel
global lineid numcommits matchinglines findinprogress
global findmergefiles
set id [lindex $ids 0]
set p [lindex $ids 1]
set pi [lsearch -exact $parents($id) $p]
set l $ffileline
while 1 {
if {$findmergefiles || $nparents($id) == 1} {
if {![info exists treediffs($ids)]} {
set findids $ids
set ffileline $l
return
}
set doesmatch 0
foreach f $treediffs($ids) {
set x [findmatches $f]
if {$x != {}} {
set doesmatch 1
break
}
}
if {$doesmatch} {
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
insertmatch $l $id
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set pi $nparents($id)
}
} else {
set pi $nparents($id)
}
if {[incr pi] >= $nparents($id)} {
set pi 0
if {[incr l] >= $numcommits} {
set l 0
}
if {$l == $findstartline} break
set id $lineid($l)
}
set p [lindex $parents($id) $pi]
set ids [list $id $p]
}
stopfindproc
if {!$finddidsel} {
bell
}
}
# mark a commit as matching by putting a yellow background
# behind the headline
proc markheadline {l id} {
global canv mainfont linehtag commitinfo
set bbox [$canv bbox $linehtag($l)]
set t [$canv create rect $bbox -outline {} -tags matches -fill yellow]
$canv lower $t
}
# mark the bits of a headline, author or date that match a find string
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
proc markmatches {canv l str tag matches font} {
set bbox [$canv bbox $tag]
set x0 [lindex $bbox 0]
set y0 [lindex $bbox 1]
set y1 [lindex $bbox 3]
foreach match $matches {
set start [lindex $match 0]
set end [lindex $match 1]
if {$start > $end} continue
set xoff [font measure $font [string range $str 0 [expr $start-1]]]
set xlen [font measure $font [string range $str 0 [expr $end]]]
set t [$canv create rect [expr $x0+$xoff] $y0 [expr $x0+$xlen+2] $y1 \
-outline {} -tags matches -fill yellow]
$canv lower $t
}
}
proc unmarkmatches {} {
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
global matchinglines findids
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
allcanvs delete matches
catch {unset matchinglines}
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
catch {unset findids}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
proc selcanvline {w x y} {
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
global canv canvy0 ctext linespc
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
global lineid linehtag linentag linedtag rowtextx
Add initial version of gitk to the CVS repository
20 years ago
set ymax [lindex [$canv cget -scrollregion] 3]
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
if {$ymax == {}} return
Add initial version of gitk to the CVS repository
20 years ago
set yfrac [lindex [$canv yview] 0]
set y [expr {$y + $yfrac * $ymax}]
set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
if {$l < 0} {
set l 0
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
if {$w eq $canv} {
if {![info exists rowtextx($l)] || $x < $rowtextx($l)} return
}
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
unmarkmatches
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $l 1
Display the list of changed files in a listbox pane.
20 years ago
}
[PATCH] "Child" information in commit window - and cleanups This adds "Child: " lines to the commit window, which tells what children a commit has. It also cleans things up: it marks the text widget as no-wrap, which means that it doesn't need to truncate the commit description arbitrarily by hand. Also, the description itself is now done by a common helper routine that handles both the parent and the children. Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
proc commit_descriptor {p} {
global commitinfo
set l "..."
if {[info exists commitinfo($p)]} {
set l [lindex $commitinfo($p) 0]
}
return "$p ($l)"
}
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
# append some text to the ctext widget, and make any SHA1 ID
# that we know about be a clickable link.
proc appendwithlinks {text} {
global ctext idline linknum
set start [$ctext index "end - 1c"]
$ctext insert end $text
$ctext insert end "\n"
set links [regexp -indices -all -inline {[0-9a-f]{40}} $text]
foreach l $links {
set s [lindex $l 0]
set e [lindex $l 1]
set linkid [string range $text $s $e]
if {![info exists idline($linkid)]} continue
incr e
$ctext tag add link "$start + $s c" "$start + $e c"
$ctext tag add link$linknum "$start + $s c" "$start + $e c"
$ctext tag bind link$linknum <1> [list selectline $idline($linkid) 1]
incr linknum
}
$ctext tag conf link -foreground blue -underline 1
$ctext tag bind link <Enter> { %W configure -cursor hand2 }
$ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
}
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
proc selectline {l isnew} {
Make getting file lists asynchronous Add some scrollbars
20 years ago
global canv canv2 canv3 ctext commitinfo selectedline
global lineid linehtag linentag linedtag
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global canvy0 linespc parents nparents children
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
global cflist currentid sha1entry
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
global commentend idtags idline linknum
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
Draw graph lines as one continuous line where possible Added context menu on lines Added headline display when the mouse hovers over a line Removed some debug messages
20 years ago
$canv delete hover
Draw selected graph line thicker and make arrowheads active.
20 years ago
normalline
Add initial version of gitk to the CVS repository
20 years ago
if {![info exists lineid($l)] || ![info exists linehtag($l)]} return
Make getting file lists asynchronous Add some scrollbars
20 years ago
$canv delete secsel
set t [eval $canv create rect [$canv bbox $linehtag($l)] -outline {{}} \
-tags secsel -fill [$canv cget -selectbackground]]
$canv lower $t
$canv2 delete secsel
set t [eval $canv2 create rect [$canv2 bbox $linentag($l)] -outline {{}} \
-tags secsel -fill [$canv2 cget -selectbackground]]
$canv2 lower $t
$canv3 delete secsel
set t [eval $canv3 create rect [$canv3 bbox $linedtag($l)] -outline {{}} \
-tags secsel -fill [$canv3 cget -selectbackground]]
$canv3 lower $t
Display the list of changed files in a listbox pane.
20 years ago
set y [expr {$canvy0 + $l * $linespc}]
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
set ymax [lindex [$canv cget -scrollregion] 3]
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
set ytop [expr {$y - $linespc - 1}]
set ybot [expr {$y + $linespc + 1}]
Display the list of changed files in a listbox pane.
20 years ago
set wnow [$canv yview]
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
set wtop [expr [lindex $wnow 0] * $ymax]
set wbot [expr [lindex $wnow 1] * $ymax]
set wh [expr {$wbot - $wtop}]
set newtop $wtop
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
if {$ytop < $wtop} {
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
if {$ybot < $wtop} {
set newtop [expr {$y - $wh / 2.0}]
} else {
set newtop $ytop
if {$newtop > $wtop - $linespc} {
set newtop [expr {$wtop - $linespc}]
}
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
}
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
} elseif {$ybot > $wbot} {
if {$ytop > $wbot} {
set newtop [expr {$y - $wh / 2.0}]
} else {
set newtop [expr {$ybot - $wh}]
if {$newtop < $wtop + $linespc} {
set newtop [expr {$wtop + $linespc}]
}
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
}
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
}
if {$newtop != $wtop} {
if {$newtop < 0} {
set newtop 0
}
allcanvs yview moveto [expr $newtop * 1.0 / $ymax]
Display the list of changed files in a listbox pane.
20 years ago
}
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
if {$isnew} {
addtohistory [list selectline $l 0]
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
}
Display the list of changed files in a listbox pane.
20 years ago
set selectedline $l
Add initial version of gitk to the CVS repository
20 years ago
set id $lineid($l)
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
set currentid $id
Add a widget to show the SHA1 ID of the current commit Add a find facility to search within the commits Cope with multiple starting points.
20 years ago
$sha1entry delete 0 end
$sha1entry insert 0 $id
$sha1entry selection from 0
$sha1entry selection to end
Display the list of changed files in a listbox pane.
20 years ago
$ctext conf -state normal
Add initial version of gitk to the CVS repository
20 years ago
$ctext delete 0.0 end
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
set linknum 0
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$ctext mark set fmark.0 0.0
$ctext mark gravity fmark.0 left
Add initial version of gitk to the CVS repository
20 years ago
set info $commitinfo($id)
Make getting file lists asynchronous Add some scrollbars
20 years ago
$ctext insert end "Author: [lindex $info 1] [lindex $info 2]\n"
$ctext insert end "Committer: [lindex $info 3] [lindex $info 4]\n"
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
if {[info exists idtags($id)]} {
$ctext insert end "Tags:"
foreach tag $idtags($id) {
$ctext insert end " $tag"
}
$ctext insert end "\n"
}
[PATCH] gitk "parent information" in commit window This adds a useful "Parent:" line to the git commit information window. It looks something like this (from the infamous octopus merge): Author: Junio C Hamano <junkio@cox.net> 2005-05-05 16:16:54 Committer: Junio C Hamano <junkio@cox.net> 2005-05-05 16:16:54 Parent: fc54a9c30ccad3fde5890d2c0ca2e2acc0848fbc (Update git-apply-patch-script ...) Parent: 9e30dd7c0ecc9f10372f31539d0122db97418353 (Make git-prune-script executa ...) Parent: c4b83e618f1df7d8ecc9392fa40e5bebccbe6b5a (Do not write out new index if ...) Parent: 660265909fc178581ef327076716dfd3550e6e7b (diff-cache shows differences ...) Parent: b28858bf65d4fd6d8bb070865518ec43817fe7f3 (Update diff engine for symlin ...) Octopus merge of the following five patches. Update git-apply-patch-script for symbolic links. Make git-prune-script executable again. Do not write out new index if nothing has changed. diff-cache shows differences for unmerged paths without --cache. Update diff engine for symlinks stored in the cache. Signed-off-by: Junio C Hamano <junkio@cox.net> where all the parent commit ID's are clickable, because the new lines are added as part of the "comment" string, and thus the regular clickability thing will match them automatically. I think this is good. And my random-tcl-monkey-skills are clearly getting better (although it's perfectly possible that somebody who actually knows what he is doing would have done things differently). Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
set comment {}
[PATCH] "Child" information in commit window - and cleanups This adds "Child: " lines to the commit window, which tells what children a commit has. It also cleans things up: it marks the text widget as no-wrap, which means that it doesn't need to truncate the commit description arbitrarily by hand. Also, the description itself is now done by a common helper routine that handles both the parent and the children. Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
if {[info exists parents($id)]} {
foreach p $parents($id) {
append comment "Parent: [commit_descriptor $p]\n"
}
}
if {[info exists children($id)]} {
foreach c $children($id) {
append comment "Child: [commit_descriptor $c]\n"
[PATCH] gitk "parent information" in commit window This adds a useful "Parent:" line to the git commit information window. It looks something like this (from the infamous octopus merge): Author: Junio C Hamano <junkio@cox.net> 2005-05-05 16:16:54 Committer: Junio C Hamano <junkio@cox.net> 2005-05-05 16:16:54 Parent: fc54a9c30ccad3fde5890d2c0ca2e2acc0848fbc (Update git-apply-patch-script ...) Parent: 9e30dd7c0ecc9f10372f31539d0122db97418353 (Make git-prune-script executa ...) Parent: c4b83e618f1df7d8ecc9392fa40e5bebccbe6b5a (Do not write out new index if ...) Parent: 660265909fc178581ef327076716dfd3550e6e7b (diff-cache shows differences ...) Parent: b28858bf65d4fd6d8bb070865518ec43817fe7f3 (Update diff engine for symlin ...) Octopus merge of the following five patches. Update git-apply-patch-script for symbolic links. Make git-prune-script executable again. Do not write out new index if nothing has changed. diff-cache shows differences for unmerged paths without --cache. Update diff engine for symlinks stored in the cache. Signed-off-by: Junio C Hamano <junkio@cox.net> where all the parent commit ID's are clickable, because the new lines are added as part of the "comment" string, and thus the regular clickability thing will match them automatically. I think this is good. And my random-tcl-monkey-skills are clearly getting better (although it's perfectly possible that somebody who actually knows what he is doing would have done things differently). Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
}
}
append comment "\n"
append comment [lindex $info 5]
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
# make anything that looks like a SHA1 ID be a clickable link
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
appendwithlinks $comment
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
$ctext tag delete Comments
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
$ctext tag remove found 1.0 end
Display the list of changed files in a listbox pane.
20 years ago
$ctext conf -state disabled
Error popups on error conditions rather than stderr msgs Stop . bindings firing on find string entry keypresses Fix geometry saving/restoring a bit Show the terminal commits Highlight comment matches in the comment window
20 years ago
set commentend [$ctext index "end - 1c"]
Display the list of changed files in a listbox pane.
20 years ago
$cflist delete 0 end
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$cflist insert end "Comments"
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
if {$nparents($id) == 1} {
startdiff [concat $id $parents($id)]
} elseif {$nparents($id) > 1} {
mergediff $id
}
}
proc selnextline {dir} {
global selectedline
if {![info exists selectedline]} return
set l [expr $selectedline + $dir]
unmarkmatches
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $l 1
}
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
proc unselectline {} {
global selectedline
catch {unset selectedline}
allcanvs delete secsel
}
proc addtohistory {cmd} {
global history historyindex
if {$historyindex > 0
&& [lindex $history [expr {$historyindex - 1}]] == $cmd} {
return
}
if {$historyindex < [llength $history]} {
set history [lreplace $history $historyindex end $cmd]
} else {
lappend history $cmd
}
incr historyindex
if {$historyindex > 1} {
.ctop.top.bar.leftbut conf -state normal
} else {
.ctop.top.bar.leftbut conf -state disabled
}
.ctop.top.bar.rightbut conf -state disabled
}
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
proc goback {} {
global history historyindex
if {$historyindex > 1} {
incr historyindex -1
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
set cmd [lindex $history [expr {$historyindex - 1}]]
eval $cmd
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
.ctop.top.bar.rightbut conf -state normal
}
if {$historyindex <= 1} {
.ctop.top.bar.leftbut conf -state disabled
}
}
proc goforw {} {
global history historyindex
if {$historyindex < [llength $history]} {
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
set cmd [lindex $history $historyindex]
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
incr historyindex
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
eval $cmd
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
.ctop.top.bar.leftbut conf -state normal
}
if {$historyindex >= [llength $history]} {
.ctop.top.bar.rightbut conf -state disabled
}
First cut at displaying the diffs for a merge. We display the files where the child differs from the first parent first in black in the file list window, followed by the second parent in blue, and so on using different colors for each parent (provided you don't have more than 6 parents; if you do we cycle around).
20 years ago
}
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
proc mergediff {id} {
global parents diffmergeid diffmergegca mergefilelist diffpindex
First cut at displaying the diffs for a merge. We display the files where the child differs from the first parent first in black in the file list window, followed by the second parent in blue, and so on using different colors for each parent (provided you don't have more than 6 parents; if you do we cycle around).
20 years ago
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
set diffmergeid $id
set diffpindex -1
set diffmergegca [findgca $parents($id)]
if {[info exists mergefilelist($id)]} {
Fix some bugs causing application error popups. Specifically this should fix the following errors: wrong # args: should be "startdiff ids" (fix from Junio Hamano) can't read "filelines(....)": no such element in array can't unset "treepending": no such variable
20 years ago
if {$mergefilelist($id) ne {}} {
showmergediff
}
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
} else {
contmergediff {}
}
}
proc findgca {ids} {
set gca {}
foreach id $ids {
if {$gca eq {}} {
set gca $id
} else {
if {[catch {
set gca [exec git-merge-base $gca $id]
} err]} {
return {}
}
}
}
return $gca
}
proc contmergediff {ids} {
global diffmergeid diffpindex parents nparents diffmergegca
Fix some bugs causing application error popups. Specifically this should fix the following errors: wrong # args: should be "startdiff ids" (fix from Junio Hamano) can't read "filelines(....)": no such element in array can't unset "treepending": no such variable
20 years ago
global treediffs mergefilelist diffids treepending
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
# diff the child against each of the parents, and diff
# each of the parents against the GCA.
while 1 {
if {[lindex $ids 0] == $diffmergeid && $diffmergegca ne {}} {
set ids [list [lindex $ids 1] $diffmergegca]
} else {
if {[incr diffpindex] >= $nparents($diffmergeid)} break
set p [lindex $parents($diffmergeid) $diffpindex]
set ids [list $diffmergeid $p]
}
if {![info exists treediffs($ids)]} {
set diffids $ids
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
if {![info exists treepending]} {
gettreediffs $ids
}
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
return
}
}
# If a file in some parent is different from the child and also
# different from the GCA, then it's interesting.
# If we don't have a GCA, then a file is interesting if it is
# different from the child in all the parents.
if {$diffmergegca ne {}} {
set files {}
foreach p $parents($diffmergeid) {
set gcadiffs $treediffs([list $p $diffmergegca])
foreach f $treediffs([list $diffmergeid $p]) {
if {[lsearch -exact $files $f] < 0
&& [lsearch -exact $gcadiffs $f] >= 0} {
lappend files $f
}
}
}
set files [lsort $files]
} else {
set p [lindex $parents($diffmergeid) 0]
set files $treediffs([list $diffmergeid $p])
for {set i 1} {$i < $nparents($diffmergeid) && $files ne {}} {incr i} {
set p [lindex $parents($diffmergeid) $i]
set df $treediffs([list $diffmergeid $p])
set nf {}
foreach f $files {
if {[lsearch -exact $df $f] >= 0} {
lappend nf $f
}
}
set files $nf
}
}
set mergefilelist($diffmergeid) $files
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
if {$files ne {}} {
showmergediff
}
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
}
proc showmergediff {} {
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
global cflist diffmergeid mergefilelist parents
Fix some bugs causing application error popups. Specifically this should fix the following errors: wrong # args: should be "startdiff ids" (fix from Junio Hamano) can't read "filelines(....)": no such element in array can't unset "treepending": no such variable
20 years ago
global diffopts diffinhunk currentfile currenthunk filelines
global diffblocked groupfilelast mergefds groupfilenum grouphunks
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
set files $mergefilelist($diffmergeid)
foreach f $files {
$cflist insert end $f
}
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
set env(GIT_DIFF_OPTS) $diffopts
set flist {}
catch {unset currentfile}
catch {unset currenthunk}
catch {unset filelines}
Fix some bugs causing application error popups. Specifically this should fix the following errors: wrong # args: should be "startdiff ids" (fix from Junio Hamano) can't read "filelines(....)": no such element in array can't unset "treepending": no such variable
20 years ago
catch {unset groupfilenum}
catch {unset grouphunks}
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
set groupfilelast -1
foreach p $parents($diffmergeid) {
set cmd [list | git-diff-tree -p $p $diffmergeid]
set cmd [concat $cmd $mergefilelist($diffmergeid)]
if {[catch {set f [open $cmd r]} err]} {
error_popup "Error getting diffs: $err"
foreach f $flist {
catch {close $f}
}
return
}
lappend flist $f
set ids [list $diffmergeid $p]
set mergefds($ids) $f
set diffinhunk($ids) 0
set diffblocked($ids) 0
fconfigure $f -blocking 0
fileevent $f readable [list getmergediffline $f $ids $diffmergeid]
}
}
proc getmergediffline {f ids id} {
global diffmergeid diffinhunk diffoldlines diffnewlines
global currentfile currenthunk
global diffoldstart diffnewstart diffoldlno diffnewlno
global diffblocked mergefilelist
global noldlines nnewlines difflcounts filelines
set n [gets $f line]
if {$n < 0} {
if {![eof $f]} return
}
if {!([info exists diffmergeid] && $diffmergeid == $id)} {
if {$n < 0} {
close $f
}
return
}
if {$diffinhunk($ids) != 0} {
set fi $currentfile($ids)
if {$n > 0 && [regexp {^[-+ \\]} $line match]} {
# continuing an existing hunk
set line [string range $line 1 end]
set p [lindex $ids 1]
if {$match eq "-" || $match eq " "} {
set filelines($p,$fi,$diffoldlno($ids)) $line
incr diffoldlno($ids)
}
if {$match eq "+" || $match eq " "} {
set filelines($id,$fi,$diffnewlno($ids)) $line
incr diffnewlno($ids)
}
if {$match eq " "} {
if {$diffinhunk($ids) == 2} {
lappend difflcounts($ids) \
[list $noldlines($ids) $nnewlines($ids)]
set noldlines($ids) 0
set diffinhunk($ids) 1
}
incr noldlines($ids)
} elseif {$match eq "-" || $match eq "+"} {
if {$diffinhunk($ids) == 1} {
lappend difflcounts($ids) [list $noldlines($ids)]
set noldlines($ids) 0
set nnewlines($ids) 0
set diffinhunk($ids) 2
}
if {$match eq "-"} {
incr noldlines($ids)
} else {
incr nnewlines($ids)
}
}
# and if it's \ No newline at end of line, then what?
return
}
# end of a hunk
if {$diffinhunk($ids) == 1 && $noldlines($ids) != 0} {
lappend difflcounts($ids) [list $noldlines($ids)]
} elseif {$diffinhunk($ids) == 2
&& ($noldlines($ids) != 0 || $nnewlines($ids) != 0)} {
lappend difflcounts($ids) [list $noldlines($ids) $nnewlines($ids)]
}
set currenthunk($ids) [list $currentfile($ids) \
$diffoldstart($ids) $diffnewstart($ids) \
$diffoldlno($ids) $diffnewlno($ids) \
$difflcounts($ids)]
set diffinhunk($ids) 0
# -1 = need to block, 0 = unblocked, 1 = is blocked
set diffblocked($ids) -1
processhunks
if {$diffblocked($ids) == -1} {
fileevent $f readable {}
set diffblocked($ids) 1
}
}
if {$n < 0} {
# eof
if {!$diffblocked($ids)} {
close $f
set currentfile($ids) [llength $mergefilelist($diffmergeid)]
set currenthunk($ids) [list $currentfile($ids) 0 0 0 0 {}]
processhunks
}
} elseif {[regexp {^diff --git a/(.*) b/} $line match fname]} {
# start of a new file
set currentfile($ids) \
[lsearch -exact $mergefilelist($diffmergeid) $fname]
} elseif {[regexp {^@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@(.*)} \
$line match f1l f1c f2l f2c rest]} {
if {[info exists currentfile($ids)] && $currentfile($ids) >= 0} {
# start of a new hunk
if {$f1l == 0 && $f1c == 0} {
set f1l 1
}
if {$f2l == 0 && $f2c == 0} {
set f2l 1
}
set diffinhunk($ids) 1
set diffoldstart($ids) $f1l
set diffnewstart($ids) $f2l
set diffoldlno($ids) $f1l
set diffnewlno($ids) $f2l
set difflcounts($ids) {}
set noldlines($ids) 0
set nnewlines($ids) 0
}
}
}
proc processhunks {} {
global diffmergeid parents nparents currenthunk
global mergefilelist diffblocked mergefds
global grouphunks grouplinestart grouplineend groupfilenum
set nfiles [llength $mergefilelist($diffmergeid)]
while 1 {
set fi $nfiles
set lno 0
# look for the earliest hunk
foreach p $parents($diffmergeid) {
set ids [list $diffmergeid $p]
if {![info exists currenthunk($ids)]} return
set i [lindex $currenthunk($ids) 0]
set l [lindex $currenthunk($ids) 2]
if {$i < $fi || ($i == $fi && $l < $lno)} {
set fi $i
set lno $l
set pi $p
}
}
if {$fi < $nfiles} {
set ids [list $diffmergeid $pi]
set hunk $currenthunk($ids)
unset currenthunk($ids)
if {$diffblocked($ids) > 0} {
fileevent $mergefds($ids) readable \
[list getmergediffline $mergefds($ids) $ids $diffmergeid]
}
set diffblocked($ids) 0
if {[info exists groupfilenum] && $groupfilenum == $fi
&& $lno <= $grouplineend} {
# add this hunk to the pending group
lappend grouphunks($pi) $hunk
set endln [lindex $hunk 4]
if {$endln > $grouplineend} {
set grouplineend $endln
}
continue
}
}
# succeeding stuff doesn't belong in this group, so
# process the group now
if {[info exists groupfilenum]} {
processgroup
unset groupfilenum
unset grouphunks
}
if {$fi >= $nfiles} break
# start a new group
set groupfilenum $fi
set grouphunks($pi) [list $hunk]
set grouplinestart $lno
set grouplineend [lindex $hunk 4]
}
}
proc processgroup {} {
global groupfilelast groupfilenum difffilestart
global mergefilelist diffmergeid ctext filelines
global parents diffmergeid diffoffset
global grouphunks grouplinestart grouplineend nparents
global mergemax
$ctext conf -state normal
set id $diffmergeid
set f $groupfilenum
if {$groupfilelast != $f} {
$ctext insert end "\n"
set here [$ctext index "end - 1c"]
set difffilestart($f) $here
set mark fmark.[expr {$f + 1}]
$ctext mark set $mark $here
$ctext mark gravity $mark left
set header [lindex $mergefilelist($id) $f]
set l [expr {(78 - [string length $header]) / 2}]
set pad [string range "----------------------------------------" 1 $l]
$ctext insert end "$pad $header $pad\n" filesep
set groupfilelast $f
foreach p $parents($id) {
set diffoffset($p) 0
}
}
$ctext insert end "@@" msep
set nlines [expr {$grouplineend - $grouplinestart}]
set events {}
set pnum 0
foreach p $parents($id) {
set startline [expr {$grouplinestart + $diffoffset($p)}]
set ol $startline
set nl $grouplinestart
if {[info exists grouphunks($p)]} {
foreach h $grouphunks($p) {
set l [lindex $h 2]
if {$nl < $l} {
for {} {$nl < $l} {incr nl} {
set filelines($p,$f,$ol) $filelines($id,$f,$nl)
incr ol
}
}
foreach chunk [lindex $h 5] {
if {[llength $chunk] == 2} {
set olc [lindex $chunk 0]
set nlc [lindex $chunk 1]
set nnl [expr {$nl + $nlc}]
lappend events [list $nl $nnl $pnum $olc $nlc]
incr ol $olc
set nl $nnl
} else {
incr ol [lindex $chunk 0]
incr nl [lindex $chunk 0]
}
}
}
}
if {$nl < $grouplineend} {
for {} {$nl < $grouplineend} {incr nl} {
set filelines($p,$f,$ol) $filelines($id,$f,$nl)
incr ol
}
}
set nlines [expr {$ol - $startline}]
$ctext insert end " -$startline,$nlines" msep
incr pnum
}
set nlines [expr {$grouplineend - $grouplinestart}]
$ctext insert end " +$grouplinestart,$nlines @@\n" msep
set events [lsort -integer -index 0 $events]
set nevents [llength $events]
set nmerge $nparents($diffmergeid)
set l $grouplinestart
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
for {set i 0} {$i < $nevents} {set i $j} {
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
set nl [lindex $events $i 0]
while {$l < $nl} {
$ctext insert end " $filelines($id,$f,$l)\n"
incr l
}
set e [lindex $events $i]
set enl [lindex $e 1]
set j $i
set active {}
while 1 {
set pnum [lindex $e 2]
set olc [lindex $e 3]
set nlc [lindex $e 4]
if {![info exists delta($pnum)]} {
set delta($pnum) [expr {$olc - $nlc}]
lappend active $pnum
} else {
incr delta($pnum) [expr {$olc - $nlc}]
}
if {[incr j] >= $nevents} break
set e [lindex $events $j]
if {[lindex $e 0] >= $enl} break
if {[lindex $e 1] > $enl} {
set enl [lindex $e 1]
}
}
set nlc [expr {$enl - $l}]
set ncol mresult
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
set bestpn -1
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
if {[llength $active] == $nmerge - 1} {
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
# no diff for one of the parents, i.e. it's identical
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
for {set pnum 0} {$pnum < $nmerge} {incr pnum} {
if {![info exists delta($pnum)]} {
if {$pnum < $mergemax} {
lappend ncol m$pnum
} else {
lappend ncol mmax
}
break
}
}
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
} elseif {[llength $active] == $nmerge} {
# all parents are different, see if one is very similar
set bestsim 30
for {set pnum 0} {$pnum < $nmerge} {incr pnum} {
set sim [similarity $pnum $l $nlc $f \
[lrange $events $i [expr {$j-1}]]]
if {$sim > $bestsim} {
set bestsim $sim
set bestpn $pnum
}
}
if {$bestpn >= 0} {
lappend ncol m$bestpn
}
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
}
set pnum -1
foreach p $parents($id) {
incr pnum
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
if {![info exists delta($pnum)] || $pnum == $bestpn} continue
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
set olc [expr {$nlc + $delta($pnum)}]
set ol [expr {$l + $diffoffset($p)}]
incr diffoffset($p) $delta($pnum)
unset delta($pnum)
for {} {$olc > 0} {incr olc -1} {
$ctext insert end "-$filelines($p,$f,$ol)\n" m$pnum
incr ol
}
}
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
set endl [expr {$l + $nlc}]
if {$bestpn >= 0} {
# show this pretty much as a normal diff
set p [lindex $parents($id) $bestpn]
set ol [expr {$l + $diffoffset($p)}]
incr diffoffset($p) $delta($bestpn)
unset delta($bestpn)
for {set k $i} {$k < $j} {incr k} {
set e [lindex $events $k]
if {[lindex $e 2] != $bestpn} continue
set nl [lindex $e 0]
set ol [expr {$ol + $nl - $l}]
for {} {$l < $nl} {incr l} {
$ctext insert end "+$filelines($id,$f,$l)\n" $ncol
}
set c [lindex $e 3]
for {} {$c > 0} {incr c -1} {
$ctext insert end "-$filelines($p,$f,$ol)\n" m$bestpn
incr ol
}
set nl [lindex $e 1]
for {} {$l < $nl} {incr l} {
$ctext insert end "+$filelines($id,$f,$l)\n" mresult
}
}
}
for {} {$l < $endl} {incr l} {
Display the diffs for a merge in a unified fashion. Stuff that ended up in the result is shown in bold with a "+" at the beginning of the line; stuff that didn't is in the normal font with a "-" at the beginning of the line. The color shows which parent the stuff was in; red for the first parent, blue for the second, then green, purple, brown, and the rest are grey. If the result is different from all of the parents it is shown in black (and bold).
20 years ago
$ctext insert end "+$filelines($id,$f,$l)\n" $ncol
}
}
while {$l < $grouplineend} {
$ctext insert end " $filelines($id,$f,$l)\n"
incr l
}
$ctext conf -state disabled
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Display the list of changed files in a listbox pane.
20 years ago
Improve the merge display when the result differs from all parents. Now we see if the result is quite similar to one of the parents, and if it is, display the result as a diff from that parent. If the result is similar to more than one parent, pick the one that it's most similar to.
20 years ago
proc similarity {pnum l nlc f events} {
global diffmergeid parents diffoffset filelines
set id $diffmergeid
set p [lindex $parents($id) $pnum]
set ol [expr {$l + $diffoffset($p)}]
set endl [expr {$l + $nlc}]
set same 0
set diff 0
foreach e $events {
if {[lindex $e 2] != $pnum} continue
set nl [lindex $e 0]
set ol [expr {$ol + $nl - $l}]
for {} {$l < $nl} {incr l} {
incr same [string length $filelines($id,$f,$l)]
incr same
}
set oc [lindex $e 3]
for {} {$oc > 0} {incr oc -1} {
incr diff [string length $filelines($p,$f,$ol)]
incr diff
incr ol
}
set nl [lindex $e 1]
for {} {$l < $nl} {incr l} {
incr diff [string length $filelines($id,$f,$l)]
incr diff
}
}
for {} {$l < $endl} {incr l} {
incr same [string length $filelines($id,$f,$l)]
incr same
}
if {$same == 0} {
return 0
}
return [expr {200 * $same / (2 * $same + $diff)}]
}
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
proc startdiff {ids} {
global treediffs diffids treepending diffmergeid
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
Fix display of mode changes in details pane. Also simplified the parsing of the git-diff-tree -p output and got rid of the unused 'seenfile' variable.
20 years ago
set diffids $ids
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
catch {unset diffmergeid}
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
if {![info exists treediffs($ids)]} {
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
if {![info exists treepending]} {
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
gettreediffs $ids
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
}
} else {
Make searching in files changed faster, and fix some bugs. We now kick off a single git-diff-tree -r --stdin and feed it all the commit pairs we want to know about, instead of doing a separate git-diff-tree invocation for each.
20 years ago
addtocflist $ids
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
}
}
proc addtocflist {ids} {
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
global treediffs cflist
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
foreach f $treediffs($ids) {
Make getting file lists asynchronous Add some scrollbars
20 years ago
$cflist insert end $f
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
getblobdiffs $ids
Make getting file lists asynchronous Add some scrollbars
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
proc gettreediffs {ids} {
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
global treediff parents treepending
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set treepending $ids
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
set treediff {}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set id [lindex $ids 0]
set p [lindex $ids 1]
Make getting file lists asynchronous Add some scrollbars
20 years ago
if [catch {set gdtf [open "|git-diff-tree -r $p $id" r]}] return
fconfigure $gdtf -blocking 0
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
fileevent $gdtf readable [list gettreediffline $gdtf $ids]
Make getting file lists asynchronous Add some scrollbars
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
proc gettreediffline {gdtf ids} {
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
global treediff treediffs treepending diffids diffmergeid
Make getting file lists asynchronous Add some scrollbars
20 years ago
set n [gets $gdtf line]
if {$n < 0} {
if {![eof $gdtf]} return
close $gdtf
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
set treediffs($ids) $treediff
Make getting file lists asynchronous Add some scrollbars
20 years ago
unset treepending
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
if {$ids != $diffids} {
gettreediffs $diffids
} else {
if {[info exists diffmergeid]} {
contmergediff $ids
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
} else {
addtocflist $ids
}
}
Make getting file lists asynchronous Add some scrollbars
20 years ago
return
}
cope with changed git-diff-tree output format
20 years ago
set file [lindex $line 5]
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
lappend treediff $file
Make getting file lists asynchronous Add some scrollbars
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
proc getblobdiffs {ids} {
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
global diffopts blobdifffd diffids env curdifftag curtagstart
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
global difffilestart nextupdate diffinhdr treediffs
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set id [lindex $ids 0]
set p [lindex $ids 1]
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
set env(GIT_DIFF_OPTS) $diffopts
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
set cmd [list | git-diff-tree -r -p -C $p $id]
if {[catch {set bdf [open $cmd r]} err]} {
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
puts "error getting diffs: $err"
return
}
Fix display of mode changes in details pane. Also simplified the parsing of the git-diff-tree -p output and got rid of the unused 'seenfile' variable.
20 years ago
set diffinhdr 0
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
fconfigure $bdf -blocking 0
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set blobdifffd($ids) $bdf
Calculate the list of interesting files for a merge. If there is a GCA for the parents of the merge, then a file is interesting if some parent has a version that is different from both the child and the GCA. If there is no GCA (e.g. for a merge that pulls in an external project) then a file is interesting if the child's version is different from all of the parents. Next step is to actually show the differences for the interesting files...
20 years ago
set curdifftag Comments
set curtagstart 0.0
catch {unset difffilestart}
fileevent $bdf readable [list getblobdiffline $bdf $diffids]
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set nextupdate [expr {[clock clicks -milliseconds] + 100}]
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
proc getblobdiffline {bdf ids} {
Fix display of mode changes in details pane. Also simplified the parsing of the git-diff-tree -p output and got rid of the unused 'seenfile' variable.
20 years ago
global diffids blobdifffd ctext curdifftag curtagstart
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
global diffnexthead diffnextnote difffilestart
global nextupdate diffinhdr treediffs
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
global gaudydiff
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
set n [gets $bdf line]
if {$n < 0} {
if {[eof $bdf]} {
close $bdf
First cut at displaying the diffs for a merge. We display the files where the child differs from the first parent first in black in the file list window, followed by the second parent in blue, and so on using different colors for each parent (provided you don't have more than 6 parents; if you do we cycle around).
20 years ago
if {$ids == $diffids && $bdf == $blobdifffd($ids)} {
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
$ctext tag add $curdifftag $curtagstart end
}
}
return
}
First cut at displaying the diffs for a merge. We display the files where the child differs from the first parent first in black in the file list window, followed by the second parent in blue, and so on using different colors for each parent (provided you don't have more than 6 parents; if you do we cycle around).
20 years ago
if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
return
}
$ctext conf -state normal
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
if {[regexp {^diff --git a/(.*) b/(.*)} $line match fname newname]} {
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
# start of a new file
$ctext insert end "\n"
$ctext tag add $curdifftag $curtagstart end
set curtagstart [$ctext index "end - 1c"]
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
set header $newname
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set here [$ctext index "end - 1c"]
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
set i [lsearch -exact $treediffs($diffids) $fname]
if {$i >= 0} {
set difffilestart($i) $here
incr i
$ctext mark set fmark.$i $here
$ctext mark gravity fmark.$i left
}
if {$newname != $fname} {
set i [lsearch -exact $treediffs($diffids) $newname]
if {$i >= 0} {
set difffilestart($i) $here
incr i
$ctext mark set fmark.$i $here
$ctext mark gravity fmark.$i left
}
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
set curdifftag "f:$fname"
$ctext tag delete $curdifftag
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
set l [expr {(78 - [string length $header]) / 2}]
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
set pad [string range "----------------------------------------" 1 $l]
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
$ctext insert end "$pad $header $pad\n" filesep
Fix display of mode changes in details pane. Also simplified the parsing of the git-diff-tree -p output and got rid of the unused 'seenfile' variable.
20 years ago
set diffinhdr 1
} elseif {[regexp {^(---|\+\+\+)} $line]} {
set diffinhdr 0
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
} elseif {[regexp {^@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@(.*)} \
$line match f1l f1c f2l f2c rest]} {
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
if {$gaudydiff} {
$ctext insert end "\t" hunksep
$ctext insert end " $f1l " d0 " $f2l " d1
$ctext insert end " $rest \n" hunksep
} else {
$ctext insert end "$line\n" hunksep
}
Fix display of mode changes in details pane. Also simplified the parsing of the git-diff-tree -p output and got rid of the unused 'seenfile' variable.
20 years ago
set diffinhdr 0
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
} else {
set x [string range $line 0 0]
if {$x == "-" || $x == "+"} {
set tag [expr {$x == "+"}]
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
if {$gaudydiff} {
set line [string range $line 1 end]
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
$ctext insert end "$line\n" d$tag
} elseif {$x == " "} {
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
if {$gaudydiff} {
set line [string range $line 1 end]
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
$ctext insert end "$line\n"
Fix display of mode changes in details pane. Also simplified the parsing of the git-diff-tree -p output and got rid of the unused 'seenfile' variable.
20 years ago
} elseif {$diffinhdr || $x == "\\"} {
Handle \ No newline at end of line lines in diff Put (deleted) or (created, mode xxx) in header lines Fix scrolling to bring lines on screen
20 years ago
# e.g. "\ No newline at end of file"
$ctext insert end "$line\n" filesep
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
} else {
# Something else we don't recognize
if {$curdifftag != "Comments"} {
$ctext insert end "\n"
$ctext tag add $curdifftag $curtagstart end
set curtagstart [$ctext index "end - 1c"]
set curdifftag Comments
}
$ctext insert end "$line\n" filesep
}
}
$ctext conf -state disabled
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
if {[clock clicks -milliseconds] >= $nextupdate} {
incr nextupdate 100
fileevent $bdf readable {}
update
fileevent $bdf readable "getblobdiffline $bdf {$ids}"
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
}
Accommodate new git-diff-tree output format Add 'f' key for moving to next file
20 years ago
proc nextfile {} {
global difffilestart ctext
set here [$ctext index @0,0]
for {set i 0} {[info exists difffilestart($i)]} {incr i} {
if {[$ctext compare $difffilestart($i) > $here]} {
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
if {![info exists pos]
|| [$ctext compare $difffilestart($i) < $pos]} {
set pos $difffilestart($i)
}
Accommodate new git-diff-tree output format Add 'f' key for moving to next file
20 years ago
}
}
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
if {[info exists pos]} {
$ctext yview $pos
}
Accommodate new git-diff-tree output format Add 'f' key for moving to next file
20 years ago
}
Show the diffs when a commit is selected Selecting in the listbox reduces the text view to just the diff for the file(s) selected Added -c option for color-by-committer Added some more key bindings
20 years ago
proc listboxsel {} {
Handle the rename cases reported by git-diff-tree -C correctly.
20 years ago
global ctext cflist currentid
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
if {![info exists currentid]} return
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set sel [lsort [$cflist curselection]]
if {$sel eq {}} return
set first [lindex $sel 0]
catch {$ctext yview fmark.$first}
Add initial version of gitk to the CVS repository
20 years ago
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
proc setcoords {} {
global linespc charspc canvx0 canvy0 mainfont
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
global xspc1 xspc2 lthickness
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set linespc [font metrics $mainfont -linespace]
set charspc [font measure $mainfont "m"]
set canvy0 [expr 3 + 0.5 * $linespc]
set canvx0 [expr 3 + 0.5 * $linespc]
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set lthickness [expr {int($linespc / 9) + 1}]
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
set xspc1(0) $linespc
set xspc2 $linespc
Make behaviour when git-rev-tree fails nicer Fix crash benh saw with currentid undefined Add menu with file/quit and help/about items Add ^Q for quit
20 years ago
}
Add initial version of gitk to the CVS repository
20 years ago
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
proc redisplay {} {
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
global stopped redisplaying phase
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
if {$stopped > 1} return
if {$phase == "getcommits"} return
set redisplaying 1
Restructure to do incremental drawing Some speedups from not doing update so often
20 years ago
if {$phase == "drawgraph" || $phase == "incrdraw"} {
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set stopped 1
} else {
drawgraph
}
}
proc incrfont {inc} {
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
global mainfont namefont textfont ctext canv phase
Use git-rev-list instead of git-rev-tree. Fix bug in changing font size in entry widgets. Fix bug with B1 click before anything has been drawn. Use "units" and "pages" instead of "u" and "p" for tk8.5.
20 years ago
global stopped entries
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
unmarkmatches
set mainfont [lreplace $mainfont 1 1 [expr {[lindex $mainfont 1] + $inc}]]
set namefont [lreplace $namefont 1 1 [expr {[lindex $namefont 1] + $inc}]]
set textfont [lreplace $textfont 1 1 [expr {[lindex $textfont 1] + $inc}]]
setcoords
$ctext conf -font $textfont
$ctext tag conf filesep -font [concat $textfont bold]
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
foreach e $entries {
$e conf -font $mainfont
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
if {$phase == "getcommits"} {
$canv itemconf textitems -font $mainfont
}
redisplay
}
Add initial version of gitk to the CVS repository
20 years ago
Clear the SHA1 entry field when we go to paste something into it If the user pastes in the selection (with the middle mouse button) and it already has 40 characters in it, clear it before pasting.
20 years ago
proc clearsha1 {} {
global sha1entry sha1string
if {[string length $sha1string] == 40} {
$sha1entry delete 0 end
}
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
proc sha1change {n1 n2 op} {
global sha1string currentid sha1but
if {$sha1string == {}
|| ([info exists currentid] && $sha1string == $currentid)} {
set state disabled
} else {
set state normal
}
if {[$sha1but cget -state] == $state} return
if {$state == "normal"} {
$sha1but conf -state normal -relief raised -text "Goto: "
} else {
$sha1but conf -state disabled -relief flat -text "SHA1 ID: "
}
}
proc gotocommit {} {
global sha1string currentid idline tagids
Allow short SHA1 IDs in the SHA1 entry field.
20 years ago
global lineid numcommits
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
if {$sha1string == {}
|| ([info exists currentid] && $sha1string == $currentid)} return
if {[info exists tagids($sha1string)]} {
set id $tagids($sha1string)
} else {
set id [string tolower $sha1string]
Allow short SHA1 IDs in the SHA1 entry field.
20 years ago
if {[regexp {^[0-9a-f]{4,39}$} $id]} {
set matches {}
for {set l 0} {$l < $numcommits} {incr l} {
if {[string match $id* $lineid($l)]} {
lappend matches $lineid($l)
}
}
if {$matches ne {}} {
if {[llength $matches] > 1} {
error_popup "Short SHA1 id $id is ambiguous"
return
}
set id [lindex $matches 0]
}
}
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
}
if {[info exists idline($id)]} {
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $idline($id) 1
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
return
}
Allow short SHA1 IDs in the SHA1 entry field.
20 years ago
if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
set type "SHA1 id"
} else {
set type "Tag"
}
error_popup "$type $sha1string is not known"
}
Draw graph lines as one continuous line where possible Added context menu on lines Added headline display when the mouse hovers over a line Removed some debug messages
20 years ago
proc lineenter {x y id} {
global hoverx hovery hoverid hovertimer
global commitinfo canv
if {![info exists commitinfo($id)]} return
set hoverx $x
set hovery $y
set hoverid $id
if {[info exists hovertimer]} {
after cancel $hovertimer
}
set hovertimer [after 500 linehover]
$canv delete hover
}
proc linemotion {x y id} {
global hoverx hovery hoverid hovertimer
if {[info exists hoverid] && $id == $hoverid} {
set hoverx $x
set hovery $y
if {[info exists hovertimer]} {
after cancel $hovertimer
}
set hovertimer [after 500 linehover]
}
}
proc lineleave {id} {
global hoverid hovertimer canv
if {[info exists hoverid] && $id == $hoverid} {
$canv delete hover
if {[info exists hovertimer]} {
after cancel $hovertimer
unset hovertimer
}
unset hoverid
}
}
proc linehover {} {
global hoverx hovery hoverid hovertimer
global canv linespc lthickness
global commitinfo mainfont
set text [lindex $commitinfo($hoverid) 0]
set ymax [lindex [$canv cget -scrollregion] 3]
if {$ymax == {}} return
set yfrac [lindex [$canv yview] 0]
set x [expr {$hoverx + 2 * $linespc}]
set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
set x0 [expr {$x - 2 * $lthickness}]
set y0 [expr {$y - 2 * $lthickness}]
set x1 [expr {$x + [font measure $mainfont $text] + 2 * $lthickness}]
set y1 [expr {$y + $linespc + 2 * $lthickness}]
set t [$canv create rectangle $x0 $y0 $x1 $y1 \
-fill \#ffff80 -outline black -width 1 -tags hover]
$canv raise $t
set t [$canv create text $x $y -anchor nw -text $text -tags hover]
$canv raise $t
}
Draw selected graph line thicker and make arrowheads active.
20 years ago
proc clickisonarrow {id y} {
global mainline mainlinearrow sidelines lthickness
set thresh [expr {2 * $lthickness + 6}]
if {[info exists mainline($id)]} {
if {$mainlinearrow($id) ne "none"} {
if {abs([lindex $mainline($id) 1] - $y) < $thresh} {
return "up"
}
}
}
if {[info exists sidelines($id)]} {
foreach ls $sidelines($id) {
set coords [lindex $ls 0]
set arrow [lindex $ls 2]
if {$arrow eq "first" || $arrow eq "both"} {
if {abs([lindex $coords 1] - $y) < $thresh} {
return "up"
}
}
if {$arrow eq "last" || $arrow eq "both"} {
if {abs([lindex $coords end] - $y) < $thresh} {
return "down"
}
}
}
}
return {}
}
proc arrowjump {id dirn y} {
global mainline sidelines canv
set yt {}
if {$dirn eq "down"} {
if {[info exists mainline($id)]} {
set y1 [lindex $mainline($id) 1]
if {$y1 > $y} {
set yt $y1
}
}
if {[info exists sidelines($id)]} {
foreach ls $sidelines($id) {
set y1 [lindex $ls 0 1]
if {$y1 > $y && ($yt eq {} || $y1 < $yt)} {
set yt $y1
}
}
}
} else {
if {[info exists sidelines($id)]} {
foreach ls $sidelines($id) {
set y1 [lindex $ls 0 end]
if {$y1 < $y && ($yt eq {} || $y1 > $yt)} {
set yt $y1
}
}
}
}
if {$yt eq {}} return
set ymax [lindex [$canv cget -scrollregion] 3]
if {$ymax eq {} || $ymax <= 0} return
set view [$canv yview]
set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
set yfrac [expr {$yt / $ymax - $yspan / 2}]
if {$yfrac < 0} {
set yfrac 0
}
$canv yview moveto $yfrac
}
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
proc lineclick {x y id isnew} {
Draw selected graph line thicker and make arrowheads active.
20 years ago
global ctext commitinfo children cflist canv thickerline
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
unmarkmatches
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
unselectline
Draw selected graph line thicker and make arrowheads active.
20 years ago
normalline
$canv delete hover
# draw this line thicker than normal
drawlines $id 1
set thickerline $id
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
if {$isnew} {
Draw selected graph line thicker and make arrowheads active.
20 years ago
set ymax [lindex [$canv cget -scrollregion] 3]
if {$ymax eq {}} return
set yfrac [lindex [$canv yview] 0]
set y [expr {$y + $yfrac * $ymax}]
}
set dirn [clickisonarrow $id $y]
if {$dirn ne {}} {
arrowjump $id $dirn $y
return
}
if {$isnew} {
addtohistory [list lineclick $x $y $id 0]
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
# fill the details pane with info about this line
$ctext conf -state normal
$ctext delete 0.0 end
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
$ctext tag conf link -foreground blue -underline 1
$ctext tag bind link <Enter> { %W configure -cursor hand2 }
$ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
$ctext insert end "Parent:\t"
$ctext insert end $id [list link link0]
$ctext tag bind link0 <1> [list selbyid $id]
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set info $commitinfo($id)
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
$ctext insert end "\n\t[lindex $info 0]\n"
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$ctext insert end "\tAuthor:\t[lindex $info 1]\n"
$ctext insert end "\tDate:\t[lindex $info 2]\n"
if {[info exists children($id)]} {
$ctext insert end "\nChildren:"
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
set i 0
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
foreach child $children($id) {
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
incr i
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set info $commitinfo($child)
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
$ctext insert end "\n\t"
$ctext insert end $child [list link link$i]
$ctext tag bind link$i <1> [list selbyid $child]
$ctext insert end "\n\t[lindex $info 0]"
$ctext insert end "\n\tAuthor:\t[lindex $info 1]"
$ctext insert end "\n\tDate:\t[lindex $info 2]\n"
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
}
}
$ctext conf -state disabled
$cflist delete 0 end
}
Draw selected graph line thicker and make arrowheads active.
20 years ago
proc normalline {} {
global thickerline
if {[info exists thickerline]} {
drawlines $thickerline 0
unset thickerline
}
}
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
proc selbyid {id} {
global idline
if {[info exists idline($id)]} {
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $idline($id) 1
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
}
}
proc mstime {} {
global startmstime
if {![info exists startmstime]} {
set startmstime [clock clicks -milliseconds]
}
return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
}
proc rowmenu {x y id} {
global rowctxmenu idline selectedline rowmenuid
if {![info exists selectedline] || $idline($id) eq $selectedline} {
set state disabled
} else {
set state normal
}
$rowctxmenu entryconfigure 0 -state $state
$rowctxmenu entryconfigure 1 -state $state
Add a menu entry for generating a patch between any two commits.
20 years ago
$rowctxmenu entryconfigure 2 -state $state
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
set rowmenuid $id
tk_popup $rowctxmenu $x $y
}
proc diffvssel {dirn} {
global rowmenuid selectedline lineid
if {![info exists selectedline]} return
if {$dirn} {
set oldid $lineid($selectedline)
set newid $rowmenuid
} else {
set oldid $rowmenuid
set newid $lineid($selectedline)
}
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
addtohistory [list doseldiff $oldid $newid]
doseldiff $oldid $newid
}
proc doseldiff {oldid newid} {
global ctext cflist
global commitinfo
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$ctext conf -state normal
$ctext delete 0.0 end
$ctext mark set fmark.0 0.0
$ctext mark gravity fmark.0 left
$cflist delete 0 end
$cflist insert end "Top"
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
$ctext insert end "From "
$ctext tag conf link -foreground blue -underline 1
$ctext tag bind link <Enter> { %W configure -cursor hand2 }
$ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
$ctext tag bind link0 <1> [list selbyid $oldid]
$ctext insert end $oldid [list link link0]
$ctext insert end "\n "
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$ctext insert end [lindex $commitinfo($oldid) 0]
Better graph line details display and expand history coverage. Now the history remembers when we have clicked on a graph line and when we have asked for a diff between two commits, as well as when we have displayed a commit. The display when you click on a graph line now uses clickable SHA1 IDs instead of the embedded "Go" buttons. Also made the IDs clickable in the header for a diff between two commits.
20 years ago
$ctext insert end "\n\nTo "
$ctext tag bind link1 <1> [list selbyid $newid]
$ctext insert end $newid [list link link1]
$ctext insert end "\n "
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
$ctext insert end [lindex $commitinfo($newid) 0]
$ctext insert end "\n"
$ctext conf -state disabled
$ctext tag delete Comments
$ctext tag remove found 1.0 end
Fix some bugs causing application error popups. Specifically this should fix the following errors: wrong # args: should be "startdiff ids" (fix from Junio Hamano) can't read "filelines(....)": no such element in array can't unset "treepending": no such variable
20 years ago
startdiff [list $newid $oldid]
Add commit row context menu and handle left-click on graph lines Right-click on a context row now brings up a menu allowing the user to generate a diff between that row and the selected row. Left-click on a graph line shows the parent and children connected by the line in the details pane. Left-click on a circle in the graph selects that commit. Left-click elsewhere in the graph does nothing. When displaying a diff, the bottom-right file list box behaves slightly differently now; instead of eliding all other files' diffs, it now just scrolls the details pane so that the selected file's diff starts at the top of the pane. Since the diffs can be rather large, arrange for an update to be done every 100ms while reading diffs. Also removed the CVS revision keywords and bumped the version number to 1.2.
20 years ago
}
Add a menu entry for generating a patch between any two commits.
20 years ago
proc mkpatch {} {
global rowmenuid currentid commitinfo patchtop patchnum
if {![info exists currentid]} return
set oldid $currentid
set oldhead [lindex $commitinfo($oldid) 0]
set newid $rowmenuid
set newhead [lindex $commitinfo($newid) 0]
set top .patch
set patchtop $top
catch {destroy $top}
toplevel $top
label $top.title -text "Generate patch"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
grid $top.title - -pady 10
Add a menu entry for generating a patch between any two commits.
20 years ago
label $top.from -text "From:"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.fromsha1 -width 40 -relief flat
Add a menu entry for generating a patch between any two commits.
20 years ago
$top.fromsha1 insert 0 $oldid
$top.fromsha1 conf -state readonly
grid $top.from $top.fromsha1 -sticky w
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.fromhead -width 60 -relief flat
Add a menu entry for generating a patch between any two commits.
20 years ago
$top.fromhead insert 0 $oldhead
$top.fromhead conf -state readonly
grid x $top.fromhead -sticky w
label $top.to -text "To:"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.tosha1 -width 40 -relief flat
Add a menu entry for generating a patch between any two commits.
20 years ago
$top.tosha1 insert 0 $newid
$top.tosha1 conf -state readonly
grid $top.to $top.tosha1 -sticky w
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.tohead -width 60 -relief flat
Add a menu entry for generating a patch between any two commits.
20 years ago
$top.tohead insert 0 $newhead
$top.tohead conf -state readonly
grid x $top.tohead -sticky w
button $top.rev -text "Reverse" -command mkpatchrev -padx 5
grid $top.rev x -pady 10
label $top.flab -text "Output file:"
entry $top.fname -width 60
$top.fname insert 0 [file normalize "patch$patchnum.patch"]
incr patchnum
Add a menu item for creating tags.
20 years ago
grid $top.flab $top.fname -sticky w
Add a menu entry for generating a patch between any two commits.
20 years ago
frame $top.buts
button $top.buts.gen -text "Generate" -command mkpatchgo
button $top.buts.can -text "Cancel" -command mkpatchcan
grid $top.buts.gen $top.buts.can
grid columnconfigure $top.buts 0 -weight 1 -uniform a
grid columnconfigure $top.buts 1 -weight 1 -uniform a
grid $top.buts - -pady 10 -sticky ew
Add a menu item for creating tags.
20 years ago
focus $top.fname
Add a menu entry for generating a patch between any two commits.
20 years ago
}
proc mkpatchrev {} {
global patchtop
set oldid [$patchtop.fromsha1 get]
set oldhead [$patchtop.fromhead get]
set newid [$patchtop.tosha1 get]
set newhead [$patchtop.tohead get]
foreach e [list fromsha1 fromhead tosha1 tohead] \
v [list $newid $newhead $oldid $oldhead] {
$patchtop.$e conf -state normal
$patchtop.$e delete 0 end
$patchtop.$e insert 0 $v
$patchtop.$e conf -state readonly
}
}
proc mkpatchgo {} {
global patchtop
set oldid [$patchtop.fromsha1 get]
set newid [$patchtop.tosha1 get]
set fname [$patchtop.fname get]
if {[catch {exec git-diff-tree -p $oldid $newid >$fname &} err]} {
error_popup "Error creating patch: $err"
}
catch {destroy $patchtop}
unset patchtop
}
proc mkpatchcan {} {
global patchtop
catch {destroy $patchtop}
unset patchtop
}
Add a menu item for creating tags.
20 years ago
proc mktag {} {
global rowmenuid mktagtop commitinfo
set top .maketag
set mktagtop $top
catch {destroy $top}
toplevel $top
label $top.title -text "Create tag"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
grid $top.title - -pady 10
Add a menu item for creating tags.
20 years ago
label $top.id -text "ID:"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.sha1 -width 40 -relief flat
Add a menu item for creating tags.
20 years ago
$top.sha1 insert 0 $rowmenuid
$top.sha1 conf -state readonly
grid $top.id $top.sha1 -sticky w
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.head -width 60 -relief flat
Add a menu item for creating tags.
20 years ago
$top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
$top.head conf -state readonly
grid x $top.head -sticky w
label $top.tlab -text "Tag name:"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
entry $top.tag -width 60
Add a menu item for creating tags.
20 years ago
grid $top.tlab $top.tag -sticky w
frame $top.buts
button $top.buts.gen -text "Create" -command mktaggo
button $top.buts.can -text "Cancel" -command mktagcan
grid $top.buts.gen $top.buts.can
grid columnconfigure $top.buts 0 -weight 1 -uniform a
grid columnconfigure $top.buts 1 -weight 1 -uniform a
grid $top.buts - -pady 10 -sticky ew
focus $top.tag
}
proc domktag {} {
global mktagtop env tagids idtags
set id [$mktagtop.sha1 get]
set tag [$mktagtop.tag get]
if {$tag == {}} {
error_popup "No tag name specified"
return
}
if {[info exists tagids($tag)]} {
error_popup "Tag \"$tag\" already exists"
return
}
if {[catch {
[PATCH] gitk: Use GIT_DIR where appropriate. Some places assumed .git is the GIT_DIR, resulting heads and tags not showing when it was run like "GIT_DIR=. gitk --all". This is not a contrived example --- I rely on it to verify my private copy of git.git repository before pushing it out. Define a single procedure "gitdir" and use it. Signed-off-by: Junio C Hamano <junkio@cox.net> Signed-off-by: Paul Mackerras <paulus@samba.org>
20 years ago
set dir [gitdir]
Add a menu item for creating tags.
20 years ago
set fname [file join $dir "refs/tags" $tag]
set f [open $fname w]
puts $f $id
close $f
} err]} {
error_popup "Error creating tag: $err"
return
}
set tagids($tag) $id
lappend idtags($id) $tag
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
redrawtags $id
}
proc redrawtags {id} {
global canv linehtag idline idpos selectedline
if {![info exists idline($id)]} return
Add a menu item for creating tags.
20 years ago
$canv delete tag.$id
set xt [eval drawtags $id $idpos($id)]
$canv coords $linehtag($idline($id)) $xt [lindex $idpos($id) 2]
if {[info exists selectedline] && $selectedline == $idline($id)} {
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
selectline $selectedline 0
Add a menu item for creating tags.
20 years ago
}
}
proc mktagcan {} {
global mktagtop
catch {destroy $mktagtop}
unset mktagtop
}
proc mktaggo {} {
domktag
mktagcan
}
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
proc writecommit {} {
global rowmenuid wrcomtop commitinfo wrcomcmd
set top .writecommit
set wrcomtop $top
catch {destroy $top}
toplevel $top
label $top.title -text "Write commit to file"
grid $top.title - -pady 10
label $top.id -text "ID:"
entry $top.sha1 -width 40 -relief flat
$top.sha1 insert 0 $rowmenuid
$top.sha1 conf -state readonly
grid $top.id $top.sha1 -sticky w
entry $top.head -width 60 -relief flat
$top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
$top.head conf -state readonly
grid x $top.head -sticky w
label $top.clab -text "Command:"
entry $top.cmd -width 60 -textvariable wrcomcmd
grid $top.clab $top.cmd -sticky w -pady 10
label $top.flab -text "Output file:"
entry $top.fname -width 60
$top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
grid $top.flab $top.fname -sticky w
frame $top.buts
button $top.buts.gen -text "Write" -command wrcomgo
button $top.buts.can -text "Cancel" -command wrcomcan
grid $top.buts.gen $top.buts.can
grid columnconfigure $top.buts 0 -weight 1 -uniform a
grid columnconfigure $top.buts 1 -weight 1 -uniform a
grid $top.buts - -pady 10 -sticky ew
focus $top.fname
}
proc wrcomgo {} {
global wrcomtop
set id [$wrcomtop.sha1 get]
set cmd "echo $id | [$wrcomtop.cmd get]"
set fname [$wrcomtop.fname get]
if {[catch {exec sh -c $cmd >$fname &} err]} {
error_popup "Error writing commit: $err"
}
catch {destroy $wrcomtop}
unset wrcomtop
}
proc wrcomcan {} {
global wrcomtop
catch {destroy $wrcomtop}
unset wrcomtop
}
Added re-read refs command, and display all refs. These are features requested by Junio. Any plain file under .git/refs whose contents start with 40 hex characters is taken as a reference and displayed like a head but with a light blue background (unless it is in .git/refs/tags or .git/refs/heads, in which case it is displayed as before). There is now a "Reread references" menu item in the File menu which re-reads all the plain files under .git/refs and redisplays any references that have changed.
20 years ago
proc listrefs {id} {
global idtags idheads idotherrefs
set x {}
if {[info exists idtags($id)]} {
set x $idtags($id)
}
set y {}
if {[info exists idheads($id)]} {
set y $idheads($id)
}
set z {}
if {[info exists idotherrefs($id)]} {
set z $idotherrefs($id)
}
return [list $x $y $z]
}
proc rereadrefs {} {
global idtags idheads idotherrefs
global tagids headids otherrefids
set refids [concat [array names idtags] \
[array names idheads] [array names idotherrefs]]
foreach id $refids {
if {![info exists ref($id)]} {
set ref($id) [listrefs $id]
}
}
foreach v {tagids idtags headids idheads otherrefids idotherrefs} {
catch {unset $v}
}
readrefs
set refids [lsort -unique [concat $refids [array names idtags] \
[array names idheads] [array names idotherrefs]]]
foreach id $refids {
set v [listrefs $id]
if {![info exists ref($id)] || $ref($id) != $v} {
redrawtags $id
}
}
}
Display the contents of a tag when the user clicks on it. This just displays the result of git-cat-file on the tag in the details pane. If the tag is a "direct" tag (the tag file contains the SHA1 ID of a commit rather than a tag), we show the tag name and SHA1 ID.
20 years ago
proc showtag {tag isnew} {
global ctext cflist tagcontents tagids linknum
if {$isnew} {
addtohistory [list showtag $tag 0]
}
$ctext conf -state normal
$ctext delete 0.0 end
set linknum 0
if {[info exists tagcontents($tag)]} {
set text $tagcontents($tag)
} else {
set text "Tag: $tag\nId: $tagids($tag)"
}
appendwithlinks $text
$ctext conf -state disabled
$cflist delete 0 end
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
proc doquit {} {
global stopped
set stopped 100
destroy .
}
Add initial version of gitk to the CVS repository
20 years ago
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
# defaults...
set datemode 0
set boldnames 0
set diffopts "-U 5 -p"
Add a menu item for writing out a commit to a file. This just invokes git-diff-tree. Also changed the readonly entry widgets in the "write patch" and "generate tag" windows to have flat relief, so it doesn't look like you should be able to modify what's in them.
20 years ago
set wrcomcmd "git-diff-tree --stdin -p --pretty"
Add initial version of gitk to the CVS repository
20 years ago
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set mainfont {Helvetica 9}
set textfont {Courier 9}
Add "Files" and "Pickaxe" to the find menu. "Files" matches the find string against each of the files modified by each commit, and can do exact, case-ignoring or regexp matching. "Pickaxe" uses git-diff-tree -S'string' and can only do exact matching. I called it "pickaxe" rather than "find within patch" since it only finds commits where the string is present in the child but not the parents or vice versa, and "pickaxe" is what the author of that feature calls it.
20 years ago
set findmergefiles 0
Make the diff display less gaudy. The old style is still available as an option (we still need a preferences window so we can set/clear it though).
20 years ago
set gaudydiff 0
Compress the graph horizontally if it gets too wide. If the graph gets to use more than a certain percentage (default 50%) of the width of the top-left pane, we now reduce the amount of space allowed for each graph line. This means it doesn't look quite as nice but you can still see the headline for the commit. (Currently the only way to customize the percentage is to edit your ~/.gitk file manually.)
20 years ago
set maxgraphpct 50
Allow graph lines to jump through hyperspace. When the graph gets too wide (as defined by the maxwidth variable, which can be set in ~/.gitk), we can now terminate graph lines with an arrow pointing downwards, and reintroduce them later with an arrow pointing upwards when we need them. This makes the graph much less cluttered on large repositories such as the linux kernel. Unfortunately this has made it slower; it takes about 10 seconds user time on the linux-2.6 repository on my machine now, compared to 6 seconds before. I'll have to work on optimizing that. Also on the todo list are making the arrow heads active (so if you click on them you jump to the other end) and improving the placement of the null entry.
20 years ago
set maxwidth 16
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set colors {green red blue magenta darkgrey brown orange}
catch {source ~/.gitk}
More fixes for geometry restoration Make up/down/pgup/pgdn work again Return in find string entry does find Scale circles and lines with font size Fix scrolling to make entire selected line visible Use white circle for commits not listed but put in to terminate lines Fix diff parsing for created and deleted files
20 years ago
set namefont $mainfont
if {$boldnames} {
lappend namefont bold
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set revtreeargs {}
foreach arg $argv {
switch -regexp -- $arg {
"^$" { }
"^-b" { set boldnames 1 }
"^-d" { set datemode 1 }
default {
lappend revtreeargs $arg
}
}
Add initial version of gitk to the CVS repository
20 years ago
}
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
Add forward and back buttons and make SHA1 IDs clickable links. When we display the commit message in the details pane, any string of 40 [0-9a-f] characters that corresponds to a SHA1 ID that we know about gets turned into a clickable link, and displayed in blue and underlined. We now keep a history of commits that we have looked at, and we have forward and back buttons for moving within the history list.
20 years ago
set history {}
set historyindex 0
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
set stopped 0
set redisplaying 0
save window geometry on exit, and restore it on startup
20 years ago
set stuffsaved 0
Add a menu entry for generating a patch between any two commits.
20 years ago
set patchnum 0
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
setcoords
makewindow
Read tags from .git/refs/tags/* and mark commits with tags with a label. Allow SHA1 ids or tags to be entered in the SHA1 ID field.
20 years ago
readrefs
Made commit list reading asynchronous Added control+/- to increase/decrease font sizes Rearranged code a little.
20 years ago
getcommits $revtreeargs